wasmtime 37.0.2 → 38.0.4

data/ext/cargo-vendor/cranelift-codegen-meta-0.125.4/src/shared/settings.rs

@@ -0,0 +1,376 @@
+use crate::cdsl::settings::{SettingGroup, SettingGroupBuilder};
+
+pub(crate) fn define() -> SettingGroup {
+    let mut settings = SettingGroupBuilder::new("shared");
+
+    settings.add_bool(
+        "regalloc_checker",
+        "Enable the symbolic checker for register allocation.",
+        r#"
+            This performs a verification that the register allocator preserves
+            equivalent dataflow with respect to the original (pre-regalloc)
+            program. This analysis is somewhat expensive. However, if it succeeds,
+            it provides independent evidence (by a carefully-reviewed, from-first-principles
+            analysis) that no regalloc bugs were triggered for the particular compilations
+            performed. This is a valuable assurance to have as regalloc bugs can be
+            very dangerous and difficult to debug.
+        "#,
+        false,
+    );
+
+    settings.add_bool(
+        "regalloc_verbose_logs",
+        "Enable verbose debug logs for regalloc2.",
+        r#"
+            This adds extra logging for regalloc2 output, that is quite valuable to understand
+            decisions taken by the register allocator as well as debugging it. It is disabled by
+            default, as it can cause many log calls which can slow down compilation by a large
+            amount.
+        "#,
+        false,
+    );
+
+    settings.add_enum(
+        "regalloc_algorithm",
+        "Algorithm to use in register allocator.",
+        r#"
+            Supported options:
+
+            - `backtracking`: A backtracking allocator with range splitting; more expensive
+                              but generates better code.
+            - `single_pass`: A single-pass algorithm that yields quick compilation but
+                             results in code with more register spills and moves.
+        "#,
+        vec!["backtracking", "single_pass"],
+    );
+
+    settings.add_enum(
+        "opt_level",
+        "Optimization level for generated code.",
+        r#"
+            Supported levels:
+
+            - `none`: Minimise compile time by disabling most optimizations.
+            - `speed`: Generate the fastest possible code
+            - `speed_and_size`: like "speed", but also perform transformations aimed at reducing code size.
+        "#,
+        vec!["none", "speed", "speed_and_size"],
+    );
+
+    settings.add_bool(
+        "enable_alias_analysis",
+        "Do redundant-load optimizations with alias analysis.",
+        r#"
+            This enables the use of a simple alias analysis to optimize away redundant loads.
+            Only effective when `opt_level` is `speed` or `speed_and_size`.
+        "#,
+        true,
+    );
+
+    settings.add_bool(
+        "enable_verifier",
+        "Run the Cranelift IR verifier at strategic times during compilation.",
+        r#"
+            This makes compilation slower but catches many bugs. The verifier is always enabled by
+            default, which is useful during development.
+        "#,
+        true,
+    );
+
+    settings.add_bool(
+        "enable_pcc",
+        "Enable proof-carrying code translation validation.",
+        r#"
+            This adds a proof-carrying-code mode. Proof-carrying code (PCC) is a strategy to verify
+            that the compiler preserves certain properties or invariants in the compiled code.
+            For example, a frontend that translates WebAssembly to CLIF can embed PCC facts in
+            the CLIF, and Cranelift will verify that the final machine code satisfies the stated
+            facts at each intermediate computed value. Loads and stores can be marked as "checked"
+            and their memory effects can be verified as safe.
+        "#,
+        false,
+    );
+
+    // Note that Cranelift doesn't currently need an is_pie flag, because PIE is
+    // just PIC where symbols can't be pre-empted, which can be expressed with the
+    // `colocated` flag on external functions and global values.
+    settings.add_bool(
+        "is_pic",
+        "Enable Position-Independent Code generation.",
+        "",
+        false,
+    );
+
+    settings.add_bool(
+        "use_colocated_libcalls",
+        "Use colocated libcalls.",
+        r#"
+            Generate code that assumes that libcalls can be declared "colocated",
+            meaning they will be defined along with the current function, such that
+            they can use more efficient addressing.
+        "#,
+        false,
+    );
+
+    settings.add_bool(
+        "enable_nan_canonicalization",
+        "Enable NaN canonicalization.",
+        r#"
+            This replaces NaNs with a single canonical value, for users requiring
+            entirely deterministic WebAssembly computation. This is not required
+            by the WebAssembly spec, so it is not enabled by default.
+        "#,
+        false,
+    );
+
+    settings.add_bool(
+        "enable_pinned_reg",
+        "Enable the use of the pinned register.",
+        r#"
+            This register is excluded from register allocation, and is completely under the control of
+            the end-user. It is possible to read it via the get_pinned_reg instruction, and to set it
+            with the set_pinned_reg instruction.
+        "#,
+        false,
+    );
+
+    settings.add_enum(
+        "tls_model",
+        "Defines the model used to perform TLS accesses.",
+        "",
+        vec!["none", "elf_gd", "macho", "coff"],
+    );
+
+    settings.add_enum(
+        "stack_switch_model",
+        "Defines the model used to performing stack switching.",
+        r#"
+           This determines the compilation of `stack_switch` instructions. If
+           set to `basic`, we simply save all registers, update stack pointer
+           and frame pointer (if needed), and jump to the target IP.
+           If set to `update_windows_tib`, we *additionally* update information
+           about the active stack in Windows' Thread Information Block.
+        "#,
+        vec!["none", "basic", "update_windows_tib"],
+    );
+
+    settings.add_enum(
+        "libcall_call_conv",
+        "Defines the calling convention to use for LibCalls call expansion.",
+        r#"
+            This may be different from the ISA default calling convention.
+
+            The default value is to use the same calling convention as the ISA
+            default calling convention.
+
+            This list should be kept in sync with the list of calling
+            conventions available in isa/call_conv.rs.
+        "#,
+        vec![
+            "isa_default",
+            "fast",
+            "cold",
+            "system_v",
+            "windows_fastcall",
+            "apple_aarch64",
+            "probestack",
+        ],
+    );
+
+    settings.add_bool(
+        "enable_llvm_abi_extensions",
+        "Enable various ABI extensions defined by LLVM's behavior.",
+        r#"
+            In some cases, LLVM's implementation of an ABI (calling convention)
+            goes beyond a standard and supports additional argument types or
+            behavior. This option instructs Cranelift codegen to follow LLVM's
+            behavior where applicable.
+
+            Currently, this applies only to Windows Fastcall on x86-64, and
+            allows an `i128` argument to be spread across two 64-bit integer
+            registers. The Fastcall implementation otherwise does not support
+            `i128` arguments, and will panic if they are present and this
+            option is not set.
+        "#,
+        false,
+    );
+
+    settings.add_bool(
+        "enable_multi_ret_implicit_sret",
+        "Enable support for sret arg introduction when there are too many ret vals.",
+        r#"
+            When there are more returns than available return registers, the
+            return value has to be returned through the introduction of a
+            return area pointer. Normally this return area pointer has to be
+            introduced as `ArgumentPurpose::StructReturn` parameter, but for
+            backward compatibility reasons Cranelift also supports implicitly
+            introducing this parameter and writing the return values through it.
+
+            **This option currently does not conform to platform ABIs and the
+            used ABI should not be assumed to remain the same between Cranelift
+            versions.**
+
+            This option is **deprecated** and will be removed in the future.
+
+            Because of the above issues, and complexities of native ABI support
+            for the concept in general, Cranelift's support for multiple return
+            values may also be removed in the future (#9510). For the most
+            robust solution, it is recommended to build a convention on top of
+            Cranelift's primitives for passing multiple return values, for
+            example by allocating a stackslot in the caller, passing it as an
+            explicit StructReturn argument, storing return values in the callee,
+            and loading results in the caller.
+        "#,
+        false,
+    );
+
+    settings.add_bool(
+        "unwind_info",
+        "Generate unwind information.",
+        r#"
+            This increases metadata size and compile time, but allows for the
+            debugger to trace frames, is needed for GC tracing that relies on
+            libunwind (such as in Wasmtime), and is unconditionally needed on
+            certain platforms (such as Windows) that must always be able to unwind.
+          "#,
+        true,
+    );
+
+    settings.add_bool(
+        "preserve_frame_pointers",
+        "Preserve frame pointers",
+        r#"
+            Preserving frame pointers -- even inside leaf functions -- makes it
+            easy to capture the stack of a running program, without requiring any
+            side tables or metadata (like `.eh_frame` sections). Many sampling
+            profilers and similar tools walk frame pointers to capture stacks.
+            Enabling this option will play nice with those tools.
+        "#,
+        false,
+    );
+
+    settings.add_bool(
+        "machine_code_cfg_info",
+        "Generate CFG metadata for machine code.",
+        r#"
+            This increases metadata size and compile time, but allows for the
+            embedder to more easily post-process or analyze the generated
+            machine code. It provides code offsets for the start of each
+            basic block in the generated machine code, and a list of CFG
+            edges (with blocks identified by start offsets) between them.
+            This is useful for, e.g., machine-code analyses that verify certain
+            properties of the generated code.
+        "#,
+        false,
+    );
+
+    // Stack probing options.
+
+    settings.add_bool(
+        "enable_probestack",
+        "Enable the use of stack probes for supported calling conventions.",
+        "",
+        false,
+    );
+
+    settings.add_num(
+        "probestack_size_log2",
+        "The log2 of the size of the stack guard region.",
+        r#"
+            Stack frames larger than this size will have stack overflow checked
+            by calling the probestack function.
+
+            The default is 12, which translates to a size of 4096.
+        "#,
+        12,
+    );
+
+    settings.add_enum(
+        "probestack_strategy",
+        "Controls what kinds of stack probes are emitted.",
+        r#"
+            Supported strategies:
+
+            - `outline`: Always emits stack probes as calls to a probe stack function.
+            - `inline`: Always emits inline stack probes.
+        "#,
+        vec!["outline", "inline"],
+    );
+
+    // Spectre options. (Only read by wasmtime-cranelift)
+    // FIXME move configuration out of Cranelift into Wasmtime
+
+    settings.add_bool(
+        "enable_heap_access_spectre_mitigation",
+        "Enable Spectre mitigation on heap bounds checks.",
+        r#"
+            This is a no-op for any heap that needs no bounds checks; e.g.,
+            if the limit is static and the guard region is large enough that
+            the index cannot reach past it.
+
+            This option is enabled by default because it is highly
+            recommended for secure sandboxing. The embedder should consider
+            the security implications carefully before disabling this option.
+        "#,
+        true,
+    );
+
+    settings.add_bool(
+        "enable_table_access_spectre_mitigation",
+        "Enable Spectre mitigation on table bounds checks.",
+        r#"
+            This option uses a conditional move to ensure that when a table
+            access index is bounds-checked and a conditional branch is used
+            for the out-of-bounds case, a misspeculation of that conditional
+            branch (falsely predicted in-bounds) will select an in-bounds
+            index to load on the speculative path.
+
+            This option is enabled by default because it is highly
+            recommended for secure sandboxing. The embedder should consider
+            the security implications carefully before disabling this option.
+        "#,
+        true,
+    );
+
+    settings.add_bool(
+        "enable_incremental_compilation_cache_checks",
+        "Enable additional checks for debugging the incremental compilation cache.",
+        r#"
+            Enables additional checks that are useful during development of the incremental
+            compilation cache. This should be mostly useful for Cranelift hackers, as well as for
+            helping to debug false incremental cache positives for embedders.
+
+            This option is disabled by default and requires enabling the "incremental-cache" Cargo
+            feature in cranelift-codegen.
+        "#,
+        false,
+    );
+
+    settings.add_num(
+        "bb_padding_log2_minus_one",
+        "The log2 of the size to insert dummy padding between basic blocks",
+        r#"
+            This is a debugging option for stressing various cases during code
+            generation without requiring large functions. This will insert
+            0-byte padding between basic blocks of the specified size.
+
+            The amount of padding inserted two raised to the power of this value
+            minus one. If this value is 0 then no padding is inserted.
+
+            The default for this option is 0 to insert no padding as it's only
+            intended for testing and development.
+        "#,
+        0,
+    );
+
+    settings.add_num(
+        "log2_min_function_alignment",
+        "The log2 of the minimum alignment of functions",
+        "The bigger of this value and the default alignment will be used as actual alignment.",
+        0,
+    );
+
+    // When adding new settings please check if they can also be added
+    // in cranelift/fuzzgen/src/lib.rs for fuzzing.
+    settings.build()
+}

data/ext/cargo-vendor/cranelift-codegen-shared-0.125.4/.cargo-checksum.json

@@ -0,0 +1 @@
+{"files":{".cargo_vcs_info.json":"5cb3be84310ae9a6001a240d53d5a82f78578286c09922bfc531546108f16b9b","Cargo.lock":"e372122142f922332ad7f054653d775baad3c1bfd7a5acd42aa5eb0857812059","Cargo.toml":"4767feccb943b6014b94942f8859f1fbed85902e1dbc5c4c2fa5ade6f576b0f1","Cargo.toml.orig":"5c8e0399e82b467ab5839c70c5aa5b6beebbe59b9ffe441602dff1eac3fa5aa1","LICENSE":"268872b9816f90fd8e85db5a28d33f8150ebb8dd016653fb39ef1f94f2686bc5","README.md":"a410bc2f5dcbde499c0cd299c2620bc8111e3c5b3fccdd9e2d85caf3c24fdab3","src/constant_hash.rs":"4dc1a4e6f31a2f25d41fc7ee4ed2ae94563a090cdc77d7bbd972aa4098bd4f01","src/constants.rs":"930ecd722ef9cef5e3a807bcab310034b1b6d17e6153e5c69a53858865b11c51","src/lib.rs":"317c5fad6b13ad2ef5b4fe5ac45a45e776dda246f293fe9f7f1248096ddfaedd"},"package":"3a50105aab667b5cc845f2be37c78475d7cc127cd8ec0a31f7b2b71d526099a7"}

data/ext/cargo-vendor/cranelift-codegen-shared-0.125.4/.cargo_vcs_info.json

@@ -0,0 +1,6 @@
+{
+  "git": {
+    "sha1": "4c22e15bade0a8590d8272f5be85426cb134601b"
+  },
+  "path_in_vcs": "cranelift/codegen/shared"
+}

data/ext/cargo-vendor/cranelift-codegen-shared-0.125.4/Cargo.lock

@@ -0,0 +1,7 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "cranelift-codegen-shared"
+version = "0.125.4"

data/ext/cargo-vendor/cranelift-codegen-shared-0.125.4/Cargo.toml

@@ -0,0 +1,34 @@
+# 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 = "2024"
+rust-version = "1.88.0"
+name = "cranelift-codegen-shared"
+version = "0.125.4"
+authors = ["The Cranelift Project Developers"]
+build = false
+autolib = false
+autobins = false
+autoexamples = false
+autotests = false
+autobenches = false
+description = "For code shared between cranelift-codegen-meta and cranelift-codegen"
+readme = "README.md"
+license = "Apache-2.0 WITH LLVM-exception"
+repository = "https://github.com/bytecodealliance/wasmtime"
+resolver = "2"
+
+[lib]
+name = "cranelift_codegen_shared"
+path = "src/lib.rs"
+
+[dependencies]

data/ext/cargo-vendor/cranelift-codegen-shared-0.125.4/Cargo.toml.orig

@@ -0,0 +1,14 @@
+[package]
+authors = ["The Cranelift Project Developers"]
+name = "cranelift-codegen-shared"
+version = "0.125.4"
+description = "For code shared between cranelift-codegen-meta and cranelift-codegen"
+license = "Apache-2.0 WITH LLVM-exception"
+repository = "https://github.com/bytecodealliance/wasmtime"
+readme = "README.md"
+edition.workspace = true
+rust-version.workspace = true
+
+[dependencies]
+# Since this is a shared dependency of several packages, please strive to keep this dependency-free
+# when no features are enabled.

data/ext/cargo-vendor/cranelift-control-0.125.4/.cargo-checksum.json

@@ -0,0 +1 @@
+{"files":{".cargo_vcs_info.json":"b9d6488b8e76fbaef916115f6b742454b8bc442baf41740952d8ab91509b34df","Cargo.lock":"aa3394e330e7a809beb188ed464939fd0ea18b9c8b8d5dea7d2a10f7a355bce0","Cargo.toml":"a4ef8c7c6c8d8a292e5fa41373556a6a2db426fb31f1c1b77522cf05b47e5870","Cargo.toml.orig":"61772831bd2e685523266e068fb8dcd1ebbba684fa72585881aea464f9070d96","LICENSE":"268872b9816f90fd8e85db5a28d33f8150ebb8dd016653fb39ef1f94f2686bc5","README.md":"9266e3c8ff78a0f5948eb24292a2b51ec272d9417816ffe23de0b1ea4589acb4","src/chaos.rs":"dde1ce4e45dab264fa611734fc3190b9710e043c83e635d67c044876e8dc9d75","src/lib.rs":"c8d0ed8144b1605446d722cf530fc96e43ac83a9c32949a6b6d7a4da65f8aa92","src/zero_sized.rs":"523f2daf803a1869b6f5728a0e6f5b7b4b88455cdcfd9b47bb63ff7d3538c656"},"package":"6adcc7aa7c0bc1727176a6f2d99c28a9e79a541ccd5ca911a0cb352da8befa36"}

data/ext/cargo-vendor/cranelift-control-0.125.4/.cargo_vcs_info.json

@@ -0,0 +1,6 @@
+{
+  "git": {
+    "sha1": "4c22e15bade0a8590d8272f5be85426cb134601b"
+  },
+  "path_in_vcs": "cranelift/control"
+}

data/ext/cargo-vendor/cranelift-control-0.125.4/Cargo.lock

@@ -0,0 +1,16 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "arbitrary"
+version = "1.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dde20b3d026af13f561bdd0f15edf01fc734f0dafcedbaf42bba506a9517f223"
+
+[[package]]
+name = "cranelift-control"
+version = "0.125.4"
+dependencies = [
+ "arbitrary",
+]

data/ext/cargo-vendor/cranelift-control-0.125.4/Cargo.toml

@@ -0,0 +1,45 @@
+# 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 = "2024"
+rust-version = "1.88.0"
+name = "cranelift-control"
+version = "0.125.4"
+authors = ["The Cranelift Project Developers"]
+build = false
+autolib = false
+autobins = false
+autoexamples = false
+autotests = false
+autobenches = false
+description = "White-box fuzz testing framework"
+readme = "README.md"
+keywords = [
+    "fuzz",
+    "test",
+]
+license = "Apache-2.0 WITH LLVM-exception"
+repository = "https://github.com/bytecodealliance/wasmtime"
+resolver = "2"
+
+[features]
+chaos = ["fuzz"]
+default = ["fuzz"]
+fuzz = ["dep:arbitrary"]
+
+[lib]
+name = "cranelift_control"
+path = "src/lib.rs"
+
+[dependencies.arbitrary]
+version = "1.4.0"
+optional = true

data/ext/cargo-vendor/cranelift-control-0.125.4/Cargo.toml.orig

@@ -0,0 +1,25 @@
+[package]
+authors = ["The Cranelift Project Developers"]
+name = "cranelift-control"
+version = "0.125.4"
+description = "White-box fuzz testing framework"
+license = "Apache-2.0 WITH LLVM-exception"
+repository = "https://github.com/bytecodealliance/wasmtime"
+readme = "README.md"
+keywords = ["fuzz", "test"]
+edition.workspace = true
+rust-version.workspace = true
+
+[dependencies]
+arbitrary = { workspace = true, optional = true }
+
+[features]
+default = ["fuzz"]
+
+# Enable fuzzing support with `arbitrary`. Does not work on `no_std` targets.
+fuzz = ["dep:arbitrary"]
+
+# Turn on chaos mode.
+# Without this feature, a zero-sized dummy will be compiled
+# for the control plane.
+chaos = ["fuzz"]

data/ext/cargo-vendor/cranelift-entity-0.125.4/.cargo-checksum.json

@@ -0,0 +1 @@
+{"files":{".cargo_vcs_info.json":"fe465f3e12cf40b68a375ce8861512bde2c2a4a5f36aef2f08b8137977d40713","Cargo.lock":"19d5a3a6827cd798155428627b18069462658f2396b8b81693b74eb463b29252","Cargo.toml":"1ecb976ac495916a9508455c264aead5f9e047b3b4c1980ea4c084d742b5a3cb","Cargo.toml.orig":"9e6c0ade9fc1dba2ff120729317039b84e17a147046143ebc8d5f777ff9d1728","LICENSE":"268872b9816f90fd8e85db5a28d33f8150ebb8dd016653fb39ef1f94f2686bc5","README.md":"96ceffbfd88fb06e3b41aa4d3087cffbbf8441d04eba7ab09662a72ab600a321","src/boxed_slice.rs":"f8d0afbb525314d1b41d5aa5ac5885bff59f4d037007d4fae28f2a915c8591d6","src/iter.rs":"61fefdc49cafad4cacba5f5a7ad2396a23160642c688a7f0b0734277391847cd","src/keys.rs":"b8c2fba26dee15bf3d1880bb2b41e8d66fe1428d242ee6d9fd30ee94bbd0407d","src/lib.rs":"4f21b2b56488851a5a60b5eee415d40207d742d09c30832da15c7ae55d2e7fb1","src/list.rs":"646eefcba9b4aafde5e243d8a7f4e0f998867d0197d69504a598dbd4c16813a6","src/map.rs":"443122e2f6f8f031e0697e87e46ac40f451239cdeb810fcb32bf5e4c4ec53bf0","src/packed_option.rs":"cdb263c64a83fbc8fea911c6c815f5c932b5c66f961bc11762fe3f83ecd61304","src/primary.rs":"c773f3fcffbdff827d81f7c6f44ec740d2fce4b762f80c8a46a081fc5ba1ee9b","src/set.rs":"1f316b6baf435bfe0d035bdfcf23b8944a6d97a2c9db28704b014b37a230a0ff","src/sparse.rs":"0bd83ff243d3e2ffc5807920289461333ce54e7f9b978f5d341e4212811caefa"},"package":"981b56af777f9a34ea6dcce93255125776d391410c2a68b75bed5941b714fa15"}

data/ext/cargo-vendor/cranelift-entity-0.125.4/.cargo_vcs_info.json

@@ -0,0 +1,6 @@
+{
+  "git": {
+    "sha1": "4c22e15bade0a8590d8272f5be85426cb134601b"
+  },
+  "path_in_vcs": "cranelift/entity"
+}

data/ext/cargo-vendor/cranelift-entity-0.125.4/Cargo.lock

@@ -0,0 +1,77 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "cranelift-bitset"
+version = "0.125.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ac0790c83cfdab95709c5d0105fd888221e3af9049a7d7ec376ec901ab4e4dba"
+dependencies = [
+ "serde",
+ "serde_derive",
+]
+
+[[package]]
+name = "cranelift-entity"
+version = "0.125.4"
+dependencies = [
+ "cranelift-bitset",
+ "serde",
+ "serde_derive",
+]
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.92"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "37d3544b3f2748c54e147655edb5025752e2303145b5aefb3c3ea2c78b973bb0"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.36"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0fa76aaf39101c457836aec0ce2316dbdc3ab723cdda1c6bd4e6ad4208acaca7"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "serde"
+version = "1.0.215"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6513c1ad0b11a9376da888e3e0baa0077f1aed55c17f50e7b2397136129fb88f"
+dependencies = [
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.215"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ad1e866f866923f252f05c889987993144fb74e722403468a4ebd70c3cd756c0"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "syn"
+version = "2.0.100"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b09a44accad81e1ba1cd74a32461ba89dee89095ba17b32f5d03683b1b1fc2a0"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e5464a87b239f13a63a501f2701565754bae92d243d4bb7eb12f6d57d2269bf4"