Bug 1577717: Bump Cranelift to fc88520b88bcaad4e4a92f28a5e17347af20edbd; r=jseward
authorBenjamin Bouvier <benj@benj.me>
Fri, 30 Aug 2019 15:12:56 +0000
changeset 551390 47f2b38ec1962f6a467c3f24b4e5ca5ca52bc9a0
parent 551389 c30a832fe71557263fd2233ae1f3ba97be2a600c
child 551391 39b55da47051eb9be3f4ad663ee1c4deb1c51245
push id11865
push userbtara@mozilla.com
push dateMon, 02 Sep 2019 08:54:37 +0000
treeherdermozilla-beta@37f59c4671b3 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersjseward
bugs1577717
milestone70.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Bug 1577717: Bump Cranelift to fc88520b88bcaad4e4a92f28a5e17347af20edbd; r=jseward Differential Revision: https://phabricator.services.mozilla.com/D44116
.cargo/config
Cargo.lock
Cargo.toml
third_party/rust/cranelift-codegen-meta/.cargo-checksum.json
third_party/rust/cranelift-codegen-meta/src/gen_binemit.rs
third_party/rust/cranelift-codegen-meta/src/gen_encodings.rs
third_party/rust/cranelift-codegen-meta/src/isa/x86/encodings.rs
third_party/rust/cranelift-codegen-meta/src/isa/x86/recipes.rs
third_party/rust/cranelift-codegen-meta/src/isa/x86/settings.rs
third_party/rust/cranelift-codegen-meta/src/shared/formats.rs
third_party/rust/cranelift-codegen-meta/src/shared/immediates.rs
third_party/rust/cranelift-codegen-meta/src/shared/instructions.rs
third_party/rust/cranelift-codegen/.cargo-checksum.json
third_party/rust/cranelift-codegen/src/binemit/memorysink.rs
third_party/rust/cranelift-codegen/src/binemit/mod.rs
third_party/rust/cranelift-codegen/src/binemit/relaxation.rs
third_party/rust/cranelift-codegen/src/ir/constant.rs
third_party/rust/cranelift-codegen/src/ir/dfg.rs
third_party/rust/cranelift-codegen/src/ir/entities.rs
third_party/rust/cranelift-codegen/src/ir/function.rs
third_party/rust/cranelift-codegen/src/ir/immediates.rs
third_party/rust/cranelift-codegen/src/ir/mod.rs
third_party/rust/cranelift-codegen/src/isa/x86/binemit.rs
third_party/rust/cranelift-codegen/src/verifier/mod.rs
third_party/rust/cranelift-codegen/src/write.rs
third_party/rust/cranelift-wasm/.cargo-checksum.json
third_party/rust/cranelift-wasm/src/code_translator.rs
third_party/rust/cranelift-wasm/tests/wasm_testsuite.rs
--- a/.cargo/config
+++ b/.cargo/config
@@ -20,17 +20,17 @@ replace-with = "vendored-sources"
 [source."https://github.com/NikVolf/tokio-named-pipes"]
 branch = "stable"
 git = "https://github.com/NikVolf/tokio-named-pipes"
 replace-with = "vendored-sources"
 
 [source."https://github.com/CraneStation/Cranelift"]
 git = "https://github.com/CraneStation/Cranelift"
 replace-with = "vendored-sources"
-rev = "164f91a1f473e582e18e48d056c51787d9a1c24d"
+rev = "fc88520b88bcaad4e4a92f28a5e17347af20edbd"
 
 [source.crates-io]
 replace-with = "vendored-sources"
 
 # Take advantage of the fact that cargo will treat lines starting with #
 # as comments to add preprocessing directives for when this file is included
 # from .cargo/config.in.
 #define REPLACE_NAME vendored-sources
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -193,18 +193,18 @@ dependencies = [
  "libc 0.2.60 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
 [[package]]
 name = "baldrdash"
 version = "0.1.0"
 dependencies = [
  "bindgen 0.51.0 (registry+https://github.com/rust-lang/crates.io-index)",
- "cranelift-codegen 0.40.0 (git+https://github.com/CraneStation/Cranelift?rev=164f91a1f473e582e18e48d056c51787d9a1c24d)",
- "cranelift-wasm 0.40.0 (git+https://github.com/CraneStation/Cranelift?rev=164f91a1f473e582e18e48d056c51787d9a1c24d)",
+ "cranelift-codegen 0.40.0 (git+https://github.com/CraneStation/Cranelift?rev=fc88520b88bcaad4e4a92f28a5e17347af20edbd)",
+ "cranelift-wasm 0.40.0 (git+https://github.com/CraneStation/Cranelift?rev=fc88520b88bcaad4e4a92f28a5e17347af20edbd)",
  "env_logger 0.5.6 (registry+https://github.com/rust-lang/crates.io-index)",
  "log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
  "target-lexicon 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
 [[package]]
 name = "base64"
 version = "0.9.3"
@@ -606,66 +606,66 @@ version = "0.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
  "cose 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
 [[package]]
 name = "cranelift-bforest"
 version = "0.40.0"
-source = "git+https://github.com/CraneStation/Cranelift?rev=164f91a1f473e582e18e48d056c51787d9a1c24d#164f91a1f473e582e18e48d056c51787d9a1c24d"
-dependencies = [
- "cranelift-entity 0.40.0 (git+https://github.com/CraneStation/Cranelift?rev=164f91a1f473e582e18e48d056c51787d9a1c24d)",
+source = "git+https://github.com/CraneStation/Cranelift?rev=fc88520b88bcaad4e4a92f28a5e17347af20edbd#fc88520b88bcaad4e4a92f28a5e17347af20edbd"
+dependencies = [
+ "cranelift-entity 0.40.0 (git+https://github.com/CraneStation/Cranelift?rev=fc88520b88bcaad4e4a92f28a5e17347af20edbd)",
 ]
 
 [[package]]
 name = "cranelift-codegen"
 version = "0.40.0"
-source = "git+https://github.com/CraneStation/Cranelift?rev=164f91a1f473e582e18e48d056c51787d9a1c24d#164f91a1f473e582e18e48d056c51787d9a1c24d"
-dependencies = [
- "cranelift-bforest 0.40.0 (git+https://github.com/CraneStation/Cranelift?rev=164f91a1f473e582e18e48d056c51787d9a1c24d)",
- "cranelift-codegen-meta 0.40.0 (git+https://github.com/CraneStation/Cranelift?rev=164f91a1f473e582e18e48d056c51787d9a1c24d)",
- "cranelift-entity 0.40.0 (git+https://github.com/CraneStation/Cranelift?rev=164f91a1f473e582e18e48d056c51787d9a1c24d)",
+source = "git+https://github.com/CraneStation/Cranelift?rev=fc88520b88bcaad4e4a92f28a5e17347af20edbd#fc88520b88bcaad4e4a92f28a5e17347af20edbd"
+dependencies = [
+ "cranelift-bforest 0.40.0 (git+https://github.com/CraneStation/Cranelift?rev=fc88520b88bcaad4e4a92f28a5e17347af20edbd)",
+ "cranelift-codegen-meta 0.40.0 (git+https://github.com/CraneStation/Cranelift?rev=fc88520b88bcaad4e4a92f28a5e17347af20edbd)",
+ "cranelift-entity 0.40.0 (git+https://github.com/CraneStation/Cranelift?rev=fc88520b88bcaad4e4a92f28a5e17347af20edbd)",
  "failure 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
  "failure_derive 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
  "log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
  "target-lexicon 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
 [[package]]
 name = "cranelift-codegen-meta"
 version = "0.40.0"
-source = "git+https://github.com/CraneStation/Cranelift?rev=164f91a1f473e582e18e48d056c51787d9a1c24d#164f91a1f473e582e18e48d056c51787d9a1c24d"
-dependencies = [
- "cranelift-entity 0.40.0 (git+https://github.com/CraneStation/Cranelift?rev=164f91a1f473e582e18e48d056c51787d9a1c24d)",
+source = "git+https://github.com/CraneStation/Cranelift?rev=fc88520b88bcaad4e4a92f28a5e17347af20edbd#fc88520b88bcaad4e4a92f28a5e17347af20edbd"
+dependencies = [
+ "cranelift-entity 0.40.0 (git+https://github.com/CraneStation/Cranelift?rev=fc88520b88bcaad4e4a92f28a5e17347af20edbd)",
 ]
 
 [[package]]
 name = "cranelift-entity"
 version = "0.40.0"
-source = "git+https://github.com/CraneStation/Cranelift?rev=164f91a1f473e582e18e48d056c51787d9a1c24d#164f91a1f473e582e18e48d056c51787d9a1c24d"
+source = "git+https://github.com/CraneStation/Cranelift?rev=fc88520b88bcaad4e4a92f28a5e17347af20edbd#fc88520b88bcaad4e4a92f28a5e17347af20edbd"
 
 [[package]]
 name = "cranelift-frontend"
 version = "0.40.0"
-source = "git+https://github.com/CraneStation/Cranelift?rev=164f91a1f473e582e18e48d056c51787d9a1c24d#164f91a1f473e582e18e48d056c51787d9a1c24d"
-dependencies = [
- "cranelift-codegen 0.40.0 (git+https://github.com/CraneStation/Cranelift?rev=164f91a1f473e582e18e48d056c51787d9a1c24d)",
+source = "git+https://github.com/CraneStation/Cranelift?rev=fc88520b88bcaad4e4a92f28a5e17347af20edbd#fc88520b88bcaad4e4a92f28a5e17347af20edbd"
+dependencies = [
+ "cranelift-codegen 0.40.0 (git+https://github.com/CraneStation/Cranelift?rev=fc88520b88bcaad4e4a92f28a5e17347af20edbd)",
  "log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
  "target-lexicon 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
 [[package]]
 name = "cranelift-wasm"
 version = "0.40.0"
-source = "git+https://github.com/CraneStation/Cranelift?rev=164f91a1f473e582e18e48d056c51787d9a1c24d#164f91a1f473e582e18e48d056c51787d9a1c24d"
-dependencies = [
- "cranelift-codegen 0.40.0 (git+https://github.com/CraneStation/Cranelift?rev=164f91a1f473e582e18e48d056c51787d9a1c24d)",
- "cranelift-entity 0.40.0 (git+https://github.com/CraneStation/Cranelift?rev=164f91a1f473e582e18e48d056c51787d9a1c24d)",
- "cranelift-frontend 0.40.0 (git+https://github.com/CraneStation/Cranelift?rev=164f91a1f473e582e18e48d056c51787d9a1c24d)",
+source = "git+https://github.com/CraneStation/Cranelift?rev=fc88520b88bcaad4e4a92f28a5e17347af20edbd#fc88520b88bcaad4e4a92f28a5e17347af20edbd"
+dependencies = [
+ "cranelift-codegen 0.40.0 (git+https://github.com/CraneStation/Cranelift?rev=fc88520b88bcaad4e4a92f28a5e17347af20edbd)",
+ "cranelift-entity 0.40.0 (git+https://github.com/CraneStation/Cranelift?rev=fc88520b88bcaad4e4a92f28a5e17347af20edbd)",
+ "cranelift-frontend 0.40.0 (git+https://github.com/CraneStation/Cranelift?rev=fc88520b88bcaad4e4a92f28a5e17347af20edbd)",
  "failure 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
  "failure_derive 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
  "log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
  "wasmparser 0.37.0 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
 [[package]]
 name = "crc"
@@ -3912,22 +3912,22 @@ dependencies = [
 "checksum constant_time_eq 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "8ff012e225ce166d4422e0e78419d901719760f62ae2b7969ca6b564d1b54a9e"
 "checksum cookie 0.12.0 (registry+https://github.com/rust-lang/crates.io-index)" = "888604f00b3db336d2af898ec3c1d5d0ddf5e6d462220f2ededc33a87ac4bbd5"
 "checksum core-foundation 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)" = "4e2640d6d0bf22e82bed1b73c6aef8d5dd31e5abe6666c57e6d45e2649f4f887"
 "checksum core-foundation-sys 0.6.2 (registry+https://github.com/rust-lang/crates.io-index)" = "e7ca8a5221364ef15ce201e8ed2f609fc312682a8f4e0e3d4aa5879764e0fa3b"
 "checksum core-graphics 0.17.1 (registry+https://github.com/rust-lang/crates.io-index)" = "62ceafe1622ffc9a332199096841d0ff9912ec8cf8f9cde01e254a7d5217cd10"
 "checksum core-text 13.0.0 (registry+https://github.com/rust-lang/crates.io-index)" = "f3f46450d6f2397261af420b4ccce23807add2e45fa206410a03d66fb7f050ae"
 "checksum cose 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)" = "72fa26cb151d3ae4b70f63d67d0fed57ce04220feafafbae7f503bef7aae590d"
 "checksum cose-c 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)" = "49726015ab0ca765144fcca61e4a7a543a16b795a777fa53f554da2fffff9a94"
-"checksum cranelift-bforest 0.40.0 (git+https://github.com/CraneStation/Cranelift?rev=164f91a1f473e582e18e48d056c51787d9a1c24d)" = "<none>"
-"checksum cranelift-codegen 0.40.0 (git+https://github.com/CraneStation/Cranelift?rev=164f91a1f473e582e18e48d056c51787d9a1c24d)" = "<none>"
-"checksum cranelift-codegen-meta 0.40.0 (git+https://github.com/CraneStation/Cranelift?rev=164f91a1f473e582e18e48d056c51787d9a1c24d)" = "<none>"
-"checksum cranelift-entity 0.40.0 (git+https://github.com/CraneStation/Cranelift?rev=164f91a1f473e582e18e48d056c51787d9a1c24d)" = "<none>"
-"checksum cranelift-frontend 0.40.0 (git+https://github.com/CraneStation/Cranelift?rev=164f91a1f473e582e18e48d056c51787d9a1c24d)" = "<none>"
-"checksum cranelift-wasm 0.40.0 (git+https://github.com/CraneStation/Cranelift?rev=164f91a1f473e582e18e48d056c51787d9a1c24d)" = "<none>"
+"checksum cranelift-bforest 0.40.0 (git+https://github.com/CraneStation/Cranelift?rev=fc88520b88bcaad4e4a92f28a5e17347af20edbd)" = "<none>"
+"checksum cranelift-codegen 0.40.0 (git+https://github.com/CraneStation/Cranelift?rev=fc88520b88bcaad4e4a92f28a5e17347af20edbd)" = "<none>"
+"checksum cranelift-codegen-meta 0.40.0 (git+https://github.com/CraneStation/Cranelift?rev=fc88520b88bcaad4e4a92f28a5e17347af20edbd)" = "<none>"
+"checksum cranelift-entity 0.40.0 (git+https://github.com/CraneStation/Cranelift?rev=fc88520b88bcaad4e4a92f28a5e17347af20edbd)" = "<none>"
+"checksum cranelift-frontend 0.40.0 (git+https://github.com/CraneStation/Cranelift?rev=fc88520b88bcaad4e4a92f28a5e17347af20edbd)" = "<none>"
+"checksum cranelift-wasm 0.40.0 (git+https://github.com/CraneStation/Cranelift?rev=fc88520b88bcaad4e4a92f28a5e17347af20edbd)" = "<none>"
 "checksum crc 1.7.0 (registry+https://github.com/rust-lang/crates.io-index)" = "bd5d02c0aac6bd68393ed69e00bbc2457f3e89075c6349db7189618dc4ddc1d7"
 "checksum crc32fast 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "ba125de2af0df55319f41944744ad91c71113bf74a4646efff39afe1f6842db1"
 "checksum crossbeam-channel 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)" = "8d4f5844607ce8da3fff431e7dba56cda8bfcc570aa50bee36adba8a32b8cad7"
 "checksum crossbeam-deque 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)" = "05e44b8cf3e1a625844d1750e1f7820da46044ff6d28f4d43e455ba3e5bb2c13"
 "checksum crossbeam-epoch 0.7.1 (registry+https://github.com/rust-lang/crates.io-index)" = "04c9e3102cc2d69cd681412141b390abd55a362afc1540965dad0ad4d34280b4"
 "checksum crossbeam-queue 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "7c979cd6cfe72335896575c6b5688da489e420d36a27a0b9eb0c73db574b4a4b"
 "checksum crossbeam-utils 0.6.5 (registry+https://github.com/rust-lang/crates.io-index)" = "f8306fcef4a7b563b76b7dd949ca48f52bc1141aa067d2ea09565f3e2652aa5c"
 "checksum cssparser 0.25.7 (registry+https://github.com/rust-lang/crates.io-index)" = "a921abc45ea75c2c817d951caeda31b94539d09a6b5e8d58a857b3b35c9c3894"
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -58,16 +58,16 @@ codegen-units = 1
 
 [patch.crates-io]
 libudev-sys = { path = "dom/webauthn/libudev-sys" }
 winapi = { git = "https://github.com/froydnj/winapi-rs", branch = "aarch64" }
 packed_simd = { git = "https://github.com/hsivonen/packed_simd", branch = "rust_1_32" }
 
 [patch.crates-io.cranelift-codegen]
 git = "https://github.com/CraneStation/Cranelift"
-rev = "164f91a1f473e582e18e48d056c51787d9a1c24d"
+rev = "fc88520b88bcaad4e4a92f28a5e17347af20edbd"
 
 [patch.crates-io.cranelift-wasm]
 git = "https://github.com/CraneStation/Cranelift"
-rev = "164f91a1f473e582e18e48d056c51787d9a1c24d"
+rev = "fc88520b88bcaad4e4a92f28a5e17347af20edbd"
 
 [patch.crates-io.coreaudio-sys]
 path = "third_party/rust/coreaudio-sys"
--- a/third_party/rust/cranelift-codegen-meta/.cargo-checksum.json
+++ b/third_party/rust/cranelift-codegen-meta/.cargo-checksum.json
@@ -1,1 +1,1 @@
-{"files":{"Cargo.toml":"2ef029c7de319de8f2007c17a7b5baeddd980f37b8cc84197bad5332f6c97d9a","LICENSE":"268872b9816f90fd8e85db5a28d33f8150ebb8dd016653fb39ef1f94f2686bc5","README.md":"b123f056d0d458396679c5f7f2a16d2762af0258fcda4ac14b6655a95e5a0022","src/cdsl/ast.rs":"1c9bf45110e47710ea160f30b3f3b00b531a8d91ff365bae856dd9d44b928253","src/cdsl/cpu_modes.rs":"7c59ae347d6f9c769d6356fe49c8406934153eefa59d9bf37c182474fcbb9715","src/cdsl/encodings.rs":"da6fa16c95fe4a586c2d00ef4ccf79b4b0f64cd8923b3ca5a5a527da1e799a4f","src/cdsl/formats.rs":"811dcf12f6e9c5be72f18543675ff52c3996edd029064bd0643f878d2ceca3bd","src/cdsl/instructions.rs":"0e702c6d005ce209b46e9f883d02725acbc018bb90f8402c26c71b6bf61a42ed","src/cdsl/isa.rs":"9b6030a935f69b07726d239c23a78d654566785f1fed61ccefdaf7d4f0a97d0e","src/cdsl/mod.rs":"c85f62a7d8d6bedc81c673b8d02be01181f79f272dbc0325a76d52e7eec732e8","src/cdsl/operands.rs":"1cda258798d861c4f467783b5c70c1202a57f554861017eead6477af2ee34063","src/cdsl/recipes.rs":"9f50f29f243f2ed8dbca3ef8b2722e9671bc164b2956254a95ed62641315eab7","src/cdsl/regs.rs":"8a92798a92b2c34c5e572e03602454c72a896d31ac301f15f43d17c101d4da6e","src/cdsl/settings.rs":"7da3c5a9df8e47ed6ca7f1d820e28eae45e783f3759f6c55730d2f17d88f1013","src/cdsl/type_inference.rs":"695d4fd2720f43569a52f29998bd92562951f0b4e7844cc0a239640e0c7d0b0f","src/cdsl/types.rs":"3418eb1f5d77fd3ba586b089c0d77ee45f4e581b1a6e06ec4feeddd9d2589239","src/cdsl/typevar.rs":"c66b14b43baba2e7940b74ada263ab65455c2f46cc06de3990e88d790bb061d0","src/cdsl/xform.rs":"64e9b70ef1265c0331ee9d71c1a1f33dba3f6975b1639385c34d68456cda0e0e","src/constant_hash.rs":"66d6f42c1e98cd4dbc95009997dc00256b57c11d2c2d9eac63b33e458c68a56f","src/default_map.rs":"8bbd6f4d9f93ef2126538cda633e6d9c80a5c7dc79b8d5a759c8be1fe2dbc605","src/error.rs":"5110a4e3c1e97396ba02d9f5abbb8af4b586f0cc4d33a5c2473f1718cc4bef05","src/gen_binemit.rs":"51d661541c6226d2ed8f4724813f66effd6124af9af89c66137a8b55edd950fd","src/gen_encodings.rs":"024b6ea8086fa1559333245753e909f306adeab7c8dfdc915610877413cba585","src/gen_inst.rs":"e3a54b53f4a3d2d98474094d0d662c4ba66c594f876f68562e9ba6ddc2d71226","src/gen_legalizer.rs":"e02c9f49ba9fa2bb04dbf3137011d5457c187fbdffab971b0be01693c4b83a9b","src/gen_registers.rs":"a544a2b91fafe08639e39e50bea0892fda89fe2f6eaf111b2d5f3e98e4d07b86","src/gen_settings.rs":"765ca86fa735342c1875021c34a92cbc39836ba3ad1c12aa615204372a1f7b61","src/gen_types.rs":"c062eaf3a2ed7368b87213922906107bbaec184fe821184a34dacb4e5b0fc3dc","src/isa/arm32/mod.rs":"a2500871fb270e5624f5561f24fe510f08708cdca2ab1c3163848b67694f7a7a","src/isa/arm64/mod.rs":"dc210e8dc9f179d87d2c5a72d7795a9e34bb30afb91c8053c362d43635629d19","src/isa/mod.rs":"fce60d19dd3c099ebee3ac5ae64a2bee363f13da9ff5a4960d3c1a0bee71d29a","src/isa/riscv/encodings.rs":"d53f80b2f166e19945c0c2c89a988a1b26d393f571212a09c5abcd9e694e4857","src/isa/riscv/mod.rs":"895492f0f379cfb02aba1cbb9759dc489bbb4d51ec40759af9f4d71c45c17a86","src/isa/riscv/recipes.rs":"8edffb212f1e5174c3e148a49311f2b7e2a1ac79a5b1ea9b641d4f88aa1c3040","src/isa/x86/encodings.rs":"37ea803b62dc4bcec2b9eee65366aa2f2fb3bfddd220ab926dc691a832b2392a","src/isa/x86/instructions.rs":"eea5fa7dd804d435dfdf289fc47f4bcc77db8dfce068d78d0a428155604b9626","src/isa/x86/legalize.rs":"192d7b9dc61e967165e43bc6da424316868a576b35aad2455c4465733c0d56b8","src/isa/x86/mod.rs":"6ed9f102238c1cb9029ec953e37629767438580cf9df8b4f2d1eace75ecd86fc","src/isa/x86/recipes.rs":"28543b64e2b0476fe84ccedb9bbc0ebec8592ecc756329f6a57197be9d58c0da","src/isa/x86/registers.rs":"c0bc60336a8c8b7b4db92dc623e9419a60af14dd6252f0b19e227e46f7166178","src/isa/x86/settings.rs":"134386d3719d8559a4df1a304c76b350cfaf79877d9894b95630c80e7b72fb50","src/lib.rs":"bc458358fd81d092f368b243d07682259dbed7a336b1eed5bcdf5228368289e9","src/shared/entities.rs":"80b8ff57a09c7b2f9dab755abbcc2738317de474776fe1de0d2a581310aa9af8","src/shared/formats.rs":"ae566a4970d7067165618d2a24a3a46444e21f8a2ac1cff767b2f70420fc2bae","src/shared/immediates.rs":"804c4c9ffa2fe55d90279ee158aaa6bd6c7f0c604d63d7457a98e82269cec9a7","src/shared/instructions.rs":"b2d8dbc2503ec3dfa8101ecddc34126e852b9e397f6ea11e5a5ecf3d8d7d27ae","src/shared/legalize.rs":"1c32c28f603b11f89e1ba9c4d301b0b8036fd81254d227836202b84573a9a446","src/shared/mod.rs":"f5bb50d8292e46380afdd83a320cb5d6021e1483741e67b1e277053c28f9b943","src/shared/settings.rs":"e2696406c7c699e125fc629d6634c75cedf96ca76871fe4e9c0adbe03eead037","src/shared/types.rs":"9d08f21523867acb89d23ce6ac60681babb0a141068c0a54948491df6644a2f3","src/srcgen.rs":"79fee2f603b33f76f7c9c8b9452c745a363d732c40c0814d84001ff3ef805677","src/unique_table.rs":"90b7203b29241a1ede70f0a3e50d96799e0b41d8f7455170d6ffb127f87f3cc3"},"package":null}
\ No newline at end of file
+{"files":{"Cargo.toml":"2ef029c7de319de8f2007c17a7b5baeddd980f37b8cc84197bad5332f6c97d9a","LICENSE":"268872b9816f90fd8e85db5a28d33f8150ebb8dd016653fb39ef1f94f2686bc5","README.md":"b123f056d0d458396679c5f7f2a16d2762af0258fcda4ac14b6655a95e5a0022","src/cdsl/ast.rs":"1c9bf45110e47710ea160f30b3f3b00b531a8d91ff365bae856dd9d44b928253","src/cdsl/cpu_modes.rs":"7c59ae347d6f9c769d6356fe49c8406934153eefa59d9bf37c182474fcbb9715","src/cdsl/encodings.rs":"da6fa16c95fe4a586c2d00ef4ccf79b4b0f64cd8923b3ca5a5a527da1e799a4f","src/cdsl/formats.rs":"811dcf12f6e9c5be72f18543675ff52c3996edd029064bd0643f878d2ceca3bd","src/cdsl/instructions.rs":"0e702c6d005ce209b46e9f883d02725acbc018bb90f8402c26c71b6bf61a42ed","src/cdsl/isa.rs":"9b6030a935f69b07726d239c23a78d654566785f1fed61ccefdaf7d4f0a97d0e","src/cdsl/mod.rs":"c85f62a7d8d6bedc81c673b8d02be01181f79f272dbc0325a76d52e7eec732e8","src/cdsl/operands.rs":"1cda258798d861c4f467783b5c70c1202a57f554861017eead6477af2ee34063","src/cdsl/recipes.rs":"9f50f29f243f2ed8dbca3ef8b2722e9671bc164b2956254a95ed62641315eab7","src/cdsl/regs.rs":"8a92798a92b2c34c5e572e03602454c72a896d31ac301f15f43d17c101d4da6e","src/cdsl/settings.rs":"7da3c5a9df8e47ed6ca7f1d820e28eae45e783f3759f6c55730d2f17d88f1013","src/cdsl/type_inference.rs":"695d4fd2720f43569a52f29998bd92562951f0b4e7844cc0a239640e0c7d0b0f","src/cdsl/types.rs":"3418eb1f5d77fd3ba586b089c0d77ee45f4e581b1a6e06ec4feeddd9d2589239","src/cdsl/typevar.rs":"c66b14b43baba2e7940b74ada263ab65455c2f46cc06de3990e88d790bb061d0","src/cdsl/xform.rs":"64e9b70ef1265c0331ee9d71c1a1f33dba3f6975b1639385c34d68456cda0e0e","src/constant_hash.rs":"66d6f42c1e98cd4dbc95009997dc00256b57c11d2c2d9eac63b33e458c68a56f","src/default_map.rs":"8bbd6f4d9f93ef2126538cda633e6d9c80a5c7dc79b8d5a759c8be1fe2dbc605","src/error.rs":"5110a4e3c1e97396ba02d9f5abbb8af4b586f0cc4d33a5c2473f1718cc4bef05","src/gen_binemit.rs":"80c27e9c66d2ac3dc8a41cc545f046bd4297ba6530805539e86461984fd2667d","src/gen_encodings.rs":"9fb5ebe9a926ad7d45614c3bcfce0f0cadea3477f3e9bea45dfa63baf947e73f","src/gen_inst.rs":"e3a54b53f4a3d2d98474094d0d662c4ba66c594f876f68562e9ba6ddc2d71226","src/gen_legalizer.rs":"e02c9f49ba9fa2bb04dbf3137011d5457c187fbdffab971b0be01693c4b83a9b","src/gen_registers.rs":"a544a2b91fafe08639e39e50bea0892fda89fe2f6eaf111b2d5f3e98e4d07b86","src/gen_settings.rs":"765ca86fa735342c1875021c34a92cbc39836ba3ad1c12aa615204372a1f7b61","src/gen_types.rs":"c062eaf3a2ed7368b87213922906107bbaec184fe821184a34dacb4e5b0fc3dc","src/isa/arm32/mod.rs":"a2500871fb270e5624f5561f24fe510f08708cdca2ab1c3163848b67694f7a7a","src/isa/arm64/mod.rs":"dc210e8dc9f179d87d2c5a72d7795a9e34bb30afb91c8053c362d43635629d19","src/isa/mod.rs":"fce60d19dd3c099ebee3ac5ae64a2bee363f13da9ff5a4960d3c1a0bee71d29a","src/isa/riscv/encodings.rs":"d53f80b2f166e19945c0c2c89a988a1b26d393f571212a09c5abcd9e694e4857","src/isa/riscv/mod.rs":"895492f0f379cfb02aba1cbb9759dc489bbb4d51ec40759af9f4d71c45c17a86","src/isa/riscv/recipes.rs":"8edffb212f1e5174c3e148a49311f2b7e2a1ac79a5b1ea9b641d4f88aa1c3040","src/isa/x86/encodings.rs":"9bdb43f7bb9d639f4cf073e3865a0ad03d98de45b91d637716365dc0c85abbd7","src/isa/x86/instructions.rs":"eea5fa7dd804d435dfdf289fc47f4bcc77db8dfce068d78d0a428155604b9626","src/isa/x86/legalize.rs":"192d7b9dc61e967165e43bc6da424316868a576b35aad2455c4465733c0d56b8","src/isa/x86/mod.rs":"6ed9f102238c1cb9029ec953e37629767438580cf9df8b4f2d1eace75ecd86fc","src/isa/x86/recipes.rs":"e3d6d95bc56c92c83985fd6f20415e04b5da89270ba6069e6d1410bc3c720d7a","src/isa/x86/registers.rs":"c0bc60336a8c8b7b4db92dc623e9419a60af14dd6252f0b19e227e46f7166178","src/isa/x86/settings.rs":"4e84ff135d6f21595bbd8f56d2e561abd3c123566f2332ac93bb4a9c627f0c00","src/lib.rs":"bc458358fd81d092f368b243d07682259dbed7a336b1eed5bcdf5228368289e9","src/shared/entities.rs":"80b8ff57a09c7b2f9dab755abbcc2738317de474776fe1de0d2a581310aa9af8","src/shared/formats.rs":"9c51381b531576c577a92abba9f825a8b60aaaedba53f39d2ea3be879987a466","src/shared/immediates.rs":"9a83d69734d06279bb20050c0f610caf06322d3cb11591cdd0ebf8724274b792","src/shared/instructions.rs":"029791f400bdb0cbdfa9d1ac544063d69c473e2ceecda3ab3e9b483579a53395","src/shared/legalize.rs":"1c32c28f603b11f89e1ba9c4d301b0b8036fd81254d227836202b84573a9a446","src/shared/mod.rs":"f5bb50d8292e46380afdd83a320cb5d6021e1483741e67b1e277053c28f9b943","src/shared/settings.rs":"e2696406c7c699e125fc629d6634c75cedf96ca76871fe4e9c0adbe03eead037","src/shared/types.rs":"9d08f21523867acb89d23ce6ac60681babb0a141068c0a54948491df6644a2f3","src/srcgen.rs":"79fee2f603b33f76f7c9c8b9452c745a363d732c40c0814d84001ff3ef805677","src/unique_table.rs":"90b7203b29241a1ede70f0a3e50d96799e0b41d8f7455170d6ffb127f87f3cc3"},"package":null}
\ No newline at end of file
--- a/third_party/rust/cranelift-codegen-meta/src/gen_binemit.rs
+++ b/third_party/rust/cranelift-codegen-meta/src/gen_binemit.rs
@@ -132,17 +132,17 @@ fn unwrap_values(
                 fmtln!(fmt, "let {} = StackRef::masked(", v);
                 fmt.indent(|fmt| {
                     fmtln!(
                         fmt,
                         "divert.stack({}[{}], &func.locations),",
                         values_slice,
                         i
                     );
-                    fmt.line(format!("{}, ", stack.stack_base_mask()));
+                    fmt.line(format!("{},", stack.stack_base_mask()));
                     fmt.line("&func.stack_slots,");
                 });
                 fmt.line(").unwrap();");
             }
             _ => {}
         }
     }
     varlist
--- a/third_party/rust/cranelift-codegen-meta/src/gen_encodings.rs
+++ b/third_party/rust/cranelift-codegen-meta/src/gen_encodings.rs
@@ -137,16 +137,17 @@ fn emit_instp(instp: &InstructionPredica
 /// Emit private functions for checking recipe predicates as well as a static `RECIPE_PREDICATES`
 /// array indexed by recipe number.
 ///
 /// A recipe predicate is a combination of an ISA predicate and an instruction predicate. Many
 /// recipes have identical predicates.
 fn emit_recipe_predicates(isa: &TargetIsa, fmt: &mut Formatter) {
     let mut predicate_names = HashMap::new();
 
+    fmt.comment(format!("{} recipe predicates.", isa.name));
     for recipe in isa.recipes.values() {
         let (isap, instp) = match (&recipe.isa_predicate, &recipe.inst_predicate) {
             (None, None) => continue,
             (isap, instp) if predicate_names.contains_key(&(isap, instp)) => continue,
             (isap, instp) => (isap, instp),
         };
 
         let func_name = format!("recipe_predicate_{}", recipe.name.to_lowercase());
@@ -172,74 +173,98 @@ fn emit_recipe_predicates(isa: &TargetIs
                     fmtln!(fmt, "isap.test({}) &&", isap);
                     emit_instp(instp, /* has func */ false, fmt);
                 }
                 _ => panic!("skipped above"),
             }
         });
         fmtln!(fmt, "}");
     }
+    fmt.empty_line();
 
     // Generate the static table.
+    fmt.doc_comment(format!(
+        r#"{} recipe predicate table.
+
+        One entry per recipe, set to Some only when the recipe is guarded by a predicate."#,
+        isa.name
+    ));
     fmtln!(
         fmt,
         "pub static RECIPE_PREDICATES: [RecipePredicate; {}] = [",
         isa.recipes.len()
     );
     fmt.indent(|fmt| {
         for recipe in isa.recipes.values() {
             match (&recipe.isa_predicate, &recipe.inst_predicate) {
                 (None, None) => fmt.line("None,"),
                 key => fmtln!(fmt, "Some({}),", predicate_names.get(&key).unwrap()),
             }
         }
     });
     fmtln!(fmt, "];");
+    fmt.empty_line();
 }
 
 /// Emit private functions for matching instruction predicates as well as a static
 /// `INST_PREDICATES` array indexed by predicate number.
 fn emit_inst_predicates(isa: &TargetIsa, fmt: &mut Formatter) {
+    fmt.comment(format!("{} instruction predicates.", isa.name));
     for (id, instp) in isa.encodings_predicates.iter() {
         fmtln!(fmt, "fn inst_predicate_{}(func: &crate::ir::Function, inst: &crate::ir::InstructionData) -> bool {{", id.index());
         fmt.indent(|fmt| {
             emit_instp(instp, /* has func */ true, fmt);
         });
         fmtln!(fmt, "}");
     }
+    fmt.empty_line();
 
     // Generate the static table.
+    fmt.doc_comment(format!(
+        r#"{} instruction predicate table.
+
+        One entry per instruction predicate, so the encoding bytecode can embed indexes into this
+        table."#,
+        isa.name
+    ));
     fmtln!(
         fmt,
         "pub static INST_PREDICATES: [InstPredicate; {}] = [",
         isa.encodings_predicates.len()
     );
     fmt.indent(|fmt| {
         for id in isa.encodings_predicates.keys() {
             fmtln!(fmt, "inst_predicate_{},", id.index());
         }
     });
     fmtln!(fmt, "];");
+    fmt.empty_line();
 }
 
 /// Emit a table of encoding recipe names keyed by recipe number.
 ///
 /// This is used for pretty-printing encodings.
 fn emit_recipe_names(isa: &TargetIsa, fmt: &mut Formatter) {
+    fmt.doc_comment(format!(
+        r#"{} recipe names, using the same recipe index spaces as the one specified by the
+        corresponding binemit file."#,
+        isa.name
+    ));
     fmtln!(
         fmt,
         "static RECIPE_NAMES: [&str; {}] = [",
         isa.recipes.len()
     );
     fmt.indent(|fmt| {
         for recipe in isa.recipes.values() {
             fmtln!(fmt, r#""{}","#, recipe.name);
         }
     });
     fmtln!(fmt, "];");
+    fmt.empty_line();
 }
 
 /// Returns a set of all the registers involved in fixed register constraints.
 fn get_fixed_registers(operands_in: &Vec<OperandConstraint>) -> HashSet<Register> {
     HashSet::from_iter(
         operands_in
             .iter()
             .map(|constraint| {
@@ -348,16 +373,22 @@ fn emit_operand_constraints(
     });
     fmtln!(fmt, "],");
 }
 
 /// Emit a table of encoding recipe operand constraints keyed by recipe number.
 ///
 /// These are used by the register allocator to pick registers that can be properly encoded.
 fn emit_recipe_constraints(isa: &TargetIsa, fmt: &mut Formatter) {
+    fmt.doc_comment(format!(
+        r#"{} recipe constraints list, using the same recipe index spaces as the one
+        specified by the corresponding binemit file. These constraints are used by register
+        allocation to select the right location to use for input and output values."#,
+        isa.name
+    ));
     fmtln!(
         fmt,
         "static RECIPE_CONSTRAINTS: [RecipeConstraints; {}] = [",
         isa.recipes.len()
     );
     fmt.indent(|fmt| {
         for recipe in isa.recipes.values() {
             // Compute a mapping of tied operands in both directions (input tied to outputs and
@@ -432,20 +463,27 @@ fn emit_recipe_constraints(isa: &TargetI
                         "false"
                     }
                 );
             });
             fmt.line("},");
         }
     });
     fmtln!(fmt, "];");
+    fmt.empty_line();
 }
 
 /// Emit a table of encoding recipe code size information.
 fn emit_recipe_sizing(isa: &TargetIsa, fmt: &mut Formatter) {
+    fmt.doc_comment(format!(
+        r#"{} recipe sizing descriptors, using the same recipe index spaces as the one
+        specified by the corresponding binemit file. These are used to compute the final size of an
+        instruction, as well as to compute the range of branches."#,
+        isa.name
+    ));
     fmtln!(
         fmt,
         "static RECIPE_SIZING: [RecipeSizing; {}] = [",
         isa.recipes.len()
     );
     fmt.indent(|fmt| {
         for recipe in isa.recipes.values() {
             fmt.comment(format!("Code size information for recipe {}:", recipe.name));
@@ -463,16 +501,17 @@ fn emit_recipe_sizing(isa: &TargetIsa, f
                 } else {
                     fmt.line("branch_range: None,");
                 }
             });
             fmt.line("},");
         }
     });
     fmtln!(fmt, "];");
+    fmt.empty_line();
 }
 
 /// Level 1 table mapping types to `Level2` objects.
 struct Level1Table<'cpu_mode> {
     cpu_mode: &'cpu_mode CpuMode,
     legalize_code: TransformGroupIndex,
 
     table_map: HashMap<Option<ValueType>, usize>,
@@ -873,17 +912,17 @@ fn encode_level2_hashtables<'a>(
     level2_hashtables: &mut Vec<Option<Level2HashTableEntry>>,
     level2_doc: &mut HashMap<usize, Vec<String>>,
 ) {
     for level2 in level1.l2tables() {
         level2.layout_hashtable(level2_hashtables, level2_doc);
     }
 }
 
-fn emit_tables(defs: &SharedDefinitions, isa: &TargetIsa, fmt: &mut Formatter) {
+fn emit_encoding_tables(defs: &SharedDefinitions, isa: &TargetIsa, fmt: &mut Formatter) {
     // Level 1 tables, one per CPU mode.
     let mut level1_tables: HashMap<&'static str, Level1Table> = HashMap::new();
 
     // Single table containing all the level2 hash tables.
     let mut level2_hashtables = Vec::new();
     let mut level2_doc: HashMap<usize, Vec<String>> = HashMap::new();
 
     // Tables for encoding lists with comments.
@@ -918,16 +957,23 @@ fn emit_tables(defs: &SharedDefinitions,
             "u32"
         }
     };
 
     let level1_offset_type = offset_type(level2_hashtables.len());
     let level2_offset_type = offset_type(enc_lists.len());
 
     // Emit encoding lists.
+    fmt.doc_comment(
+        format!(r#"{} encoding lists.
+
+        This contains the entire encodings bytecode for every single instruction; the encodings
+        interpreter knows where to start from thanks to the initial lookup in the level 1 and level 2
+        table entries below."#, isa.name)
+    );
     fmtln!(fmt, "pub static ENCLISTS: [u16; {}] = [", enc_lists.len());
     fmt.indent(|fmt| {
         let mut line = Vec::new();
         for (index, entry) in enc_lists.iter().enumerate() {
             if let Some(comments) = enc_lists_doc.get(&index) {
                 if !line.is_empty() {
                     fmtln!(fmt, "{},", line.join(", "));
                     line.clear();
@@ -938,18 +984,27 @@ fn emit_tables(defs: &SharedDefinitions,
             }
             line.push(format!("{:#06x}", entry));
         }
         if !line.is_empty() {
             fmtln!(fmt, "{},", line.join(", "));
         }
     });
     fmtln!(fmt, "];");
+    fmt.empty_line();
 
     // Emit the full concatenation of level 2 hash tables.
+    fmt.doc_comment(format!(
+        r#"{} level 2 hash tables.
+
+        This hash table, keyed by instruction opcode, contains all the starting offsets for the
+        encodings interpreter, for all the CPU modes. It is jumped to after a lookup on the
+        instruction's controlling type in the level 1 hash table."#,
+        isa.name
+    ));
     fmtln!(
         fmt,
         "pub static LEVEL2: [Level2Entry<{}>; {}] = [",
         level2_offset_type,
         level2_hashtables.len()
     );
     fmt.indent(|fmt| {
         for (offset, entry) in level2_hashtables.iter().enumerate() {
@@ -966,32 +1021,43 @@ fn emit_tables(defs: &SharedDefinitions,
                     entry.offset
                 );
             } else {
                 fmt.line("Level2Entry { opcode: None, offset: 0 },");
             }
         }
     });
     fmtln!(fmt, "];");
+    fmt.empty_line();
 
     // Emit a level 1 hash table for each CPU mode.
     for cpu_mode in &isa.cpu_modes {
         let level1 = &level1_tables.get(cpu_mode.name).unwrap();
         let hash_table = generate_table(
             level1.table_vec.iter(),
             level1.table_vec.len(),
             |level2_table| {
                 if let Some(typ) = &level2_table.typ {
                     typ.number().expect("type without a number") as usize
                 } else {
                     0
                 }
             },
         );
 
+        fmt.doc_comment(format!(
+            r#"{} level 1 hash table for the CPU mode {}.
+
+            This hash table, keyed by instruction controlling type, contains all the level 2
+            hash-tables offsets for the given CPU mode, as well as a legalization identifier indicating
+            which legalization scheme to apply when the instruction doesn't have any valid encoding for
+            this CPU mode.
+        "#,
+            isa.name, cpu_mode.name
+        ));
         fmtln!(
             fmt,
             "pub static LEVEL1_{}: [Level1Entry<{}>; {}] = [",
             cpu_mode.name.to_uppercase(),
             level1_offset_type,
             hash_table.len()
         );
         fmt.indent(|fmt| {
@@ -1028,27 +1094,28 @@ fn emit_tables(defs: &SharedDefinitions,
                 // Proper level 2 hash table.
                 let l2l = (level2.hash_table_len.unwrap() as f64).log2() as i32;
                 assert!(l2l > 0, "Level2 hash table was too small.");
                 fmtln!(fmt, "Level1Entry {{ ty: {}, log2len: {}, offset: {:#08x}, legalize: {} }}, // {}",
                        typ_name, l2l, level2.hash_table_offset.unwrap(), legalize_code, legalize_comment);
             }
         });
         fmtln!(fmt, "];");
+        fmt.empty_line();
     }
 }
 
 fn gen_isa(defs: &SharedDefinitions, isa: &TargetIsa, fmt: &mut Formatter) {
     // Make the `RECIPE_PREDICATES` table.
     emit_recipe_predicates(isa, fmt);
 
     // Make the `INST_PREDICATES` table.
     emit_inst_predicates(isa, fmt);
 
-    emit_tables(defs, isa, fmt);
+    emit_encoding_tables(defs, isa, fmt);
 
     emit_recipe_names(isa, fmt);
     emit_recipe_constraints(isa, fmt);
     emit_recipe_sizing(isa, fmt);
 
     // Finally, tie it all together in an `EncInfo`.
     fmt.line("pub static INFO: isa::EncInfo = isa::EncInfo {");
     fmt.indent(|fmt| {
--- a/third_party/rust/cranelift-codegen-meta/src/isa/x86/encodings.rs
+++ b/third_party/rust/cranelift-codegen-meta/src/isa/x86/encodings.rs
@@ -265,39 +265,39 @@ impl PerCpuModeEncodings {
             self.enc64(inst.clone().bind(I64).bind_any(), template.clone().rex());
             self.enc64(inst.clone().bind(I64).bind_any(), template);
         }
     }
 
     /// Add the same encoding to both X86_32 and X86_64; assumes configuration (e.g. REX, operand binding) has already happened
     fn enc_32_64_maybe_isap(
         &mut self,
-        inst: BoundInstruction,
+        inst: impl Clone + Into<InstSpec>,
         template: Template,
         isap: Option<SettingPredicateNumber>,
     ) {
         self.enc32_maybe_isap(inst.clone(), template.clone(), isap);
         self.enc64_maybe_isap(inst, template, isap);
     }
 
     fn enc32_maybe_isap(
         &mut self,
-        inst: BoundInstruction,
+        inst: impl Into<InstSpec>,
         template: Template,
         isap: Option<SettingPredicateNumber>,
     ) {
         match isap {
             None => self.enc32(inst, template),
             Some(isap) => self.enc32_isap(inst, template, isap),
         }
     }
 
     fn enc64_maybe_isap(
         &mut self,
-        inst: BoundInstruction,
+        inst: impl Into<InstSpec>,
         template: Template,
         isap: Option<SettingPredicateNumber>,
     ) {
         match isap {
             None => self.enc64(inst, template),
             Some(isap) => self.enc64_isap(inst, template, isap),
         }
     }
@@ -427,16 +427,17 @@ pub fn define(
     let uload16 = shared.by_name("uload16");
     let uload16_complex = shared.by_name("uload16_complex");
     let uload32 = shared.by_name("uload32");
     let uload32_complex = shared.by_name("uload32_complex");
     let uload8 = shared.by_name("uload8");
     let uload8_complex = shared.by_name("uload8_complex");
     let ushr = shared.by_name("ushr");
     let ushr_imm = shared.by_name("ushr_imm");
+    let vconst = shared.by_name("vconst");
     let x86_bsf = x86.by_name("x86_bsf");
     let x86_bsr = x86.by_name("x86_bsr");
     let x86_cvtt2si = x86.by_name("x86_cvtt2si");
     let x86_fmax = x86.by_name("x86_fmax");
     let x86_fmin = x86.by_name("x86_fmin");
     let x86_pop = x86.by_name("x86_pop");
     let x86_pshufd = x86.by_name("x86_pshufd");
     let x86_pshufb = x86.by_name("x86_pshufb");
@@ -573,29 +574,31 @@ pub fn define(
     let rec_trapff = r.recipe("trapff");
     let rec_u_id = r.template("u_id");
     let rec_umr = r.template("umr");
     let rec_umr_reg_to_ssa = r.template("umr_reg_to_ssa");
     let rec_ur = r.template("ur");
     let rec_urm = r.template("urm");
     let rec_urm_noflags = r.template("urm_noflags");
     let rec_urm_noflags_abcd = r.template("urm_noflags_abcd");
+    let rec_vconst = r.template("vconst");
 
     // Predicates shorthands.
     let all_ones_funcaddrs_and_not_is_pic =
         settings.predicate_by_name("all_ones_funcaddrs_and_not_is_pic");
     let is_pic = settings.predicate_by_name("is_pic");
     let not_all_ones_funcaddrs_and_not_is_pic =
         settings.predicate_by_name("not_all_ones_funcaddrs_and_not_is_pic");
     let not_is_pic = settings.predicate_by_name("not_is_pic");
     let use_popcnt = settings.predicate_by_name("use_popcnt");
     let use_lzcnt = settings.predicate_by_name("use_lzcnt");
     let use_bmi1 = settings.predicate_by_name("use_bmi1");
-    let use_ssse3 = settings.predicate_by_name("use_ssse3");
     let use_sse41 = settings.predicate_by_name("use_sse41");
+    let use_ssse3_simd = settings.predicate_by_name("use_ssse3_simd");
+    let use_sse41_simd = settings.predicate_by_name("use_sse41_simd");
 
     // Definitions.
     let mut e = PerCpuModeEncodings::new();
 
     e.enc_i32_i64(iadd, rec_rr.opcodes(vec![0x01]));
     e.enc_i32_i64(isub, rec_rr.opcodes(vec![0x29]));
     e.enc_i32_i64(band, rec_rr.opcodes(vec![0x21]));
     e.enc_i32_i64(bor, rec_rr.opcodes(vec![0x09]));
@@ -1689,18 +1692,18 @@ pub fn define(
     // SIMD splat: before x86 can use vector data, it must be moved to XMM registers; see
     // legalize.rs for how this is done; once there, x86_pshuf* (below) is used for broadcasting the
     // value across the register
 
     // PSHUFB, 8-bit shuffle using two XMM registers
     for ty in ValueType::all_lane_types().filter(|t| t.lane_bits() == 8) {
         let instruction = x86_pshufb.bind_vector_from_lane(ty, sse_vector_size);
         let template = rec_fa.nonrex().opcodes(vec![0x66, 0x0f, 0x38, 00]);
-        e.enc32_isap(instruction.clone(), template.clone(), use_ssse3);
-        e.enc64_isap(instruction, template, use_ssse3);
+        e.enc32_isap(instruction.clone(), template.clone(), use_ssse3_simd);
+        e.enc64_isap(instruction, template, use_ssse3_simd);
     }
 
     // PSHUFD, 32-bit shuffle using one XMM register and a u8 immediate
     for ty in ValueType::all_lane_types().filter(|t| t.lane_bits() == 32) {
         let instruction = x86_pshufd.bind_vector_from_lane(ty, sse_vector_size);
         let template = rec_r_ib_unsigned_fpr
             .nonrex()
             .opcodes(vec![0x66, 0x0f, 0x70]);
@@ -1721,20 +1724,20 @@ pub fn define(
             e.enc32(instruction.clone(), template.clone());
         }
         e.enc_x86_64(instruction, template);
     }
 
     // SIMD insertlane
     let mut insertlane_mapping: HashMap<u64, (Vec<u8>, Option<SettingPredicateNumber>)> =
         HashMap::new();
-    insertlane_mapping.insert(8, (vec![0x66, 0x0f, 0x3a, 0x20], Some(use_sse41))); // PINSRB
+    insertlane_mapping.insert(8, (vec![0x66, 0x0f, 0x3a, 0x20], Some(use_sse41_simd))); // PINSRB
     insertlane_mapping.insert(16, (vec![0x66, 0x0f, 0xc4], None)); // PINSRW from SSE2
-    insertlane_mapping.insert(32, (vec![0x66, 0x0f, 0x3a, 0x22], Some(use_sse41))); // PINSRD
-    insertlane_mapping.insert(64, (vec![0x66, 0x0f, 0x3a, 0x22], Some(use_sse41))); // PINSRQ, only x86_64
+    insertlane_mapping.insert(32, (vec![0x66, 0x0f, 0x3a, 0x22], Some(use_sse41_simd))); // PINSRD
+    insertlane_mapping.insert(64, (vec![0x66, 0x0f, 0x3a, 0x22], Some(use_sse41_simd))); // PINSRQ, only x86_64
 
     for ty in ValueType::all_lane_types() {
         if let Some((opcode, isap)) = insertlane_mapping.get(&ty.lane_bits()) {
             let instruction = insertlane.bind_vector_from_lane(ty, sse_vector_size);
             let template = rec_r_ib_unsigned_r.opcodes(opcode.clone());
             if ty.lane_bits() < 64 {
                 e.enc_32_64_maybe_isap(instruction, template.nonrex(), isap.clone());
             } else {
@@ -1742,20 +1745,20 @@ pub fn define(
                 e.enc64_maybe_isap(instruction, template.rex().w(), isap.clone());
             }
         }
     }
 
     // SIMD extractlane
     let mut extractlane_mapping: HashMap<u64, (Vec<u8>, Option<SettingPredicateNumber>)> =
         HashMap::new();
-    extractlane_mapping.insert(8, (vec![0x66, 0x0f, 0x3a, 0x14], Some(use_sse41))); // PEXTRB
+    extractlane_mapping.insert(8, (vec![0x66, 0x0f, 0x3a, 0x14], Some(use_sse41_simd))); // PEXTRB
     extractlane_mapping.insert(16, (vec![0x66, 0x0f, 0xc5], None)); // PEXTRW from zSSE2, SSE4.1 has a PEXTRW that can move to reg/m16 but the opcode is four bytes
-    extractlane_mapping.insert(32, (vec![0x66, 0x0f, 0x3a, 0x16], Some(use_sse41))); // PEXTRD
-    extractlane_mapping.insert(64, (vec![0x66, 0x0f, 0x3a, 0x16], Some(use_sse41))); // PEXTRQ, only x86_64
+    extractlane_mapping.insert(32, (vec![0x66, 0x0f, 0x3a, 0x16], Some(use_sse41_simd))); // PEXTRD
+    extractlane_mapping.insert(64, (vec![0x66, 0x0f, 0x3a, 0x16], Some(use_sse41_simd))); // PEXTRQ, only x86_64
 
     for ty in ValueType::all_lane_types() {
         if let Some((opcode, isap)) = extractlane_mapping.get(&ty.lane_bits()) {
             let instruction = extractlane.bind_vector_from_lane(ty, sse_vector_size);
             let template = rec_r_ib_unsigned_gpr.opcodes(opcode.clone());
             if ty.lane_bits() < 64 {
                 e.enc_32_64_maybe_isap(instruction, template.nonrex(), isap.clone());
             } else {
@@ -1779,16 +1782,28 @@ pub fn define(
             let instruction = raw_bitcast
                 .bind_vector_from_lane(to_type, sse_vector_size)
                 .bind_vector_from_lane(from_type, sse_vector_size);
             e.enc32_rec(instruction.clone(), rec_null_fpr, 0);
             e.enc64_rec(instruction, rec_null_fpr, 0);
         }
     }
 
+    // SIMD vconst using MOVUPS
+    // TODO it would be ideal if eventually this became the more efficient MOVAPS but we would have
+    // to guarantee that the constants are aligned when emitted and there is currently no mechanism
+    // for that; alternately, constants could be loaded into XMM registers using a sequence like:
+    // MOVQ + MOVHPD + MOVQ + MOVLPD (this allows the constants to be immediates instead of stored
+    // in memory) but some performance measurements are needed.
+    for ty in ValueType::all_lane_types().filter(|t| t.lane_bits() >= 8) {
+        let instruction = vconst.bind_vector_from_lane(ty, sse_vector_size);
+        let template = rec_vconst.nonrex().opcodes(vec![0x0f, 0x10]);
+        e.enc_32_64_maybe_isap(instruction, template, None); // from SSE
+    }
+
     // Reference type instructions
 
     // Null references implemented as iconst 0.
     e.enc32(null.bind_ref(R32), rec_pu_id_ref.opcodes(vec![0xb8]));
 
     e.enc64(null.bind_ref(R64), rec_pu_id_ref.rex().opcodes(vec![0xb8]));
     e.enc64(null.bind_ref(R64), rec_pu_id_ref.opcodes(vec![0xb8]));
 
--- a/third_party/rust/cranelift-codegen-meta/src/isa/x86/recipes.rs
+++ b/third_party/rust/cranelift-codegen-meta/src/isa/x86/recipes.rs
@@ -394,16 +394,17 @@ pub fn define<'shared>(
     let f_ternary = formats.by_name("Ternary");
     let f_trap = formats.by_name("Trap");
     let f_unary = formats.by_name("Unary");
     let f_unary_bool = formats.by_name("UnaryBool");
     let f_unary_global_value = formats.by_name("UnaryGlobalValue");
     let f_unary_ieee32 = formats.by_name("UnaryIeee32");
     let f_unary_ieee64 = formats.by_name("UnaryIeee64");
     let f_unary_imm = formats.by_name("UnaryImm");
+    let f_unary_imm128 = formats.by_name("UnaryImm128");
 
     // Predicates shorthands.
     let use_sse41 = settings.predicate_by_name("use_sse41");
 
     // Definitions.
     let mut recipes = RecipeGroup::new(formats, regs);
 
     // A null unary instruction that takes a GPR register. Can be used for identity copies and
@@ -2378,16 +2379,29 @@ pub fn define<'shared>(
                         modrm_sib(out_reg0, sink);
                         sib(imm.trailing_zeros() as u8, in_reg0, in_reg1, sink);
                     }
                 "#,
             ),
     );
 
     recipes.add_template_recipe(
+        EncodingRecipeBuilder::new("vconst", f_unary_imm128, 5)
+            .operands_out(vec![fpr])
+            .clobbers_flags(false)
+            .emit(
+                r#"
+                    {{PUT_OP}}(bits, rex2(0, out_reg0), sink);
+                    modrm_riprel(out_reg0, sink);
+                    const_disp4(imm, func, sink);
+                "#,
+            ),
+    );
+
+    recipes.add_template_recipe(
         EncodingRecipeBuilder::new("jt_base", f_branch_table_base, 5)
             .operands_out(vec![gpr])
             .clobbers_flags(false)
             .emit(
                 r#"
                     {{PUT_OP}}(bits, rex2(0, out_reg0), sink);
                     modrm_riprel(out_reg0, sink);
 
--- a/third_party/rust/cranelift-codegen-meta/src/isa/x86/settings.rs
+++ b/third_party/rust/cranelift-codegen-meta/src/isa/x86/settings.rs
@@ -27,22 +27,33 @@ pub fn define(shared: &SettingGroup) -> 
     let has_lzcnt = settings.add_bool(
         "has_lzcnt",
         "LZCNT: CPUID.EAX=80000001H:ECX.LZCNT[bit 5]",
         false,
     );
 
     let shared_enable_simd = shared.get_bool("enable_simd");
 
-    settings.add_predicate("use_ssse3", predicate!(shared_enable_simd && has_ssse3));
-    settings.add_predicate("use_sse41", predicate!(shared_enable_simd && has_sse41));
+    settings.add_predicate("use_ssse3", predicate!(has_ssse3));
+    settings.add_predicate("use_sse41", predicate!(has_sse41));
+    settings.add_predicate("use_sse42", predicate!(has_sse41 && has_sse42));
+
     settings.add_predicate(
-        "use_sse42",
+        "use_ssse3_simd",
+        predicate!(shared_enable_simd && has_ssse3),
+    );
+    settings.add_predicate(
+        "use_sse41_simd",
+        predicate!(shared_enable_simd && has_sse41),
+    );
+    settings.add_predicate(
+        "use_sse42_simd",
         predicate!(shared_enable_simd && has_sse41 && has_sse42),
     );
+
     settings.add_predicate("use_popcnt", predicate!(has_popcnt && has_sse42));
     settings.add_predicate("use_bmi1", predicate!(has_bmi1));
     settings.add_predicate("use_lzcnt", predicate!(has_lzcnt));
 
     // Some shared boolean values are used in x86 instruction predicates, so we need to group them
     // in the same TargetIsa, for compabitibity with code generated by meta-python.
     // TODO Once all the meta generation code has been migrated from Python to Rust, we can put it
     // back in the shared SettingGroup, and use it in x86 instruction predicates.
--- a/third_party/rust/cranelift-codegen-meta/src/shared/formats.rs
+++ b/third_party/rust/cranelift-codegen-meta/src/shared/formats.rs
@@ -1,15 +1,16 @@
 use crate::cdsl::formats::{FormatRegistry, InstructionFormatBuilder as Builder};
 use crate::shared::OperandKinds;
 
 pub fn define(immediates: &OperandKinds, entities: &OperandKinds) -> FormatRegistry {
     // Shorthands for immediates.
     let uimm8 = immediates.by_name("uimm8");
     let uimm32 = immediates.by_name("uimm32");
+    let uimm128 = immediates.by_name("uimm128");
     let imm64 = immediates.by_name("imm64");
     let ieee32 = immediates.by_name("ieee32");
     let ieee64 = immediates.by_name("ieee64");
     let boolean = immediates.by_name("boolean");
     let intcc = immediates.by_name("intcc");
     let floatcc = immediates.by_name("floatcc");
     let memflags = immediates.by_name("memflags");
     let offset32 = immediates.by_name("offset32");
@@ -25,16 +26,17 @@ pub fn define(immediates: &OperandKinds,
     let stack_slot = entities.by_name("stack_slot");
     let heap = entities.by_name("heap");
     let table = entities.by_name("table");
 
     let mut registry = FormatRegistry::new();
 
     registry.insert(Builder::new("Unary").value());
     registry.insert(Builder::new("UnaryImm").imm(imm64));
+    registry.insert(Builder::new("UnaryImm128").imm(uimm128));
     registry.insert(Builder::new("UnaryIeee32").imm(ieee32));
     registry.insert(Builder::new("UnaryIeee64").imm(ieee64));
     registry.insert(Builder::new("UnaryBool").imm(boolean));
     registry.insert(Builder::new("UnaryGlobalValue").imm(global_value));
 
     registry.insert(Builder::new("Binary").value().value());
     registry.insert(Builder::new("BinaryImm").value().imm(imm64));
 
--- a/third_party/rust/cranelift-codegen-meta/src/shared/immediates.rs
+++ b/third_party/rust/cranelift-codegen-meta/src/shared/immediates.rs
@@ -24,16 +24,26 @@ pub fn define() -> Vec<OperandKind> {
     kinds.push(uimm8);
 
     // An unsigned 32-bit immediate integer operand.
     let uimm32 = Builder::new_imm("uimm32")
         .doc("A 32-bit immediate unsigned integer.")
         .build();
     kinds.push(uimm32);
 
+    // An unsigned 128-bit immediate integer operand.
+    //
+    // This operand is used to pass entire 128-bit vectors as immediates to
+    // instructions like const.
+    let uimm128 = Builder::new_imm("uimm128")
+        .doc("A 128-bit immediate unsigned integer.")
+        .rust_type("ir::Constant")
+        .build();
+    kinds.push(uimm128);
+
     // A 32-bit immediate signed offset.
     //
     // This is used to represent an immediate address offset in load/store
     // instructions.
     let offset32 = Builder::new_imm("offset32")
         .doc("A 32-bit immediate signed offset.")
         .default_member("offset")
         .build();
--- a/third_party/rust/cranelift-codegen-meta/src/shared/instructions.rs
+++ b/third_party/rust/cranelift-codegen-meta/src/shared/instructions.rs
@@ -25,16 +25,17 @@ pub fn define(
 
     // Operand kind shorthands.
     let intcc = immediates.by_name("intcc");
     let floatcc = immediates.by_name("floatcc");
     let trapcode = immediates.by_name("trapcode");
     let uimm8 = immediates.by_name("uimm8");
     let uimm32 = immediates.by_name("uimm32");
     let imm64 = immediates.by_name("imm64");
+    let uimm128 = immediates.by_name("uimm128");
     let offset32 = immediates.by_name("offset32");
     let memflags = immediates.by_name("memflags");
     let ieee32 = immediates.by_name("ieee32");
     let ieee64 = immediates.by_name("ieee64");
     let boolean = immediates.by_name("boolean");
     let regunit = immediates.by_name("regunit");
 
     let ebb = entities.by_name("ebb");
@@ -1083,16 +1084,32 @@ pub fn define(
         Create a scalar boolean SSA value with an immediate constant value, or
         a boolean vector where all the lanes have the same value.
         "#,
         )
         .operands_in(vec![N])
         .operands_out(vec![a]),
     );
 
+    let N = &operand_doc("N", uimm128, "The 16 immediate bytes of a 128-bit vector");
+    let a = &operand_doc("a", TxN, "A constant vector value");
+
+    ig.push(
+        Inst::new(
+            "vconst",
+            r#"
+        SIMD vector constant.
+
+        Construct a vector with the given immediate bytes.
+        "#,
+        )
+        .operands_in(vec![N])
+        .operands_out(vec![a]),
+    );
+
     let a = &operand_doc("a", Ref, "A constant reference null value");
 
     ig.push(
         Inst::new(
             "null",
             r#"
         Null constant value for reference types.
 
--- a/third_party/rust/cranelift-codegen/.cargo-checksum.json
+++ b/third_party/rust/cranelift-codegen/.cargo-checksum.json
@@ -1,1 +1,1 @@
-{"files":{"Cargo.toml":"f797893f65d711c9e0df429ec0b85816c3526e87f0d6baa3300bc5d667f36d20","LICENSE":"268872b9816f90fd8e85db5a28d33f8150ebb8dd016653fb39ef1f94f2686bc5","README.md":"e5127227a7db4a8aa92fa6613ed71801025790e696bb41b0323fb7f3c6f7495a","build.rs":"8587e8557a046dc858f7662f63f1fa54e57ff92ed87b30fbcdfce6feafda9d60","src/abi.rs":"76ee030cf0780fe63ccbf855b1161f215e3e2991cb9abe71ca9aff25e5f1dbc2","src/binemit/memorysink.rs":"bf90f397b4c696e2fc49f27f866fe267727c2c8950dffbc8aac6f4a09bafbf20","src/binemit/mod.rs":"498f84442badcc753b0cae2f8153a3ba93d35a3af8d397c2dd183780f13bf42d","src/binemit/relaxation.rs":"3fbd14c98807e23da337bf1e658e077ab2e6aca585b663ab041a6fe1a0875cec","src/binemit/shrink.rs":"79a2dcca2633c8449d49bf7cfb1e2fe14b46753a4d52ef412078c53d7742fe86","src/binemit/stackmap.rs":"da3187d96d21b14927279061ccaba4c880d0ad7169b83bd32c1381d45a39af70","src/bitset.rs":"d57a79058a31b094b4bbe9d34876a5543286df1e08b5ceadfd05a9efc5a3b1ce","src/cfg_printer.rs":"a84dee96d8c6f4775b8ba022243cf1c0bcf847c6d7ec532698cfd331655aa453","src/constant_hash.rs":"77eb898f7b0a4ae3b8165a03c25fcd23ce9c1d0cd32c793fa6cb31666ce27eb1","src/context.rs":"ee09647590a7a583c37df398fe3eb51dca034a5aca4e164288c9f7ed2b30274e","src/cursor.rs":"874d1c7ef6e114d6ae47e0a1f92da7c5cec2e555597558042a3b214da7bc5fe4","src/dbg.rs":"1898d94cff0975815eb348651702e95c8f2f63886501d3b7043ee75668480472","src/dce.rs":"d8ab7c0cac0416f9d75afdacc60ba02e532361ec927c3f8bd171b1a53ec8b31a","src/divconst_magic_numbers.rs":"09691389c9055bef7a0cfd5d77fbfeba4be468d05d981d4de088516a94b8b28e","src/dominator_tree.rs":"7ee4114026011b11d49e48c5a9202970bafe3b22c2074f7c1390b98ebb2edb7a","src/flowgraph.rs":"c975c05949017f0b2efeff85bf82017b6a5779ed92e25f13742aeea76ca95c52","src/fx.rs":"8a5d07487906d8316a179e826fcd817a92a4860686256a6fd9d78ba47c63f330","src/ir/builder.rs":"6f111f2a65dfe27633dcec918f74b767277131a72cd94b7bec2e1ef5c4308d5b","src/ir/condcodes.rs":"5247c8d849e1372d2a22379c33a4a88226ec6187be18ca6f2c4e0f315d812aa8","src/ir/dfg.rs":"632f7bec7d2ac63a4f6bb4c5fb4141b9845d6172e82c40c023a733606935549b","src/ir/entities.rs":"5da0d988588d36c0997c7f6208d37b90be5a36816a7a8df46306b244e0b97219","src/ir/extfunc.rs":"f26200741eb91be0d9a72a7aea194fd28f78696754ed9c26e88c8dd277ecd082","src/ir/extname.rs":"ed2c0b52cdaecc7f0ba9a894ef9fffe139e09b520e43dcd6f0c887a3d41a31ac","src/ir/function.rs":"68b1ed2a262c691d4459501feb6358e6cb96663b32796c67e94a3f14a146fdd0","src/ir/globalvalue.rs":"906d29f3d4190b811f66fc549c4e0408bdd2807eac98e33c0b3d5c2b876acc02","src/ir/heap.rs":"a59d3e5901412b53c0b53a8cdf10765ff5921de9c410ae9acea226c89827df3c","src/ir/immediates.rs":"2b2ed4df22ccddbec85be96efea8f5afd21dafe6cd90f08b25aa7746529be06c","src/ir/instructions.rs":"7fe853efeb0379486d7878f7925962144ce208d230107d83e5a9165997a07587","src/ir/jumptable.rs":"7764abc9aa027a5a89d22059b360372bd9a19686887c5a7830f7637d6f188e1e","src/ir/layout.rs":"bb45eefde16ac9423f637dfcc2796ae7b955a97f38a55f23a19cc45da5decce1","src/ir/libcall.rs":"64eeae70e767424ddc8dd01167dc56019df45c3fba5c96bf05fa0d3d7670f344","src/ir/memflags.rs":"dbcf3798ab66dc764b73fb7f139a621c54cc6bcc683f1f70a33ed7e8c3486bfd","src/ir/mod.rs":"bb92d69a52e75e9fec4060ed33239d9194d6ff1514d37ec51f5e64223810ecd0","src/ir/progpoint.rs":"49433f22bd6ff3a96ad0733ff612f3617b312e4492b6b663187141966f6aa701","src/ir/sourceloc.rs":"e1442572958b138f7637a14b662200ea9f729a513b77108be2a39745d8c2a0d5","src/ir/stackslot.rs":"a116aec3d41fcb570044584d06c97e21fc65d68b31f921ab6b5d7a2daddb614b","src/ir/table.rs":"dcc3b663a989b2b084402b08dc9a0e928dbd052e194a46a1886cc6f0cf1a5f2c","src/ir/trapcode.rs":"59e223193617b8c1043ddd3a907c6131f2987e8fe0965ebfd9f7c056c064b7c5","src/ir/types.rs":"3828c0ff0aee4c101135dcbf0a9a39cd8d89cc9f9d52ca0ce7a42d549a9a4a50","src/ir/valueloc.rs":"1bf764fde5ff8140fa2b59f0192086ed17e9ba7018c74719788b74fc5ca05636","src/isa/arm32/abi.rs":"74775c5f1eb95764e46815fa8b31891416a616fdd212972eb77aead43b3345a9","src/isa/arm32/binemit.rs":"eecd7296c27d2520db8e86dd462833ecf06afd33548b03ae676c02454cdd13c2","src/isa/arm32/enc_tables.rs":"e94b12af802de59484cab1124d2ac8a88d08433f6e1a476724ed0403f4b5967f","src/isa/arm32/mod.rs":"1e02aef8ad188d347a17a7ecce42a9064b2d46ac2a5d246bf9b5cd44180a9b60","src/isa/arm32/registers.rs":"254b568a02480f46bb4967a24a438390231014258f0c159f0a41dbafe8e66d56","src/isa/arm32/settings.rs":"2314460f885c24f9571d640f9737a8e0b7d20ca02bcda1127f878fd3891c0529","src/isa/arm64/abi.rs":"52353ed2e2133dacddaad70a876ecebb9c179c19b911ffa823b5b89d3ee7a17c","src/isa/arm64/binemit.rs":"3afbb78f6d9ae5614d908023f84b774c0493c8757ad86fd8301baf0928bb0104","src/isa/arm64/enc_tables.rs":"73fedf7da610a982e37c76e5211dbce880f77841b71c678b0dab2b9e7217cb7c","src/isa/arm64/mod.rs":"49b7f398ec8baa2802a283f780bd039e2a630591e74cf1dddc8d9147345c2816","src/isa/arm64/registers.rs":"308cfcfd9ff2191d7656e7350bb36e41803664eb86ae490fb4b4d3549b25b6a2","src/isa/arm64/settings.rs":"5405ce3560b7ba0705ef525c706eb9f1593e901e1767b837c012084397639042","src/isa/call_conv.rs":"46a03271aed9cb38f87f2d0301721725f99a4f513ee77e39931ea338f13aa0f7","src/isa/constraints.rs":"bddb5c68e56b122a53d8be215e41d22ccf8c4563630b1486e6eb31c0d3337565","src/isa/enc_tables.rs":"382e714f9500afc292c563cb66d4c963d6787e58f197b1db242db7a099c22b9a","src/isa/encoding.rs":"7ea5b4400530172f96e263561682886ea6c67e706398d44a83933ef7f0ac98a5","src/isa/mod.rs":"cb5e4ffba5575d23b8ec5897393a5e2d7eb3259397f76a47e717b41340879de1","src/isa/registers.rs":"2050f34d87dd6e8a3d1cefc6248383ac5a888ec9b6766359edd883714ef03bda","src/isa/riscv/abi.rs":"36557b91ad16a1344c80fbb16a62b46eac88500d76cb9ebcd4eae224dd67b2de","src/isa/riscv/binemit.rs":"264d223da311d4482ebf2f55438b665c67b163058251bc78173c76ba983a31ef","src/isa/riscv/enc_tables.rs":"8491f2082b24c7dedeb7c36cfd913bf9aeaa0a4c8fc754166e9285f4ae002f40","src/isa/riscv/mod.rs":"41136889df9512d8311f8c015cf3f654557a17d784a17fcefeb0afa2f0ec3674","src/isa/riscv/registers.rs":"666c2abe1a93db5f1573d1603db6c13c37f3fc877c0c93b64d1b971921bfa950","src/isa/riscv/settings.rs":"f6362769e9bc5be0c12b091e414ce924b0d2053b05b0ae88fef118cb8c68761e","src/isa/stack.rs":"5d30e2e19662ff3b3a641888bbb29640094ccd51b9a73368a056352afee46320","src/isa/x86/abi.rs":"52df0eb35643a721d2d1acbee550b2194a4407205a340acd139e8e717dfc2801","src/isa/x86/binemit.rs":"24b89af26bcea26955306ad910c72747264e5eccd347bd05761cd151b3258a95","src/isa/x86/enc_tables.rs":"b67d453834e0fdcc2885dfe359502755514c9190a8699bae2c4b5026f1ab4017","src/isa/x86/mod.rs":"77879d642905156885b8f502a6b53423dea8a33cf465d74326049a658c8118d8","src/isa/x86/registers.rs":"bed70bbe1f56f3ef03ea7cd1bea68eb911913cb4c8b93167e044dfc639f7f461","src/isa/x86/settings.rs":"d3e403db3507830f79bcc976c17340b57052cf1b50877fcf1a79549f2a054458","src/iterators.rs":"f85f52d3fa707a0eb974c92215b3e976923ce8f9481219f7812e0f2869c2bd37","src/legalizer/boundary.rs":"70a6819cbb116f07d0a09f8e5b0e2fe91145f423ad02e10225f8879ff4e61351","src/legalizer/call.rs":"be6074c64c1a00e5e81159dd94c8401fef62205b22c15e07e0c56cf922554d00","src/legalizer/globalvalue.rs":"59ab09a0faf593c7f228500b3fd3bacfc0412bdcb2864ec3621aa65adc4a5693","src/legalizer/heap.rs":"b83dc83a5876b024db058023692f71d8f910f6b212f34200e9bcf61a19daeb8e","src/legalizer/libcall.rs":"875daf54ac05114e50eba801b25b2c201351e9f6c276ba0358b356498c54d1c6","src/legalizer/mod.rs":"aef4a458f3ab26239e8ac18c0c20791875fbd21e02085fa130be057e5f899a68","src/legalizer/split.rs":"13fe4d2cecea166ecdc1ebb11f5254374ee170518f1a61de7ac0a921bc8fb25d","src/legalizer/table.rs":"c36d03525312e3191aba8ee00c26a87c1ea200f9a9a0370f0cc84eeacff71786","src/lib.rs":"49ad98df2949c815d717e5a076a8654994fe5b71a7b639b058cb86c2183067fd","src/licm.rs":"07534926e2986c01e3b76a2faf2336f5b96411f06d93d44d74e991f76265e29d","src/loop_analysis.rs":"58fc3cc0e700f05e3131ff1b16ff975d4f32a68c790f095d8445bd300356d3c0","src/nan_canonicalization.rs":"9619bb5554791bd1be75ecd98564d6c9f5b65132bc07c5c4d8c210cd79b66f82","src/partition_slice.rs":"bc13504e7658aab565918d965a0b67e941eb572e583870571bc6dbb2b9aad272","src/postopt.rs":"d4c487f0299fb905bb5a5822e38dea6f70afa4d4577288988b5bec8660bc1ba0","src/predicates.rs":"2d62e2f25a6c4327e75716a5f3508edf810c4957d0b20d855ed5a865359c8dfb","src/print_errors.rs":"3fbd77a01b5404a4bbcf2970e44299ad33948c71f4014d92026415daa8325314","src/redundant_reload_remover.rs":"3b2e49280375c9294fb7e190a8b02ef4fcef05ffcf1cb9e6e583cdc8e484bde1","src/ref_slice.rs":"421a61323c11858a596d50220487f399e1bcedeff0e8d1b716dd4b3531eb01a5","src/regalloc/affinity.rs":"19cec5495c8bddc1fcc8f3c8659d527a5a3ea373ffcc130e3fbd5b462ef15930","src/regalloc/coalescing.rs":"d83be1c1067eb56f2f8f16380450a327d6495b4c6f1f489ded68271c055aec07","src/regalloc/coloring.rs":"45fa9a5f19f790f6bcee66ed3d578144712f8f6f19f564b5b84323f63353a8f7","src/regalloc/context.rs":"25e67e8562bbf757e3198d3a70c56d7b9fc5c86e1ada54cd556aac4144ec7ef2","src/regalloc/diversion.rs":"d46d733f6d00a8f536d5c7c8b8fc6f348c3d0605dd0ee77e1d8359367ba53347","src/regalloc/live_value_tracker.rs":"28823003dc72e8a4702776a8ab5ffd878712700a272b64376b0de2022e0ee31a","src/regalloc/liveness.rs":"a59673fda65d1e3c0e5b3f4468686d05a389c877bee7b10323264595c3c54677","src/regalloc/liverange.rs":"7a28454e5f70d570db439b966a01ead759b65eb65c5845f9c58bf2f230a5f2ab","src/regalloc/mod.rs":"594e059f9f2cbb1e1e2d45ec080c7544c3549bf8b309e6a1b30fcb36b8d7810e","src/regalloc/pressure.rs":"04738e95418f0f858885dfc45183efc3dfb59c8d2ad2fd88bbd9a73a62907730","src/regalloc/register_set.rs":"a816187bc0ca7e0fd9464fde9a37cdeaf09c5f5e7b10faee0eb12f6873034e1c","src/regalloc/reload.rs":"ccccb716a694b53103bd4d55efb2323e788c1127469233c17b648fa06baa67b1","src/regalloc/safepoint.rs":"93a4f963990298a2f2d64148c72859a4a0d5d3176b404834ab743b756882bf56","src/regalloc/solver.rs":"0787ddf732fae9112fb905d6a1dc0c29673800985e67bd57d900426269847e7b","src/regalloc/spilling.rs":"dff4af64409c9a1db7697423576826c3920c26c892fbdde89ee31c680d672e03","src/regalloc/virtregs.rs":"e5c8da6860ba9495f9396621530347e1dd6fc5b2fae2eb23c171ea77429356f1","src/result.rs":"c10354d615f93caa446c3c8c49d6ba3af762816af470f9c4accf04315cce9753","src/scoped_hash_map.rs":"5afafb3a4039094c3a2aad1582354220d21f399aa50046e7f4a1259e1976597e","src/settings.rs":"6c86c3d9b7b9a6424010c08cf6649d405edea5c1955645fa8ec43b9d6f22c3cb","src/simple_gvn.rs":"c8feb380d4831badc59aa1e65efeafa6702711585817fe5f6b31de6b265fac24","src/simple_preopt.rs":"9ee5b9deff729ee6b5b7111a15897f989ff26b9316848fcd5c22930df857467a","src/stack_layout.rs":"c5de271e296fc424f1a30017620bc88500369c8e553fef6e95beccb9c6640e7c","src/timing.rs":"a6808943eec68f5d3ff32132d40c07c142e6aa8073473561573a013978883e4f","src/topo_order.rs":"b01ed68a7300691f41ac434e58a5267b10a8b4a7056d65035e24aa8a6722122a","src/unreachable_code.rs":"40cc71a02887ee4065c76ce96dda0a363a8cc134ec784fe5ed1f276db76596ce","src/value_label.rs":"b81376e0b79252de8dff19d003bcdae210c0848229e63e7682b0148bbcde5961","src/verifier/cssa.rs":"e3e1d77b763c0ba82d3b59ab5b4667fd3152d5a08be50b58b0c82f86376bb062","src/verifier/flags.rs":"cac8ba7ed5fe621eaa425112b931423cb5f3523d580fcf0b7536deb252e96186","src/verifier/liveness.rs":"ac3413b464ee8b5aa5928bee724799b9a1e0cbbdce433c819b9d870483ed070a","src/verifier/locations.rs":"04635edc12bc741a23c9318611aac4abcb42f01effbebee6d858f108f9393a44","src/verifier/mod.rs":"768548894baa6a518244f526ba4b5160c1c3230868f5eeaa376a3f5d98b41df7","src/write.rs":"9abbf2fd10a8611b546f987a11194678fb40d6869fded363b020e5f35a3b4943"},"package":null}
\ No newline at end of file
+{"files":{"Cargo.toml":"f797893f65d711c9e0df429ec0b85816c3526e87f0d6baa3300bc5d667f36d20","LICENSE":"268872b9816f90fd8e85db5a28d33f8150ebb8dd016653fb39ef1f94f2686bc5","README.md":"e5127227a7db4a8aa92fa6613ed71801025790e696bb41b0323fb7f3c6f7495a","build.rs":"8587e8557a046dc858f7662f63f1fa54e57ff92ed87b30fbcdfce6feafda9d60","src/abi.rs":"76ee030cf0780fe63ccbf855b1161f215e3e2991cb9abe71ca9aff25e5f1dbc2","src/binemit/memorysink.rs":"da415b20c563e636bcccaafb43dbdb77d6c48f9c205b16229865abb1afa40964","src/binemit/mod.rs":"b05271c3b1d4e44c2f8f9fe0669778775d33e9dda4c70101ddc420275286e72c","src/binemit/relaxation.rs":"1d61f9e9eef5f81b1649aa3918f821d870d712ee5a56b02a18c704d43d344ace","src/binemit/shrink.rs":"79a2dcca2633c8449d49bf7cfb1e2fe14b46753a4d52ef412078c53d7742fe86","src/binemit/stackmap.rs":"da3187d96d21b14927279061ccaba4c880d0ad7169b83bd32c1381d45a39af70","src/bitset.rs":"d57a79058a31b094b4bbe9d34876a5543286df1e08b5ceadfd05a9efc5a3b1ce","src/cfg_printer.rs":"a84dee96d8c6f4775b8ba022243cf1c0bcf847c6d7ec532698cfd331655aa453","src/constant_hash.rs":"77eb898f7b0a4ae3b8165a03c25fcd23ce9c1d0cd32c793fa6cb31666ce27eb1","src/context.rs":"ee09647590a7a583c37df398fe3eb51dca034a5aca4e164288c9f7ed2b30274e","src/cursor.rs":"874d1c7ef6e114d6ae47e0a1f92da7c5cec2e555597558042a3b214da7bc5fe4","src/dbg.rs":"1898d94cff0975815eb348651702e95c8f2f63886501d3b7043ee75668480472","src/dce.rs":"d8ab7c0cac0416f9d75afdacc60ba02e532361ec927c3f8bd171b1a53ec8b31a","src/divconst_magic_numbers.rs":"09691389c9055bef7a0cfd5d77fbfeba4be468d05d981d4de088516a94b8b28e","src/dominator_tree.rs":"7ee4114026011b11d49e48c5a9202970bafe3b22c2074f7c1390b98ebb2edb7a","src/flowgraph.rs":"c975c05949017f0b2efeff85bf82017b6a5779ed92e25f13742aeea76ca95c52","src/fx.rs":"8a5d07487906d8316a179e826fcd817a92a4860686256a6fd9d78ba47c63f330","src/ir/builder.rs":"6f111f2a65dfe27633dcec918f74b767277131a72cd94b7bec2e1ef5c4308d5b","src/ir/condcodes.rs":"5247c8d849e1372d2a22379c33a4a88226ec6187be18ca6f2c4e0f315d812aa8","src/ir/constant.rs":"cffcc1817b4881b87731d59f33f434ffe9be769c0604e3069b1c5e8ee0ebd7d1","src/ir/dfg.rs":"ad5a597584966c3202774bd3cd8bbf3138c474b8fb89347855915b6f4edc8ae8","src/ir/entities.rs":"976f51a1e704b63b0bc701eb814b10ec8eee373d8f93ee73ceeeaeeea2c5b821","src/ir/extfunc.rs":"f26200741eb91be0d9a72a7aea194fd28f78696754ed9c26e88c8dd277ecd082","src/ir/extname.rs":"ed2c0b52cdaecc7f0ba9a894ef9fffe139e09b520e43dcd6f0c887a3d41a31ac","src/ir/function.rs":"01dd3b9c7e95324a5683f3d9edb8f272c5e551c0eb84673ca3bf6740e9707b8e","src/ir/globalvalue.rs":"906d29f3d4190b811f66fc549c4e0408bdd2807eac98e33c0b3d5c2b876acc02","src/ir/heap.rs":"a59d3e5901412b53c0b53a8cdf10765ff5921de9c410ae9acea226c89827df3c","src/ir/immediates.rs":"90e5c07d25d093b084adc3c086c8aeddc4c380aa0a1f67c82c59aec9adb00915","src/ir/instructions.rs":"7fe853efeb0379486d7878f7925962144ce208d230107d83e5a9165997a07587","src/ir/jumptable.rs":"7764abc9aa027a5a89d22059b360372bd9a19686887c5a7830f7637d6f188e1e","src/ir/layout.rs":"bb45eefde16ac9423f637dfcc2796ae7b955a97f38a55f23a19cc45da5decce1","src/ir/libcall.rs":"64eeae70e767424ddc8dd01167dc56019df45c3fba5c96bf05fa0d3d7670f344","src/ir/memflags.rs":"dbcf3798ab66dc764b73fb7f139a621c54cc6bcc683f1f70a33ed7e8c3486bfd","src/ir/mod.rs":"7590a2035a6f88a830e6c440d3c5a22102e921445806d04627e46ee42d82d167","src/ir/progpoint.rs":"49433f22bd6ff3a96ad0733ff612f3617b312e4492b6b663187141966f6aa701","src/ir/sourceloc.rs":"e1442572958b138f7637a14b662200ea9f729a513b77108be2a39745d8c2a0d5","src/ir/stackslot.rs":"a116aec3d41fcb570044584d06c97e21fc65d68b31f921ab6b5d7a2daddb614b","src/ir/table.rs":"dcc3b663a989b2b084402b08dc9a0e928dbd052e194a46a1886cc6f0cf1a5f2c","src/ir/trapcode.rs":"59e223193617b8c1043ddd3a907c6131f2987e8fe0965ebfd9f7c056c064b7c5","src/ir/types.rs":"3828c0ff0aee4c101135dcbf0a9a39cd8d89cc9f9d52ca0ce7a42d549a9a4a50","src/ir/valueloc.rs":"1bf764fde5ff8140fa2b59f0192086ed17e9ba7018c74719788b74fc5ca05636","src/isa/arm32/abi.rs":"74775c5f1eb95764e46815fa8b31891416a616fdd212972eb77aead43b3345a9","src/isa/arm32/binemit.rs":"eecd7296c27d2520db8e86dd462833ecf06afd33548b03ae676c02454cdd13c2","src/isa/arm32/enc_tables.rs":"e94b12af802de59484cab1124d2ac8a88d08433f6e1a476724ed0403f4b5967f","src/isa/arm32/mod.rs":"1e02aef8ad188d347a17a7ecce42a9064b2d46ac2a5d246bf9b5cd44180a9b60","src/isa/arm32/registers.rs":"254b568a02480f46bb4967a24a438390231014258f0c159f0a41dbafe8e66d56","src/isa/arm32/settings.rs":"2314460f885c24f9571d640f9737a8e0b7d20ca02bcda1127f878fd3891c0529","src/isa/arm64/abi.rs":"52353ed2e2133dacddaad70a876ecebb9c179c19b911ffa823b5b89d3ee7a17c","src/isa/arm64/binemit.rs":"3afbb78f6d9ae5614d908023f84b774c0493c8757ad86fd8301baf0928bb0104","src/isa/arm64/enc_tables.rs":"73fedf7da610a982e37c76e5211dbce880f77841b71c678b0dab2b9e7217cb7c","src/isa/arm64/mod.rs":"49b7f398ec8baa2802a283f780bd039e2a630591e74cf1dddc8d9147345c2816","src/isa/arm64/registers.rs":"308cfcfd9ff2191d7656e7350bb36e41803664eb86ae490fb4b4d3549b25b6a2","src/isa/arm64/settings.rs":"5405ce3560b7ba0705ef525c706eb9f1593e901e1767b837c012084397639042","src/isa/call_conv.rs":"46a03271aed9cb38f87f2d0301721725f99a4f513ee77e39931ea338f13aa0f7","src/isa/constraints.rs":"bddb5c68e56b122a53d8be215e41d22ccf8c4563630b1486e6eb31c0d3337565","src/isa/enc_tables.rs":"382e714f9500afc292c563cb66d4c963d6787e58f197b1db242db7a099c22b9a","src/isa/encoding.rs":"7ea5b4400530172f96e263561682886ea6c67e706398d44a83933ef7f0ac98a5","src/isa/mod.rs":"cb5e4ffba5575d23b8ec5897393a5e2d7eb3259397f76a47e717b41340879de1","src/isa/registers.rs":"2050f34d87dd6e8a3d1cefc6248383ac5a888ec9b6766359edd883714ef03bda","src/isa/riscv/abi.rs":"36557b91ad16a1344c80fbb16a62b46eac88500d76cb9ebcd4eae224dd67b2de","src/isa/riscv/binemit.rs":"264d223da311d4482ebf2f55438b665c67b163058251bc78173c76ba983a31ef","src/isa/riscv/enc_tables.rs":"8491f2082b24c7dedeb7c36cfd913bf9aeaa0a4c8fc754166e9285f4ae002f40","src/isa/riscv/mod.rs":"41136889df9512d8311f8c015cf3f654557a17d784a17fcefeb0afa2f0ec3674","src/isa/riscv/registers.rs":"666c2abe1a93db5f1573d1603db6c13c37f3fc877c0c93b64d1b971921bfa950","src/isa/riscv/settings.rs":"f6362769e9bc5be0c12b091e414ce924b0d2053b05b0ae88fef118cb8c68761e","src/isa/stack.rs":"5d30e2e19662ff3b3a641888bbb29640094ccd51b9a73368a056352afee46320","src/isa/x86/abi.rs":"52df0eb35643a721d2d1acbee550b2194a4407205a340acd139e8e717dfc2801","src/isa/x86/binemit.rs":"66fb00826397a5c6c99b9ef6b9daedaec0753d4e87279e2ecbca81863bc4309c","src/isa/x86/enc_tables.rs":"b67d453834e0fdcc2885dfe359502755514c9190a8699bae2c4b5026f1ab4017","src/isa/x86/mod.rs":"77879d642905156885b8f502a6b53423dea8a33cf465d74326049a658c8118d8","src/isa/x86/registers.rs":"bed70bbe1f56f3ef03ea7cd1bea68eb911913cb4c8b93167e044dfc639f7f461","src/isa/x86/settings.rs":"d3e403db3507830f79bcc976c17340b57052cf1b50877fcf1a79549f2a054458","src/iterators.rs":"f85f52d3fa707a0eb974c92215b3e976923ce8f9481219f7812e0f2869c2bd37","src/legalizer/boundary.rs":"70a6819cbb116f07d0a09f8e5b0e2fe91145f423ad02e10225f8879ff4e61351","src/legalizer/call.rs":"be6074c64c1a00e5e81159dd94c8401fef62205b22c15e07e0c56cf922554d00","src/legalizer/globalvalue.rs":"59ab09a0faf593c7f228500b3fd3bacfc0412bdcb2864ec3621aa65adc4a5693","src/legalizer/heap.rs":"b83dc83a5876b024db058023692f71d8f910f6b212f34200e9bcf61a19daeb8e","src/legalizer/libcall.rs":"875daf54ac05114e50eba801b25b2c201351e9f6c276ba0358b356498c54d1c6","src/legalizer/mod.rs":"aef4a458f3ab26239e8ac18c0c20791875fbd21e02085fa130be057e5f899a68","src/legalizer/split.rs":"13fe4d2cecea166ecdc1ebb11f5254374ee170518f1a61de7ac0a921bc8fb25d","src/legalizer/table.rs":"c36d03525312e3191aba8ee00c26a87c1ea200f9a9a0370f0cc84eeacff71786","src/lib.rs":"49ad98df2949c815d717e5a076a8654994fe5b71a7b639b058cb86c2183067fd","src/licm.rs":"07534926e2986c01e3b76a2faf2336f5b96411f06d93d44d74e991f76265e29d","src/loop_analysis.rs":"58fc3cc0e700f05e3131ff1b16ff975d4f32a68c790f095d8445bd300356d3c0","src/nan_canonicalization.rs":"9619bb5554791bd1be75ecd98564d6c9f5b65132bc07c5c4d8c210cd79b66f82","src/partition_slice.rs":"bc13504e7658aab565918d965a0b67e941eb572e583870571bc6dbb2b9aad272","src/postopt.rs":"d4c487f0299fb905bb5a5822e38dea6f70afa4d4577288988b5bec8660bc1ba0","src/predicates.rs":"2d62e2f25a6c4327e75716a5f3508edf810c4957d0b20d855ed5a865359c8dfb","src/print_errors.rs":"3fbd77a01b5404a4bbcf2970e44299ad33948c71f4014d92026415daa8325314","src/redundant_reload_remover.rs":"3b2e49280375c9294fb7e190a8b02ef4fcef05ffcf1cb9e6e583cdc8e484bde1","src/ref_slice.rs":"421a61323c11858a596d50220487f399e1bcedeff0e8d1b716dd4b3531eb01a5","src/regalloc/affinity.rs":"19cec5495c8bddc1fcc8f3c8659d527a5a3ea373ffcc130e3fbd5b462ef15930","src/regalloc/coalescing.rs":"d83be1c1067eb56f2f8f16380450a327d6495b4c6f1f489ded68271c055aec07","src/regalloc/coloring.rs":"45fa9a5f19f790f6bcee66ed3d578144712f8f6f19f564b5b84323f63353a8f7","src/regalloc/context.rs":"25e67e8562bbf757e3198d3a70c56d7b9fc5c86e1ada54cd556aac4144ec7ef2","src/regalloc/diversion.rs":"d46d733f6d00a8f536d5c7c8b8fc6f348c3d0605dd0ee77e1d8359367ba53347","src/regalloc/live_value_tracker.rs":"28823003dc72e8a4702776a8ab5ffd878712700a272b64376b0de2022e0ee31a","src/regalloc/liveness.rs":"a59673fda65d1e3c0e5b3f4468686d05a389c877bee7b10323264595c3c54677","src/regalloc/liverange.rs":"7a28454e5f70d570db439b966a01ead759b65eb65c5845f9c58bf2f230a5f2ab","src/regalloc/mod.rs":"594e059f9f2cbb1e1e2d45ec080c7544c3549bf8b309e6a1b30fcb36b8d7810e","src/regalloc/pressure.rs":"04738e95418f0f858885dfc45183efc3dfb59c8d2ad2fd88bbd9a73a62907730","src/regalloc/register_set.rs":"a816187bc0ca7e0fd9464fde9a37cdeaf09c5f5e7b10faee0eb12f6873034e1c","src/regalloc/reload.rs":"ccccb716a694b53103bd4d55efb2323e788c1127469233c17b648fa06baa67b1","src/regalloc/safepoint.rs":"93a4f963990298a2f2d64148c72859a4a0d5d3176b404834ab743b756882bf56","src/regalloc/solver.rs":"0787ddf732fae9112fb905d6a1dc0c29673800985e67bd57d900426269847e7b","src/regalloc/spilling.rs":"dff4af64409c9a1db7697423576826c3920c26c892fbdde89ee31c680d672e03","src/regalloc/virtregs.rs":"e5c8da6860ba9495f9396621530347e1dd6fc5b2fae2eb23c171ea77429356f1","src/result.rs":"c10354d615f93caa446c3c8c49d6ba3af762816af470f9c4accf04315cce9753","src/scoped_hash_map.rs":"5afafb3a4039094c3a2aad1582354220d21f399aa50046e7f4a1259e1976597e","src/settings.rs":"6c86c3d9b7b9a6424010c08cf6649d405edea5c1955645fa8ec43b9d6f22c3cb","src/simple_gvn.rs":"c8feb380d4831badc59aa1e65efeafa6702711585817fe5f6b31de6b265fac24","src/simple_preopt.rs":"9ee5b9deff729ee6b5b7111a15897f989ff26b9316848fcd5c22930df857467a","src/stack_layout.rs":"c5de271e296fc424f1a30017620bc88500369c8e553fef6e95beccb9c6640e7c","src/timing.rs":"a6808943eec68f5d3ff32132d40c07c142e6aa8073473561573a013978883e4f","src/topo_order.rs":"b01ed68a7300691f41ac434e58a5267b10a8b4a7056d65035e24aa8a6722122a","src/unreachable_code.rs":"40cc71a02887ee4065c76ce96dda0a363a8cc134ec784fe5ed1f276db76596ce","src/value_label.rs":"b81376e0b79252de8dff19d003bcdae210c0848229e63e7682b0148bbcde5961","src/verifier/cssa.rs":"e3e1d77b763c0ba82d3b59ab5b4667fd3152d5a08be50b58b0c82f86376bb062","src/verifier/flags.rs":"cac8ba7ed5fe621eaa425112b931423cb5f3523d580fcf0b7536deb252e96186","src/verifier/liveness.rs":"ac3413b464ee8b5aa5928bee724799b9a1e0cbbdce433c819b9d870483ed070a","src/verifier/locations.rs":"04635edc12bc741a23c9318611aac4abcb42f01effbebee6d858f108f9393a44","src/verifier/mod.rs":"4d013e70bdc90743637fb91a8f3d32790c25aeff168219d147431c02c44f37b7","src/write.rs":"35dff9d0f5ed74779e536cbc6b1de7381cec521a0c54f6d8513041d118bbfc4b"},"package":null}
\ No newline at end of file
--- a/third_party/rust/cranelift-codegen/src/binemit/memorysink.rs
+++ b/third_party/rust/cranelift-codegen/src/binemit/memorysink.rs
@@ -11,17 +11,17 @@
 //! The `MemoryCodeSink` type fixes the performance problem because it is a type known to
 //! `TargetIsa` so it can specialize its machine code generation for the type. The trade-off is
 //! that a `MemoryCodeSink` will always write binary machine code to raw memory. It forwards any
 //! relocations to a `RelocSink` trait object. Relocations are less frequent than the
 //! `CodeSink::put*` methods, so the performance impact of the virtual callbacks is less severe.
 use super::{Addend, CodeInfo, CodeOffset, CodeSink, Reloc};
 use crate::binemit::stackmap::Stackmap;
 use crate::ir::entities::Value;
-use crate::ir::{ExternalName, Function, JumpTable, SourceLoc, TrapCode};
+use crate::ir::{ConstantOffset, ExternalName, Function, JumpTable, SourceLoc, TrapCode};
 use crate::isa::TargetIsa;
 use core::ptr::write_unaligned;
 
 /// A `CodeSink` that writes binary machine code directly into memory.
 ///
 /// A `MemoryCodeSink` object should be used when emitting a Cranelift IR function into executable
 /// memory. It writes machine code directly to a raw pointer without any bounds checking, so make
 /// sure to allocate enough memory for the whole function. The number of bytes required is returned
@@ -73,16 +73,19 @@ impl<'a> MemoryCodeSink<'a> {
 /// A trait for receiving relocations for code that is emitted directly into memory.
 pub trait RelocSink {
     /// Add a relocation referencing an EBB at the current offset.
     fn reloc_ebb(&mut self, _: CodeOffset, _: Reloc, _: CodeOffset);
 
     /// Add a relocation referencing an external symbol at the current offset.
     fn reloc_external(&mut self, _: CodeOffset, _: Reloc, _: &ExternalName, _: Addend);
 
+    /// Add a relocation referencing a constant.
+    fn reloc_constant(&mut self, _: CodeOffset, _: Reloc, _: ConstantOffset);
+
     /// Add a relocation referencing a jump table.
     fn reloc_jt(&mut self, _: CodeOffset, _: Reloc, _: JumpTable);
 }
 
 /// A trait for receiving trap codes and offsets.
 ///
 /// If you don't need information about possible traps, you can use the
 /// [`NullTrapSink`](NullTrapSink) implementation.
@@ -127,16 +130,21 @@ impl<'a> CodeSink for MemoryCodeSink<'a>
         self.relocs.reloc_ebb(ofs, rel, ebb_offset);
     }
 
     fn reloc_external(&mut self, rel: Reloc, name: &ExternalName, addend: Addend) {
         let ofs = self.offset();
         self.relocs.reloc_external(ofs, rel, name, addend);
     }
 
+    fn reloc_constant(&mut self, rel: Reloc, constant_offset: ConstantOffset) {
+        let ofs = self.offset();
+        self.relocs.reloc_constant(ofs, rel, constant_offset);
+    }
+
     fn reloc_jt(&mut self, rel: Reloc, jt: JumpTable) {
         let ofs = self.offset();
         self.relocs.reloc_jt(ofs, rel, jt);
     }
 
     fn trap(&mut self, code: TrapCode, srcloc: SourceLoc) {
         let ofs = self.offset();
         self.traps.trap(ofs, srcloc, code);
@@ -164,16 +172,17 @@ impl<'a> CodeSink for MemoryCodeSink<'a>
 
 /// A `RelocSink` implementation that does nothing, which is convenient when
 /// compiling code that does not relocate anything.
 pub struct NullRelocSink {}
 
 impl RelocSink for NullRelocSink {
     fn reloc_ebb(&mut self, _: u32, _: Reloc, _: u32) {}
     fn reloc_external(&mut self, _: u32, _: Reloc, _: &ExternalName, _: i64) {}
+    fn reloc_constant(&mut self, _: CodeOffset, _: Reloc, _: ConstantOffset) {}
     fn reloc_jt(&mut self, _: u32, _: Reloc, _: JumpTable) {}
 }
 
 /// A `TrapSink` implementation that does nothing, which is convenient when
 /// compiling code that does not rely on trapping semantics.
 pub struct NullTrapSink {}
 
 impl TrapSink for NullTrapSink {
--- a/third_party/rust/cranelift-codegen/src/binemit/mod.rs
+++ b/third_party/rust/cranelift-codegen/src/binemit/mod.rs
@@ -11,17 +11,17 @@ mod stackmap;
 pub use self::memorysink::{
     MemoryCodeSink, NullRelocSink, NullStackmapSink, NullTrapSink, RelocSink, StackmapSink,
     TrapSink,
 };
 pub use self::relaxation::relax_branches;
 pub use self::shrink::shrink_instructions;
 pub use self::stackmap::Stackmap;
 use crate::ir::entities::Value;
-use crate::ir::{ExternalName, Function, Inst, JumpTable, SourceLoc, TrapCode};
+use crate::ir::{ConstantOffset, ExternalName, Function, Inst, JumpTable, SourceLoc, TrapCode};
 use crate::isa::TargetIsa;
 pub use crate::regalloc::RegDiversions;
 use core::fmt;
 #[cfg(feature = "enable-serde")]
 use serde::{Deserialize, Serialize};
 
 /// Offset in bytes from the beginning of the function.
 ///
@@ -129,16 +129,19 @@ pub trait CodeSink {
 
     /// Add a relocation referencing an EBB at the current offset.
     fn reloc_ebb(&mut self, _: Reloc, _: CodeOffset);
 
     /// Add a relocation referencing an external symbol plus the addend at the current offset.
     fn reloc_external(&mut self, _: Reloc, _: &ExternalName, _: Addend);
 
     /// Add a relocation referencing a jump table.
+    fn reloc_constant(&mut self, _: Reloc, _: ConstantOffset);
+
+    /// Add a relocation referencing a jump table.
     fn reloc_jt(&mut self, _: Reloc, _: JumpTable);
 
     /// Add trap information for the current offset.
     fn trap(&mut self, _: TrapCode, _: SourceLoc);
 
     /// Machine code output is complete, jump table data may follow.
     fn begin_jumptables(&mut self);
 
@@ -187,12 +190,18 @@ where
         let jt_offset = func.jt_offsets[jt];
         for ebb in jt_data.iter() {
             let rel_offset: i32 = func.offsets[*ebb] as i32 - jt_offset as i32;
             sink.put4(rel_offset as u32)
         }
     }
 
     sink.begin_rodata();
-    // TODO: No read-only data (constant pools) at this time.
+
+    // output constants
+    for (_, constant_data) in func.dfg.constants.iter() {
+        for byte in constant_data.iter() {
+            sink.put1(*byte)
+        }
+    }
 
     sink.end_codegen();
 }
--- a/third_party/rust/cranelift-codegen/src/binemit/relaxation.rs
+++ b/third_party/rust/cranelift-codegen/src/binemit/relaxation.rs
@@ -32,16 +32,17 @@ use crate::cursor::{Cursor, FuncCursor};
 use crate::dominator_tree::DominatorTree;
 use crate::flowgraph::ControlFlowGraph;
 use crate::ir::{Function, InstructionData, Opcode};
 use crate::isa::{EncInfo, TargetIsa};
 use crate::iterators::IteratorExtras;
 use crate::regalloc::RegDiversions;
 use crate::timing;
 use crate::CodegenResult;
+use core::convert::TryFrom;
 use log::debug;
 
 #[cfg(feature = "basic-blocks")]
 use crate::ir::{Ebb, Inst, Value, ValueList};
 
 /// Relax branches and compute the final layout of EBB headers in `func`.
 ///
 /// Fill in the `func.offsets` table so the function is ready for binary emission.
@@ -130,17 +131,21 @@ pub fn relax_branches(
         // TODO: this should be computed based on the min size needed to hold
         //        the furthest branch.
         offset += jt_data.len() as u32 * 4;
     }
 
     let jumptables_size = offset - jumptables;
     let rodata = offset;
 
-    // TODO: Once we have constant pools we'll do some processing here to update offset.
+    for constant in func.dfg.constants.entries_mut() {
+        constant.set_offset(offset);
+        offset +=
+            u32::try_from(constant.len()).expect("Constants must have a length that fits in a u32")
+    }
 
     let rodata_size = offset - rodata;
 
     Ok(CodeInfo {
         code_size,
         jumptables_size,
         rodata_size,
         total_size: offset,
new file mode 100644
--- /dev/null
+++ b/third_party/rust/cranelift-codegen/src/ir/constant.rs
@@ -0,0 +1,220 @@
+//! Constants
+//!
+//! The constant pool defined here allows cranelift to avoid emitting the same constant multiple
+//! times. As constants are inserted in the pool, a handle is returned; the handle is a cranelift
+//! Entity. Inserting the same data multiple times will always return the same handle. Future work
+//! could include: ensuring alignment of constants within the pool, bucketing constants by size.
+
+use crate::ir::Constant;
+use cranelift_entity::EntityRef;
+use std::collections::{BTreeMap, HashMap};
+use std::vec::Vec;
+
+/// This type describes the actual constant data.
+pub type ConstantData = Vec<u8>;
+
+/// This type describes an offset in bytes within a constant pool.
+pub type ConstantOffset = u32;
+
+/// Inner type for storing data and offset together in the constant pool. The offset is optional
+/// because it must be set relative to the function code size (i.e. constants are emitted after the
+/// function body); because the function is not yet compiled when constants are inserted,
+/// [`set_offset`](crate::ir::ConstantPool::set_offset) must be called once a constant's
+/// offset from the beginning of the function is known (see
+/// [`relaxation.rs`](crate::binemit::relaxation)).
+#[derive(Clone)]
+pub struct ConstantPoolEntry {
+    data: ConstantData,
+    offset: Option<ConstantOffset>,
+}
+
+impl ConstantPoolEntry {
+    fn new(data: ConstantData) -> Self {
+        ConstantPoolEntry { data, offset: None }
+    }
+
+    /// Return the size of the constant at this entry.
+    pub fn len(&self) -> usize {
+        self.data.len()
+    }
+
+    /// Assign a new offset to the constant at this entry.
+    pub fn set_offset(&mut self, offset: ConstantOffset) {
+        self.offset = Some(offset)
+    }
+}
+
+/// Maintains the mapping between a constant handle (i.e.
+/// [`Constant`](crate::ir::Constant)) and its constant data (i.e.
+/// [`ConstantData`](crate::ir::ConstantData)).
+#[derive(Clone)]
+pub struct ConstantPool {
+    /// This mapping maintains the insertion order as long as Constants are created with sequentially increasing integers.
+    handles_to_values: BTreeMap<Constant, ConstantPoolEntry>,
+    /// This mapping is unordered (no need for lexicographic ordering) but allows us to map constant data back to handles.
+    values_to_handles: HashMap<ConstantData, Constant>,
+}
+
+impl ConstantPool {
+    /// Create a new constant pool instance.
+    pub fn new() -> Self {
+        ConstantPool {
+            handles_to_values: BTreeMap::new(),
+            values_to_handles: HashMap::new(),
+        }
+    }
+
+    /// Empty the constant pool of all data.
+    pub fn clear(&mut self) {
+        self.handles_to_values.clear();
+        self.values_to_handles.clear();
+    }
+
+    /// Insert constant data into the pool, returning a handle for later referencing; when constant
+    /// data is inserted that is a duplicate of previous constant data, the existing handle will be
+    /// returned.
+    pub fn insert(&mut self, constant_value: ConstantData) -> Constant {
+        if self.values_to_handles.contains_key(&constant_value) {
+            self.values_to_handles
+                .get(&constant_value)
+                .expect("A constant handle must have a corresponding constant value; this is an implementation error in ConstantPool")
+                .clone()
+        } else {
+            let constant_handle = Constant::new(self.len());
+            self.values_to_handles
+                .insert(constant_value.clone(), constant_handle.clone());
+            self.handles_to_values.insert(
+                constant_handle.clone(),
+                ConstantPoolEntry::new(constant_value),
+            );
+            constant_handle
+        }
+    }
+
+    /// Retrieve the constant data given a handle.
+    pub fn get(&self, constant_handle: Constant) -> &ConstantData {
+        assert!(self.handles_to_values.contains_key(&constant_handle));
+        &self.handles_to_values
+            .get(&constant_handle)
+            .expect("A constant handle must have a corresponding constant value; was a constant handle created outside of the pool?")
+            .data
+    }
+
+    /// Assign an offset to a given constant, where the offset is the number of bytes from the
+    /// beginning of the function to the beginning of the constant data inside the pool.
+    pub fn set_offset(&mut self, constant_handle: Constant, constant_offset: ConstantOffset) {
+        assert!(self.handles_to_values.contains_key(&constant_handle), "A constant handle must have already been inserted into the pool; perhaps a constant pool was created outside of the pool?");
+        self.handles_to_values
+            .entry(constant_handle)
+            .and_modify(|e| e.offset = Some(constant_offset));
+    }
+
+    /// Retrieve the offset of a given constant, where the offset is the number of bytes from the
+    /// beginning of the function to the beginning of the constant data inside the pool.
+    pub fn get_offset(&self, constant_handle: Constant) -> ConstantOffset {
+        self.handles_to_values.get(&constant_handle)
+            .expect("A constant handle must have a corresponding constant value; was a constant handle created outside of the pool?")
+            .offset
+            .expect("A constant offset has not yet been set; verify that `set_offset` has been called before this point")
+    }
+
+    /// Iterate over the constants in insertion order.
+    pub fn iter(&self) -> impl Iterator<Item = (&Constant, &ConstantData)> {
+        self.handles_to_values.iter().map(|(h, e)| (h, &e.data))
+    }
+
+    /// Iterate over mutable entries in the constant pool in insertion order.
+    pub fn entries_mut(&mut self) -> impl Iterator<Item = &mut ConstantPoolEntry> {
+        self.handles_to_values.values_mut()
+    }
+
+    /// Return the number of constants in the pool.
+    pub fn len(&self) -> usize {
+        self.handles_to_values.len()
+    }
+
+    /// Return the combined size of all of the constant values in the pool.
+    pub fn byte_size(&self) -> usize {
+        self.values_to_handles.keys().map(|c| c.len()).sum()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn empty() {
+        let sut = ConstantPool::new();
+        assert_eq!(sut.len(), 0);
+    }
+
+    #[test]
+    fn insert() {
+        let mut sut = ConstantPool::new();
+        sut.insert(vec![1, 2, 3]);
+        sut.insert(vec![4, 5, 6]);
+        assert_eq!(sut.len(), 2);
+    }
+
+    #[test]
+    fn insert_duplicate() {
+        let mut sut = ConstantPool::new();
+        let a = sut.insert(vec![1, 2, 3]);
+        sut.insert(vec![4, 5, 6]);
+        let b = sut.insert(vec![1, 2, 3]);
+        assert_eq!(a, b);
+    }
+
+    #[test]
+    fn clear() {
+        let mut sut = ConstantPool::new();
+        sut.insert(vec![1, 2, 3]);
+        assert_eq!(sut.len(), 1);
+
+        sut.clear();
+        assert_eq!(sut.len(), 0);
+    }
+
+    #[test]
+    fn iteration_order() {
+        let mut sut = ConstantPool::new();
+        sut.insert(vec![1, 2, 3]);
+        sut.insert(vec![4, 5, 6]);
+        sut.insert(vec![1, 2, 3]);
+        let data = sut.iter().map(|(_, v)| v).collect::<Vec<&ConstantData>>();
+        assert_eq!(data, vec![&vec![1, 2, 3], &vec![4, 5, 6]]);
+    }
+
+    #[test]
+    fn get() {
+        let mut sut = ConstantPool::new();
+        let data = vec![1, 2, 3];
+        let handle = sut.insert(data.clone());
+        assert_eq!(sut.get(handle), &data);
+    }
+
+    #[test]
+    #[should_panic]
+    fn get_nonexistent_constant() {
+        let sut = ConstantPool::new();
+        let a = Constant::with_number(42).unwrap();
+        sut.get(a); // panics, only use constants returned by ConstantPool
+    }
+
+    #[test]
+    fn get_offset() {
+        let mut sut = ConstantPool::new();
+        let a = sut.insert(vec![1]);
+        sut.set_offset(a, 42);
+        assert_eq!(sut.get_offset(a), 42)
+    }
+
+    #[test]
+    #[should_panic]
+    fn get_nonexistent_offset() {
+        let mut sut = ConstantPool::new();
+        let a = sut.insert(vec![1]);
+        sut.get_offset(a); // panics, set_offset should have been called
+    }
+}
--- a/third_party/rust/cranelift-codegen/src/ir/dfg.rs
+++ b/third_party/rust/cranelift-codegen/src/ir/dfg.rs
@@ -1,16 +1,16 @@
 //! Data flow graph tracking Instructions, Values, and EBBs.
 
 use crate::entity::{self, PrimaryMap, SecondaryMap};
 use crate::ir;
 use crate::ir::builder::ReplaceBuilder;
 use crate::ir::extfunc::ExtFuncData;
 use crate::ir::instructions::{BranchInfo, CallInfo, InstructionData};
-use crate::ir::types;
+use crate::ir::{types, ConstantPool};
 use crate::ir::{
     Ebb, FuncRef, Inst, SigRef, Signature, Type, Value, ValueLabelAssignments, ValueList,
     ValueListPool,
 };
 use crate::isa::TargetIsa;
 use crate::packed_option::ReservedValue;
 use crate::write::write_operands;
 use core::fmt;
@@ -62,43 +62,48 @@ pub struct DataFlowGraph {
     /// well as the external function references.
     pub signatures: PrimaryMap<SigRef, Signature>,
 
     /// External function references. These are functions that can be called directly.
     pub ext_funcs: PrimaryMap<FuncRef, ExtFuncData>,
 
     /// Saves Value labels.
     pub values_labels: Option<HashMap<Value, ValueLabelAssignments>>,
+
+    /// Constants used within the function
+    pub constants: ConstantPool,
 }
 
 impl DataFlowGraph {
     /// Create a new empty `DataFlowGraph`.
     pub fn new() -> Self {
         Self {
             insts: PrimaryMap::new(),
             results: SecondaryMap::new(),
             ebbs: PrimaryMap::new(),
             value_lists: ValueListPool::new(),
             values: PrimaryMap::new(),
             signatures: PrimaryMap::new(),
             ext_funcs: PrimaryMap::new(),
             values_labels: None,
+            constants: ConstantPool::new(),
         }
     }
 
     /// Clear everything.
     pub fn clear(&mut self) {
         self.insts.clear();
         self.results.clear();
         self.ebbs.clear();
         self.value_lists.clear();
         self.values.clear();
         self.signatures.clear();
         self.ext_funcs.clear();
         self.values_labels = None;
+        self.constants.clear()
     }
 
     /// Get the total number of instructions created in this function, whether they are currently
     /// inserted in the layout or not.
     ///
     /// This is intended for use with `SecondaryMap::with_capacity`.
     pub fn num_insts(&self) -> usize {
         self.insts.len()
--- a/third_party/rust/cranelift-codegen/src/ir/entities.rs
+++ b/third_party/rust/cranelift-codegen/src/ir/entities.rs
@@ -99,16 +99,34 @@ impl GlobalValue {
         if n < u32::MAX {
             Some(GlobalValue(n))
         } else {
             None
         }
     }
 }
 
+/// An opaque reference to a constant
+#[derive(Copy, Clone, PartialEq, Eq, Hash, Ord, PartialOrd)]
+pub struct Constant(u32);
+entity_impl!(Constant, "const");
+
+impl Constant {
+    /// Create a const reference from its number.
+    ///
+    /// This method is for use by the parser.
+    pub fn with_number(n: u32) -> Option<Self> {
+        if n < u32::MAX {
+            Some(Constant(n))
+        } else {
+            None
+        }
+    }
+}
+
 /// An opaque reference to a jump table.
 #[derive(Copy, Clone, PartialEq, Eq, Hash)]
 #[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
 pub struct JumpTable(u32);
 entity_impl!(JumpTable, "jt");
 
 impl JumpTable {
     /// Create a new jump table reference from its number.
@@ -190,17 +208,17 @@ impl Table {
         if n < u32::MAX {
             Some(Table(n))
         } else {
             None
         }
     }
 }
 
-/// A reference to any of the entities defined in this module.
+/// A reference to any of the entities defined in this module that can appear in CLIF IR.
 #[derive(Copy, Clone, PartialEq, Eq, Hash)]
 pub enum AnyEntity {
     /// The whole function.
     Function,
     /// An extended basic block.
     Ebb(Ebb),
     /// An instruction.
     Inst(Inst),
@@ -326,9 +344,15 @@ mod tests {
         use crate::packed_option::PackedOption;
         use core::mem;
         // This is the whole point of `PackedOption`.
         assert_eq!(
             mem::size_of::<Value>(),
             mem::size_of::<PackedOption<Value>>()
         );
     }
+
+    #[test]
+    fn constant_with_number() {
+        assert_eq!(Constant::with_number(0).unwrap().to_string(), "const0");
+        assert_eq!(Constant::with_number(1).unwrap().to_string(), "const1");
+    }
 }
--- a/third_party/rust/cranelift-codegen/src/ir/function.rs
+++ b/third_party/rust/cranelift-codegen/src/ir/function.rs
@@ -108,16 +108,17 @@ impl Function {
         self.heaps.clear();
         self.tables.clear();
         self.jump_tables.clear();
         self.dfg.clear();
         self.layout.clear();
         self.encodings.clear();
         self.locations.clear();
         self.offsets.clear();
+        self.jt_offsets.clear();
         self.srclocs.clear();
     }
 
     /// Create a new empty, anonymous function with a Fast calling convention.
     pub fn new() -> Self {
         Self::with_name_signature(ExternalName::default(), Signature::new(CallConv::Fast))
     }
 
--- a/third_party/rust/cranelift-codegen/src/ir/immediates.rs
+++ b/third_party/rust/cranelift-codegen/src/ir/immediates.rs
@@ -259,16 +259,84 @@ impl FromStr for Uimm32 {
                 Ok(Uimm32(x as u32))
             } else {
                 Err("Uimm32 out of range")
             }
         })
     }
 }
 
+/// A 128-bit unsigned integer immediate operand.
+///
+/// This is used as an immediate value in SIMD instructions
+#[derive(Copy, Clone, PartialEq, Eq, Debug, Hash)]
+pub struct Uimm128(pub [u8; 16]);
+
+impl Display for Uimm128 {
+    // print a 128-bit vector in hexadecimal, e.g. 0x000102030405060708090a0b0c0d0e0f
+    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+        write!(f, "0x")?;
+        let mut anything_written = false;
+        for &b in self.0.iter().rev() {
+            if b == 0 && !anything_written {
+                continue;
+            } else {
+                anything_written = true;
+                write!(f, "{:02x}", b)?;
+            }
+        }
+        if !anything_written {
+            write!(f, "00")?;
+        }
+        Ok(())
+    }
+}
+
+impl From<u64> for Uimm128 {
+    fn from(x: u64) -> Self {
+        let mut buffer: [u8; 16] = [0; 16]; // zero-fill
+        (0..8).for_each(|byte| buffer[byte] = (x >> (byte as u64 * 8) & 0xff) as u8); // insert each byte from the u64 into v in little-endian order
+        Uimm128(buffer)
+    }
+}
+
+impl From<&[u8]> for Uimm128 {
+    fn from(slice: &[u8]) -> Self {
+        assert_eq!(slice.len(), 16);
+        let mut buffer = [0; 16];
+        buffer.copy_from_slice(slice);
+        Uimm128(buffer)
+    }
+}
+
+impl FromStr for Uimm128 {
+    type Err = &'static str;
+
+    // parse a 128-bit vector from a hexadecimal string, formatted as above
+    fn from_str(s: &str) -> Result<Self, &'static str> {
+        if s.len() <= 2 || &s[0..2] != "0x" {
+            Err("Expected a hexadecimal string, e.g. 0x1234")
+        } else if s.len() % 2 != 0 {
+            Err("Hexadecimal string must have an even number of digits")
+        } else if s.len() > 34 {
+            Err("Hexadecimal string has too many digits to fit in a 128-bit vector")
+        } else {
+            let mut buffer = [0; 16]; // zero-fill
+            let start_at = s.len() / 2 - 1;
+            for i in (2..s.len()).step_by(2) {
+                let byte = u8::from_str_radix(&s[i..i + 2], 16)
+                    .or_else(|_| Err("Unable to parse as hexadecimal"))?;
+                let position = start_at - (i / 2);
+                buffer[position] = byte;
+            }
+            Ok(Uimm128(buffer))
+        }
+    }
+}
+
 /// 32-bit signed immediate offset.
 ///
 /// This is used to encode an immediate offset for load/store instructions. All supported ISAs have
 /// a maximum load/store offset that fits in an `i32`.
 #[derive(Copy, Clone, PartialEq, Eq, Debug, Hash)]
 pub struct Offset32(i32);
 
 impl Offset32 {
@@ -880,16 +948,64 @@ mod tests {
         parse_err::<Uimm64>("-0", "Invalid character in decimal number");
         parse_err::<Uimm64>("-1", "Invalid character in decimal number");
 
         // Hex count overflow.
         parse_err::<Uimm64>("0x0_0000_0000_0000_0000", "Too many hexadecimal digits");
     }
 
     #[test]
+    fn format_uimm128() {
+        assert_eq!(Uimm128::from(0).to_string(), "0x00");
+        assert_eq!(Uimm128::from(42).to_string(), "0x2a");
+        assert_eq!(Uimm128::from(3735928559).to_string(), "0xdeadbeef");
+        assert_eq!(
+            Uimm128::from(0x0102030405060708).to_string(),
+            "0x0102030405060708"
+        );
+    }
+
+    #[test]
+    fn parse_uimm128() {
+        parse_ok::<Uimm128>("0x00", "0x00");
+        parse_ok::<Uimm128>("0x00000042", "0x42");
+        parse_ok::<Uimm128>(
+            "0x0102030405060708090a0b0c0d0e0f",
+            "0x0102030405060708090a0b0c0d0e0f",
+        );
+
+        parse_err::<Uimm128>("", "Expected a hexadecimal string, e.g. 0x1234");
+        parse_err::<Uimm128>("0x", "Expected a hexadecimal string, e.g. 0x1234");
+        parse_err::<Uimm128>(
+            "0x042",
+            "Hexadecimal string must have an even number of digits",
+        );
+        parse_err::<Uimm128>(
+            "0x00000000000000000000000000000000000000000000000000",
+            "Hexadecimal string has too many digits to fit in a 128-bit vector",
+        );
+    }
+
+    #[test]
+    fn uimm128_endianness() {
+        assert_eq!(
+            "0x42".parse::<Uimm128>().unwrap().0,
+            [0x42, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+        );
+        assert_eq!(
+            "0x00".parse::<Uimm128>().unwrap().0,
+            [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+        );
+        assert_eq!(
+            "0x12345678".parse::<Uimm128>().unwrap().0,
+            [0x78, 0x56, 0x34, 0x12, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+        )
+    }
+
+    #[test]
     fn format_offset32() {
         assert_eq!(Offset32(0).to_string(), "");
         assert_eq!(Offset32(1).to_string(), "+1");
         assert_eq!(Offset32(-1).to_string(), "-1");
         assert_eq!(Offset32(9999).to_string(), "+9999");
         assert_eq!(Offset32(10000).to_string(), "+0x2710");
         assert_eq!(Offset32(-9999).to_string(), "-9999");
         assert_eq!(Offset32(-10000).to_string(), "-0x2710");
--- a/third_party/rust/cranelift-codegen/src/ir/mod.rs
+++ b/third_party/rust/cranelift-codegen/src/ir/mod.rs
@@ -1,12 +1,13 @@
 //! Representation of Cranelift IR functions.
 
 mod builder;
 pub mod condcodes;
+pub mod constant;
 pub mod dfg;
 pub mod entities;
 mod extfunc;
 mod extname;
 pub mod function;
 mod globalvalue;
 mod heap;
 pub mod immediates;
@@ -22,19 +23,20 @@ mod table;
 mod trapcode;
 pub mod types;
 mod valueloc;
 
 #[cfg(feature = "enable-serde")]
 use serde::{Deserialize, Serialize};
 
 pub use crate::ir::builder::{InsertBuilder, InstBuilder, InstBuilderBase, InstInserterBase};
+pub use crate::ir::constant::{ConstantData, ConstantOffset, ConstantPool};
 pub use crate::ir::dfg::{DataFlowGraph, ValueDef};
 pub use crate::ir::entities::{
-    Ebb, FuncRef, GlobalValue, Heap, Inst, JumpTable, SigRef, StackSlot, Table, Value,
+    Constant, Ebb, FuncRef, GlobalValue, Heap, Inst, JumpTable, SigRef, StackSlot, Table, Value,
 };
 pub use crate::ir::extfunc::{
     AbiParam, ArgumentExtension, ArgumentPurpose, ExtFuncData, Signature,
 };
 pub use crate::ir::extname::ExternalName;
 pub use crate::ir::function::{DisplayFunctionAnnotations, Function};
 pub use crate::ir::globalvalue::GlobalValueData;
 pub use crate::ir::heap::{HeapData, HeapStyle};
--- a/third_party/rust/cranelift-codegen/src/isa/x86/binemit.rs
+++ b/third_party/rust/cranelift-codegen/src/isa/x86/binemit.rs
@@ -1,15 +1,15 @@
 //! Emitting binary x86 machine code.
 
 use super::enc_tables::{needs_offset, needs_sib_byte};
 use super::registers::RU;
 use crate::binemit::{bad_encoding, CodeSink, Reloc};
 use crate::ir::condcodes::{CondCode, FloatCC, IntCC};
-use crate::ir::{Ebb, Function, Inst, InstructionData, JumpTable, Opcode, TrapCode};
+use crate::ir::{Constant, Ebb, Function, Inst, InstructionData, JumpTable, Opcode, TrapCode};
 use crate::isa::{RegUnit, StackBase, StackBaseMask, StackRef, TargetIsa};
 use crate::regalloc::RegDiversions;
 
 include!(concat!(env!("OUT_DIR"), "/binemit-x86.rs"));
 
 // Convert a stack base to the corresponding register.
 fn stk_base(base: StackBase) -> RegUnit {
     let ru = match base {
@@ -336,8 +336,16 @@ fn disp4<CS: CodeSink + ?Sized>(destinat
 }
 
 /// Emit a four-byte displacement to jump table `jt`.
 fn jt_disp4<CS: CodeSink + ?Sized>(jt: JumpTable, func: &Function, sink: &mut CS) {
     let delta = func.jt_offsets[jt].wrapping_sub(sink.offset() + 4);
     sink.put4(delta);
     sink.reloc_jt(Reloc::X86PCRelRodata4, jt);
 }
+
+/// Emit a four-byte displacement to `constant`
+fn const_disp4<CS: CodeSink + ?Sized>(constant: Constant, func: &Function, sink: &mut CS) {
+    let offset = func.dfg.constants.get_offset(constant);
+    let delta = offset.wrapping_sub(sink.offset() + 4);
+    sink.put4(delta);
+    sink.reloc_constant(Reloc::X86PCRelRodata4, offset);
+}
--- a/third_party/rust/cranelift-codegen/src/verifier/mod.rs
+++ b/third_party/rust/cranelift-codegen/src/verifier/mod.rs
@@ -674,16 +674,17 @@ impl<'a> Verifier<'a> {
             }
             StoreComplex { ref args, .. } => {
                 self.verify_value_list(inst, args, errors)?;
             }
 
             // Exhaustive list so we can't forget to add new formats
             Unary { .. }
             | UnaryImm { .. }
+            | UnaryImm128 { .. }
             | UnaryIeee32 { .. }
             | UnaryIeee64 { .. }
             | UnaryBool { .. }
             | Binary { .. }
             | BinaryImm { .. }
             | Ternary { .. }
             | InsertLane { .. }
             | ExtractLane { .. }
--- a/third_party/rust/cranelift-codegen/src/write.rs
+++ b/third_party/rust/cranelift-codegen/src/write.rs
@@ -1,15 +1,16 @@
 //! 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::immediates::Uimm128;
 use crate::ir::{
     DataFlowGraph, DisplayFunctionAnnotations, Ebb, Function, Inst, SigRef, Type, Value, ValueDef,
     ValueLoc,
 };
 use crate::isa::{RegInfo, TargetIsa};
 use crate::packed_option::ReservedValue;
 use crate::value_label::ValueLabelsRanges;
 use core::fmt::{self, Write};
@@ -482,16 +483,21 @@ pub fn write_operands(
     isa: Option<&dyn TargetIsa>,
     inst: Inst,
 ) -> fmt::Result {
     let pool = &dfg.value_lists;
     use crate::ir::instructions::InstructionData::*;
     match dfg[inst] {
         Unary { arg, .. } => write!(w, " {}", arg),
         UnaryImm { imm, .. } => write!(w, " {}", imm),
+        UnaryImm128 { imm, .. } => {
+            let data = dfg.constants.get(imm);
+            let uimm128 = Uimm128::from(&data[..]);
+            write!(w, " {}", uimm128)
+        }
         UnaryIeee32 { imm, .. } => write!(w, " {}", imm),
         UnaryIeee64 { imm, .. } => write!(w, " {}", imm),
         UnaryBool { imm, .. } => write!(w, " {}", imm),
         UnaryGlobalValue { global_value, .. } => write!(w, " {}", global_value),
         Binary { args, .. } => write!(w, " {}, {}", args[0], args[1]),
         BinaryImm { arg, imm, .. } => write!(w, " {}, {}", arg, imm),
         Ternary { args, .. } => write!(w, " {}, {}, {}", args[0], args[1], args[2]),
         MultiAry { ref args, .. } => {
--- a/third_party/rust/cranelift-wasm/.cargo-checksum.json
+++ b/third_party/rust/cranelift-wasm/.cargo-checksum.json
@@ -1,1 +1,1 @@
-{"files":{"Cargo.toml":"0acc3911c582b0f38099b4694d7600e6d5bb59a701c0b71144ba4cdd0ee2babf","LICENSE":"268872b9816f90fd8e85db5a28d33f8150ebb8dd016653fb39ef1f94f2686bc5","README.md":"87679cdb53e8cbec3b1aa45afb2124727c1c059f8bd10363d27daf318a9f9a36","src/code_translator.rs":"ec67a88ce22cc456d3bd9c410bcf15982b196688374d06f2c1f633c838cb138d","src/environ/dummy.rs":"cca4a867849e82d3fe6793d306d24e89080198e74a58947085edbc12aab2a4ff","src/environ/mod.rs":"b046f5344a1017357c1ee9d661d2193e0247327df293436fa1381a0f45f80584","src/environ/spec.rs":"5f92d6da837267f85543f2700b658b4fb80052816f77d9fbfaa6e511d1ca3116","src/func_translator.rs":"2f1a80ede583cb14cfc2714c1d96855d6d0fdc5e044e092b0257179cd118d876","src/lib.rs":"4664114c8f4c174bea6c0385d36f29198fc9b01a8503308c7d75ea094987744b","src/module_translator.rs":"8f23a0e17c512b6fcb19fc3f19b41aebce6bde51923e812ddd326409ac967efd","src/sections_translator.rs":"cab0e57e173cf752a8ada6cff74abb364c3191a9c3341e5c686d750f51c83995","src/state.rs":"fc2a8d468b4b681d9262fdb8762f3300ffce709cb0b2e48f3835a5b9164e7c93","src/translation_utils.rs":"134ab514ba2a21cca88d603419cf233ffa00f671c8552fd3262a8cd85d3bb97d","tests/wasm_testsuite.rs":"9b4e008587c61377cf38f9d0e4635418ee38e32a865db8da5dfc6e0fae047436"},"package":null}
\ No newline at end of file
+{"files":{"Cargo.toml":"0acc3911c582b0f38099b4694d7600e6d5bb59a701c0b71144ba4cdd0ee2babf","LICENSE":"268872b9816f90fd8e85db5a28d33f8150ebb8dd016653fb39ef1f94f2686bc5","README.md":"87679cdb53e8cbec3b1aa45afb2124727c1c059f8bd10363d27daf318a9f9a36","src/code_translator.rs":"1a830b7a75c868246ee6a648187da60fd60b3620bc47c3dfaa716c2712765def","src/environ/dummy.rs":"cca4a867849e82d3fe6793d306d24e89080198e74a58947085edbc12aab2a4ff","src/environ/mod.rs":"b046f5344a1017357c1ee9d661d2193e0247327df293436fa1381a0f45f80584","src/environ/spec.rs":"5f92d6da837267f85543f2700b658b4fb80052816f77d9fbfaa6e511d1ca3116","src/func_translator.rs":"2f1a80ede583cb14cfc2714c1d96855d6d0fdc5e044e092b0257179cd118d876","src/lib.rs":"4664114c8f4c174bea6c0385d36f29198fc9b01a8503308c7d75ea094987744b","src/module_translator.rs":"8f23a0e17c512b6fcb19fc3f19b41aebce6bde51923e812ddd326409ac967efd","src/sections_translator.rs":"cab0e57e173cf752a8ada6cff74abb364c3191a9c3341e5c686d750f51c83995","src/state.rs":"fc2a8d468b4b681d9262fdb8762f3300ffce709cb0b2e48f3835a5b9164e7c93","src/translation_utils.rs":"134ab514ba2a21cca88d603419cf233ffa00f671c8552fd3262a8cd85d3bb97d","tests/wasm_testsuite.rs":"9e01f9053516ce6a411449aaf41438867fc83c83d45cdbe5e84a9a34d4a1ca02"},"package":null}
\ No newline at end of file
--- a/third_party/rust/cranelift-wasm/src/code_translator.rs
+++ b/third_party/rust/cranelift-wasm/src/code_translator.rs
@@ -28,17 +28,17 @@ use crate::state::{ControlStackFrame, Tr
 use crate::translation_utils::{
     blocktype_to_type, f32_translation, f64_translation, num_return_values,
 };
 use crate::translation_utils::{FuncIndex, MemoryIndex, SignatureIndex, TableIndex};
 use crate::wasm_unsupported;
 use core::{i32, u32};
 use cranelift_codegen::ir::condcodes::{FloatCC, IntCC};
 use cranelift_codegen::ir::types::*;
-use cranelift_codegen::ir::{self, InstBuilder, JumpTableData, MemFlags, ValueLabel};
+use cranelift_codegen::ir::{self, InstBuilder, JumpTableData, MemFlags, Value, ValueLabel};
 use cranelift_codegen::packed_option::ReservedValue;
 use cranelift_frontend::{FunctionBuilder, Variable};
 use wasmparser::{MemoryImmediate, Operator};
 
 // Clippy warns about "flags: _" but its important to document that the flags field is ignored
 #[cfg_attr(feature = "cargo-clippy", allow(clippy::unneeded_field_pattern))]
 /// Translates wasm operators into Cranelift IR instructions. Returns `true` if it inserted
 /// a return.
@@ -917,40 +917,65 @@ pub fn translate_operator<FE: FuncEnviro
         | Operator::ElemDrop { .. }
         | Operator::TableCopy
         | Operator::TableGet { .. }
         | Operator::TableSet { .. }
         | Operator::TableGrow { .. }
         | Operator::TableSize { .. } => {
             wasm_unsupported!("proposed bulk memory operator {:?}", op);
         }
+        Operator::V128Const { value } => {
+            let handle = builder.func.dfg.constants.insert(value.bytes().to_vec());
+            let value = builder.ins().vconst(I8X16, handle);
+            // the v128.const is typed in CLIF as a I8x16 but raw_bitcast to a different type before use
+            state.push1(value)
+        }
+        Operator::I8x16Splat
+        | Operator::I16x8Splat
+        | Operator::I32x4Splat
+        | Operator::I64x2Splat
+        | Operator::F32x4Splat
+        | Operator::F64x2Splat => {
+            let value_to_splat = state.pop1();
+            let ty = type_of(op);
+            let splatted = builder.ins().splat(ty, value_to_splat);
+            state.push1(splatted)
+        }
+        Operator::I32x4ExtractLane { lane }
+        | Operator::I64x2ExtractLane { lane }
+        | Operator::F32x4ExtractLane { lane }
+        | Operator::F64x2ExtractLane { lane } => {
+            let vector = optionally_bitcast_vector(state.pop1(), type_of(op), builder);
+            state.push1(builder.ins().extractlane(vector, lane.clone()))
+        }
+        Operator::I8x16ReplaceLane { lane }
+        | Operator::I16x8ReplaceLane { lane }
+        | Operator::I32x4ReplaceLane { lane }
+        | Operator::I64x2ReplaceLane { lane }
+        | Operator::F32x4ReplaceLane { lane }
+        | Operator::F64x2ReplaceLane { lane } => {
+            let (vector, replacement_value) = state.pop2();
+            let original_vector_type = builder.func.dfg.value_type(vector);
+            let vector = optionally_bitcast_vector(vector, type_of(op), builder);
+            let replaced_vector = builder
+                .ins()
+                .insertlane(vector, lane.clone(), replacement_value);
+            state.push1(optionally_bitcast_vector(
+                replaced_vector,
+                original_vector_type,
+                builder,
+            ))
+        }
         Operator::V128Load { .. }
         | Operator::V128Store { .. }
-        | Operator::V128Const { .. }
-        | Operator::V8x16Shuffle { .. }
-        | Operator::I8x16Splat
         | Operator::I8x16ExtractLaneS { .. }
         | Operator::I8x16ExtractLaneU { .. }
-        | Operator::I8x16ReplaceLane { .. }
-        | Operator::I16x8Splat
         | Operator::I16x8ExtractLaneS { .. }
         | Operator::I16x8ExtractLaneU { .. }
-        | Operator::I16x8ReplaceLane { .. }
-        | Operator::I32x4Splat
-        | Operator::I32x4ExtractLane { .. }
-        | Operator::I32x4ReplaceLane { .. }
-        | Operator::I64x2Splat
-        | Operator::I64x2ExtractLane { .. }
-        | Operator::I64x2ReplaceLane { .. }
-        | Operator::F32x4Splat
-        | Operator::F32x4ExtractLane { .. }
-        | Operator::F32x4ReplaceLane { .. }
-        | Operator::F64x2Splat
-        | Operator::F64x2ExtractLane { .. }
-        | Operator::F64x2ReplaceLane { .. }
+        | Operator::V8x16Shuffle { .. }
         | Operator::I8x16Eq
         | Operator::I8x16Ne
         | Operator::I8x16LtS
         | Operator::I8x16LtU
         | Operator::I8x16GtS
         | Operator::I8x16GtU
         | Operator::I8x16LeS
         | Operator::I8x16LeU
@@ -1286,8 +1311,179 @@ fn translate_br_if_args(
         } else {
             frame.num_return_values()
         };
         (return_count, frame.br_destination())
     };
     let inputs = state.peekn(return_count);
     (br_destination, inputs)
 }
+
+/// Determine the returned value type of a WebAssembly operator
+fn type_of(operator: &Operator) -> Type {
+    match operator {
+        Operator::V128Load { .. }
+        | Operator::V128Store { .. }
+        | Operator::V128Const { .. }
+        | Operator::V128Not
+        | Operator::V128And
+        | Operator::V128Or
+        | Operator::V128Xor
+        | Operator::V128Bitselect => I8X16, // default type representing V128
+
+        Operator::V8x16Shuffle { .. }
+        | Operator::I8x16Splat
+        | Operator::I8x16ExtractLaneS { .. }
+        | Operator::I8x16ExtractLaneU { .. }
+        | Operator::I8x16ReplaceLane { .. }
+        | Operator::I8x16Eq
+        | Operator::I8x16Ne
+        | Operator::I8x16LtS
+        | Operator::I8x16LtU
+        | Operator::I8x16GtS
+        | Operator::I8x16GtU
+        | Operator::I8x16LeS
+        | Operator::I8x16LeU
+        | Operator::I8x16GeS
+        | Operator::I8x16GeU
+        | Operator::I8x16Neg
+        | Operator::I8x16AnyTrue
+        | Operator::I8x16AllTrue
+        | Operator::I8x16Shl
+        | Operator::I8x16ShrS
+        | Operator::I8x16ShrU
+        | Operator::I8x16Add
+        | Operator::I8x16AddSaturateS
+        | Operator::I8x16AddSaturateU
+        | Operator::I8x16Sub
+        | Operator::I8x16SubSaturateS
+        | Operator::I8x16SubSaturateU
+        | Operator::I8x16Mul => I8X16,
+
+        Operator::I16x8Splat
+        | Operator::I16x8ExtractLaneS { .. }
+        | Operator::I16x8ExtractLaneU { .. }
+        | Operator::I16x8ReplaceLane { .. }
+        | Operator::I16x8Eq
+        | Operator::I16x8Ne
+        | Operator::I16x8LtS
+        | Operator::I16x8LtU
+        | Operator::I16x8GtS
+        | Operator::I16x8GtU
+        | Operator::I16x8LeS
+        | Operator::I16x8LeU
+        | Operator::I16x8GeS
+        | Operator::I16x8GeU
+        | Operator::I16x8Neg
+        | Operator::I16x8AnyTrue
+        | Operator::I16x8AllTrue
+        | Operator::I16x8Shl
+        | Operator::I16x8ShrS
+        | Operator::I16x8ShrU
+        | Operator::I16x8Add
+        | Operator::I16x8AddSaturateS
+        | Operator::I16x8AddSaturateU
+        | Operator::I16x8Sub
+        | Operator::I16x8SubSaturateS
+        | Operator::I16x8SubSaturateU
+        | Operator::I16x8Mul => I16X8,
+
+        Operator::I32x4Splat
+        | Operator::I32x4ExtractLane { .. }
+        | Operator::I32x4ReplaceLane { .. }
+        | Operator::I32x4Eq
+        | Operator::I32x4Ne
+        | Operator::I32x4LtS
+        | Operator::I32x4LtU
+        | Operator::I32x4GtS
+        | Operator::I32x4GtU
+        | Operator::I32x4LeS
+        | Operator::I32x4LeU
+        | Operator::I32x4GeS
+        | Operator::I32x4GeU
+        | Operator::I32x4Neg
+        | Operator::I32x4AnyTrue
+        | Operator::I32x4AllTrue
+        | Operator::I32x4Shl
+        | Operator::I32x4ShrS
+        | Operator::I32x4ShrU
+        | Operator::I32x4Add
+        | Operator::I32x4Sub
+        | Operator::I32x4Mul
+        | Operator::F32x4ConvertSI32x4
+        | Operator::F32x4ConvertUI32x4 => I32X4,
+
+        Operator::I64x2Splat
+        | Operator::I64x2ExtractLane { .. }
+        | Operator::I64x2ReplaceLane { .. }
+        | Operator::I64x2Neg
+        | Operator::I64x2AnyTrue
+        | Operator::I64x2AllTrue
+        | Operator::I64x2Shl
+        | Operator::I64x2ShrS
+        | Operator::I64x2ShrU
+        | Operator::I64x2Add
+        | Operator::I64x2Sub
+        | Operator::F64x2ConvertSI64x2
+        | Operator::F64x2ConvertUI64x2 => I64X2,
+
+        Operator::F32x4Splat
+        | Operator::F32x4ExtractLane { .. }
+        | Operator::F32x4ReplaceLane { .. }
+        | Operator::F32x4Eq
+        | Operator::F32x4Ne
+        | Operator::F32x4Lt
+        | Operator::F32x4Gt
+        | Operator::F32x4Le
+        | Operator::F32x4Ge
+        | Operator::F32x4Abs
+        | Operator::F32x4Neg
+        | Operator::F32x4Sqrt
+        | Operator::F32x4Add
+        | Operator::F32x4Sub
+        | Operator::F32x4Mul
+        | Operator::F32x4Div
+        | Operator::F32x4Min
+        | Operator::F32x4Max
+        | Operator::I32x4TruncSF32x4Sat
+        | Operator::I32x4TruncUF32x4Sat => F32X4,
+
+        Operator::F64x2Splat
+        | Operator::F64x2ExtractLane { .. }
+        | Operator::F64x2ReplaceLane { .. }
+        | Operator::F64x2Eq
+        | Operator::F64x2Ne
+        | Operator::F64x2Lt
+        | Operator::F64x2Gt
+        | Operator::F64x2Le
+        | Operator::F64x2Ge
+        | Operator::F64x2Abs
+        | Operator::F64x2Neg
+        | Operator::F64x2Sqrt
+        | Operator::F64x2Add
+        | Operator::F64x2Sub
+        | Operator::F64x2Mul
+        | Operator::F64x2Div
+        | Operator::F64x2Min
+        | Operator::F64x2Max
+        | Operator::I64x2TruncSF64x2Sat
+        | Operator::I64x2TruncUF64x2Sat => F64X2,
+
+        _ => unimplemented!(
+            "Currently only the SIMD instructions are translated to their return type: {:?}",
+            operator
+        ),
+    }
+}
+
+/// Some SIMD operations only operate on I8X16 in CLIF; this will convert them to that type by
+/// adding a raw_bitcast if necessary
+fn optionally_bitcast_vector(
+    value: Value,
+    needed_type: Type,
+    builder: &mut FunctionBuilder,
+) -> Value {
+    if builder.func.dfg.value_type(value) != needed_type {
+        builder.ins().raw_bitcast(needed_type, value)
+    } else {
+        value
+    }
+}
--- a/third_party/rust/cranelift-wasm/tests/wasm_testsuite.rs
+++ b/third_party/rust/cranelift-wasm/tests/wasm_testsuite.rs
@@ -5,17 +5,17 @@ use cranelift_codegen::verifier;
 use cranelift_wasm::{translate_module, DummyEnvironment, ReturnMode};
 use std::fs;
 use std::fs::File;
 use std::io;
 use std::io::prelude::*;
 use std::path::Path;
 use std::str::FromStr;
 use target_lexicon::triple;
-use wabt::wat2wasm;
+use wabt::{wat2wasm_with_features, Features};
 
 #[test]
 fn testsuite() {
     let mut paths: Vec<_> = fs::read_dir("../wasmtests")
         .unwrap()
         .map(|r| r.unwrap())
         .filter(|p| {
             // Ignore files starting with `.`, which could be editor temporary files
@@ -48,25 +48,27 @@ fn use_fallthrough_return() {
 fn read_file(path: &Path) -> io::Result<Vec<u8>> {
     let mut buf: Vec<u8> = Vec::new();
     let mut file = File::open(path)?;
     file.read_to_end(&mut buf)?;
     Ok(buf)
 }
 
 fn handle_module(path: &Path, flags: &Flags, return_mode: ReturnMode) {
+    let mut features = Features::new();
+    features.enable_all();
     let data = match path.extension() {
         None => {
             panic!("the file extension is not wasm or wat");
         }
         Some(ext) => match ext.to_str() {
             Some("wasm") => read_file(path).expect("error reading wasm file"),
             Some("wat") => {
                 let wat = read_file(path).expect("error reading wat file");
-                match wat2wasm(&wat) {
+                match wat2wasm_with_features(&wat, features) {
                     Ok(wasm) => wasm,
                     Err(e) => {
                         panic!("error converting wat to wasm: {:?}", e);
                     }
                 }
             }
             None | Some(&_) => panic!("the file extension for {:?} is not wasm or wat", path),
         },