wasmtime 22.0.0 → 23.0.2

data/ext/cargo-vendor/cranelift-codegen-0.109.0/src/write.rs

@@ -1,638 +0,0 @@
-//! Converting Cranelift IR to text.
-//!
-//! The `write` module provides the `write_function` function which converts an IR `Function` to an
-//! equivalent textual form. This textual form can be read back by the `cranelift-reader` crate.
-
-use crate::entity::SecondaryMap;
-use crate::ir::entities::AnyEntity;
-use crate::ir::pcc::Fact;
-use crate::ir::{Block, DataFlowGraph, Function, Inst, SigRef, Type, Value, ValueDef};
-use crate::packed_option::ReservedValue;
-use alloc::string::{String, ToString};
-use alloc::vec::Vec;
-use core::fmt::{self, Write};
-
-/// A `FuncWriter` used to decorate functions during printing.
-pub trait FuncWriter {
-    /// Write the basic block header for the current function.
-    fn write_block_header(
-        &mut self,
-        w: &mut dyn Write,
-        func: &Function,
-        block: Block,
-        indent: usize,
-    ) -> fmt::Result;
-
-    /// Write the given `inst` to `w`.
-    fn write_instruction(
-        &mut self,
-        w: &mut dyn Write,
-        func: &Function,
-        aliases: &SecondaryMap<Value, Vec<Value>>,
-        inst: Inst,
-        indent: usize,
-    ) -> fmt::Result;
-
-    /// Write the preamble to `w`. By default, this uses `write_entity_definition`.
-    fn write_preamble(&mut self, w: &mut dyn Write, func: &Function) -> Result<bool, fmt::Error> {
-        self.super_preamble(w, func)
-    }
-
-    /// Default impl of `write_preamble`
-    fn super_preamble(&mut self, w: &mut dyn Write, func: &Function) -> Result<bool, fmt::Error> {
-        let mut any = false;
-
-        for (ss, slot) in func.dynamic_stack_slots.iter() {
-            any = true;
-            self.write_entity_definition(w, func, ss.into(), slot, None)?;
-        }
-
-        for (ss, slot) in func.sized_stack_slots.iter() {
-            any = true;
-            self.write_entity_definition(w, func, ss.into(), slot, None)?;
-        }
-
-        for (gv, gv_data) in &func.global_values {
-            any = true;
-            let maybe_fact = func.global_value_facts[gv].as_ref();
-            self.write_entity_definition(w, func, gv.into(), gv_data, maybe_fact)?;
-        }
-
-        for (mt, mt_data) in &func.memory_types {
-            any = true;
-            self.write_entity_definition(w, func, mt.into(), mt_data, None)?;
-        }
-
-        // Write out all signatures before functions since function declarations can refer to
-        // signatures.
-        for (sig, sig_data) in &func.dfg.signatures {
-            any = true;
-            self.write_entity_definition(w, func, sig.into(), &sig_data, None)?;
-        }
-
-        for (fnref, ext_func) in &func.dfg.ext_funcs {
-            if ext_func.signature != SigRef::reserved_value() {
-                any = true;
-                self.write_entity_definition(
-                    w,
-                    func,
-                    fnref.into(),
-                    &ext_func.display(Some(&func.params)),
-                    None,
-                )?;
-            }
-        }
-
-        for (&cref, cval) in func.dfg.constants.iter() {
-            any = true;
-            self.write_entity_definition(w, func, cref.into(), cval, None)?;
-        }
-
-        if let Some(limit) = func.stack_limit {
-            any = true;
-            self.write_entity_definition(w, func, AnyEntity::StackLimit, &limit, None)?;
-        }
-
-        Ok(any)
-    }
-
-    /// Write an entity definition defined in the preamble to `w`.
-    fn write_entity_definition(
-        &mut self,
-        w: &mut dyn Write,
-        func: &Function,
-        entity: AnyEntity,
-        value: &dyn fmt::Display,
-        maybe_fact: Option<&Fact>,
-    ) -> fmt::Result {
-        self.super_entity_definition(w, func, entity, value, maybe_fact)
-    }
-
-    /// Default impl of `write_entity_definition`
-    #[allow(unused_variables)]
-    fn super_entity_definition(
-        &mut self,
-        w: &mut dyn Write,
-        func: &Function,
-        entity: AnyEntity,
-        value: &dyn fmt::Display,
-        maybe_fact: Option<&Fact>,
-    ) -> fmt::Result {
-        if let Some(fact) = maybe_fact {
-            writeln!(w, "    {} ! {} = {}", entity, fact, value)
-        } else {
-            writeln!(w, "    {} = {}", entity, value)
-        }
-    }
-}
-
-/// A `PlainWriter` that doesn't decorate the function.
-pub struct PlainWriter;
-
-impl FuncWriter for PlainWriter {
-    fn write_instruction(
-        &mut self,
-        w: &mut dyn Write,
-        func: &Function,
-        aliases: &SecondaryMap<Value, Vec<Value>>,
-        inst: Inst,
-        indent: usize,
-    ) -> fmt::Result {
-        write_instruction(w, func, aliases, inst, indent)
-    }
-
-    fn write_block_header(
-        &mut self,
-        w: &mut dyn Write,
-        func: &Function,
-        block: Block,
-        indent: usize,
-    ) -> fmt::Result {
-        write_block_header(w, func, block, indent)
-    }
-}
-
-/// Write `func` to `w` as equivalent text.
-/// Use `isa` to emit ISA-dependent annotations.
-pub fn write_function(w: &mut dyn Write, func: &Function) -> fmt::Result {
-    decorate_function(&mut PlainWriter, w, func)
-}
-
-/// Create a reverse-alias map from a value to all aliases having that value as a direct target
-fn alias_map(func: &Function) -> SecondaryMap<Value, Vec<Value>> {
-    let mut aliases = SecondaryMap::<_, Vec<_>>::new();
-    for v in func.dfg.values() {
-        // VADFS returns the immediate target of an alias
-        if let Some(k) = func.dfg.value_alias_dest_for_serialization(v) {
-            aliases[k].push(v);
-        }
-    }
-    aliases
-}
-
-/// Writes `func` to `w` as text.
-/// write_function_plain is passed as 'closure' to print instructions as text.
-/// pretty_function_error is passed as 'closure' to add error decoration.
-pub fn decorate_function<FW: FuncWriter>(
-    func_w: &mut FW,
-    w: &mut dyn Write,
-    func: &Function,
-) -> fmt::Result {
-    write!(w, "function ")?;
-    write_spec(w, func)?;
-    writeln!(w, " {{")?;
-    let aliases = alias_map(func);
-    let mut any = func_w.write_preamble(w, func)?;
-    for block in &func.layout {
-        if any {
-            writeln!(w)?;
-        }
-        decorate_block(func_w, w, func, &aliases, block)?;
-        any = true;
-    }
-    writeln!(w, "}}")
-}
-
-//----------------------------------------------------------------------
-//
-// Function spec.
-
-fn write_spec(w: &mut dyn Write, func: &Function) -> fmt::Result {
-    write!(w, "{}{}", func.name, func.signature)
-}
-
-//----------------------------------------------------------------------
-//
-// Basic blocks
-
-fn write_arg(w: &mut dyn Write, func: &Function, arg: Value) -> fmt::Result {
-    let ty = func.dfg.value_type(arg);
-    if let Some(f) = &func.dfg.facts[arg] {
-        write!(w, "{} ! {}: {}", arg, f, ty)
-    } else {
-        write!(w, "{}: {}", arg, ty)
-    }
-}
-
-/// Write out the basic block header, outdented:
-///
-///    block1:
-///    block1(v1: i32):
-///    block10(v4: f64, v5: i8):
-///
-pub fn write_block_header(
-    w: &mut dyn Write,
-    func: &Function,
-    block: Block,
-    indent: usize,
-) -> fmt::Result {
-    let cold = if func.layout.is_cold(block) {
-        " cold"
-    } else {
-        ""
-    };
-
-    // The `indent` is the instruction indentation. block headers are 4 spaces out from that.
-    write!(w, "{1:0$}{2}", indent - 4, "", block)?;
-
-    let mut args = func.dfg.block_params(block).iter().cloned();
-    match args.next() {
-        None => return writeln!(w, "{}:", cold),
-        Some(arg) => {
-            write!(w, "(")?;
-            write_arg(w, func, arg)?;
-        }
-    }
-    // Remaining arguments.
-    for arg in args {
-        write!(w, ", ")?;
-        write_arg(w, func, arg)?;
-    }
-    writeln!(w, "){}:", cold)
-}
-
-fn decorate_block<FW: FuncWriter>(
-    func_w: &mut FW,
-    w: &mut dyn Write,
-    func: &Function,
-    aliases: &SecondaryMap<Value, Vec<Value>>,
-    block: Block,
-) -> fmt::Result {
-    // Indent all instructions if any srclocs are present.
-    let indent = if func.rel_srclocs().is_empty() { 4 } else { 36 };
-
-    func_w.write_block_header(w, func, block, indent)?;
-    for a in func.dfg.block_params(block).iter().cloned() {
-        write_value_aliases(w, aliases, a, indent)?;
-    }
-
-    for inst in func.layout.block_insts(block) {
-        func_w.write_instruction(w, func, aliases, inst, indent)?;
-    }
-
-    Ok(())
-}
-
-//----------------------------------------------------------------------
-//
-// Instructions
-
-// Should `inst` be printed with a type suffix?
-//
-// Polymorphic instructions may need a suffix indicating the value of the controlling type variable
-// if it can't be trivially inferred.
-//
-fn type_suffix(func: &Function, inst: Inst) -> Option<Type> {
-    let inst_data = &func.dfg.insts[inst];
-    let constraints = inst_data.opcode().constraints();
-
-    if !constraints.is_polymorphic() {
-        return None;
-    }
-
-    // If the controlling type variable can be inferred from the type of the designated value input
-    // operand, we don't need the type suffix.
-    if constraints.use_typevar_operand() {
-        let ctrl_var = inst_data.typevar_operand(&func.dfg.value_lists).unwrap();
-        let def_block = match func.dfg.value_def(ctrl_var) {
-            ValueDef::Result(instr, _) => func.layout.inst_block(instr),
-            ValueDef::Param(block, _) => Some(block),
-            ValueDef::Union(..) => None,
-        };
-        if def_block.is_some() && def_block == func.layout.inst_block(inst) {
-            return None;
-        }
-    }
-
-    let rtype = func.dfg.ctrl_typevar(inst);
-    assert!(
-        !rtype.is_invalid(),
-        "Polymorphic instruction must produce a result"
-    );
-    Some(rtype)
-}
-
-/// Write out any aliases to the given target, including indirect aliases
-fn write_value_aliases(
-    w: &mut dyn Write,
-    aliases: &SecondaryMap<Value, Vec<Value>>,
-    target: Value,
-    indent: usize,
-) -> fmt::Result {
-    let mut todo_stack = vec![target];
-    while let Some(target) = todo_stack.pop() {
-        for &a in &aliases[target] {
-            writeln!(w, "{1:0$}{2} -> {3}", indent, "", a, target)?;
-            todo_stack.push(a);
-        }
-    }
-
-    Ok(())
-}
-
-fn write_instruction(
-    w: &mut dyn Write,
-    func: &Function,
-    aliases: &SecondaryMap<Value, Vec<Value>>,
-    inst: Inst,
-    indent: usize,
-) -> fmt::Result {
-    // Prefix containing source location, encoding, and value locations.
-    let mut s = String::with_capacity(16);
-
-    // Source location goes first.
-    let srcloc = func.srcloc(inst);
-    if !srcloc.is_default() {
-        write!(s, "{} ", srcloc)?;
-    }
-
-    // Write out prefix and indent the instruction.
-    write!(w, "{1:0$}", indent, s)?;
-
-    // Write out the result values, if any.
-    let mut has_results = false;
-    for r in func.dfg.inst_results(inst) {
-        if !has_results {
-            has_results = true;
-            write!(w, "{}", r)?;
-        } else {
-            write!(w, ", {}", r)?;
-        }
-        if let Some(f) = &func.dfg.facts[*r] {
-            write!(w, " ! {}", f)?;
-        }
-    }
-    if has_results {
-        write!(w, " = ")?;
-    }
-
-    // Then the opcode, possibly with a '.type' suffix.
-    let opcode = func.dfg.insts[inst].opcode();
-
-    match type_suffix(func, inst) {
-        Some(suf) => write!(w, "{}.{}", opcode, suf)?,
-        None => write!(w, "{}", opcode)?,
-    }
-
-    write_operands(w, &func.dfg, inst)?;
-    writeln!(w)?;
-
-    // Value aliases come out on lines after the instruction defining the referent.
-    for r in func.dfg.inst_results(inst) {
-        write_value_aliases(w, aliases, *r, indent)?;
-    }
-    Ok(())
-}
-
-/// Write the operands of `inst` to `w` with a prepended space.
-pub fn write_operands(w: &mut dyn Write, dfg: &DataFlowGraph, inst: Inst) -> fmt::Result {
-    let pool = &dfg.value_lists;
-    let jump_tables = &dfg.jump_tables;
-    use crate::ir::instructions::InstructionData::*;
-    match dfg.insts[inst] {
-        AtomicRmw { op, args, .. } => write!(w, " {} {}, {}", op, args[0], args[1]),
-        AtomicCas { args, .. } => write!(w, " {}, {}, {}", args[0], args[1], args[2]),
-        LoadNoOffset { flags, arg, .. } => write!(w, "{} {}", flags, arg),
-        StoreNoOffset { flags, args, .. } => write!(w, "{} {}, {}", flags, args[0], args[1]),
-        Unary { arg, .. } => write!(w, " {}", arg),
-        UnaryImm { imm, .. } => write!(w, " {}", imm),
-        UnaryIeee32 { imm, .. } => write!(w, " {}", imm),
-        UnaryIeee64 { imm, .. } => write!(w, " {}", imm),
-        UnaryGlobalValue { global_value, .. } => write!(w, " {}", global_value),
-        UnaryConst {
-            constant_handle, ..
-        } => write!(w, " {}", constant_handle),
-        Binary { args, .. } => write!(w, " {}, {}", args[0], args[1]),
-        BinaryImm8 { arg, imm, .. } => write!(w, " {}, {}", arg, imm),
-        BinaryImm64 { arg, imm, .. } => write!(w, " {}, {}", arg, imm),
-        Ternary { args, .. } => write!(w, " {}, {}, {}", args[0], args[1], args[2]),
-        MultiAry { ref args, .. } => {
-            if args.is_empty() {
-                write!(w, "")
-            } else {
-                write!(w, " {}", DisplayValues(args.as_slice(pool)))
-            }
-        }
-        NullAry { .. } => write!(w, " "),
-        TernaryImm8 { imm, args, .. } => write!(w, " {}, {}, {}", args[0], args[1], imm),
-        Shuffle { imm, args, .. } => {
-            let data = dfg.immediates.get(imm).expect(
-                "Expected the shuffle mask to already be inserted into the immediates table",
-            );
-            write!(w, " {}, {}, {}", args[0], args[1], data)
-        }
-        IntCompare { cond, args, .. } => write!(w, " {} {}, {}", cond, args[0], args[1]),
-        IntCompareImm { cond, arg, imm, .. } => write!(w, " {} {}, {}", cond, arg, imm),
-        IntAddTrap { args, code, .. } => write!(w, " {}, {}, {}", args[0], args[1], code),
-        FloatCompare { cond, args, .. } => write!(w, " {} {}, {}", cond, args[0], args[1]),
-        Jump { destination, .. } => {
-            write!(w, " {}", destination.display(pool))
-        }
-        Brif {
-            arg,
-            blocks: [block_then, block_else],
-            ..
-        } => {
-            write!(w, " {}, {}", arg, block_then.display(pool))?;
-            write!(w, ", {}", block_else.display(pool))
-        }
-        BranchTable { arg, table, .. } => {
-            write!(w, " {}, {}", arg, jump_tables[table].display(pool))
-        }
-        Call {
-            func_ref, ref args, ..
-        } => write!(w, " {}({})", func_ref, DisplayValues(args.as_slice(pool))),
-        CallIndirect {
-            sig_ref, ref args, ..
-        } => {
-            let args = args.as_slice(pool);
-            write!(
-                w,
-                " {}, {}({})",
-                sig_ref,
-                args[0],
-                DisplayValues(&args[1..])
-            )
-        }
-        FuncAddr { func_ref, .. } => write!(w, " {}", func_ref),
-        StackLoad {
-            stack_slot, offset, ..
-        } => write!(w, " {}{}", stack_slot, offset),
-        StackStore {
-            arg,
-            stack_slot,
-            offset,
-            ..
-        } => write!(w, " {}, {}{}", arg, stack_slot, offset),
-        DynamicStackLoad {
-            dynamic_stack_slot, ..
-        } => write!(w, " {}", dynamic_stack_slot),
-        DynamicStackStore {
-            arg,
-            dynamic_stack_slot,
-            ..
-        } => write!(w, " {}, {}", arg, dynamic_stack_slot),
-        Load {
-            flags, arg, offset, ..
-        } => write!(w, "{} {}{}", flags, arg, offset),
-        Store {
-            flags,
-            args,
-            offset,
-            ..
-        } => write!(w, "{} {}, {}{}", flags, args[0], args[1], offset),
-        Trap { code, .. } => write!(w, " {}", code),
-        CondTrap { arg, code, .. } => write!(w, " {}, {}", arg, code),
-    }?;
-
-    let mut sep = "  ; ";
-    for arg in dfg.inst_values(inst) {
-        if let ValueDef::Result(src, _) = dfg.value_def(arg) {
-            let imm = match dfg.insts[src] {
-                UnaryImm { imm, .. } => imm.to_string(),
-                UnaryIeee32 { imm, .. } => imm.to_string(),
-                UnaryIeee64 { imm, .. } => imm.to_string(),
-                UnaryConst {
-                    constant_handle, ..
-                } => constant_handle.to_string(),
-                _ => continue,
-            };
-            write!(w, "{}{} = {}", sep, arg, imm)?;
-            sep = ", ";
-        }
-    }
-    Ok(())
-}
-
-/// Displayable slice of values.
-struct DisplayValues<'a>(&'a [Value]);
-
-impl<'a> fmt::Display for DisplayValues<'a> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        for (i, val) in self.0.iter().enumerate() {
-            if i == 0 {
-                write!(f, "{}", val)?;
-            } else {
-                write!(f, ", {}", val)?;
-            }
-        }
-        Ok(())
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use crate::cursor::{Cursor, CursorPosition, FuncCursor};
-    use crate::ir::types;
-    use crate::ir::{Function, InstBuilder, StackSlotData, StackSlotKind, UserFuncName};
-    use alloc::string::ToString;
-
-    #[test]
-    fn basic() {
-        let mut f = Function::new();
-        assert_eq!(f.to_string(), "function u0:0() fast {\n}\n");
-
-        f.name = UserFuncName::testcase("foo");
-        assert_eq!(f.to_string(), "function %foo() fast {\n}\n");
-
-        f.create_sized_stack_slot(StackSlotData::new(StackSlotKind::ExplicitSlot, 4, 0));
-        assert_eq!(
-            f.to_string(),
-            "function %foo() fast {\n    ss0 = explicit_slot 4\n}\n"
-        );
-
-        let block = f.dfg.make_block();
-        f.layout.append_block(block);
-        assert_eq!(
-            f.to_string(),
-            "function %foo() fast {\n    ss0 = explicit_slot 4\n\nblock0:\n}\n"
-        );
-
-        f.dfg.append_block_param(block, types::I8);
-        assert_eq!(
-            f.to_string(),
-            "function %foo() fast {\n    ss0 = explicit_slot 4\n\nblock0(v0: i8):\n}\n"
-        );
-
-        f.dfg.append_block_param(block, types::F32.by(4).unwrap());
-        assert_eq!(
-            f.to_string(),
-            "function %foo() fast {\n    ss0 = explicit_slot 4\n\nblock0(v0: i8, v1: f32x4):\n}\n"
-        );
-
-        {
-            let mut cursor = FuncCursor::new(&mut f);
-            cursor.set_position(CursorPosition::After(block));
-            cursor.ins().return_(&[])
-        };
-        assert_eq!(
-            f.to_string(),
-            "function %foo() fast {\n    ss0 = explicit_slot 4\n\nblock0(v0: i8, v1: f32x4):\n    return\n}\n"
-        );
-
-        let mut f = Function::new();
-        f.create_sized_stack_slot(StackSlotData::new(StackSlotKind::ExplicitSlot, 4, 2));
-        assert_eq!(
-            f.to_string(),
-            "function u0:0() fast {\n    ss0 = explicit_slot 4, align = 4\n}\n"
-        );
-    }
-
-    #[test]
-    fn aliases() {
-        use crate::ir::InstBuilder;
-
-        let mut func = Function::new();
-        {
-            let block0 = func.dfg.make_block();
-            let mut pos = FuncCursor::new(&mut func);
-            pos.insert_block(block0);
-
-            // make some detached values for change_to_alias
-            let v0 = pos.func.dfg.append_block_param(block0, types::I32);
-            let v1 = pos.func.dfg.append_block_param(block0, types::I32);
-            let v2 = pos.func.dfg.append_block_param(block0, types::I32);
-            pos.func.dfg.detach_block_params(block0);
-
-            // alias to a param--will be printed at beginning of block defining param
-            let v3 = pos.func.dfg.append_block_param(block0, types::I32);
-            pos.func.dfg.change_to_alias(v0, v3);
-
-            // alias to an alias--should print attached to alias, not ultimate target
-            pos.func.dfg.make_value_alias_for_serialization(v0, v2); // v0 <- v2
-
-            // alias to a result--will be printed after instruction producing result
-            let _dummy0 = pos.ins().iconst(types::I32, 42);
-            let v4 = pos.ins().iadd(v0, v0);
-            pos.func.dfg.change_to_alias(v1, v4);
-            let _dummy1 = pos.ins().iconst(types::I32, 23);
-            let _v7 = pos.ins().iadd(v1, v1);
-        }
-        assert_eq!(
-            func.to_string(),
-            "function u0:0() fast {\nblock0(v3: i32):\n    v0 -> v3\n    v2 -> v0\n    v4 = iconst.i32 42\n    v5 = iadd v0, v0\n    v1 -> v5\n    v6 = iconst.i32 23\n    v7 = iadd v1, v1\n}\n"
-        );
-    }
-
-    #[test]
-    fn cold_blocks() {
-        let mut func = Function::new();
-        {
-            let mut pos = FuncCursor::new(&mut func);
-
-            let block0 = pos.func.dfg.make_block();
-            pos.insert_block(block0);
-            pos.func.layout.set_cold(block0);
-
-            let block1 = pos.func.dfg.make_block();
-            pos.insert_block(block1);
-            pos.func.dfg.append_block_param(block1, types::I32);
-            pos.func.layout.set_cold(block1);
-        }
-
-        assert_eq!(
-            func.to_string(),
-            "function u0:0() fast {\nblock0 cold:\n\nblock1(v0: i32) cold:\n}\n"
-        );
-    }
-}

data/ext/cargo-vendor/cranelift-codegen-meta-0.109.0/.cargo-checksum.json

@@ -1 +0,0 @@
-{"files":{"Cargo.toml":"bc7693db58641e79dd5cb7f022cb0835a1b57f663dbba27362f8f2206c54f0ea","LICENSE":"268872b9816f90fd8e85db5a28d33f8150ebb8dd016653fb39ef1f94f2686bc5","README.md":"b123f056d0d458396679c5f7f2a16d2762af0258fcda4ac14b6655a95e5a0022","src/cdsl/formats.rs":"3dbbbe2b05ac1df9d88ce8cfafba5a41c485566a6ba9dc6dfcfd71b1b85e85f2","src/cdsl/instructions.rs":"43d84c2cc7b1516d30fc8f60678623e887f2aa7758703ce798dd93345573f6c4","src/cdsl/isa.rs":"fbb5848baea534584ec113fab8d13015b80b125392e86cad0c91e14f746c038c","src/cdsl/mod.rs":"7faf3c1159b05a11aba71bd791dba544423a3e765f5d016f9bb225263edb039d","src/cdsl/operands.rs":"f531120b794e9a79e24a24212ad55a999f02be41af4cea788042ba562c109ecf","src/cdsl/settings.rs":"974e91afbd5e24282b5f0deb3a1349f131a7efb9544e0ca2e4c7c7ef905ba160","src/cdsl/types.rs":"f18e99076dc46dbdc13cc4dc9660be9bac326e34924eed5947c6e16b19f88c86","src/cdsl/typevar.rs":"625f2f5ebf40a91e028a9dcb7776793bd86361f0ab27ab215931549a56229105","src/constant_hash.rs":"7f21c124e58286bf5239bba064c3f1bdd76ba95f27c2f6c82ffff1ec54f46274","src/error.rs":"e9b11b2feb2d867b94c8810fdc5a6c4e0d9131604a0bfa5340ff2639a55100b4","src/gen_inst.rs":"58efc860f72594b7d0fe930beff3069ba8d491485da84e1ccb83df395768da9d","src/gen_isle.rs":"7d19b9ba9d29adb08775a6226c2eaf630464fe5767fa911f2b5cc9722ea08911","src/gen_settings.rs":"6dbe40822b34cd74a366e984d0a1308d8aa2480ce25fe4d243e31dd0267f130e","src/gen_types.rs":"856adbaec3fc4d052bc3afc0744a41b1d48c2010cae1c900814d3f99c7b6e7a3","src/isa/arm64.rs":"2d5d6c1871155fbba7a7032b92bc39eb43e0082a109d530eb32f415723412003","src/isa/mod.rs":"396ec4c885ef0d7c101abdb33724795a01b1182031f05590ee6066594263afd4","src/isa/riscv64.rs":"a04cf98e8229c48105c86aa341496f3974611d19b36ed7df05140cdce5e376f8","src/isa/s390x.rs":"54ed76179d0696d6244720666685336b90e318be848dc32217ccc16a28a40490","src/isa/x86.rs":"240905e57f2892f7e7220977e64986c6ee6de371cc6df2d6f7e72517fbbe2776","src/isle.rs":"6d2e15094862a9a7e395c7d6b0cd40947e5fbce80a502d6351084501afe7399a","src/lib.rs":"1c43c834c66ee320c53ecb03446c919fd0a6edddbaa5c1ba7861083f8f1c0306","src/shared/entities.rs":"b93ccbec3531fe3ad002eeb400214f84439b46c64f4c1b6e06f641fbffed334c","src/shared/formats.rs":"6628329845cf6d5309e4b8ae3c257173f74d96cb8265dda60b847d041b9f91cf","src/shared/immediates.rs":"9db6a6933a78e4810b326024d0ab879f83e989e044f617b0882841c2556f4a78","src/shared/instructions.rs":"4706846e26b654a854dbc5865b8ae5dbcdde63bfdd63e17d9fc23639bc4f0147","src/shared/mod.rs":"56ec881fdad048dfaf48055d481e8804a628e8cf51e02d89eeda7a2903e776bc","src/shared/settings.rs":"ff1caab9dce846d42808c54ab7c5e1a7b8ae6229056f1bbc481242a03caaa8d1","src/shared/types.rs":"bad3d2b305610e3f1000f3a7700c9347c10ddb75040eccebf9f952525a09f4d4","src/srcgen.rs":"23650d392d95c11687e8c0406b4967d2ab13e50c415d8b903ec68f84818667a0","src/unique_table.rs":"d804720d23d3db4cc8630fd3975dbde13dcd111137e98513c950ad3618ce1168"},"package":"e934d301392b73b3f8b0540391fb82465a0f179a3cee7c726482ac4727efcc97"}

data/ext/cargo-vendor/cranelift-codegen-meta-0.109.0/Cargo.toml

@@ -1,36 +0,0 @@
-# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
-#
-# When uploading crates to the registry Cargo will automatically
-# "normalize" Cargo.toml files for maximal compatibility
-# with all versions of Cargo and also rewrite `path` dependencies
-# to registry (e.g., crates.io) dependencies.
-#
-# If you are reading this file be aware that the original Cargo.toml
-# will likely look very different (and much more reasonable).
-# See Cargo.toml.orig for the original contents.
-
-[package]
-edition = "2021"
-name = "cranelift-codegen-meta"
-version = "0.109.0"
-authors = ["The Cranelift Project Developers"]
-description = "Metaprogram for cranelift-codegen code generator library"
-readme = "README.md"
-license = "Apache-2.0 WITH LLVM-exception"
-repository = "https://github.com/bytecodealliance/wasmtime"
-
-[package.metadata.docs.rs]
-rustdoc-args = ["--document-private-items"]
-
-[dependencies.cranelift-codegen-shared]
-version = "0.109.0"
-
-[lints.clippy]
-all = "allow"
-
-[lints.rust]
-trivial_numeric_casts = "warn"
-unstable_features = "warn"
-unused-lifetimes = "warn"
-unused_extern_crates = "warn"
-unused_import_braces = "warn"