From 5d671952eee65269e6af57f5ec5b31bf07059dd6 Mon Sep 17 00:00:00 2001 From: Chris Fallin Date: Wed, 11 May 2022 22:25:24 -0700 Subject: [PATCH] Cranelift: do not check in generated ISLE code; regenerate on every compile. (#4143) This PR fixes #4066: it modifies the Cranelift `build.rs` workflow to invoke the ISLE DSL compiler on every compilation, rather than only when the user specifies a special "rebuild ISLE" feature. The main benefit of this change is that it vastly simplifies the mental model required of developers, and removes a bunch of failure modes we have tried to work around in other ways. There is now just one "source of truth", the ISLE source itself, in the repository, and so there is no need to understand a special "rebuild" step and how to handle merge errors. There is no special process needed to develop the compiler when modifying the DSL. And there is no "noise" in the git history produced by constantly-regenerated files. The two main downsides we discussed in #4066 are: - Compile time could increase, by adding more to the "meta" step before the main build; - It becomes less obvious where the source definitions are (everything becomes more "magic"), which makes exploration and debugging harder. This PR addresses each of these concerns: 1. To maintain reasonable compile time, it includes work to cut down the dependencies of the `cranelift-isle` crate to *nothing* (only the Rust stdlib), in the default build. It does this by putting the error-reporting bits (`miette` crate) under an optional feature, and the logging (`log` crate) under a feature-controlled macro, and manually writing an `Error` impl rather than using `thiserror`. This completely avoids proc macros and the `syn` build slowness. The user can still get nice errors out of `miette`: this is enabled by specifying a Cargo feature `--features isle-errors`. 2. To allow the user to optionally inspect the generated source, which nominally lives in a hard-to-find path inside `target/` now, this PR adds a feature `isle-in-source-tree` that, as implied by the name, moves the target for ISLE generated source into the source tree, at `cranelift/codegen/isle_generated_source/`. It seems reasonable to do this when an explicit feature (opt-in) is specified because this is how ISLE regeneration currently works as well. To prevent surprises, if the feature is *not* specified, the build fails if this directory exists. --- .github/workflows/main.yml | 17 +- Cargo.lock | 22 +- ci/ensure_deterministic_build.sh | 8 +- cranelift/codegen/Cargo.toml | 14 +- cranelift/codegen/build.rs | 383 +- cranelift/codegen/meta/Cargo.toml | 3 - cranelift/codegen/meta/src/cdsl/operands.rs | 1 - cranelift/codegen/meta/src/gen_inst.rs | 20 +- cranelift/codegen/meta/src/lib.rs | 5 +- cranelift/codegen/src/clif.isle | 1579 -- .../lower/isle/generated_code.manifest | 4 - .../isa/aarch64/lower/isle/generated_code.rs | 7323 +------- .../s390x/lower/isle/generated_code.manifest | 4 - .../isa/s390x/lower/isle/generated_code.rs | 13835 +--------------- .../x64/lower/isle/generated_code.manifest | 4 - .../src/isa/x64/lower/isle/generated_code.rs | 12337 +------------- cranelift/isle/fuzz/fuzz_targets/compile.rs | 3 +- cranelift/isle/isle/Cargo.toml | 11 +- cranelift/isle/isle/src/ast.rs | 5 +- cranelift/isle/isle/src/codegen.rs | 54 +- cranelift/isle/isle/src/compile.rs | 4 +- cranelift/isle/isle/src/error.rs | 89 +- cranelift/isle/isle/src/error_miette.rs | 65 + cranelift/isle/isle/src/ir.rs | 5 +- cranelift/isle/isle/src/lexer.rs | 4 +- cranelift/isle/isle/src/lib.rs | 4 + cranelift/isle/isle/src/log.rs | 17 + cranelift/isle/isle/src/parser.rs | 2 +- cranelift/isle/isle/src/sema.rs | 21 +- cranelift/isle/isle/src/trie.rs | 9 +- cranelift/isle/isle/tests/run_tests.rs | 3 +- cranelift/isle/islec/Cargo.toml | 4 +- cranelift/isle/islec/src/main.rs | 3 +- scripts/force-rebuild-isle.sh | 19 - 34 files changed, 395 insertions(+), 35486 deletions(-) delete mode 100644 cranelift/codegen/src/clif.isle delete mode 100644 cranelift/codegen/src/isa/aarch64/lower/isle/generated_code.manifest delete mode 100644 cranelift/codegen/src/isa/s390x/lower/isle/generated_code.manifest delete mode 100644 cranelift/codegen/src/isa/x64/lower/isle/generated_code.manifest create mode 100644 cranelift/isle/isle/src/error_miette.rs create mode 100644 cranelift/isle/isle/src/log.rs delete mode 100755 scripts/force-rebuild-isle.sh diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml index 789825fbf2..663fac5f2d 100644 --- a/.github/workflows/main.yml +++ b/.github/workflows/main.yml @@ -188,21 +188,6 @@ jobs: # Check that the ISLE fuzz targets build too. - run: cargo fuzz build --dev --fuzz-dir ./cranelift/isle/fuzz - rebuild_isle: - name: Rebuild ISLE - runs-on: ubuntu-latest - steps: - - uses: actions/checkout@v2 - with: - submodules: true - - uses: ./.github/actions/install-rust - - name: Force-rebuild ISLE DSL files - run: ./scripts/force-rebuild-isle.sh - - name: Reformat - run: cargo fmt -p cranelift-codegen - - name: Check that the ISLE DSL files are up-to-date - run: git diff --exit-code - # Perform all tests (debug mode) for `wasmtime`. This runs stable/beta/nightly # channels of Rust as well as macOS/Linux/Windows. test: @@ -364,7 +349,7 @@ jobs: submodules: true - name: Install Rust run: rustup update stable && rustup default stable - - run: cd cranelift/codegen && cargo build --features "all-arch completely-skip-isle-for-ci-deterministic-check" + - run: cd cranelift/codegen && cargo build --features all-arch - run: ci/ensure_deterministic_build.sh # Perform release builds of `wasmtime` and `libwasmtime.so`. Builds on diff --git a/Cargo.lock b/Cargo.lock index e66e3407a2..45c21157bd 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -605,7 +605,6 @@ dependencies = [ "log", "miette", "tempfile", - "thiserror", ] [[package]] @@ -1664,9 +1663,9 @@ checksum = "71d96e3f3c0b6325d8ccd83c33b28acb183edcb6c67938ba104ec546854b0882" [[package]] name = "miette" -version = "3.3.0" +version = "4.7.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cd2adcfcced5d625bf90a958a82ae5b93231f57f3df1383fee28c9b5096d35ed" +checksum = "a565d01cf2dcab463159347d98a18f509fda8e4824e2965c3b430dd045ac1f23" dependencies = [ "atty", "backtrace", @@ -1677,15 +1676,16 @@ dependencies = [ "supports-hyperlinks", "supports-unicode", "terminal_size", - "textwrap 0.14.2", + "textwrap 0.15.0", "thiserror", + "unicode-width", ] [[package]] name = "miette-derive" -version = "3.3.0" +version = "4.7.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5c01a8b61312d367ce87956bb686731f87e4c6dd5dbc550e8f06e3c24fb1f67f" +checksum = "3240cd84b71bf89e5994030c21221f399a882251ed4b89849d3b8610fe8fe8ab" dependencies = [ "proc-macro2", "quote", @@ -2817,21 +2817,15 @@ dependencies = [ [[package]] name = "textwrap" -version = "0.14.2" +version = "0.15.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0066c8d12af8b5acd21e00547c3797fde4e8677254a7ee429176ccebbe93dd80" +checksum = "b1141d4d61095b28419e22cb0bbf02755f5e54e0526f97f1e3d1d160e60885fb" dependencies = [ "smawk", "unicode-linebreak", "unicode-width", ] -[[package]] -name = "textwrap" -version = "0.15.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b1141d4d61095b28419e22cb0bbf02755f5e54e0526f97f1e3d1d160e60885fb" - [[package]] name = "thiserror" version = "1.0.31" diff --git a/ci/ensure_deterministic_build.sh b/ci/ensure_deterministic_build.sh index 7c80062ec5..fbe8f98a83 100755 --- a/ci/ensure_deterministic_build.sh +++ b/ci/ensure_deterministic_build.sh @@ -3,6 +3,10 @@ # This script makes sure that the meta crate deterministically generate files # with a high probability. # The current directory must be set to the repository's root. +# +# We set SKIP_ISLE=1 to skip ISLE generation, because it depends on files +# in-tree (cranelift/codegen/.../*.isle) but these are not available when we +# switch to different working directories during this test. set -e @@ -11,7 +15,7 @@ BUILD_SCRIPT=$(find -wholename "./target/debug/build/cranelift-codegen-*/build-s # First, run the script to generate a reference comparison. rm -rf /tmp/reference mkdir /tmp/reference -OUT_DIR=/tmp/reference TARGET=x86_64 CARGO_PKG_VERSION=0.1.0 CARGO_MANIFEST_DIR=/tmp $BUILD_SCRIPT +SKIP_ISLE=1 OUT_DIR=/tmp/reference TARGET=x86_64 CARGO_PKG_VERSION=0.1.0 CARGO_MANIFEST_DIR=/tmp $BUILD_SCRIPT # To make sure the build script doesn't depend on the current directory, we'll # change the current working directory on every iteration. Make this easy to @@ -36,6 +40,6 @@ do rm -rf /tmp/try mkdir /tmp/try - OUT_DIR=/tmp/try TARGET=x86_64 CARGO_PKG_VERSION=0.1.0 CARGO_MANIFEST_DIR=/tmp/src$i $BUILD_SCRIPT + SKIP_ISLE=1 OUT_DIR=/tmp/try TARGET=x86_64 CARGO_PKG_VERSION=0.1.0 CARGO_MANIFEST_DIR=/tmp/src$i $BUILD_SCRIPT diff -qr /tmp/reference /tmp/try done diff --git a/cranelift/codegen/Cargo.toml b/cranelift/codegen/Cargo.toml index 104f592fe4..d96c54e460 100644 --- a/cranelift/codegen/Cargo.toml +++ b/cranelift/codegen/Cargo.toml @@ -35,8 +35,8 @@ criterion = "0.3" [build-dependencies] cranelift-codegen-meta = { path = "meta", version = "0.85.0" } -cranelift-isle = { path = "../isle/isle", version = "=0.85.0", optional = true } -miette = { version = "3", features = ["fancy"], optional = true } +cranelift-isle = { path = "../isle/isle", version = "=0.85.0" } +miette = { version = "4.7.0", features = ["fancy"], optional = true } [features] default = ["std", "unwind"] @@ -84,12 +84,12 @@ enable-serde = [ # Enable support for the Souper harvester. souper-harvest = ["souper-ir", "souper-ir/stringify"] -# Recompile ISLE DSL source files into their generated Rust code. -rebuild-isle = ["cranelift-isle", "miette", "cranelift-codegen-meta/rebuild-isle"] +# Provide fancy Miette-produced errors for ISLE. +isle-errors = ["miette", "cranelift-isle/miette-errors"] -# A hack to skip the ISLE-rebuild logic when testing for determinism -# with the "Meta deterministic check" CI job. -completely-skip-isle-for-ci-deterministic-check = [] +# Put ISLE generated files in isle_generated_code/, for easier +# inspection, rather than inside of target/. +isle-in-source-tree = [] [badges] maintenance = { status = "experimental" } diff --git a/cranelift/codegen/build.rs b/cranelift/codegen/build.rs index 29b3d03c56..db9c2447cc 100644 --- a/cranelift/codegen/build.rs +++ b/cranelift/codegen/build.rs @@ -51,11 +51,42 @@ fn main() { println!("cargo:rerun-if-changed=build.rs"); - if let Err(err) = meta::generate(&isas, &out_dir, crate_dir) { + let explicit_isle_dir = &crate_dir.join("isle_generated_code"); + #[cfg(feature = "isle-in-source-tree")] + let isle_dir = explicit_isle_dir; + #[cfg(not(feature = "isle-in-source-tree"))] + let isle_dir = std::path::Path::new(&out_dir); + + #[cfg(feature = "isle-in-source-tree")] + { + std::fs::create_dir_all(isle_dir).expect("Could not create ISLE source directory"); + } + #[cfg(not(feature = "isle-in-source-tree"))] + { + if explicit_isle_dir.is_dir() { + eprintln!(concat!( + "Error: directory isle_generated_code/ exists but is only used when\n", + "`--feature isle-in-source-tree` is specified. To prevent confusion,\n", + "this build script requires the directory to be removed when reverting\n", + "to the usual generated code in target/. Please delete the directory and\n", + "re-run this build.\n", + )); + std::process::exit(1); + } + } + + if let Err(err) = meta::generate(&isas, &out_dir, isle_dir.to_str().unwrap()) { eprintln!("Error: {}", err); process::exit(1); } + if &std::env::var("SKIP_ISLE").unwrap_or("0".to_string()) != "1" { + if let Err(err) = build_isle(crate_dir, isle_dir) { + eprintln!("Error: {}", err); + process::exit(1); + } + } + if env::var("CRANELIFT_VERBOSE").is_ok() { for isa in &isas { println!("cargo:warning=Includes support for {} ISA", isa.to_string()); @@ -67,18 +98,6 @@ fn main() { println!("cargo:warning=Generated files are in {}", out_dir); } - // The "Meta deterministic check" CI job runs this build script N - // times to ensure it produces the same output - // consistently. However, it runs the script in a fresh directory, - // without any of the source tree present; this breaks our - // manifest check (we need the ISLE source to be present). To keep - // things simple, we just disable all ISLE-related logic for this - // specific CI job. - #[cfg(not(feature = "completely-skip-isle-for-ci-deterministic-check"))] - { - maybe_rebuild_isle(crate_dir).expect("Unhandled failure in ISLE rebuild"); - } - let pkg_version = env::var("CARGO_PKG_VERSION").unwrap(); let mut cmd = std::process::Command::new("git"); cmd.arg("rev-parse") @@ -149,71 +168,15 @@ struct IsleCompilation { inputs: Vec, } -impl IsleCompilation { - /// Compute the manifest filename for the given generated Rust file. - fn manifest_filename(&self) -> std::path::PathBuf { - self.output.with_extension("manifest") - } - - /// Compute the content of the source manifest for all ISLE source - /// files that go into the compilation of one Rust file. - /// - /// We store this alongside the `.rs` file as - /// `.manifest` and use it to verify that a - /// rebuild was done if necessary. - fn compute_manifest(&self) -> Result> { - // We use the deprecated SipHasher from std::hash in order to verify - // that ISLE sources haven't changed since the generated source was - // last regenerated. - // - // We use this instead of a stronger and more usual content hash, like - // SHA-{160,256,512}, because it's built into the standard library and - // we don't want to pull in a separate crate. We try to keep Cranelift - // crate dependencies as intentionally small as possible. In fact, we - // used to use the `sha2` crate for SHA-512 and this turns out to be - // undesirable for downstream consumers (see #3609). - // - // Why not the recommended replacement - // `std::collections::hash_map::DefaultHasher`? Because we need the - // hash to be deterministic, both between runs (i.e., not seeded with - // random state) and across Rust versions. - // - // If `SipHasher` is ever actually removed from `std`, we'll need to - // find a new option, either a very small crate or something else - // that's built-in. - #![allow(deprecated)] - use std::fmt::Write; - use std::hash::{Hasher, SipHasher}; - - let mut manifest = String::new(); - - for filename in &self.inputs { - // Our source must be valid UTF-8 for this to work, else user - // will get an error on build. This is not expected to be an - // issue. - let content = std::fs::read_to_string(filename)?; - // On Windows, source is checked out with line-endings changed - // to `\r\n`; canonicalize the source that we hash to - // Unix-style (`\n`) so hashes will match. - let content = content.replace("\r\n", "\n"); - // One line in the manifest: . - let mut hasher = SipHasher::new_with_keys(0, 0); // fixed keys for determinism - hasher.write(content.as_bytes()); - let filename = format!("{}", filename.display()).replace("\\", "/"); - writeln!(&mut manifest, "{} {:x}", filename, hasher.finish())?; - } - - Ok(manifest) - } -} - /// Construct the list of compilations (transformations from ISLE /// source to generated Rust source) that exist in the repository. -fn get_isle_compilations(crate_dir: &std::path::Path) -> Result { +fn get_isle_compilations( + crate_dir: &std::path::Path, + out_dir: &std::path::Path, +) -> Result { let cur_dir = std::env::current_dir()?; - let clif_isle = - make_isle_source_path_relative(&cur_dir, crate_dir.join("src").join("clif.isle")); + let clif_isle = out_dir.join("clif.isle"); let prelude_isle = make_isle_source_path_relative(&cur_dir, crate_dir.join("src").join("prelude.isle")); let src_isa_x64 = @@ -240,10 +203,7 @@ fn get_isle_compilations(crate_dir: &std::path::Path) -> Result Result Result Result Result<(), Box> { - let isle_compilations = get_isle_compilations(crate_dir)?; - let mut rebuild_compilations = vec![]; + let isle_compilations = get_isle_compilations(crate_dir, isle_dir)?; + let mut had_error = false; for compilation in &isle_compilations.items { for file in &compilation.inputs { println!("cargo:rerun-if-changed={}", file.display()); } - let manifest = - std::fs::read_to_string(compilation.manifest_filename()).unwrap_or(String::new()); - // Canonicalize Windows line-endings into Unix line-endings in - // the manifest text itself. - let manifest = manifest.replace("\r\n", "\n"); - let expected_manifest = compilation.compute_manifest()?.replace("\r\n", "\n"); - if manifest != expected_manifest { - rebuild_compilations.push((compilation, expected_manifest)); - } - } - - #[cfg(feature = "rebuild-isle")] - { - if !rebuild_compilations.is_empty() { - set_miette_hook(); - } - let mut had_error = false; - for (compilation, expected_manifest) in rebuild_compilations { - if let Err(e) = rebuild_isle(compilation, &expected_manifest) { - eprintln!("Error building ISLE files: {:?}", e); - let mut source = e.source(); - while let Some(e) = source { - eprintln!("{:?}", e); - source = e.source(); - } - had_error = true; + if let Err(e) = run_compilation(compilation) { + eprintln!("Error building ISLE files: {:?}", e); + let mut source = e.source(); + while let Some(e) = source { + eprintln!("{:?}", e); + source = e.source(); } - } - - if had_error { - std::process::exit(1); + had_error = true; } } - #[cfg(not(feature = "rebuild-isle"))] - { - if !rebuild_compilations.is_empty() { - for (compilation, _) in rebuild_compilations { - eprintln!(""); - eprintln!( - "Error: the ISLE source files that resulted in the generated Rust source" - ); - eprintln!(""); - eprintln!(" * {}", compilation.output.display()); - eprintln!(""); - eprintln!( - "have changed but the generated source was not rebuilt! These ISLE source" - ); - eprintln!("files are:"); - eprintln!(""); - for file in &compilation.inputs { - eprintln!(" * {}", file.display()); - } - } - - eprintln!(""); - eprintln!("Please add `--features rebuild-isle` to your `cargo build` command"); - eprintln!("if you wish to rebuild the generated source, then include these changes"); - eprintln!("in any git commits you make that include the changes to the ISLE."); - eprintln!(""); - eprintln!("For example:"); - eprintln!(""); - eprintln!(" $ cargo build -p cranelift-codegen --features rebuild-isle"); - eprintln!(""); - eprintln!("(This build script cannot do this for you by default because we cannot"); - eprintln!("modify checked-into-git source without your explicit opt-in.)"); - eprintln!(""); - std::process::exit(1); - } + if had_error { + std::process::exit(1); } + println!("cargo:rustc-env=ISLE_DIR={}", isle_dir.to_str().unwrap()); + Ok(()) } -#[cfg(feature = "rebuild-isle")] -fn set_miette_hook() { - use std::sync::Once; - static SET_MIETTE_HOOK: Once = Once::new(); - SET_MIETTE_HOOK.call_once(|| { - let _ = miette::set_hook(Box::new(|_| { - Box::new( - miette::MietteHandlerOpts::new() - // This is necessary for `miette` to properly display errors - // until https://github.com/zkat/miette/issues/93 is fixed. - .force_graphical(true) - .build(), - ) - })); - }); -} - -/// Rebuild ISLE DSL source text into generated Rust code. +/// Build ISLE DSL source text into generated Rust code. /// /// NB: This must happen *after* the `cranelift-codegen-meta` functions, since /// it consumes files generated by them. -#[cfg(feature = "rebuild-isle")] -fn rebuild_isle( +fn run_compilation( compilation: &IsleCompilation, - manifest: &str, ) -> Result<(), Box> { use cranelift_isle as isle; println!("Rebuilding {}", compilation.output.display()); - // First, remove the manifest, if any; we will recreate it - // below if the compilation is successful. Ignore error if no - // manifest was present. - let manifest_filename = compilation.manifest_filename(); - let _ = std::fs::remove_file(&manifest_filename); - let code = (|| { let lexer = isle::lexer::Lexer::from_files(&compilation.inputs[..])?; let defs = isle::parser::parse(lexer)?; - isle::compile::compile(&defs) + + let mut options = isle::codegen::CodegenOptions::default(); + // Because we include!() the generated ISLE source, we cannot + // put the global pragmas (`#![allow(...)]`) in the ISLE + // source itself; we have to put them in the source that + // include!()s it. (See + // https://github.com/rust-lang/rust/issues/47995.) + options.exclude_global_allow_pragmas = true; + + isle::compile::compile(&defs, &options) })() .map_err(|e| { // Make sure to include the source snippets location info along with // the error messages. - let report = miette::Report::new(e); - return DebugReport(report); + #[cfg(feature = "isle-errors")] + { + let report = miette::Report::new(e); + return DebugReport(report); - struct DebugReport(miette::Report); + struct DebugReport(miette::Report); - impl std::fmt::Display for DebugReport { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - self.0.handler().debug(&*self.0, f) + impl std::fmt::Display for DebugReport { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + self.0.handler().debug(&*self.0, f) + } } - } - impl std::fmt::Debug for DebugReport { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self, f) + impl std::fmt::Debug for DebugReport { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + std::fmt::Display::fmt(self, f) + } } - } - impl std::error::Error for DebugReport {} + impl std::error::Error for DebugReport {} + } + #[cfg(not(feature = "isle-errors"))] + { + return DebugReport(format!("{}", e)); + + struct DebugReport(String); + + impl std::fmt::Display for DebugReport { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + writeln!(f, "ISLE errors:\n\n{}\n", self.0)?; + writeln!(f, "To see a more detailed error report, run: ")?; + writeln!(f, "")?; + writeln!( + f, + " $ cargo check -p cranelift-codegen --features isle-errors" + )?; + writeln!(f, "")?; + Ok(()) + } + } + + impl std::fmt::Debug for DebugReport { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + std::fmt::Display::fmt(self, f) + } + } + + impl std::error::Error for DebugReport {} + } })?; let code = rustfmt(&code).unwrap_or_else(|e| { @@ -461,39 +361,32 @@ fn rebuild_isle( ); std::fs::write(&compilation.output, code)?; - // Write the manifest so that, in the default build configuration - // without the `rebuild-isle` feature, we can at least verify that - // no changes were made that will not be picked up. Note that we - // only write this *after* we write the source above, so no - // manifest is produced if there was an error. - std::fs::write(&manifest_filename, manifest)?; - - return Ok(()); - - fn rustfmt(code: &str) -> std::io::Result { - use std::io::Write; - - let mut rustfmt = std::process::Command::new("rustfmt") - .stdin(std::process::Stdio::piped()) - .stdout(std::process::Stdio::piped()) - .spawn()?; - - let mut stdin = rustfmt.stdin.take().unwrap(); - stdin.write_all(code.as_bytes())?; - drop(stdin); - - let mut stdout = rustfmt.stdout.take().unwrap(); - let mut data = vec![]; - stdout.read_to_end(&mut data)?; - - let status = rustfmt.wait()?; - if !status.success() { - return Err(std::io::Error::new( - std::io::ErrorKind::Other, - format!("`rustfmt` exited with status {}", status), - )); - } - - Ok(String::from_utf8(data).expect("rustfmt always writs utf-8 to stdout")) - } + Ok(()) +} + +fn rustfmt(code: &str) -> std::io::Result { + use std::io::Write; + + let mut rustfmt = std::process::Command::new("rustfmt") + .stdin(std::process::Stdio::piped()) + .stdout(std::process::Stdio::piped()) + .spawn()?; + + let mut stdin = rustfmt.stdin.take().unwrap(); + stdin.write_all(code.as_bytes())?; + drop(stdin); + + let mut stdout = rustfmt.stdout.take().unwrap(); + let mut data = vec![]; + stdout.read_to_end(&mut data)?; + + let status = rustfmt.wait()?; + if !status.success() { + return Err(std::io::Error::new( + std::io::ErrorKind::Other, + format!("`rustfmt` exited with status {}", status), + )); + } + + Ok(String::from_utf8(data).expect("rustfmt always writs utf-8 to stdout")) } diff --git a/cranelift/codegen/meta/Cargo.toml b/cranelift/codegen/meta/Cargo.toml index d8114777d9..0ad8ca37fc 100644 --- a/cranelift/codegen/meta/Cargo.toml +++ b/cranelift/codegen/meta/Cargo.toml @@ -17,6 +17,3 @@ cranelift-codegen-shared = { path = "../shared", version = "0.85.0" } [badges] maintenance = { status = "experimental" } - -[features] -rebuild-isle = [] diff --git a/cranelift/codegen/meta/src/cdsl/operands.rs b/cranelift/codegen/meta/src/cdsl/operands.rs index 945f2f6e3a..c278617b85 100644 --- a/cranelift/codegen/meta/src/cdsl/operands.rs +++ b/cranelift/codegen/meta/src/cdsl/operands.rs @@ -113,7 +113,6 @@ pub(crate) enum OperandKindFields { impl OperandKindFields { /// Return the [EnumValues] for this field if it is an `enum`. - #[cfg(feature = "rebuild-isle")] pub(crate) fn enum_values(&self) -> Option<&EnumValues> { match self { OperandKindFields::ImmEnum(map) => Some(map), diff --git a/cranelift/codegen/meta/src/gen_inst.rs b/cranelift/codegen/meta/src/gen_inst.rs index ccd75ba1e8..e6ae750435 100644 --- a/cranelift/codegen/meta/src/gen_inst.rs +++ b/cranelift/codegen/meta/src/gen_inst.rs @@ -1,6 +1,5 @@ //! Generate instruction data (including opcodes, formats, builders, etc.). use std::fmt; -use std::path::Path; use cranelift_codegen_shared::constant_hash; @@ -1085,7 +1084,6 @@ fn gen_inst_builder(inst: &Instruction, format: &InstructionFormat, fmt: &mut Fo fmtln!(fmt, "}") } -#[cfg(feature = "rebuild-isle")] fn gen_isle(formats: &[&InstructionFormat], instructions: &AllInstructions, fmt: &mut Formatter) { use std::collections::{BTreeMap, BTreeSet}; use std::fmt::Write; @@ -1341,7 +1339,6 @@ fn gen_isle(formats: &[&InstructionFormat], instructions: &AllInstructions, fmt: } /// Generate an `enum` immediate in ISLE. -#[cfg(feature = "rebuild-isle")] fn gen_isle_enum(name: &str, mut variants: Vec<&str>, fmt: &mut Formatter) { variants.sort(); let prefix = format!(";;;; Enumerated Immediate: {} ", name); @@ -1407,7 +1404,7 @@ pub(crate) fn generate( inst_builder_filename: &str, isle_filename: &str, out_dir: &str, - crate_dir: &Path, + isle_dir: &str, ) -> Result<(), error::Error> { // Opcodes. let mut fmt = Formatter::new(); @@ -1424,18 +1421,9 @@ pub(crate) fn generate( fmt.update_file(opcode_filename, out_dir)?; // ISLE DSL. - #[cfg(feature = "rebuild-isle")] - { - let mut fmt = Formatter::new(); - gen_isle(&formats, all_inst, &mut fmt); - let crate_src_dir = crate_dir.join("src"); - fmt.update_file(isle_filename, &crate_src_dir.display().to_string())?; - } - #[cfg(not(feature = "rebuild-isle"))] - { - // Silence unused variable warnings. - let _ = (isle_filename, crate_dir); - } + let mut fmt = Formatter::new(); + gen_isle(&formats, all_inst, &mut fmt); + fmt.update_file(isle_filename, isle_dir)?; // Instruction builder. let mut fmt = Formatter::new(); diff --git a/cranelift/codegen/meta/src/lib.rs b/cranelift/codegen/meta/src/lib.rs index e688f89b7d..8b525acabf 100644 --- a/cranelift/codegen/meta/src/lib.rs +++ b/cranelift/codegen/meta/src/lib.rs @@ -1,7 +1,6 @@ //! This crate generates Rust sources for use by //! [`cranelift_codegen`](../cranelift_codegen/index.html). -use std::path::Path; #[macro_use] mod cdsl; mod srcgen; @@ -23,7 +22,7 @@ pub fn isa_from_arch(arch: &str) -> Result { } /// Generates all the Rust source files used in Cranelift from the meta-language. -pub fn generate(isas: &[isa::Isa], out_dir: &str, crate_dir: &Path) -> Result<(), error::Error> { +pub fn generate(isas: &[isa::Isa], out_dir: &str, isle_dir: &str) -> Result<(), error::Error> { // Create all the definitions: // - common definitions. let mut shared_defs = shared::define(); @@ -50,7 +49,7 @@ pub fn generate(isas: &[isa::Isa], out_dir: &str, crate_dir: &Path) -> Result<() "inst_builder.rs", "clif.isle", &out_dir, - crate_dir, + isle_dir, )?; for isa in target_isas { diff --git a/cranelift/codegen/src/clif.isle b/cranelift/codegen/src/clif.isle deleted file mode 100644 index 82ff498da0..0000000000 --- a/cranelift/codegen/src/clif.isle +++ /dev/null @@ -1,1579 +0,0 @@ -;; GENERATED BY `gen_isle`. DO NOT EDIT!!! -;; -;; This ISLE file defines all the external type declarations for Cranelift's -;; data structures that ISLE will process, such as `InstructionData` and -;; `Opcode`. - -;;;; Extern type declarations for immediates ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - -(type Block (primitive Block)) -(type Constant (primitive Constant)) -(type FuncRef (primitive FuncRef)) -(type GlobalValue (primitive GlobalValue)) -(type Heap (primitive Heap)) -(type Ieee32 (primitive Ieee32)) -(type Ieee64 (primitive Ieee64)) -(type Imm64 (primitive Imm64)) -(type Immediate (primitive Immediate)) -(type JumpTable (primitive JumpTable)) -(type MemFlags (primitive MemFlags)) -(type Offset32 (primitive Offset32)) -(type SigRef (primitive SigRef)) -(type StackSlot (primitive StackSlot)) -(type Table (primitive Table)) -(type Uimm32 (primitive Uimm32)) -(type Uimm8 (primitive Uimm8)) -(type bool (primitive bool)) - -;;;; Enumerated Immediate: AtomicRmwOp ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - -(type AtomicRmwOp extern - (enum - Add - And - Nand - Or - Smax - Smin - Sub - Umax - Umin - Xchg - Xor - ) -) - -;;;; Enumerated Immediate: FloatCC ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - -(type FloatCC extern - (enum - Equal - GreaterThan - GreaterThanOrEqual - LessThan - LessThanOrEqual - NotEqual - Ordered - OrderedNotEqual - Unordered - UnorderedOrEqual - UnorderedOrGreaterThan - UnorderedOrGreaterThanOrEqual - UnorderedOrLessThan - UnorderedOrLessThanOrEqual - ) -) - -;;;; Enumerated Immediate: IntCC ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - -(type IntCC extern - (enum - Equal - NotEqual - NotOverflow - Overflow - SignedGreaterThan - SignedGreaterThanOrEqual - SignedLessThan - SignedLessThanOrEqual - UnsignedGreaterThan - UnsignedGreaterThanOrEqual - UnsignedLessThan - UnsignedLessThanOrEqual - ) -) - -;;;; Enumerated Immediate: TrapCode ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - -(type TrapCode extern - (enum - HeapOutOfBounds - IntegerDivisionByZero - IntegerOverflow - StackOverflow - ) -) - -;;;; Value Arrays ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - -;; ISLE representation of `[Value; 2]`. -(type ValueArray2 extern (enum)) - -(decl value_array_2 (Value Value) ValueArray2) -(extern constructor value_array_2 pack_value_array_2) -(extern extractor infallible value_array_2 unpack_value_array_2) - -;; ISLE representation of `[Value; 3]`. -(type ValueArray3 extern (enum)) - -(decl value_array_3 (Value Value Value) ValueArray3) -(extern constructor value_array_3 pack_value_array_3) -(extern extractor infallible value_array_3 unpack_value_array_3) - -;;;; `Opcode` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - -(type Opcode extern - (enum - Jump - Brz - Brnz - BrIcmp - Brif - Brff - BrTable - Debugtrap - Trap - Trapz - ResumableTrap - Trapnz - ResumableTrapnz - Trapif - Trapff - Return - FallthroughReturn - Call - CallIndirect - FuncAddr - Splat - Swizzle - Insertlane - Extractlane - Imin - Umin - Imax - Umax - AvgRound - UaddSat - SaddSat - UsubSat - SsubSat - Load - Store - Uload8 - Sload8 - Istore8 - Uload16 - Sload16 - Istore16 - Uload32 - Sload32 - Istore32 - Uload8x8 - Sload8x8 - Uload16x4 - Sload16x4 - Uload32x2 - Sload32x2 - StackLoad - StackStore - StackAddr - GlobalValue - SymbolValue - TlsValue - HeapAddr - GetPinnedReg - SetPinnedReg - TableAddr - Iconst - F32const - F64const - Bconst - Vconst - ConstAddr - Shuffle - Null - Nop - Select - Selectif - SelectifSpectreGuard - Bitselect - Copy - IfcmpSp - Vsplit - Vconcat - Vselect - VanyTrue - VallTrue - VhighBits - Icmp - IcmpImm - Ifcmp - IfcmpImm - Iadd - Isub - Ineg - Iabs - Imul - Umulhi - Smulhi - SqmulRoundSat - Udiv - Sdiv - Urem - Srem - IaddImm - ImulImm - UdivImm - SdivImm - UremImm - SremImm - IrsubImm - IaddCin - IaddIfcin - IaddCout - IaddIfcout - IaddCarry - IaddIfcarry - IsubBin - IsubIfbin - IsubBout - IsubIfbout - IsubBorrow - IsubIfborrow - Band - Bor - Bxor - Bnot - BandNot - BorNot - BxorNot - BandImm - BorImm - BxorImm - Rotl - Rotr - RotlImm - RotrImm - Ishl - Ushr - Sshr - IshlImm - UshrImm - SshrImm - Bitrev - Clz - Cls - Ctz - Popcnt - Fcmp - Ffcmp - Fadd - Fsub - Fmul - Fdiv - Sqrt - Fma - Fneg - Fabs - Fcopysign - Fmin - FminPseudo - Fmax - FmaxPseudo - Ceil - Floor - Trunc - Nearest - IsNull - IsInvalid - Trueif - Trueff - Bitcast - RawBitcast - ScalarToVector - Breduce - Bextend - Bint - Bmask - Ireduce - Snarrow - Unarrow - Uunarrow - SwidenLow - SwidenHigh - UwidenLow - UwidenHigh - IaddPairwise - WideningPairwiseDotProductS - Uextend - Sextend - Fpromote - Fdemote - Fvdemote - FvpromoteLow - FcvtToUint - FcvtToUintSat - FcvtToSint - FcvtToSintSat - FcvtFromUint - FcvtFromSint - FcvtLowFromSint - Isplit - Iconcat - AtomicRmw - AtomicCas - AtomicLoad - AtomicStore - Fence - ) -) - -;;;; `InstructionData` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - -(type InstructionData extern - (enum - (AtomicCas (opcode Opcode) (args ValueArray3) (flags MemFlags)) - (AtomicRmw (opcode Opcode) (args ValueArray2) (flags MemFlags) (op AtomicRmwOp)) - (Binary (opcode Opcode) (args ValueArray2)) - (BinaryImm64 (opcode Opcode) (arg Value) (imm Imm64)) - (BinaryImm8 (opcode Opcode) (arg Value) (imm Uimm8)) - (Branch (opcode Opcode) (args ValueList) (destination Block)) - (BranchFloat (opcode Opcode) (args ValueList) (cond FloatCC) (destination Block)) - (BranchIcmp (opcode Opcode) (args ValueList) (cond IntCC) (destination Block)) - (BranchInt (opcode Opcode) (args ValueList) (cond IntCC) (destination Block)) - (BranchTable (opcode Opcode) (arg Value) (destination Block) (table JumpTable)) - (Call (opcode Opcode) (args ValueList) (func_ref FuncRef)) - (CallIndirect (opcode Opcode) (args ValueList) (sig_ref SigRef)) - (CondTrap (opcode Opcode) (arg Value) (code TrapCode)) - (FloatCompare (opcode Opcode) (args ValueArray2) (cond FloatCC)) - (FloatCond (opcode Opcode) (arg Value) (cond FloatCC)) - (FloatCondTrap (opcode Opcode) (arg Value) (cond FloatCC) (code TrapCode)) - (FuncAddr (opcode Opcode) (func_ref FuncRef)) - (HeapAddr (opcode Opcode) (arg Value) (heap Heap) (imm Uimm32)) - (IntCompare (opcode Opcode) (args ValueArray2) (cond IntCC)) - (IntCompareImm (opcode Opcode) (arg Value) (cond IntCC) (imm Imm64)) - (IntCond (opcode Opcode) (arg Value) (cond IntCC)) - (IntCondTrap (opcode Opcode) (arg Value) (cond IntCC) (code TrapCode)) - (IntSelect (opcode Opcode) (args ValueArray3) (cond IntCC)) - (Jump (opcode Opcode) (args ValueList) (destination Block)) - (Load (opcode Opcode) (arg Value) (flags MemFlags) (offset Offset32)) - (LoadNoOffset (opcode Opcode) (arg Value) (flags MemFlags)) - (MultiAry (opcode Opcode) (args ValueList)) - (NullAry (opcode Opcode)) - (Shuffle (opcode Opcode) (args ValueArray2) (imm Immediate)) - (StackLoad (opcode Opcode) (stack_slot StackSlot) (offset Offset32)) - (StackStore (opcode Opcode) (arg Value) (stack_slot StackSlot) (offset Offset32)) - (Store (opcode Opcode) (args ValueArray2) (flags MemFlags) (offset Offset32)) - (StoreNoOffset (opcode Opcode) (args ValueArray2) (flags MemFlags)) - (TableAddr (opcode Opcode) (arg Value) (table Table) (offset Offset32)) - (Ternary (opcode Opcode) (args ValueArray3)) - (TernaryImm8 (opcode Opcode) (args ValueArray2) (imm Uimm8)) - (Trap (opcode Opcode) (code TrapCode)) - (Unary (opcode Opcode) (arg Value)) - (UnaryBool (opcode Opcode) (imm bool)) - (UnaryConst (opcode Opcode) (constant_handle Constant)) - (UnaryGlobalValue (opcode Opcode) (global_value GlobalValue)) - (UnaryIeee32 (opcode Opcode) (imm Ieee32)) - (UnaryIeee64 (opcode Opcode) (imm Ieee64)) - (UnaryImm (opcode Opcode) (imm Imm64)) - ) -) - -;;;; Extracting Opcode, Operands, and Immediates from `InstructionData` ;;;;;;;; - -(decl jump (Block ValueSlice) Inst) -(extractor - (jump block args) - (inst_data (InstructionData.Jump (Opcode.Jump) (value_list_slice args) block)) -) - -(decl brz (Value Block ValueSlice) Inst) -(extractor - (brz c block args) - (inst_data (InstructionData.Branch (Opcode.Brz) (unwrap_head_value_list_1 c args) block)) -) - -(decl brnz (Value Block ValueSlice) Inst) -(extractor - (brnz c block args) - (inst_data (InstructionData.Branch (Opcode.Brnz) (unwrap_head_value_list_1 c args) block)) -) - -(decl br_icmp (IntCC Value Value Block ValueSlice) Inst) -(extractor - (br_icmp Cond x y block args) - (inst_data (InstructionData.BranchIcmp (Opcode.BrIcmp) (unwrap_head_value_list_2 x y args) Cond block)) -) - -(decl brif (IntCC Value Block ValueSlice) Inst) -(extractor - (brif Cond f block args) - (inst_data (InstructionData.BranchInt (Opcode.Brif) (unwrap_head_value_list_1 f args) Cond block)) -) - -(decl brff (FloatCC Value Block ValueSlice) Inst) -(extractor - (brff Cond f block args) - (inst_data (InstructionData.BranchFloat (Opcode.Brff) (unwrap_head_value_list_1 f args) Cond block)) -) - -(decl br_table (Value Block JumpTable) Inst) -(extractor - (br_table x block JT) - (inst_data (InstructionData.BranchTable (Opcode.BrTable) x block JT)) -) - -(decl debugtrap () Inst) -(extractor - (debugtrap ) - (inst_data (InstructionData.NullAry (Opcode.Debugtrap))) -) - -(decl trap (TrapCode) Inst) -(extractor - (trap code) - (inst_data (InstructionData.Trap (Opcode.Trap) code)) -) - -(decl trapz (Value TrapCode) Inst) -(extractor - (trapz c code) - (inst_data (InstructionData.CondTrap (Opcode.Trapz) c code)) -) - -(decl resumable_trap (TrapCode) Inst) -(extractor - (resumable_trap code) - (inst_data (InstructionData.Trap (Opcode.ResumableTrap) code)) -) - -(decl trapnz (Value TrapCode) Inst) -(extractor - (trapnz c code) - (inst_data (InstructionData.CondTrap (Opcode.Trapnz) c code)) -) - -(decl resumable_trapnz (Value TrapCode) Inst) -(extractor - (resumable_trapnz c code) - (inst_data (InstructionData.CondTrap (Opcode.ResumableTrapnz) c code)) -) - -(decl trapif (IntCC Value TrapCode) Inst) -(extractor - (trapif Cond f code) - (inst_data (InstructionData.IntCondTrap (Opcode.Trapif) f Cond code)) -) - -(decl trapff (FloatCC Value TrapCode) Inst) -(extractor - (trapff Cond f code) - (inst_data (InstructionData.FloatCondTrap (Opcode.Trapff) f Cond code)) -) - -(decl return (ValueSlice) Inst) -(extractor - (return rvals) - (inst_data (InstructionData.MultiAry (Opcode.Return) (value_list_slice rvals))) -) - -(decl fallthrough_return (ValueSlice) Inst) -(extractor - (fallthrough_return rvals) - (inst_data (InstructionData.MultiAry (Opcode.FallthroughReturn) (value_list_slice rvals))) -) - -(decl call (FuncRef ValueSlice) Inst) -(extractor - (call FN args) - (inst_data (InstructionData.Call (Opcode.Call) (value_list_slice args) FN)) -) - -(decl call_indirect (SigRef Value ValueSlice) Inst) -(extractor - (call_indirect SIG callee args) - (inst_data (InstructionData.CallIndirect (Opcode.CallIndirect) (unwrap_head_value_list_1 callee args) SIG)) -) - -(decl func_addr (FuncRef) Inst) -(extractor - (func_addr FN) - (inst_data (InstructionData.FuncAddr (Opcode.FuncAddr) FN)) -) - -(decl splat (Value) Inst) -(extractor - (splat x) - (inst_data (InstructionData.Unary (Opcode.Splat) x)) -) - -(decl swizzle (Value Value) Inst) -(extractor - (swizzle x y) - (inst_data (InstructionData.Binary (Opcode.Swizzle) (value_array_2 x y))) -) - -(decl insertlane (Value Value Uimm8) Inst) -(extractor - (insertlane x y Idx) - (inst_data (InstructionData.TernaryImm8 (Opcode.Insertlane) (value_array_2 x y) Idx)) -) - -(decl extractlane (Value Uimm8) Inst) -(extractor - (extractlane x Idx) - (inst_data (InstructionData.BinaryImm8 (Opcode.Extractlane) x Idx)) -) - -(decl imin (Value Value) Inst) -(extractor - (imin x y) - (inst_data (InstructionData.Binary (Opcode.Imin) (value_array_2 x y))) -) - -(decl umin (Value Value) Inst) -(extractor - (umin x y) - (inst_data (InstructionData.Binary (Opcode.Umin) (value_array_2 x y))) -) - -(decl imax (Value Value) Inst) -(extractor - (imax x y) - (inst_data (InstructionData.Binary (Opcode.Imax) (value_array_2 x y))) -) - -(decl umax (Value Value) Inst) -(extractor - (umax x y) - (inst_data (InstructionData.Binary (Opcode.Umax) (value_array_2 x y))) -) - -(decl avg_round (Value Value) Inst) -(extractor - (avg_round x y) - (inst_data (InstructionData.Binary (Opcode.AvgRound) (value_array_2 x y))) -) - -(decl uadd_sat (Value Value) Inst) -(extractor - (uadd_sat x y) - (inst_data (InstructionData.Binary (Opcode.UaddSat) (value_array_2 x y))) -) - -(decl sadd_sat (Value Value) Inst) -(extractor - (sadd_sat x y) - (inst_data (InstructionData.Binary (Opcode.SaddSat) (value_array_2 x y))) -) - -(decl usub_sat (Value Value) Inst) -(extractor - (usub_sat x y) - (inst_data (InstructionData.Binary (Opcode.UsubSat) (value_array_2 x y))) -) - -(decl ssub_sat (Value Value) Inst) -(extractor - (ssub_sat x y) - (inst_data (InstructionData.Binary (Opcode.SsubSat) (value_array_2 x y))) -) - -(decl load (MemFlags Value Offset32) Inst) -(extractor - (load MemFlags p Offset) - (inst_data (InstructionData.Load (Opcode.Load) p MemFlags Offset)) -) - -(decl store (MemFlags Value Value Offset32) Inst) -(extractor - (store MemFlags x p Offset) - (inst_data (InstructionData.Store (Opcode.Store) (value_array_2 x p) MemFlags Offset)) -) - -(decl uload8 (MemFlags Value Offset32) Inst) -(extractor - (uload8 MemFlags p Offset) - (inst_data (InstructionData.Load (Opcode.Uload8) p MemFlags Offset)) -) - -(decl sload8 (MemFlags Value Offset32) Inst) -(extractor - (sload8 MemFlags p Offset) - (inst_data (InstructionData.Load (Opcode.Sload8) p MemFlags Offset)) -) - -(decl istore8 (MemFlags Value Value Offset32) Inst) -(extractor - (istore8 MemFlags x p Offset) - (inst_data (InstructionData.Store (Opcode.Istore8) (value_array_2 x p) MemFlags Offset)) -) - -(decl uload16 (MemFlags Value Offset32) Inst) -(extractor - (uload16 MemFlags p Offset) - (inst_data (InstructionData.Load (Opcode.Uload16) p MemFlags Offset)) -) - -(decl sload16 (MemFlags Value Offset32) Inst) -(extractor - (sload16 MemFlags p Offset) - (inst_data (InstructionData.Load (Opcode.Sload16) p MemFlags Offset)) -) - -(decl istore16 (MemFlags Value Value Offset32) Inst) -(extractor - (istore16 MemFlags x p Offset) - (inst_data (InstructionData.Store (Opcode.Istore16) (value_array_2 x p) MemFlags Offset)) -) - -(decl uload32 (MemFlags Value Offset32) Inst) -(extractor - (uload32 MemFlags p Offset) - (inst_data (InstructionData.Load (Opcode.Uload32) p MemFlags Offset)) -) - -(decl sload32 (MemFlags Value Offset32) Inst) -(extractor - (sload32 MemFlags p Offset) - (inst_data (InstructionData.Load (Opcode.Sload32) p MemFlags Offset)) -) - -(decl istore32 (MemFlags Value Value Offset32) Inst) -(extractor - (istore32 MemFlags x p Offset) - (inst_data (InstructionData.Store (Opcode.Istore32) (value_array_2 x p) MemFlags Offset)) -) - -(decl uload8x8 (MemFlags Value Offset32) Inst) -(extractor - (uload8x8 MemFlags p Offset) - (inst_data (InstructionData.Load (Opcode.Uload8x8) p MemFlags Offset)) -) - -(decl sload8x8 (MemFlags Value Offset32) Inst) -(extractor - (sload8x8 MemFlags p Offset) - (inst_data (InstructionData.Load (Opcode.Sload8x8) p MemFlags Offset)) -) - -(decl uload16x4 (MemFlags Value Offset32) Inst) -(extractor - (uload16x4 MemFlags p Offset) - (inst_data (InstructionData.Load (Opcode.Uload16x4) p MemFlags Offset)) -) - -(decl sload16x4 (MemFlags Value Offset32) Inst) -(extractor - (sload16x4 MemFlags p Offset) - (inst_data (InstructionData.Load (Opcode.Sload16x4) p MemFlags Offset)) -) - -(decl uload32x2 (MemFlags Value Offset32) Inst) -(extractor - (uload32x2 MemFlags p Offset) - (inst_data (InstructionData.Load (Opcode.Uload32x2) p MemFlags Offset)) -) - -(decl sload32x2 (MemFlags Value Offset32) Inst) -(extractor - (sload32x2 MemFlags p Offset) - (inst_data (InstructionData.Load (Opcode.Sload32x2) p MemFlags Offset)) -) - -(decl stack_load (StackSlot Offset32) Inst) -(extractor - (stack_load SS Offset) - (inst_data (InstructionData.StackLoad (Opcode.StackLoad) SS Offset)) -) - -(decl stack_store (Value StackSlot Offset32) Inst) -(extractor - (stack_store x SS Offset) - (inst_data (InstructionData.StackStore (Opcode.StackStore) x SS Offset)) -) - -(decl stack_addr (StackSlot Offset32) Inst) -(extractor - (stack_addr SS Offset) - (inst_data (InstructionData.StackLoad (Opcode.StackAddr) SS Offset)) -) - -(decl global_value (GlobalValue) Inst) -(extractor - (global_value GV) - (inst_data (InstructionData.UnaryGlobalValue (Opcode.GlobalValue) GV)) -) - -(decl symbol_value (GlobalValue) Inst) -(extractor - (symbol_value GV) - (inst_data (InstructionData.UnaryGlobalValue (Opcode.SymbolValue) GV)) -) - -(decl tls_value (GlobalValue) Inst) -(extractor - (tls_value GV) - (inst_data (InstructionData.UnaryGlobalValue (Opcode.TlsValue) GV)) -) - -(decl heap_addr (Heap Value Uimm32) Inst) -(extractor - (heap_addr H p Size) - (inst_data (InstructionData.HeapAddr (Opcode.HeapAddr) p H Size)) -) - -(decl get_pinned_reg () Inst) -(extractor - (get_pinned_reg ) - (inst_data (InstructionData.NullAry (Opcode.GetPinnedReg))) -) - -(decl set_pinned_reg (Value) Inst) -(extractor - (set_pinned_reg addr) - (inst_data (InstructionData.Unary (Opcode.SetPinnedReg) addr)) -) - -(decl table_addr (Table Value Offset32) Inst) -(extractor - (table_addr T p Offset) - (inst_data (InstructionData.TableAddr (Opcode.TableAddr) p T Offset)) -) - -(decl iconst (Imm64) Inst) -(extractor - (iconst N) - (inst_data (InstructionData.UnaryImm (Opcode.Iconst) N)) -) - -(decl f32const (Ieee32) Inst) -(extractor - (f32const N) - (inst_data (InstructionData.UnaryIeee32 (Opcode.F32const) N)) -) - -(decl f64const (Ieee64) Inst) -(extractor - (f64const N) - (inst_data (InstructionData.UnaryIeee64 (Opcode.F64const) N)) -) - -(decl bconst (bool) Inst) -(extractor - (bconst N) - (inst_data (InstructionData.UnaryBool (Opcode.Bconst) N)) -) - -(decl vconst (Constant) Inst) -(extractor - (vconst N) - (inst_data (InstructionData.UnaryConst (Opcode.Vconst) N)) -) - -(decl const_addr (Constant) Inst) -(extractor - (const_addr constant) - (inst_data (InstructionData.UnaryConst (Opcode.ConstAddr) constant)) -) - -(decl shuffle (Value Value Immediate) Inst) -(extractor - (shuffle a b mask) - (inst_data (InstructionData.Shuffle (Opcode.Shuffle) (value_array_2 a b) mask)) -) - -(decl null () Inst) -(extractor - (null ) - (inst_data (InstructionData.NullAry (Opcode.Null))) -) - -(decl nop () Inst) -(extractor - (nop ) - (inst_data (InstructionData.NullAry (Opcode.Nop))) -) - -(decl select (Value Value Value) Inst) -(extractor - (select c x y) - (inst_data (InstructionData.Ternary (Opcode.Select) (value_array_3 c x y))) -) - -(decl selectif (IntCC Value Value Value) Inst) -(extractor - (selectif cc flags x y) - (inst_data (InstructionData.IntSelect (Opcode.Selectif) (value_array_3 flags x y) cc)) -) - -(decl selectif_spectre_guard (IntCC Value Value Value) Inst) -(extractor - (selectif_spectre_guard cc flags x y) - (inst_data (InstructionData.IntSelect (Opcode.SelectifSpectreGuard) (value_array_3 flags x y) cc)) -) - -(decl bitselect (Value Value Value) Inst) -(extractor - (bitselect c x y) - (inst_data (InstructionData.Ternary (Opcode.Bitselect) (value_array_3 c x y))) -) - -(decl copy (Value) Inst) -(extractor - (copy x) - (inst_data (InstructionData.Unary (Opcode.Copy) x)) -) - -(decl ifcmp_sp (Value) Inst) -(extractor - (ifcmp_sp addr) - (inst_data (InstructionData.Unary (Opcode.IfcmpSp) addr)) -) - -(decl vsplit (Value) Inst) -(extractor - (vsplit x) - (inst_data (InstructionData.Unary (Opcode.Vsplit) x)) -) - -(decl vconcat (Value Value) Inst) -(extractor - (vconcat x y) - (inst_data (InstructionData.Binary (Opcode.Vconcat) (value_array_2 x y))) -) - -(decl vselect (Value Value Value) Inst) -(extractor - (vselect c x y) - (inst_data (InstructionData.Ternary (Opcode.Vselect) (value_array_3 c x y))) -) - -(decl vany_true (Value) Inst) -(extractor - (vany_true a) - (inst_data (InstructionData.Unary (Opcode.VanyTrue) a)) -) - -(decl vall_true (Value) Inst) -(extractor - (vall_true a) - (inst_data (InstructionData.Unary (Opcode.VallTrue) a)) -) - -(decl vhigh_bits (Value) Inst) -(extractor - (vhigh_bits a) - (inst_data (InstructionData.Unary (Opcode.VhighBits) a)) -) - -(decl icmp (IntCC Value Value) Inst) -(extractor - (icmp Cond x y) - (inst_data (InstructionData.IntCompare (Opcode.Icmp) (value_array_2 x y) Cond)) -) - -(decl icmp_imm (IntCC Value Imm64) Inst) -(extractor - (icmp_imm Cond x Y) - (inst_data (InstructionData.IntCompareImm (Opcode.IcmpImm) x Cond Y)) -) - -(decl ifcmp (Value Value) Inst) -(extractor - (ifcmp x y) - (inst_data (InstructionData.Binary (Opcode.Ifcmp) (value_array_2 x y))) -) - -(decl ifcmp_imm (Value Imm64) Inst) -(extractor - (ifcmp_imm x Y) - (inst_data (InstructionData.BinaryImm64 (Opcode.IfcmpImm) x Y)) -) - -(decl iadd (Value Value) Inst) -(extractor - (iadd x y) - (inst_data (InstructionData.Binary (Opcode.Iadd) (value_array_2 x y))) -) - -(decl isub (Value Value) Inst) -(extractor - (isub x y) - (inst_data (InstructionData.Binary (Opcode.Isub) (value_array_2 x y))) -) - -(decl ineg (Value) Inst) -(extractor - (ineg x) - (inst_data (InstructionData.Unary (Opcode.Ineg) x)) -) - -(decl iabs (Value) Inst) -(extractor - (iabs x) - (inst_data (InstructionData.Unary (Opcode.Iabs) x)) -) - -(decl imul (Value Value) Inst) -(extractor - (imul x y) - (inst_data (InstructionData.Binary (Opcode.Imul) (value_array_2 x y))) -) - -(decl umulhi (Value Value) Inst) -(extractor - (umulhi x y) - (inst_data (InstructionData.Binary (Opcode.Umulhi) (value_array_2 x y))) -) - -(decl smulhi (Value Value) Inst) -(extractor - (smulhi x y) - (inst_data (InstructionData.Binary (Opcode.Smulhi) (value_array_2 x y))) -) - -(decl sqmul_round_sat (Value Value) Inst) -(extractor - (sqmul_round_sat x y) - (inst_data (InstructionData.Binary (Opcode.SqmulRoundSat) (value_array_2 x y))) -) - -(decl udiv (Value Value) Inst) -(extractor - (udiv x y) - (inst_data (InstructionData.Binary (Opcode.Udiv) (value_array_2 x y))) -) - -(decl sdiv (Value Value) Inst) -(extractor - (sdiv x y) - (inst_data (InstructionData.Binary (Opcode.Sdiv) (value_array_2 x y))) -) - -(decl urem (Value Value) Inst) -(extractor - (urem x y) - (inst_data (InstructionData.Binary (Opcode.Urem) (value_array_2 x y))) -) - -(decl srem (Value Value) Inst) -(extractor - (srem x y) - (inst_data (InstructionData.Binary (Opcode.Srem) (value_array_2 x y))) -) - -(decl iadd_imm (Value Imm64) Inst) -(extractor - (iadd_imm x Y) - (inst_data (InstructionData.BinaryImm64 (Opcode.IaddImm) x Y)) -) - -(decl imul_imm (Value Imm64) Inst) -(extractor - (imul_imm x Y) - (inst_data (InstructionData.BinaryImm64 (Opcode.ImulImm) x Y)) -) - -(decl udiv_imm (Value Imm64) Inst) -(extractor - (udiv_imm x Y) - (inst_data (InstructionData.BinaryImm64 (Opcode.UdivImm) x Y)) -) - -(decl sdiv_imm (Value Imm64) Inst) -(extractor - (sdiv_imm x Y) - (inst_data (InstructionData.BinaryImm64 (Opcode.SdivImm) x Y)) -) - -(decl urem_imm (Value Imm64) Inst) -(extractor - (urem_imm x Y) - (inst_data (InstructionData.BinaryImm64 (Opcode.UremImm) x Y)) -) - -(decl srem_imm (Value Imm64) Inst) -(extractor - (srem_imm x Y) - (inst_data (InstructionData.BinaryImm64 (Opcode.SremImm) x Y)) -) - -(decl irsub_imm (Value Imm64) Inst) -(extractor - (irsub_imm x Y) - (inst_data (InstructionData.BinaryImm64 (Opcode.IrsubImm) x Y)) -) - -(decl iadd_cin (Value Value Value) Inst) -(extractor - (iadd_cin x y c_in) - (inst_data (InstructionData.Ternary (Opcode.IaddCin) (value_array_3 x y c_in))) -) - -(decl iadd_ifcin (Value Value Value) Inst) -(extractor - (iadd_ifcin x y c_in) - (inst_data (InstructionData.Ternary (Opcode.IaddIfcin) (value_array_3 x y c_in))) -) - -(decl iadd_cout (Value Value) Inst) -(extractor - (iadd_cout x y) - (inst_data (InstructionData.Binary (Opcode.IaddCout) (value_array_2 x y))) -) - -(decl iadd_ifcout (Value Value) Inst) -(extractor - (iadd_ifcout x y) - (inst_data (InstructionData.Binary (Opcode.IaddIfcout) (value_array_2 x y))) -) - -(decl iadd_carry (Value Value Value) Inst) -(extractor - (iadd_carry x y c_in) - (inst_data (InstructionData.Ternary (Opcode.IaddCarry) (value_array_3 x y c_in))) -) - -(decl iadd_ifcarry (Value Value Value) Inst) -(extractor - (iadd_ifcarry x y c_in) - (inst_data (InstructionData.Ternary (Opcode.IaddIfcarry) (value_array_3 x y c_in))) -) - -(decl isub_bin (Value Value Value) Inst) -(extractor - (isub_bin x y b_in) - (inst_data (InstructionData.Ternary (Opcode.IsubBin) (value_array_3 x y b_in))) -) - -(decl isub_ifbin (Value Value Value) Inst) -(extractor - (isub_ifbin x y b_in) - (inst_data (InstructionData.Ternary (Opcode.IsubIfbin) (value_array_3 x y b_in))) -) - -(decl isub_bout (Value Value) Inst) -(extractor - (isub_bout x y) - (inst_data (InstructionData.Binary (Opcode.IsubBout) (value_array_2 x y))) -) - -(decl isub_ifbout (Value Value) Inst) -(extractor - (isub_ifbout x y) - (inst_data (InstructionData.Binary (Opcode.IsubIfbout) (value_array_2 x y))) -) - -(decl isub_borrow (Value Value Value) Inst) -(extractor - (isub_borrow x y b_in) - (inst_data (InstructionData.Ternary (Opcode.IsubBorrow) (value_array_3 x y b_in))) -) - -(decl isub_ifborrow (Value Value Value) Inst) -(extractor - (isub_ifborrow x y b_in) - (inst_data (InstructionData.Ternary (Opcode.IsubIfborrow) (value_array_3 x y b_in))) -) - -(decl band (Value Value) Inst) -(extractor - (band x y) - (inst_data (InstructionData.Binary (Opcode.Band) (value_array_2 x y))) -) - -(decl bor (Value Value) Inst) -(extractor - (bor x y) - (inst_data (InstructionData.Binary (Opcode.Bor) (value_array_2 x y))) -) - -(decl bxor (Value Value) Inst) -(extractor - (bxor x y) - (inst_data (InstructionData.Binary (Opcode.Bxor) (value_array_2 x y))) -) - -(decl bnot (Value) Inst) -(extractor - (bnot x) - (inst_data (InstructionData.Unary (Opcode.Bnot) x)) -) - -(decl band_not (Value Value) Inst) -(extractor - (band_not x y) - (inst_data (InstructionData.Binary (Opcode.BandNot) (value_array_2 x y))) -) - -(decl bor_not (Value Value) Inst) -(extractor - (bor_not x y) - (inst_data (InstructionData.Binary (Opcode.BorNot) (value_array_2 x y))) -) - -(decl bxor_not (Value Value) Inst) -(extractor - (bxor_not x y) - (inst_data (InstructionData.Binary (Opcode.BxorNot) (value_array_2 x y))) -) - -(decl band_imm (Value Imm64) Inst) -(extractor - (band_imm x Y) - (inst_data (InstructionData.BinaryImm64 (Opcode.BandImm) x Y)) -) - -(decl bor_imm (Value Imm64) Inst) -(extractor - (bor_imm x Y) - (inst_data (InstructionData.BinaryImm64 (Opcode.BorImm) x Y)) -) - -(decl bxor_imm (Value Imm64) Inst) -(extractor - (bxor_imm x Y) - (inst_data (InstructionData.BinaryImm64 (Opcode.BxorImm) x Y)) -) - -(decl rotl (Value Value) Inst) -(extractor - (rotl x y) - (inst_data (InstructionData.Binary (Opcode.Rotl) (value_array_2 x y))) -) - -(decl rotr (Value Value) Inst) -(extractor - (rotr x y) - (inst_data (InstructionData.Binary (Opcode.Rotr) (value_array_2 x y))) -) - -(decl rotl_imm (Value Imm64) Inst) -(extractor - (rotl_imm x Y) - (inst_data (InstructionData.BinaryImm64 (Opcode.RotlImm) x Y)) -) - -(decl rotr_imm (Value Imm64) Inst) -(extractor - (rotr_imm x Y) - (inst_data (InstructionData.BinaryImm64 (Opcode.RotrImm) x Y)) -) - -(decl ishl (Value Value) Inst) -(extractor - (ishl x y) - (inst_data (InstructionData.Binary (Opcode.Ishl) (value_array_2 x y))) -) - -(decl ushr (Value Value) Inst) -(extractor - (ushr x y) - (inst_data (InstructionData.Binary (Opcode.Ushr) (value_array_2 x y))) -) - -(decl sshr (Value Value) Inst) -(extractor - (sshr x y) - (inst_data (InstructionData.Binary (Opcode.Sshr) (value_array_2 x y))) -) - -(decl ishl_imm (Value Imm64) Inst) -(extractor - (ishl_imm x Y) - (inst_data (InstructionData.BinaryImm64 (Opcode.IshlImm) x Y)) -) - -(decl ushr_imm (Value Imm64) Inst) -(extractor - (ushr_imm x Y) - (inst_data (InstructionData.BinaryImm64 (Opcode.UshrImm) x Y)) -) - -(decl sshr_imm (Value Imm64) Inst) -(extractor - (sshr_imm x Y) - (inst_data (InstructionData.BinaryImm64 (Opcode.SshrImm) x Y)) -) - -(decl bitrev (Value) Inst) -(extractor - (bitrev x) - (inst_data (InstructionData.Unary (Opcode.Bitrev) x)) -) - -(decl clz (Value) Inst) -(extractor - (clz x) - (inst_data (InstructionData.Unary (Opcode.Clz) x)) -) - -(decl cls (Value) Inst) -(extractor - (cls x) - (inst_data (InstructionData.Unary (Opcode.Cls) x)) -) - -(decl ctz (Value) Inst) -(extractor - (ctz x) - (inst_data (InstructionData.Unary (Opcode.Ctz) x)) -) - -(decl popcnt (Value) Inst) -(extractor - (popcnt x) - (inst_data (InstructionData.Unary (Opcode.Popcnt) x)) -) - -(decl fcmp (FloatCC Value Value) Inst) -(extractor - (fcmp Cond x y) - (inst_data (InstructionData.FloatCompare (Opcode.Fcmp) (value_array_2 x y) Cond)) -) - -(decl ffcmp (Value Value) Inst) -(extractor - (ffcmp x y) - (inst_data (InstructionData.Binary (Opcode.Ffcmp) (value_array_2 x y))) -) - -(decl fadd (Value Value) Inst) -(extractor - (fadd x y) - (inst_data (InstructionData.Binary (Opcode.Fadd) (value_array_2 x y))) -) - -(decl fsub (Value Value) Inst) -(extractor - (fsub x y) - (inst_data (InstructionData.Binary (Opcode.Fsub) (value_array_2 x y))) -) - -(decl fmul (Value Value) Inst) -(extractor - (fmul x y) - (inst_data (InstructionData.Binary (Opcode.Fmul) (value_array_2 x y))) -) - -(decl fdiv (Value Value) Inst) -(extractor - (fdiv x y) - (inst_data (InstructionData.Binary (Opcode.Fdiv) (value_array_2 x y))) -) - -(decl sqrt (Value) Inst) -(extractor - (sqrt x) - (inst_data (InstructionData.Unary (Opcode.Sqrt) x)) -) - -(decl fma (Value Value Value) Inst) -(extractor - (fma x y z) - (inst_data (InstructionData.Ternary (Opcode.Fma) (value_array_3 x y z))) -) - -(decl fneg (Value) Inst) -(extractor - (fneg x) - (inst_data (InstructionData.Unary (Opcode.Fneg) x)) -) - -(decl fabs (Value) Inst) -(extractor - (fabs x) - (inst_data (InstructionData.Unary (Opcode.Fabs) x)) -) - -(decl fcopysign (Value Value) Inst) -(extractor - (fcopysign x y) - (inst_data (InstructionData.Binary (Opcode.Fcopysign) (value_array_2 x y))) -) - -(decl fmin (Value Value) Inst) -(extractor - (fmin x y) - (inst_data (InstructionData.Binary (Opcode.Fmin) (value_array_2 x y))) -) - -(decl fmin_pseudo (Value Value) Inst) -(extractor - (fmin_pseudo x y) - (inst_data (InstructionData.Binary (Opcode.FminPseudo) (value_array_2 x y))) -) - -(decl fmax (Value Value) Inst) -(extractor - (fmax x y) - (inst_data (InstructionData.Binary (Opcode.Fmax) (value_array_2 x y))) -) - -(decl fmax_pseudo (Value Value) Inst) -(extractor - (fmax_pseudo x y) - (inst_data (InstructionData.Binary (Opcode.FmaxPseudo) (value_array_2 x y))) -) - -(decl ceil (Value) Inst) -(extractor - (ceil x) - (inst_data (InstructionData.Unary (Opcode.Ceil) x)) -) - -(decl floor (Value) Inst) -(extractor - (floor x) - (inst_data (InstructionData.Unary (Opcode.Floor) x)) -) - -(decl trunc (Value) Inst) -(extractor - (trunc x) - (inst_data (InstructionData.Unary (Opcode.Trunc) x)) -) - -(decl nearest (Value) Inst) -(extractor - (nearest x) - (inst_data (InstructionData.Unary (Opcode.Nearest) x)) -) - -(decl is_null (Value) Inst) -(extractor - (is_null x) - (inst_data (InstructionData.Unary (Opcode.IsNull) x)) -) - -(decl is_invalid (Value) Inst) -(extractor - (is_invalid x) - (inst_data (InstructionData.Unary (Opcode.IsInvalid) x)) -) - -(decl trueif (IntCC Value) Inst) -(extractor - (trueif Cond f) - (inst_data (InstructionData.IntCond (Opcode.Trueif) f Cond)) -) - -(decl trueff (FloatCC Value) Inst) -(extractor - (trueff Cond f) - (inst_data (InstructionData.FloatCond (Opcode.Trueff) f Cond)) -) - -(decl bitcast (Value) Inst) -(extractor - (bitcast x) - (inst_data (InstructionData.Unary (Opcode.Bitcast) x)) -) - -(decl raw_bitcast (Value) Inst) -(extractor - (raw_bitcast x) - (inst_data (InstructionData.Unary (Opcode.RawBitcast) x)) -) - -(decl scalar_to_vector (Value) Inst) -(extractor - (scalar_to_vector s) - (inst_data (InstructionData.Unary (Opcode.ScalarToVector) s)) -) - -(decl breduce (Value) Inst) -(extractor - (breduce x) - (inst_data (InstructionData.Unary (Opcode.Breduce) x)) -) - -(decl bextend (Value) Inst) -(extractor - (bextend x) - (inst_data (InstructionData.Unary (Opcode.Bextend) x)) -) - -(decl bint (Value) Inst) -(extractor - (bint x) - (inst_data (InstructionData.Unary (Opcode.Bint) x)) -) - -(decl bmask (Value) Inst) -(extractor - (bmask x) - (inst_data (InstructionData.Unary (Opcode.Bmask) x)) -) - -(decl ireduce (Value) Inst) -(extractor - (ireduce x) - (inst_data (InstructionData.Unary (Opcode.Ireduce) x)) -) - -(decl snarrow (Value Value) Inst) -(extractor - (snarrow x y) - (inst_data (InstructionData.Binary (Opcode.Snarrow) (value_array_2 x y))) -) - -(decl unarrow (Value Value) Inst) -(extractor - (unarrow x y) - (inst_data (InstructionData.Binary (Opcode.Unarrow) (value_array_2 x y))) -) - -(decl uunarrow (Value Value) Inst) -(extractor - (uunarrow x y) - (inst_data (InstructionData.Binary (Opcode.Uunarrow) (value_array_2 x y))) -) - -(decl swiden_low (Value) Inst) -(extractor - (swiden_low x) - (inst_data (InstructionData.Unary (Opcode.SwidenLow) x)) -) - -(decl swiden_high (Value) Inst) -(extractor - (swiden_high x) - (inst_data (InstructionData.Unary (Opcode.SwidenHigh) x)) -) - -(decl uwiden_low (Value) Inst) -(extractor - (uwiden_low x) - (inst_data (InstructionData.Unary (Opcode.UwidenLow) x)) -) - -(decl uwiden_high (Value) Inst) -(extractor - (uwiden_high x) - (inst_data (InstructionData.Unary (Opcode.UwidenHigh) x)) -) - -(decl iadd_pairwise (Value Value) Inst) -(extractor - (iadd_pairwise x y) - (inst_data (InstructionData.Binary (Opcode.IaddPairwise) (value_array_2 x y))) -) - -(decl widening_pairwise_dot_product_s (Value Value) Inst) -(extractor - (widening_pairwise_dot_product_s x y) - (inst_data (InstructionData.Binary (Opcode.WideningPairwiseDotProductS) (value_array_2 x y))) -) - -(decl uextend (Value) Inst) -(extractor - (uextend x) - (inst_data (InstructionData.Unary (Opcode.Uextend) x)) -) - -(decl sextend (Value) Inst) -(extractor - (sextend x) - (inst_data (InstructionData.Unary (Opcode.Sextend) x)) -) - -(decl fpromote (Value) Inst) -(extractor - (fpromote x) - (inst_data (InstructionData.Unary (Opcode.Fpromote) x)) -) - -(decl fdemote (Value) Inst) -(extractor - (fdemote x) - (inst_data (InstructionData.Unary (Opcode.Fdemote) x)) -) - -(decl fvdemote (Value) Inst) -(extractor - (fvdemote x) - (inst_data (InstructionData.Unary (Opcode.Fvdemote) x)) -) - -(decl fvpromote_low (Value) Inst) -(extractor - (fvpromote_low a) - (inst_data (InstructionData.Unary (Opcode.FvpromoteLow) a)) -) - -(decl fcvt_to_uint (Value) Inst) -(extractor - (fcvt_to_uint x) - (inst_data (InstructionData.Unary (Opcode.FcvtToUint) x)) -) - -(decl fcvt_to_uint_sat (Value) Inst) -(extractor - (fcvt_to_uint_sat x) - (inst_data (InstructionData.Unary (Opcode.FcvtToUintSat) x)) -) - -(decl fcvt_to_sint (Value) Inst) -(extractor - (fcvt_to_sint x) - (inst_data (InstructionData.Unary (Opcode.FcvtToSint) x)) -) - -(decl fcvt_to_sint_sat (Value) Inst) -(extractor - (fcvt_to_sint_sat x) - (inst_data (InstructionData.Unary (Opcode.FcvtToSintSat) x)) -) - -(decl fcvt_from_uint (Value) Inst) -(extractor - (fcvt_from_uint x) - (inst_data (InstructionData.Unary (Opcode.FcvtFromUint) x)) -) - -(decl fcvt_from_sint (Value) Inst) -(extractor - (fcvt_from_sint x) - (inst_data (InstructionData.Unary (Opcode.FcvtFromSint) x)) -) - -(decl fcvt_low_from_sint (Value) Inst) -(extractor - (fcvt_low_from_sint x) - (inst_data (InstructionData.Unary (Opcode.FcvtLowFromSint) x)) -) - -(decl isplit (Value) Inst) -(extractor - (isplit x) - (inst_data (InstructionData.Unary (Opcode.Isplit) x)) -) - -(decl iconcat (Value Value) Inst) -(extractor - (iconcat lo hi) - (inst_data (InstructionData.Binary (Opcode.Iconcat) (value_array_2 lo hi))) -) - -(decl atomic_rmw (MemFlags AtomicRmwOp Value Value) Inst) -(extractor - (atomic_rmw MemFlags AtomicRmwOp p x) - (inst_data (InstructionData.AtomicRmw (Opcode.AtomicRmw) (value_array_2 p x) MemFlags AtomicRmwOp)) -) - -(decl atomic_cas (MemFlags Value Value Value) Inst) -(extractor - (atomic_cas MemFlags p e x) - (inst_data (InstructionData.AtomicCas (Opcode.AtomicCas) (value_array_3 p e x) MemFlags)) -) - -(decl atomic_load (MemFlags Value) Inst) -(extractor - (atomic_load MemFlags p) - (inst_data (InstructionData.LoadNoOffset (Opcode.AtomicLoad) p MemFlags)) -) - -(decl atomic_store (MemFlags Value Value) Inst) -(extractor - (atomic_store MemFlags x p) - (inst_data (InstructionData.StoreNoOffset (Opcode.AtomicStore) (value_array_2 x p) MemFlags)) -) - -(decl fence () Inst) -(extractor - (fence ) - (inst_data (InstructionData.NullAry (Opcode.Fence))) -) - diff --git a/cranelift/codegen/src/isa/aarch64/lower/isle/generated_code.manifest b/cranelift/codegen/src/isa/aarch64/lower/isle/generated_code.manifest deleted file mode 100644 index 3bc4853e2d..0000000000 --- a/cranelift/codegen/src/isa/aarch64/lower/isle/generated_code.manifest +++ /dev/null @@ -1,4 +0,0 @@ -src/clif.isle 443b34b797fc8ace -src/prelude.isle e6c91b0115343ab9 -src/isa/aarch64/inst.isle 21a43af20be377d2 -src/isa/aarch64/lower.isle 75ad8450963e3829 diff --git a/cranelift/codegen/src/isa/aarch64/lower/isle/generated_code.rs b/cranelift/codegen/src/isa/aarch64/lower/isle/generated_code.rs index f034e4fbde..f9fc2d34e6 100644 --- a/cranelift/codegen/src/isa/aarch64/lower/isle/generated_code.rs +++ b/cranelift/codegen/src/isa/aarch64/lower/isle/generated_code.rs @@ -1,7322 +1,9 @@ -// GENERATED BY ISLE. DO NOT EDIT! -// -// Generated automatically from the instruction-selection DSL code in: -// - src/clif.isle -// - src/prelude.isle -// - src/isa/aarch64/inst.isle -// - src/isa/aarch64/lower.isle - +// See https://github.com/rust-lang/rust/issues/47995: we cannot use `#![...]` attributes inside of +// the generated ISLE source below because we include!() it. We must include!() it because its path +// depends on an environment variable; and also because of this, we can't do the `#[path = "..."] +// mod generated_code;` trick either. #![allow(dead_code, unreachable_code, unreachable_patterns)] #![allow(unused_imports, unused_variables, non_snake_case, unused_mut)] #![allow(irrefutable_let_patterns)] -use super::*; // Pulls in all external types. - -/// Context during lowering: an implementation of this trait -/// must be provided with all external constructors and extractors. -/// A mutable borrow is passed along through all lowering logic. -pub trait Context { - fn unpack_value_array_2(&mut self, arg0: &ValueArray2) -> (Value, Value); - fn pack_value_array_2(&mut self, arg0: Value, arg1: Value) -> ValueArray2; - fn unpack_value_array_3(&mut self, arg0: &ValueArray3) -> (Value, Value, Value); - fn pack_value_array_3(&mut self, arg0: Value, arg1: Value, arg2: Value) -> ValueArray3; - fn u32_add(&mut self, arg0: u32, arg1: u32) -> u32; - fn s32_add_fallible(&mut self, arg0: u32, arg1: u32) -> Option; - fn u32_nonnegative(&mut self, arg0: u32) -> Option; - fn offset32(&mut self, arg0: Offset32) -> Option; - fn u32_lteq(&mut self, arg0: u32, arg1: u32) -> Option; - fn simm32(&mut self, arg0: Imm64) -> Option; - fn uimm8(&mut self, arg0: Imm64) -> Option; - fn u8_and(&mut self, arg0: u8, arg1: u8) -> u8; - fn value_reg(&mut self, arg0: Reg) -> ValueRegs; - fn value_regs(&mut self, arg0: Reg, arg1: Reg) -> ValueRegs; - fn value_regs_invalid(&mut self) -> ValueRegs; - fn output_none(&mut self) -> InstOutput; - fn output(&mut self, arg0: ValueRegs) -> InstOutput; - fn output_pair(&mut self, arg0: ValueRegs, arg1: ValueRegs) -> InstOutput; - fn output_builder_new(&mut self) -> InstOutputBuilder; - fn output_builder_push(&mut self, arg0: &InstOutputBuilder, arg1: ValueRegs) -> Unit; - fn output_builder_finish(&mut self, arg0: &InstOutputBuilder) -> InstOutput; - fn temp_writable_reg(&mut self, arg0: Type) -> WritableReg; - fn invalid_reg_etor(&mut self, arg0: Reg) -> Option<()>; - fn invalid_reg(&mut self) -> Reg; - fn valid_reg(&mut self, arg0: Reg) -> Option<()>; - fn put_in_reg(&mut self, arg0: Value) -> Reg; - fn put_in_regs(&mut self, arg0: Value) -> ValueRegs; - fn ensure_in_vreg(&mut self, arg0: Reg, arg1: Type) -> Reg; - fn value_regs_get(&mut self, arg0: ValueRegs, arg1: usize) -> Reg; - fn u8_as_u32(&mut self, arg0: u8) -> Option; - fn u8_as_u64(&mut self, arg0: u8) -> Option; - fn u16_as_u64(&mut self, arg0: u16) -> Option; - fn u32_as_u64(&mut self, arg0: u32) -> Option; - fn i64_as_u64(&mut self, arg0: i64) -> Option; - fn u64_add(&mut self, arg0: u64, arg1: u64) -> Option; - fn u64_sub(&mut self, arg0: u64, arg1: u64) -> Option; - fn u64_and(&mut self, arg0: u64, arg1: u64) -> Option; - fn ty_bits(&mut self, arg0: Type) -> Option; - fn ty_bits_u16(&mut self, arg0: Type) -> u16; - fn ty_bits_u64(&mut self, arg0: Type) -> u64; - fn ty_mask(&mut self, arg0: Type) -> u64; - fn ty_bytes(&mut self, arg0: Type) -> u16; - fn lane_type(&mut self, arg0: Type) -> Type; - fn fits_in_16(&mut self, arg0: Type) -> Option; - fn fits_in_32(&mut self, arg0: Type) -> Option; - fn fits_in_64(&mut self, arg0: Type) -> Option; - fn ty_32_or_64(&mut self, arg0: Type) -> Option; - fn ty_8_or_16(&mut self, arg0: Type) -> Option; - fn ty_int_bool_64(&mut self, arg0: Type) -> Option; - fn ty_int_bool_ref_64(&mut self, arg0: Type) -> Option; - fn ty_int_bool_128(&mut self, arg0: Type) -> Option; - fn ty_scalar_float(&mut self, arg0: Type) -> Option; - fn ty_vec128(&mut self, arg0: Type) -> Option; - fn ty_vec128_int(&mut self, arg0: Type) -> Option; - fn not_i64x2(&mut self, arg0: Type) -> Option<()>; - fn value_list_slice(&mut self, arg0: ValueList) -> ValueSlice; - fn value_slice_empty(&mut self, arg0: ValueSlice) -> Option<()>; - fn value_slice_unwrap(&mut self, arg0: ValueSlice) -> Option<(Value, ValueSlice)>; - fn value_slice_len(&mut self, arg0: ValueSlice) -> usize; - fn value_slice_get(&mut self, arg0: ValueSlice, arg1: usize) -> Value; - fn writable_reg_to_reg(&mut self, arg0: WritableReg) -> Reg; - fn u8_from_uimm8(&mut self, arg0: Uimm8) -> u8; - fn u64_from_imm64(&mut self, arg0: Imm64) -> u64; - fn nonzero_u64_from_imm64(&mut self, arg0: Imm64) -> Option; - fn u64_from_ieee32(&mut self, arg0: Ieee32) -> u64; - fn u64_from_ieee64(&mut self, arg0: Ieee64) -> u64; - fn inst_results(&mut self, arg0: Inst) -> ValueSlice; - fn first_result(&mut self, arg0: Inst) -> Option; - fn inst_data(&mut self, arg0: Inst) -> InstructionData; - fn value_type(&mut self, arg0: Value) -> Type; - fn multi_lane(&mut self, arg0: Type) -> Option<(u8, u16)>; - fn def_inst(&mut self, arg0: Value) -> Option; - fn offset32_to_u32(&mut self, arg0: Offset32) -> u32; - fn emit(&mut self, arg0: &MInst) -> Unit; - fn emit_u64_le_const(&mut self, arg0: u64) -> VCodeConstant; - fn trap_code_division_by_zero(&mut self) -> TrapCode; - fn trap_code_integer_overflow(&mut self) -> TrapCode; - fn trap_code_bad_conversion_to_integer(&mut self) -> TrapCode; - fn avoid_div_traps(&mut self, arg0: Type) -> Option<()>; - fn func_ref_data(&mut self, arg0: FuncRef) -> (SigRef, ExternalName, RelocDistance); - fn symbol_value_data( - &mut self, - arg0: GlobalValue, - ) -> Option<(ExternalName, RelocDistance, i64)>; - fn reloc_distance_near(&mut self, arg0: RelocDistance) -> Option<()>; - fn use_lse(&mut self, arg0: Inst) -> Option<()>; - fn move_wide_const_from_u64(&mut self, arg0: u64) -> Option; - fn move_wide_const_from_negated_u64(&mut self, arg0: u64) -> Option; - fn imm_logic_from_u64(&mut self, arg0: Type, arg1: u64) -> Option; - fn imm_logic_from_imm64(&mut self, arg0: Type, arg1: Imm64) -> Option; - fn imm_shift_from_imm64(&mut self, arg0: Type, arg1: Imm64) -> Option; - fn imm_shift_from_u8(&mut self, arg0: u8) -> ImmShift; - fn imm12_from_u64(&mut self, arg0: u64) -> Option; - fn u8_into_uimm5(&mut self, arg0: u8) -> UImm5; - fn u8_into_imm12(&mut self, arg0: u8) -> Imm12; - fn u64_into_imm_logic(&mut self, arg0: Type, arg1: u64) -> ImmLogic; - fn imm12_from_negated_u64(&mut self, arg0: u64) -> Option; - fn lshl_from_imm64(&mut self, arg0: Type, arg1: Imm64) -> Option; - fn integral_ty(&mut self, arg0: Type) -> Option; - fn valid_atomic_transaction(&mut self, arg0: Type) -> Option; - fn extended_value_from_value(&mut self, arg0: Value) -> Option; - fn put_extended_in_reg(&mut self, arg0: &ExtendedValue) -> Reg; - fn get_extended_op(&mut self, arg0: &ExtendedValue) -> ExtendOp; - fn nzcv(&mut self, arg0: bool, arg1: bool, arg2: bool, arg3: bool) -> NZCV; - fn cond_br_zero(&mut self, arg0: Reg) -> CondBrKind; - fn cond_br_cond(&mut self, arg0: &Cond) -> CondBrKind; - fn zero_reg(&mut self) -> Reg; - fn writable_zero_reg(&mut self) -> WritableReg; - fn xreg(&mut self, arg0: u8) -> Reg; - fn writable_xreg(&mut self, arg0: u8) -> WritableReg; - fn load_constant64_full(&mut self, arg0: u64) -> Reg; - fn sinkable_atomic_load(&mut self, arg0: Value) -> Option; - fn sink_atomic_load(&mut self, arg0: &SinkableAtomicLoad) -> Reg; - fn zero_value_f32(&mut self, arg0: Ieee32) -> Option; - fn zero_value_f64(&mut self, arg0: Ieee64) -> Option; - fn float_cc_cmp_zero_to_vec_misc_op(&mut self, arg0: &FloatCC) -> VecMisc2; - fn float_cc_cmp_zero_to_vec_misc_op_swap(&mut self, arg0: &FloatCC) -> VecMisc2; - fn fcmp_zero_cond(&mut self, arg0: &FloatCC) -> Option; - fn fcmp_zero_cond_not_eq(&mut self, arg0: &FloatCC) -> Option; - fn zero_value(&mut self, arg0: Imm64) -> Option; - fn int_cc_cmp_zero_to_vec_misc_op(&mut self, arg0: &IntCC) -> VecMisc2; - fn int_cc_cmp_zero_to_vec_misc_op_swap(&mut self, arg0: &IntCC) -> VecMisc2; - fn icmp_zero_cond(&mut self, arg0: &IntCC) -> Option; - fn icmp_zero_cond_not_eq(&mut self, arg0: &IntCC) -> Option; - fn safe_divisor_from_imm64(&mut self, arg0: Imm64) -> Option; - fn shift_mask(&mut self, arg0: Type) -> ImmLogic; - fn negate_imm_shift(&mut self, arg0: Type, arg1: ImmShift) -> ImmShift; - fn rotr_mask(&mut self, arg0: Type) -> ImmLogic; - fn rotr_opposite_amount(&mut self, arg0: Type, arg1: ImmShift) -> ImmShift; -} - -/// Internal type SideEffectNoResult: defined at src/prelude.isle line 457. -#[derive(Clone, Debug)] -pub enum SideEffectNoResult { - Inst { inst: MInst }, - Inst2 { inst1: MInst, inst2: MInst }, -} - -/// Internal type ProducesFlags: defined at src/prelude.isle line 484. -#[derive(Clone, Debug)] -pub enum ProducesFlags { - ProducesFlagsSideEffect { inst: MInst }, - ProducesFlagsReturnsReg { inst: MInst, result: Reg }, - ProducesFlagsReturnsResultWithConsumer { inst: MInst, result: Reg }, -} - -/// Internal type ConsumesFlags: defined at src/prelude.isle line 495. -#[derive(Clone, Debug)] -pub enum ConsumesFlags { - ConsumesFlagsReturnsResultWithProducer { - inst: MInst, - result: Reg, - }, - ConsumesFlagsReturnsReg { - inst: MInst, - result: Reg, - }, - ConsumesFlagsTwiceReturnsValueRegs { - inst1: MInst, - inst2: MInst, - result: ValueRegs, - }, - ConsumesFlagsFourTimesReturnsValueRegs { - inst1: MInst, - inst2: MInst, - inst3: MInst, - inst4: MInst, - result: ValueRegs, - }, -} - -/// Internal type MInst: defined at src/isa/aarch64/inst.isle line 2. -#[derive(Clone, Debug)] -pub enum MInst { - Nop0, - Nop4, - AluRRR { - alu_op: ALUOp, - size: OperandSize, - rd: WritableReg, - rn: Reg, - rm: Reg, - }, - AluRRRR { - alu_op: ALUOp3, - size: OperandSize, - rd: WritableReg, - rn: Reg, - rm: Reg, - ra: Reg, - }, - AluRRImm12 { - alu_op: ALUOp, - size: OperandSize, - rd: WritableReg, - rn: Reg, - imm12: Imm12, - }, - AluRRImmLogic { - alu_op: ALUOp, - size: OperandSize, - rd: WritableReg, - rn: Reg, - imml: ImmLogic, - }, - AluRRImmShift { - alu_op: ALUOp, - size: OperandSize, - rd: WritableReg, - rn: Reg, - immshift: ImmShift, - }, - AluRRRShift { - alu_op: ALUOp, - size: OperandSize, - rd: WritableReg, - rn: Reg, - rm: Reg, - shiftop: ShiftOpAndAmt, - }, - AluRRRExtend { - alu_op: ALUOp, - size: OperandSize, - rd: WritableReg, - rn: Reg, - rm: Reg, - extendop: ExtendOp, - }, - BitRR { - op: BitOp, - size: OperandSize, - rd: WritableReg, - rn: Reg, - }, - ULoad8 { - rd: WritableReg, - mem: AMode, - flags: MemFlags, - }, - SLoad8 { - rd: WritableReg, - mem: AMode, - flags: MemFlags, - }, - ULoad16 { - rd: WritableReg, - mem: AMode, - flags: MemFlags, - }, - SLoad16 { - rd: WritableReg, - mem: AMode, - flags: MemFlags, - }, - ULoad32 { - rd: WritableReg, - mem: AMode, - flags: MemFlags, - }, - SLoad32 { - rd: WritableReg, - mem: AMode, - flags: MemFlags, - }, - ULoad64 { - rd: WritableReg, - mem: AMode, - flags: MemFlags, - }, - Store8 { - rd: Reg, - mem: AMode, - flags: MemFlags, - }, - Store16 { - rd: Reg, - mem: AMode, - flags: MemFlags, - }, - Store32 { - rd: Reg, - mem: AMode, - flags: MemFlags, - }, - Store64 { - rd: Reg, - mem: AMode, - flags: MemFlags, - }, - StoreP64 { - rt: Reg, - rt2: Reg, - mem: PairAMode, - flags: MemFlags, - }, - LoadP64 { - rt: WritableReg, - rt2: WritableReg, - mem: PairAMode, - flags: MemFlags, - }, - Mov { - size: OperandSize, - rd: WritableReg, - rm: Reg, - }, - MovWide { - op: MoveWideOp, - rd: WritableReg, - imm: MoveWideConst, - size: OperandSize, - }, - Extend { - rd: WritableReg, - rn: Reg, - signed: bool, - from_bits: u8, - to_bits: u8, - }, - CSel { - rd: WritableReg, - cond: Cond, - rn: Reg, - rm: Reg, - }, - CSet { - rd: WritableReg, - cond: Cond, - }, - CSetm { - rd: WritableReg, - cond: Cond, - }, - CCmpImm { - size: OperandSize, - rn: Reg, - imm: UImm5, - nzcv: NZCV, - cond: Cond, - }, - AtomicRMWLoop { - ty: Type, - op: AtomicRMWLoopOp, - }, - AtomicCASLoop { - ty: Type, - }, - AtomicRMW { - op: AtomicRMWOp, - rs: Reg, - rt: WritableReg, - rn: Reg, - ty: Type, - }, - AtomicCAS { - rs: WritableReg, - rt: Reg, - rn: Reg, - ty: Type, - }, - LoadAcquire { - access_ty: Type, - rt: WritableReg, - rn: Reg, - }, - StoreRelease { - access_ty: Type, - rt: Reg, - rn: Reg, - }, - Fence, - FpuMove64 { - rd: WritableReg, - rn: Reg, - }, - FpuMove128 { - rd: WritableReg, - rn: Reg, - }, - FpuMoveFromVec { - rd: WritableReg, - rn: Reg, - idx: u8, - size: VectorSize, - }, - FpuExtend { - rd: WritableReg, - rn: Reg, - size: ScalarSize, - }, - FpuRR { - fpu_op: FPUOp1, - size: ScalarSize, - rd: WritableReg, - rn: Reg, - }, - FpuRRR { - fpu_op: FPUOp2, - size: ScalarSize, - rd: WritableReg, - rn: Reg, - rm: Reg, - }, - FpuRRI { - fpu_op: FPUOpRI, - rd: WritableReg, - rn: Reg, - }, - FpuRRRR { - fpu_op: FPUOp3, - rd: WritableReg, - rn: Reg, - rm: Reg, - ra: Reg, - }, - FpuCmp { - size: ScalarSize, - rn: Reg, - rm: Reg, - }, - FpuLoad32 { - rd: WritableReg, - mem: AMode, - flags: MemFlags, - }, - FpuStore32 { - rd: Reg, - mem: AMode, - flags: MemFlags, - }, - FpuLoad64 { - rd: WritableReg, - mem: AMode, - flags: MemFlags, - }, - FpuStore64 { - rd: Reg, - mem: AMode, - flags: MemFlags, - }, - FpuLoad128 { - rd: WritableReg, - mem: AMode, - flags: MemFlags, - }, - FpuStore128 { - rd: Reg, - mem: AMode, - flags: MemFlags, - }, - FpuLoadP64 { - rt: WritableReg, - rt2: WritableReg, - mem: PairAMode, - flags: MemFlags, - }, - FpuStoreP64 { - rt: Reg, - rt2: Reg, - mem: PairAMode, - flags: MemFlags, - }, - FpuLoadP128 { - rt: WritableReg, - rt2: WritableReg, - mem: PairAMode, - flags: MemFlags, - }, - FpuStoreP128 { - rt: Reg, - rt2: Reg, - mem: PairAMode, - flags: MemFlags, - }, - LoadFpuConst64 { - rd: WritableReg, - const_data: u64, - }, - LoadFpuConst128 { - rd: WritableReg, - const_data: u128, - }, - FpuToInt { - op: FpuToIntOp, - rd: WritableReg, - rn: Reg, - }, - IntToFpu { - op: IntToFpuOp, - rd: WritableReg, - rn: Reg, - }, - FpuCSel32 { - rd: WritableReg, - rn: Reg, - rm: Reg, - cond: Cond, - }, - FpuCSel64 { - rd: WritableReg, - rn: Reg, - rm: Reg, - cond: Cond, - }, - FpuRound { - op: FpuRoundMode, - rd: WritableReg, - rn: Reg, - }, - MovToFpu { - rd: WritableReg, - rn: Reg, - size: ScalarSize, - }, - FpuMoveFPImm { - rd: WritableReg, - imm: ASIMDFPModImm, - size: ScalarSize, - }, - MovToVec { - rd: WritableReg, - rn: Reg, - idx: u8, - size: VectorSize, - }, - MovFromVec { - rd: WritableReg, - rn: Reg, - idx: u8, - size: VectorSize, - }, - MovFromVecSigned { - rd: WritableReg, - rn: Reg, - idx: u8, - size: VectorSize, - scalar_size: OperandSize, - }, - VecDup { - rd: WritableReg, - rn: Reg, - size: VectorSize, - }, - VecDupFromFpu { - rd: WritableReg, - rn: Reg, - size: VectorSize, - }, - VecDupFPImm { - rd: WritableReg, - imm: ASIMDFPModImm, - size: VectorSize, - }, - VecDupImm { - rd: WritableReg, - imm: ASIMDMovModImm, - invert: bool, - size: VectorSize, - }, - VecExtend { - t: VecExtendOp, - rd: WritableReg, - rn: Reg, - high_half: bool, - }, - VecMovElement { - rd: WritableReg, - rn: Reg, - dest_idx: u8, - src_idx: u8, - size: VectorSize, - }, - VecRRLong { - op: VecRRLongOp, - rd: WritableReg, - rn: Reg, - high_half: bool, - }, - VecRRNarrow { - op: VecRRNarrowOp, - rd: WritableReg, - rn: Reg, - high_half: bool, - }, - VecRRPair { - op: VecPairOp, - rd: WritableReg, - rn: Reg, - }, - VecRRRLong { - alu_op: VecRRRLongOp, - rd: WritableReg, - rn: Reg, - rm: Reg, - high_half: bool, - }, - VecRRPairLong { - op: VecRRPairLongOp, - rd: WritableReg, - rn: Reg, - }, - VecRRR { - alu_op: VecALUOp, - rd: WritableReg, - rn: Reg, - rm: Reg, - size: VectorSize, - }, - VecMisc { - op: VecMisc2, - rd: WritableReg, - rn: Reg, - size: VectorSize, - }, - VecLanes { - op: VecLanesOp, - rd: WritableReg, - rn: Reg, - size: VectorSize, - }, - VecShiftImm { - op: VecShiftImmOp, - rd: WritableReg, - rn: Reg, - size: VectorSize, - imm: u8, - }, - VecExtract { - rd: WritableReg, - rn: Reg, - rm: Reg, - imm4: u8, - }, - VecTbl { - rd: WritableReg, - rn: Reg, - rm: Reg, - is_extension: bool, - }, - VecTbl2 { - rd: WritableReg, - rn: Reg, - rn2: Reg, - rm: Reg, - is_extension: bool, - }, - VecLoadReplicate { - rd: WritableReg, - rn: Reg, - size: VectorSize, - }, - VecCSel { - rd: WritableReg, - rn: Reg, - rm: Reg, - cond: Cond, - }, - MovToNZCV { - rn: Reg, - }, - MovFromNZCV { - rd: WritableReg, - }, - Call { - info: BoxCallInfo, - }, - CallInd { - info: BoxCallIndInfo, - }, - Ret { - rets: VecReg, - }, - EpiloguePlaceholder, - Jump { - dest: BranchTarget, - }, - CondBr { - taken: BranchTarget, - not_taken: BranchTarget, - kind: CondBrKind, - }, - TrapIf { - kind: CondBrKind, - trap_code: TrapCode, - }, - IndirectBr { - rn: Reg, - targets: VecMachLabel, - }, - Brk, - Udf { - trap_code: TrapCode, - }, - Adr { - rd: WritableReg, - off: i32, - }, - Word4 { - data: u32, - }, - Word8 { - data: u64, - }, - JTSequence { - info: BoxJTSequenceInfo, - ridx: Reg, - rtmp1: WritableReg, - rtmp2: WritableReg, - }, - LoadExtName { - rd: WritableReg, - name: BoxExternalName, - offset: i64, - }, - LoadAddr { - rd: WritableReg, - mem: AMode, - }, - VirtualSPOffsetAdj { - offset: i64, - }, - EmitIsland { - needed_space: CodeOffset, - }, - ElfTlsGetAddr { - symbol: ExternalName, - }, - Unwind { - inst: UnwindInst, - }, - DummyUse { - reg: Reg, - }, -} - -/// Internal type ALUOp: defined at src/isa/aarch64/inst.isle line 776. -#[derive(Copy, Clone, PartialEq, Eq, Debug)] -pub enum ALUOp { - Add, - Sub, - Orr, - OrrNot, - And, - AndS, - AndNot, - Eor, - EorNot, - AddS, - SubS, - SMulH, - UMulH, - SDiv, - UDiv, - RotR, - Lsr, - Asr, - Lsl, - Adc, - AdcS, - Sbc, - SbcS, -} - -/// Internal type ALUOp3: defined at src/isa/aarch64/inst.isle line 814. -#[derive(Copy, Clone, PartialEq, Eq, Debug)] -pub enum ALUOp3 { - MAdd, - MSub, -} - -/// Internal type MoveWideOp: defined at src/isa/aarch64/inst.isle line 822. -#[derive(Copy, Clone, PartialEq, Eq, Debug)] -pub enum MoveWideOp { - MovZ, - MovN, - MovK, -} - -/// Internal type BitOp: defined at src/isa/aarch64/inst.isle line 860. -#[derive(Copy, Clone, PartialEq, Eq, Debug)] -pub enum BitOp { - RBit, - Clz, - Cls, -} - -/// Internal type FPUOp1: defined at src/isa/aarch64/inst.isle line 927. -#[derive(Copy, Clone, PartialEq, Eq, Debug)] -pub enum FPUOp1 { - Abs, - Neg, - Sqrt, - Cvt32To64, - Cvt64To32, -} - -/// Internal type FPUOp2: defined at src/isa/aarch64/inst.isle line 937. -#[derive(Copy, Clone, PartialEq, Eq, Debug)] -pub enum FPUOp2 { - Add, - Sub, - Mul, - Div, - Max, - Min, -} - -/// Internal type FPUOp3: defined at src/isa/aarch64/inst.isle line 948. -#[derive(Copy, Clone, PartialEq, Eq, Debug)] -pub enum FPUOp3 { - MAdd32, - MAdd64, -} - -/// Internal type FpuToIntOp: defined at src/isa/aarch64/inst.isle line 955. -#[derive(Copy, Clone, PartialEq, Eq, Debug)] -pub enum FpuToIntOp { - F32ToU32, - F32ToI32, - F32ToU64, - F32ToI64, - F64ToU32, - F64ToI32, - F64ToU64, - F64ToI64, -} - -/// Internal type IntToFpuOp: defined at src/isa/aarch64/inst.isle line 968. -#[derive(Copy, Clone, PartialEq, Eq, Debug)] -pub enum IntToFpuOp { - U32ToF32, - I32ToF32, - U32ToF64, - I32ToF64, - U64ToF32, - I64ToF32, - U64ToF64, - I64ToF64, -} - -/// Internal type FpuRoundMode: defined at src/isa/aarch64/inst.isle line 982. -#[derive(Copy, Clone, PartialEq, Eq, Debug)] -pub enum FpuRoundMode { - Minus32, - Minus64, - Plus32, - Plus64, - Zero32, - Zero64, - Nearest32, - Nearest64, -} - -/// Internal type VecExtendOp: defined at src/isa/aarch64/inst.isle line 995. -#[derive(Copy, Clone, PartialEq, Eq, Debug)] -pub enum VecExtendOp { - Sxtl8, - Sxtl16, - Sxtl32, - Uxtl8, - Uxtl16, - Uxtl32, -} - -/// Internal type VecALUOp: defined at src/isa/aarch64/inst.isle line 1012. -#[derive(Copy, Clone, PartialEq, Eq, Debug)] -pub enum VecALUOp { - Sqadd, - Uqadd, - Sqsub, - Uqsub, - Cmeq, - Cmge, - Cmgt, - Cmhs, - Cmhi, - Fcmeq, - Fcmgt, - Fcmge, - And, - Bic, - Orr, - Eor, - Bsl, - Umaxp, - Add, - Sub, - Mul, - Sshl, - Ushl, - Umin, - Smin, - Umax, - Smax, - Urhadd, - Fadd, - Fsub, - Fdiv, - Fmax, - Fmin, - Fmul, - Addp, - Zip1, - Sqrdmulh, -} - -/// Internal type VecMisc2: defined at src/isa/aarch64/inst.isle line 1091. -#[derive(Copy, Clone, PartialEq, Eq, Debug)] -pub enum VecMisc2 { - Not, - Neg, - Abs, - Fabs, - Fneg, - Fsqrt, - Rev64, - Fcvtzs, - Fcvtzu, - Scvtf, - Ucvtf, - Frintn, - Frintz, - Frintm, - Frintp, - Cnt, - Cmeq0, - Cmge0, - Cmgt0, - Cmle0, - Cmlt0, - Fcmeq0, - Fcmge0, - Fcmgt0, - Fcmle0, - Fcmlt0, -} - -/// Internal type VecRRLongOp: defined at src/isa/aarch64/inst.isle line 1148. -#[derive(Copy, Clone, PartialEq, Eq, Debug)] -pub enum VecRRLongOp { - Fcvtl16, - Fcvtl32, - Shll8, - Shll16, - Shll32, -} - -/// Internal type VecRRNarrowOp: defined at src/isa/aarch64/inst.isle line 1163. -#[derive(Copy, Clone, PartialEq, Eq, Debug)] -pub enum VecRRNarrowOp { - Xtn16, - Xtn32, - Xtn64, - Sqxtn16, - Sqxtn32, - Sqxtn64, - Sqxtun16, - Sqxtun32, - Sqxtun64, - Uqxtn16, - Uqxtn32, - Uqxtn64, - Fcvtn32, - Fcvtn64, -} - -/// Internal type VecRRRLongOp: defined at src/isa/aarch64/inst.isle line 1195. -#[derive(Copy, Clone, PartialEq, Eq, Debug)] -pub enum VecRRRLongOp { - Smull8, - Smull16, - Smull32, - Umull8, - Umull16, - Umull32, - Umlal8, - Umlal16, - Umlal32, -} - -/// Internal type VecPairOp: defined at src/isa/aarch64/inst.isle line 1212. -#[derive(Copy, Clone, PartialEq, Eq, Debug)] -pub enum VecPairOp { - Addp, -} - -/// Internal type VecRRPairLongOp: defined at src/isa/aarch64/inst.isle line 1220. -#[derive(Copy, Clone, PartialEq, Eq, Debug)] -pub enum VecRRPairLongOp { - Saddlp8, - Saddlp16, - Uaddlp8, - Uaddlp16, -} - -/// Internal type VecLanesOp: defined at src/isa/aarch64/inst.isle line 1231. -#[derive(Copy, Clone, PartialEq, Eq, Debug)] -pub enum VecLanesOp { - Addv, - Uminv, -} - -/// Internal type VecShiftImmOp: defined at src/isa/aarch64/inst.isle line 1240. -#[derive(Copy, Clone, PartialEq, Eq, Debug)] -pub enum VecShiftImmOp { - Shl, - Ushr, - Sshr, -} - -/// Internal type AtomicRMWOp: defined at src/isa/aarch64/inst.isle line 1251. -#[derive(Copy, Clone, PartialEq, Eq, Debug)] -pub enum AtomicRMWOp { - Add, - Clr, - Eor, - Set, - Smax, - Smin, - Umax, - Umin, - Swp, -} - -/// Internal type AtomicRMWLoopOp: defined at src/isa/aarch64/inst.isle line 1266. -#[derive(Copy, Clone, PartialEq, Eq, Debug)] -pub enum AtomicRMWLoopOp { - Add, - Sub, - And, - Nand, - Eor, - Orr, - Smax, - Smin, - Umax, - Umin, - Xchg, -} - -// Generated as internal constructor for term output_reg. -pub fn constructor_output_reg(ctx: &mut C, arg0: Reg) -> Option { - let pattern0_0 = arg0; - // Rule at src/prelude.isle line 113. - let expr0_0 = C::value_reg(ctx, pattern0_0); - let expr1_0 = C::output(ctx, expr0_0); - return Some(expr1_0); -} - -// Generated as internal constructor for term output_value. -pub fn constructor_output_value(ctx: &mut C, arg0: Value) -> Option { - let pattern0_0 = arg0; - // Rule at src/prelude.isle line 117. - let expr0_0 = C::put_in_regs(ctx, pattern0_0); - let expr1_0 = C::output(ctx, expr0_0); - return Some(expr1_0); -} - -// Generated as internal constructor for term temp_reg. -pub fn constructor_temp_reg(ctx: &mut C, arg0: Type) -> Option { - let pattern0_0 = arg0; - // Rule at src/prelude.isle line 137. - let expr0_0 = C::temp_writable_reg(ctx, pattern0_0); - let expr1_0 = C::writable_reg_to_reg(ctx, expr0_0); - return Some(expr1_0); -} - -// Generated as internal constructor for term lo_reg. -pub fn constructor_lo_reg(ctx: &mut C, arg0: Value) -> Option { - let pattern0_0 = arg0; - // Rule at src/prelude.isle line 182. - let expr0_0 = C::put_in_regs(ctx, pattern0_0); - let expr1_0: usize = 0; - let expr2_0 = C::value_regs_get(ctx, expr0_0, expr1_0); - return Some(expr2_0); -} - -// Generated as internal constructor for term side_effect. -pub fn constructor_side_effect( - ctx: &mut C, - arg0: &SideEffectNoResult, -) -> Option { - let pattern0_0 = arg0; - match pattern0_0 { - &SideEffectNoResult::Inst { - inst: ref pattern1_0, - } => { - // Rule at src/prelude.isle line 465. - let expr0_0 = C::emit(ctx, pattern1_0); - let expr1_0 = C::output_none(ctx); - return Some(expr1_0); - } - &SideEffectNoResult::Inst2 { - inst1: ref pattern1_0, - inst2: ref pattern1_1, - } => { - // Rule at src/prelude.isle line 468. - let expr0_0 = C::emit(ctx, pattern1_0); - let expr1_0 = C::emit(ctx, pattern1_1); - let expr2_0 = C::output_none(ctx); - return Some(expr2_0); - } - _ => {} - } - return None; -} - -// Generated as internal constructor for term side_effect_concat. -pub fn constructor_side_effect_concat( - ctx: &mut C, - arg0: &SideEffectNoResult, - arg1: &SideEffectNoResult, -) -> Option { - let pattern0_0 = arg0; - if let &SideEffectNoResult::Inst { - inst: ref pattern1_0, - } = pattern0_0 - { - let pattern2_0 = arg1; - if let &SideEffectNoResult::Inst { - inst: ref pattern3_0, - } = pattern2_0 - { - // Rule at src/prelude.isle line 474. - let expr0_0 = SideEffectNoResult::Inst2 { - inst1: pattern1_0.clone(), - inst2: pattern3_0.clone(), - }; - return Some(expr0_0); - } - } - return None; -} - -// Generated as internal constructor for term produces_flags_get_reg. -pub fn constructor_produces_flags_get_reg( - ctx: &mut C, - arg0: &ProducesFlags, -) -> Option { - let pattern0_0 = arg0; - if let &ProducesFlags::ProducesFlagsReturnsReg { - inst: ref pattern1_0, - result: pattern1_1, - } = pattern0_0 - { - // Rule at src/prelude.isle line 511. - return Some(pattern1_1); - } - return None; -} - -// Generated as internal constructor for term produces_flags_ignore. -pub fn constructor_produces_flags_ignore( - ctx: &mut C, - arg0: &ProducesFlags, -) -> Option { - let pattern0_0 = arg0; - match pattern0_0 { - &ProducesFlags::ProducesFlagsReturnsReg { - inst: ref pattern1_0, - result: pattern1_1, - } => { - // Rule at src/prelude.isle line 516. - let expr0_0 = ProducesFlags::ProducesFlagsSideEffect { - inst: pattern1_0.clone(), - }; - return Some(expr0_0); - } - &ProducesFlags::ProducesFlagsReturnsResultWithConsumer { - inst: ref pattern1_0, - result: pattern1_1, - } => { - // Rule at src/prelude.isle line 518. - let expr0_0 = ProducesFlags::ProducesFlagsSideEffect { - inst: pattern1_0.clone(), - }; - return Some(expr0_0); - } - _ => {} - } - return None; -} - -// Generated as internal constructor for term consumes_flags_concat. -pub fn constructor_consumes_flags_concat( - ctx: &mut C, - arg0: &ConsumesFlags, - arg1: &ConsumesFlags, -) -> Option { - let pattern0_0 = arg0; - if let &ConsumesFlags::ConsumesFlagsReturnsReg { - inst: ref pattern1_0, - result: pattern1_1, - } = pattern0_0 - { - let pattern2_0 = arg1; - if let &ConsumesFlags::ConsumesFlagsReturnsReg { - inst: ref pattern3_0, - result: pattern3_1, - } = pattern2_0 - { - // Rule at src/prelude.isle line 525. - let expr0_0 = C::value_regs(ctx, pattern1_1, pattern3_1); - let expr1_0 = ConsumesFlags::ConsumesFlagsTwiceReturnsValueRegs { - inst1: pattern1_0.clone(), - inst2: pattern3_0.clone(), - result: expr0_0, - }; - return Some(expr1_0); - } - } - return None; -} - -// Generated as internal constructor for term with_flags. -pub fn constructor_with_flags( - ctx: &mut C, - arg0: &ProducesFlags, - arg1: &ConsumesFlags, -) -> Option { - let pattern0_0 = arg0; - match pattern0_0 { - &ProducesFlags::ProducesFlagsSideEffect { - inst: ref pattern1_0, - } => { - let pattern2_0 = arg1; - match pattern2_0 { - &ConsumesFlags::ConsumesFlagsReturnsReg { - inst: ref pattern3_0, - result: pattern3_1, - } => { - // Rule at src/prelude.isle line 550. - let expr0_0 = C::emit(ctx, pattern1_0); - let expr1_0 = C::emit(ctx, pattern3_0); - let expr2_0 = C::value_reg(ctx, pattern3_1); - return Some(expr2_0); - } - &ConsumesFlags::ConsumesFlagsTwiceReturnsValueRegs { - inst1: ref pattern3_0, - inst2: ref pattern3_1, - result: pattern3_2, - } => { - // Rule at src/prelude.isle line 556. - let expr0_0 = C::emit(ctx, pattern1_0); - let expr1_0 = C::emit(ctx, pattern3_0); - let expr2_0 = C::emit(ctx, pattern3_1); - return Some(pattern3_2); - } - &ConsumesFlags::ConsumesFlagsFourTimesReturnsValueRegs { - inst1: ref pattern3_0, - inst2: ref pattern3_1, - inst3: ref pattern3_2, - inst4: ref pattern3_3, - result: pattern3_4, - } => { - // Rule at src/prelude.isle line 568. - let expr0_0 = C::emit(ctx, pattern1_0); - let expr1_0 = C::emit(ctx, pattern3_0); - let expr2_0 = C::emit(ctx, pattern3_1); - let expr3_0 = C::emit(ctx, pattern3_2); - let expr4_0 = C::emit(ctx, pattern3_3); - return Some(pattern3_4); - } - _ => {} - } - } - &ProducesFlags::ProducesFlagsReturnsResultWithConsumer { - inst: ref pattern1_0, - result: pattern1_1, - } => { - let pattern2_0 = arg1; - if let &ConsumesFlags::ConsumesFlagsReturnsResultWithProducer { - inst: ref pattern3_0, - result: pattern3_1, - } = pattern2_0 - { - // Rule at src/prelude.isle line 544. - let expr0_0 = C::emit(ctx, pattern1_0); - let expr1_0 = C::emit(ctx, pattern3_0); - let expr2_0 = C::value_regs(ctx, pattern1_1, pattern3_1); - return Some(expr2_0); - } - } - _ => {} - } - return None; -} - -// Generated as internal constructor for term with_flags_reg. -pub fn constructor_with_flags_reg( - ctx: &mut C, - arg0: &ProducesFlags, - arg1: &ConsumesFlags, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/prelude.isle line 585. - let expr0_0 = constructor_with_flags(ctx, pattern0_0, pattern1_0)?; - let expr1_0: usize = 0; - let expr2_0 = C::value_regs_get(ctx, expr0_0, expr1_0); - return Some(expr2_0); -} - -// Generated as internal constructor for term operand_size. -pub fn constructor_operand_size(ctx: &mut C, arg0: Type) -> Option { - let pattern0_0 = arg0; - if let Some(pattern1_0) = C::fits_in_32(ctx, pattern0_0) { - // Rule at src/isa/aarch64/inst.isle line 878. - let expr0_0 = OperandSize::Size32; - return Some(expr0_0); - } - if let Some(pattern1_0) = C::fits_in_64(ctx, pattern0_0) { - // Rule at src/isa/aarch64/inst.isle line 879. - let expr0_0 = OperandSize::Size64; - return Some(expr0_0); - } - return None; -} - -// Generated as internal constructor for term vector_size. -pub fn constructor_vector_size(ctx: &mut C, arg0: Type) -> Option { - let pattern0_0 = arg0; - if let Some((pattern1_0, pattern1_1)) = C::multi_lane(ctx, pattern0_0) { - if pattern1_0 == 8 { - if pattern1_1 == 16 { - // Rule at src/isa/aarch64/inst.isle line 921. - let expr0_0 = VectorSize::Size8x16; - return Some(expr0_0); - } - } - if pattern1_0 == 16 { - if pattern1_1 == 8 { - // Rule at src/isa/aarch64/inst.isle line 922. - let expr0_0 = VectorSize::Size16x8; - return Some(expr0_0); - } - } - if pattern1_0 == 32 { - if pattern1_1 == 4 { - // Rule at src/isa/aarch64/inst.isle line 923. - let expr0_0 = VectorSize::Size32x4; - return Some(expr0_0); - } - } - if pattern1_0 == 64 { - if pattern1_1 == 2 { - // Rule at src/isa/aarch64/inst.isle line 924. - let expr0_0 = VectorSize::Size64x2; - return Some(expr0_0); - } - } - } - return None; -} - -// Generated as internal constructor for term mov64_to_real. -pub fn constructor_mov64_to_real(ctx: &mut C, arg0: u8, arg1: Reg) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/aarch64/inst.isle line 1379. - let expr0_0 = C::writable_xreg(ctx, pattern0_0); - let expr1_0: Type = I64; - let expr2_0 = constructor_operand_size(ctx, expr1_0)?; - let expr3_0 = MInst::Mov { - size: expr2_0, - rd: expr0_0, - rm: pattern1_0, - }; - let expr4_0 = C::emit(ctx, &expr3_0); - let expr5_0 = C::writable_reg_to_reg(ctx, expr0_0); - return Some(expr5_0); -} - -// Generated as internal constructor for term mov64_from_real. -pub fn constructor_mov64_from_real(ctx: &mut C, arg0: u8) -> Option { - let pattern0_0 = arg0; - // Rule at src/isa/aarch64/inst.isle line 1385. - let expr0_0: Type = I64; - let expr1_0 = C::temp_writable_reg(ctx, expr0_0); - let expr2_0: Type = I64; - let expr3_0 = constructor_operand_size(ctx, expr2_0)?; - let expr4_0 = C::xreg(ctx, pattern0_0); - let expr5_0 = MInst::Mov { - size: expr3_0, - rd: expr1_0, - rm: expr4_0, - }; - let expr6_0 = C::emit(ctx, &expr5_0); - let expr7_0 = C::writable_reg_to_reg(ctx, expr1_0); - return Some(expr7_0); -} - -// Generated as internal constructor for term movz. -pub fn constructor_movz( - ctx: &mut C, - arg0: MoveWideConst, - arg1: &OperandSize, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/aarch64/inst.isle line 1392. - let expr0_0: Type = I64; - let expr1_0 = C::temp_writable_reg(ctx, expr0_0); - let expr2_0 = MoveWideOp::MovZ; - let expr3_0 = MInst::MovWide { - op: expr2_0, - rd: expr1_0, - imm: pattern0_0, - size: pattern1_0.clone(), - }; - let expr4_0 = C::emit(ctx, &expr3_0); - let expr5_0 = C::writable_reg_to_reg(ctx, expr1_0); - return Some(expr5_0); -} - -// Generated as internal constructor for term movn. -pub fn constructor_movn( - ctx: &mut C, - arg0: MoveWideConst, - arg1: &OperandSize, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/aarch64/inst.isle line 1399. - let expr0_0: Type = I64; - let expr1_0 = C::temp_writable_reg(ctx, expr0_0); - let expr2_0 = MoveWideOp::MovN; - let expr3_0 = MInst::MovWide { - op: expr2_0, - rd: expr1_0, - imm: pattern0_0, - size: pattern1_0.clone(), - }; - let expr4_0 = C::emit(ctx, &expr3_0); - let expr5_0 = C::writable_reg_to_reg(ctx, expr1_0); - return Some(expr5_0); -} - -// Generated as internal constructor for term alu_rr_imm_logic. -pub fn constructor_alu_rr_imm_logic( - ctx: &mut C, - arg0: &ALUOp, - arg1: Type, - arg2: Reg, - arg3: ImmLogic, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - let pattern3_0 = arg3; - // Rule at src/isa/aarch64/inst.isle line 1406. - let expr0_0: Type = I64; - let expr1_0 = C::temp_writable_reg(ctx, expr0_0); - let expr2_0 = constructor_operand_size(ctx, pattern1_0)?; - let expr3_0 = MInst::AluRRImmLogic { - alu_op: pattern0_0.clone(), - size: expr2_0, - rd: expr1_0, - rn: pattern2_0, - imml: pattern3_0, - }; - let expr4_0 = C::emit(ctx, &expr3_0); - let expr5_0 = C::writable_reg_to_reg(ctx, expr1_0); - return Some(expr5_0); -} - -// Generated as internal constructor for term alu_rr_imm_shift. -pub fn constructor_alu_rr_imm_shift( - ctx: &mut C, - arg0: &ALUOp, - arg1: Type, - arg2: Reg, - arg3: ImmShift, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - let pattern3_0 = arg3; - // Rule at src/isa/aarch64/inst.isle line 1413. - let expr0_0: Type = I64; - let expr1_0 = C::temp_writable_reg(ctx, expr0_0); - let expr2_0 = constructor_operand_size(ctx, pattern1_0)?; - let expr3_0 = MInst::AluRRImmShift { - alu_op: pattern0_0.clone(), - size: expr2_0, - rd: expr1_0, - rn: pattern2_0, - immshift: pattern3_0, - }; - let expr4_0 = C::emit(ctx, &expr3_0); - let expr5_0 = C::writable_reg_to_reg(ctx, expr1_0); - return Some(expr5_0); -} - -// Generated as internal constructor for term alu_rrr. -pub fn constructor_alu_rrr( - ctx: &mut C, - arg0: &ALUOp, - arg1: Type, - arg2: Reg, - arg3: Reg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - let pattern3_0 = arg3; - // Rule at src/isa/aarch64/inst.isle line 1420. - let expr0_0: Type = I64; - let expr1_0 = C::temp_writable_reg(ctx, expr0_0); - let expr2_0 = constructor_operand_size(ctx, pattern1_0)?; - let expr3_0 = MInst::AluRRR { - alu_op: pattern0_0.clone(), - size: expr2_0, - rd: expr1_0, - rn: pattern2_0, - rm: pattern3_0, - }; - let expr4_0 = C::emit(ctx, &expr3_0); - let expr5_0 = C::writable_reg_to_reg(ctx, expr1_0); - return Some(expr5_0); -} - -// Generated as internal constructor for term vec_rrr. -pub fn constructor_vec_rrr( - ctx: &mut C, - arg0: &VecALUOp, - arg1: Reg, - arg2: Reg, - arg3: &VectorSize, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - let pattern3_0 = arg3; - // Rule at src/isa/aarch64/inst.isle line 1427. - let expr0_0: Type = I8X16; - let expr1_0 = C::temp_writable_reg(ctx, expr0_0); - let expr2_0 = MInst::VecRRR { - alu_op: pattern0_0.clone(), - rd: expr1_0, - rn: pattern1_0, - rm: pattern2_0, - size: pattern3_0.clone(), - }; - let expr3_0 = C::emit(ctx, &expr2_0); - let expr4_0 = C::writable_reg_to_reg(ctx, expr1_0); - return Some(expr4_0); -} - -// Generated as internal constructor for term vec_lanes. -pub fn constructor_vec_lanes( - ctx: &mut C, - arg0: &VecLanesOp, - arg1: Reg, - arg2: &VectorSize, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/aarch64/inst.isle line 1434. - let expr0_0: Type = I8X16; - let expr1_0 = C::temp_writable_reg(ctx, expr0_0); - let expr2_0 = MInst::VecLanes { - op: pattern0_0.clone(), - rd: expr1_0, - rn: pattern1_0, - size: pattern2_0.clone(), - }; - let expr3_0 = C::emit(ctx, &expr2_0); - let expr4_0 = C::writable_reg_to_reg(ctx, expr1_0); - return Some(expr4_0); -} - -// Generated as internal constructor for term vec_dup. -pub fn constructor_vec_dup(ctx: &mut C, arg0: Reg, arg1: &VectorSize) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/aarch64/inst.isle line 1441. - let expr0_0: Type = I8X16; - let expr1_0 = C::temp_writable_reg(ctx, expr0_0); - let expr2_0 = MInst::VecDup { - rd: expr1_0, - rn: pattern0_0, - size: pattern1_0.clone(), - }; - let expr3_0 = C::emit(ctx, &expr2_0); - let expr4_0 = C::writable_reg_to_reg(ctx, expr1_0); - return Some(expr4_0); -} - -// Generated as internal constructor for term alu_rr_imm12. -pub fn constructor_alu_rr_imm12( - ctx: &mut C, - arg0: &ALUOp, - arg1: Type, - arg2: Reg, - arg3: Imm12, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - let pattern3_0 = arg3; - // Rule at src/isa/aarch64/inst.isle line 1448. - let expr0_0: Type = I64; - let expr1_0 = C::temp_writable_reg(ctx, expr0_0); - let expr2_0 = constructor_operand_size(ctx, pattern1_0)?; - let expr3_0 = MInst::AluRRImm12 { - alu_op: pattern0_0.clone(), - size: expr2_0, - rd: expr1_0, - rn: pattern2_0, - imm12: pattern3_0, - }; - let expr4_0 = C::emit(ctx, &expr3_0); - let expr5_0 = C::writable_reg_to_reg(ctx, expr1_0); - return Some(expr5_0); -} - -// Generated as internal constructor for term alu_rrr_shift. -pub fn constructor_alu_rrr_shift( - ctx: &mut C, - arg0: &ALUOp, - arg1: Type, - arg2: Reg, - arg3: Reg, - arg4: ShiftOpAndAmt, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - let pattern3_0 = arg3; - let pattern4_0 = arg4; - // Rule at src/isa/aarch64/inst.isle line 1455. - let expr0_0: Type = I64; - let expr1_0 = C::temp_writable_reg(ctx, expr0_0); - let expr2_0 = constructor_operand_size(ctx, pattern1_0)?; - let expr3_0 = MInst::AluRRRShift { - alu_op: pattern0_0.clone(), - size: expr2_0, - rd: expr1_0, - rn: pattern2_0, - rm: pattern3_0, - shiftop: pattern4_0, - }; - let expr4_0 = C::emit(ctx, &expr3_0); - let expr5_0 = C::writable_reg_to_reg(ctx, expr1_0); - return Some(expr5_0); -} - -// Generated as internal constructor for term alu_rrr_extend. -pub fn constructor_alu_rrr_extend( - ctx: &mut C, - arg0: &ALUOp, - arg1: Type, - arg2: Reg, - arg3: Reg, - arg4: &ExtendOp, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - let pattern3_0 = arg3; - let pattern4_0 = arg4; - // Rule at src/isa/aarch64/inst.isle line 1462. - let expr0_0: Type = I64; - let expr1_0 = C::temp_writable_reg(ctx, expr0_0); - let expr2_0 = constructor_operand_size(ctx, pattern1_0)?; - let expr3_0 = MInst::AluRRRExtend { - alu_op: pattern0_0.clone(), - size: expr2_0, - rd: expr1_0, - rn: pattern2_0, - rm: pattern3_0, - extendop: pattern4_0.clone(), - }; - let expr4_0 = C::emit(ctx, &expr3_0); - let expr5_0 = C::writable_reg_to_reg(ctx, expr1_0); - return Some(expr5_0); -} - -// Generated as internal constructor for term alu_rr_extend_reg. -pub fn constructor_alu_rr_extend_reg( - ctx: &mut C, - arg0: &ALUOp, - arg1: Type, - arg2: Reg, - arg3: &ExtendedValue, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - let pattern3_0 = arg3; - // Rule at src/isa/aarch64/inst.isle line 1470. - let expr0_0 = C::put_extended_in_reg(ctx, pattern3_0); - let expr1_0 = C::get_extended_op(ctx, pattern3_0); - let expr2_0 = - constructor_alu_rrr_extend(ctx, pattern0_0, pattern1_0, pattern2_0, expr0_0, &expr1_0)?; - return Some(expr2_0); -} - -// Generated as internal constructor for term alu_rrrr. -pub fn constructor_alu_rrrr( - ctx: &mut C, - arg0: &ALUOp3, - arg1: Type, - arg2: Reg, - arg3: Reg, - arg4: Reg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - let pattern3_0 = arg3; - let pattern4_0 = arg4; - // Rule at src/isa/aarch64/inst.isle line 1477. - let expr0_0: Type = I64; - let expr1_0 = C::temp_writable_reg(ctx, expr0_0); - let expr2_0 = constructor_operand_size(ctx, pattern1_0)?; - let expr3_0 = MInst::AluRRRR { - alu_op: pattern0_0.clone(), - size: expr2_0, - rd: expr1_0, - rn: pattern2_0, - rm: pattern3_0, - ra: pattern4_0, - }; - let expr4_0 = C::emit(ctx, &expr3_0); - let expr5_0 = C::writable_reg_to_reg(ctx, expr1_0); - return Some(expr5_0); -} - -// Generated as internal constructor for term bit_rr. -pub fn constructor_bit_rr( - ctx: &mut C, - arg0: &BitOp, - arg1: Type, - arg2: Reg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/aarch64/inst.isle line 1484. - let expr0_0: Type = I64; - let expr1_0 = C::temp_writable_reg(ctx, expr0_0); - let expr2_0 = constructor_operand_size(ctx, pattern1_0)?; - let expr3_0 = MInst::BitRR { - op: pattern0_0.clone(), - size: expr2_0, - rd: expr1_0, - rn: pattern2_0, - }; - let expr4_0 = C::emit(ctx, &expr3_0); - let expr5_0 = C::writable_reg_to_reg(ctx, expr1_0); - return Some(expr5_0); -} - -// Generated as internal constructor for term add_with_flags_paired. -pub fn constructor_add_with_flags_paired( - ctx: &mut C, - arg0: Type, - arg1: Reg, - arg2: Reg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/aarch64/inst.isle line 1491. - let expr0_0: Type = I64; - let expr1_0 = C::temp_writable_reg(ctx, expr0_0); - let expr2_0 = ALUOp::AddS; - let expr3_0 = constructor_operand_size(ctx, pattern0_0)?; - let expr4_0 = MInst::AluRRR { - alu_op: expr2_0, - size: expr3_0, - rd: expr1_0, - rn: pattern1_0, - rm: pattern2_0, - }; - let expr5_0 = C::writable_reg_to_reg(ctx, expr1_0); - let expr6_0 = ProducesFlags::ProducesFlagsReturnsResultWithConsumer { - inst: expr4_0, - result: expr5_0, - }; - return Some(expr6_0); -} - -// Generated as internal constructor for term adc_paired. -pub fn constructor_adc_paired( - ctx: &mut C, - arg0: Type, - arg1: Reg, - arg2: Reg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/aarch64/inst.isle line 1499. - let expr0_0: Type = I64; - let expr1_0 = C::temp_writable_reg(ctx, expr0_0); - let expr2_0 = ALUOp::Adc; - let expr3_0 = constructor_operand_size(ctx, pattern0_0)?; - let expr4_0 = MInst::AluRRR { - alu_op: expr2_0, - size: expr3_0, - rd: expr1_0, - rn: pattern1_0, - rm: pattern2_0, - }; - let expr5_0 = C::writable_reg_to_reg(ctx, expr1_0); - let expr6_0 = ConsumesFlags::ConsumesFlagsReturnsResultWithProducer { - inst: expr4_0, - result: expr5_0, - }; - return Some(expr6_0); -} - -// Generated as internal constructor for term sub_with_flags_paired. -pub fn constructor_sub_with_flags_paired( - ctx: &mut C, - arg0: Type, - arg1: Reg, - arg2: Reg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/aarch64/inst.isle line 1507. - let expr0_0: Type = I64; - let expr1_0 = C::temp_writable_reg(ctx, expr0_0); - let expr2_0 = ALUOp::SubS; - let expr3_0 = constructor_operand_size(ctx, pattern0_0)?; - let expr4_0 = MInst::AluRRR { - alu_op: expr2_0, - size: expr3_0, - rd: expr1_0, - rn: pattern1_0, - rm: pattern2_0, - }; - let expr5_0 = C::writable_reg_to_reg(ctx, expr1_0); - let expr6_0 = ProducesFlags::ProducesFlagsReturnsResultWithConsumer { - inst: expr4_0, - result: expr5_0, - }; - return Some(expr6_0); -} - -// Generated as internal constructor for term cmp64_imm. -pub fn constructor_cmp64_imm( - ctx: &mut C, - arg0: Reg, - arg1: Imm12, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/aarch64/inst.isle line 1514. - let expr0_0 = ALUOp::SubS; - let expr1_0 = OperandSize::Size64; - let expr2_0 = C::writable_zero_reg(ctx); - let expr3_0 = MInst::AluRRImm12 { - alu_op: expr0_0, - size: expr1_0, - rd: expr2_0, - rn: pattern0_0, - imm12: pattern1_0, - }; - let expr4_0 = ProducesFlags::ProducesFlagsSideEffect { inst: expr3_0 }; - return Some(expr4_0); -} - -// Generated as internal constructor for term sbc_paired. -pub fn constructor_sbc_paired( - ctx: &mut C, - arg0: Type, - arg1: Reg, - arg2: Reg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/aarch64/inst.isle line 1521. - let expr0_0: Type = I64; - let expr1_0 = C::temp_writable_reg(ctx, expr0_0); - let expr2_0 = ALUOp::Sbc; - let expr3_0 = constructor_operand_size(ctx, pattern0_0)?; - let expr4_0 = MInst::AluRRR { - alu_op: expr2_0, - size: expr3_0, - rd: expr1_0, - rn: pattern1_0, - rm: pattern2_0, - }; - let expr5_0 = C::writable_reg_to_reg(ctx, expr1_0); - let expr6_0 = ConsumesFlags::ConsumesFlagsReturnsResultWithProducer { - inst: expr4_0, - result: expr5_0, - }; - return Some(expr6_0); -} - -// Generated as internal constructor for term vec_misc. -pub fn constructor_vec_misc( - ctx: &mut C, - arg0: &VecMisc2, - arg1: Reg, - arg2: &VectorSize, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/aarch64/inst.isle line 1529. - let expr0_0: Type = I8X16; - let expr1_0 = C::temp_writable_reg(ctx, expr0_0); - let expr2_0 = MInst::VecMisc { - op: pattern0_0.clone(), - rd: expr1_0, - rn: pattern1_0, - size: pattern2_0.clone(), - }; - let expr3_0 = C::emit(ctx, &expr2_0); - let expr4_0 = C::writable_reg_to_reg(ctx, expr1_0); - return Some(expr4_0); -} - -// Generated as internal constructor for term vec_rrr_long. -pub fn constructor_vec_rrr_long( - ctx: &mut C, - arg0: &VecRRRLongOp, - arg1: Reg, - arg2: Reg, - arg3: bool, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - let pattern3_0 = arg3; - // Rule at src/isa/aarch64/inst.isle line 1536. - let expr0_0: Type = I8X16; - let expr1_0 = C::temp_writable_reg(ctx, expr0_0); - let expr2_0 = MInst::VecRRRLong { - alu_op: pattern0_0.clone(), - rd: expr1_0, - rn: pattern1_0, - rm: pattern2_0, - high_half: pattern3_0, - }; - let expr3_0 = C::emit(ctx, &expr2_0); - let expr4_0 = C::writable_reg_to_reg(ctx, expr1_0); - return Some(expr4_0); -} - -// Generated as internal constructor for term vec_rrrr_long. -pub fn constructor_vec_rrrr_long( - ctx: &mut C, - arg0: &VecRRRLongOp, - arg1: Reg, - arg2: Reg, - arg3: Reg, - arg4: bool, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - let pattern3_0 = arg3; - let pattern4_0 = arg4; - // Rule at src/isa/aarch64/inst.isle line 1546. - let expr0_0: Type = I8X16; - let expr1_0 = C::temp_writable_reg(ctx, expr0_0); - let expr2_0 = MInst::FpuMove128 { - rd: expr1_0, - rn: pattern1_0, - }; - let expr3_0 = C::emit(ctx, &expr2_0); - let expr4_0 = MInst::VecRRRLong { - alu_op: pattern0_0.clone(), - rd: expr1_0, - rn: pattern2_0, - rm: pattern3_0, - high_half: pattern4_0, - }; - let expr5_0 = C::emit(ctx, &expr4_0); - let expr6_0 = C::writable_reg_to_reg(ctx, expr1_0); - return Some(expr6_0); -} - -// Generated as internal constructor for term vec_rr_narrow. -pub fn constructor_vec_rr_narrow( - ctx: &mut C, - arg0: &VecRRNarrowOp, - arg1: Reg, - arg2: bool, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/aarch64/inst.isle line 1554. - let expr0_0: Type = I8X16; - let expr1_0 = C::temp_writable_reg(ctx, expr0_0); - let expr2_0 = MInst::VecRRNarrow { - op: pattern0_0.clone(), - rd: expr1_0, - rn: pattern1_0, - high_half: pattern2_0, - }; - let expr3_0 = C::emit(ctx, &expr2_0); - let expr4_0 = C::writable_reg_to_reg(ctx, expr1_0); - return Some(expr4_0); -} - -// Generated as internal constructor for term vec_rr_long. -pub fn constructor_vec_rr_long( - ctx: &mut C, - arg0: &VecRRLongOp, - arg1: Reg, - arg2: bool, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/aarch64/inst.isle line 1561. - let expr0_0: Type = I8X16; - let expr1_0 = C::temp_writable_reg(ctx, expr0_0); - let expr2_0 = MInst::VecRRLong { - op: pattern0_0.clone(), - rd: expr1_0, - rn: pattern1_0, - high_half: pattern2_0, - }; - let expr3_0 = C::emit(ctx, &expr2_0); - let expr4_0 = C::writable_reg_to_reg(ctx, expr1_0); - return Some(expr4_0); -} - -// Generated as internal constructor for term mov_to_fpu. -pub fn constructor_mov_to_fpu( - ctx: &mut C, - arg0: Reg, - arg1: &ScalarSize, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/aarch64/inst.isle line 1568. - let expr0_0: Type = I8X16; - let expr1_0 = C::temp_writable_reg(ctx, expr0_0); - let expr2_0 = MInst::MovToFpu { - rd: expr1_0, - rn: pattern0_0, - size: pattern1_0.clone(), - }; - let expr3_0 = C::emit(ctx, &expr2_0); - let expr4_0 = C::writable_reg_to_reg(ctx, expr1_0); - return Some(expr4_0); -} - -// Generated as internal constructor for term mov_to_vec. -pub fn constructor_mov_to_vec( - ctx: &mut C, - arg0: Reg, - arg1: Reg, - arg2: u8, - arg3: &VectorSize, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - let pattern3_0 = arg3; - // Rule at src/isa/aarch64/inst.isle line 1575. - let expr0_0: Type = I8X16; - let expr1_0 = C::temp_writable_reg(ctx, expr0_0); - let expr2_0 = MInst::FpuMove128 { - rd: expr1_0, - rn: pattern0_0, - }; - let expr3_0 = C::emit(ctx, &expr2_0); - let expr4_0 = MInst::MovToVec { - rd: expr1_0, - rn: pattern1_0, - idx: pattern2_0, - size: pattern3_0.clone(), - }; - let expr5_0 = C::emit(ctx, &expr4_0); - let expr6_0 = C::writable_reg_to_reg(ctx, expr1_0); - return Some(expr6_0); -} - -// Generated as internal constructor for term mov_from_vec. -pub fn constructor_mov_from_vec( - ctx: &mut C, - arg0: Reg, - arg1: u8, - arg2: &VectorSize, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/aarch64/inst.isle line 1583. - let expr0_0: Type = I64; - let expr1_0 = C::temp_writable_reg(ctx, expr0_0); - let expr2_0 = MInst::MovFromVec { - rd: expr1_0, - rn: pattern0_0, - idx: pattern1_0, - size: pattern2_0.clone(), - }; - let expr3_0 = C::emit(ctx, &expr2_0); - let expr4_0 = C::writable_reg_to_reg(ctx, expr1_0); - return Some(expr4_0); -} - -// Generated as internal constructor for term mov_from_vec_signed. -pub fn constructor_mov_from_vec_signed( - ctx: &mut C, - arg0: Reg, - arg1: u8, - arg2: &VectorSize, - arg3: &OperandSize, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - let pattern3_0 = arg3; - // Rule at src/isa/aarch64/inst.isle line 1590. - let expr0_0: Type = I64; - let expr1_0 = C::temp_writable_reg(ctx, expr0_0); - let expr2_0 = MInst::MovFromVecSigned { - rd: expr1_0, - rn: pattern0_0, - idx: pattern1_0, - size: pattern2_0.clone(), - scalar_size: pattern3_0.clone(), - }; - let expr3_0 = C::emit(ctx, &expr2_0); - let expr4_0 = C::writable_reg_to_reg(ctx, expr1_0); - return Some(expr4_0); -} - -// Generated as internal constructor for term extend. -pub fn constructor_extend( - ctx: &mut C, - arg0: Reg, - arg1: bool, - arg2: u8, - arg3: u8, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - let pattern3_0 = arg3; - // Rule at src/isa/aarch64/inst.isle line 1597. - let expr0_0: Type = I64; - let expr1_0 = C::temp_writable_reg(ctx, expr0_0); - let expr2_0 = MInst::Extend { - rd: expr1_0, - rn: pattern0_0, - signed: pattern1_0, - from_bits: pattern2_0, - to_bits: pattern3_0, - }; - let expr3_0 = C::emit(ctx, &expr2_0); - let expr4_0 = C::writable_reg_to_reg(ctx, expr1_0); - return Some(expr4_0); -} - -// Generated as internal constructor for term load_acquire. -pub fn constructor_load_acquire(ctx: &mut C, arg0: Type, arg1: Reg) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/aarch64/inst.isle line 1604. - let expr0_0: Type = I64; - let expr1_0 = C::temp_writable_reg(ctx, expr0_0); - let expr2_0 = MInst::LoadAcquire { - access_ty: pattern0_0, - rt: expr1_0, - rn: pattern1_0, - }; - let expr3_0 = C::emit(ctx, &expr2_0); - let expr4_0 = C::writable_reg_to_reg(ctx, expr1_0); - return Some(expr4_0); -} - -// Generated as internal constructor for term tst_imm. -pub fn constructor_tst_imm( - ctx: &mut C, - arg0: Type, - arg1: Reg, - arg2: ImmLogic, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/aarch64/inst.isle line 1614. - let expr0_0 = ALUOp::AndS; - let expr1_0 = constructor_operand_size(ctx, pattern0_0)?; - let expr2_0 = C::writable_zero_reg(ctx); - let expr3_0 = MInst::AluRRImmLogic { - alu_op: expr0_0, - size: expr1_0, - rd: expr2_0, - rn: pattern1_0, - imml: pattern2_0, - }; - let expr4_0 = ProducesFlags::ProducesFlagsSideEffect { inst: expr3_0 }; - return Some(expr4_0); -} - -// Generated as internal constructor for term csel. -pub fn constructor_csel( - ctx: &mut C, - arg0: &Cond, - arg1: Reg, - arg2: Reg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/aarch64/inst.isle line 1628. - let expr0_0: Type = I64; - let expr1_0 = C::temp_writable_reg(ctx, expr0_0); - let expr2_0 = MInst::CSel { - rd: expr1_0, - cond: pattern0_0.clone(), - rn: pattern1_0, - rm: pattern2_0, - }; - let expr3_0 = C::writable_reg_to_reg(ctx, expr1_0); - let expr4_0 = ConsumesFlags::ConsumesFlagsReturnsReg { - inst: expr2_0, - result: expr3_0, - }; - return Some(expr4_0); -} - -// Generated as internal constructor for term add. -pub fn constructor_add(ctx: &mut C, arg0: Type, arg1: Reg, arg2: Reg) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/aarch64/inst.isle line 1637. - let expr0_0 = ALUOp::Add; - let expr1_0 = constructor_alu_rrr(ctx, &expr0_0, pattern0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term add_imm. -pub fn constructor_add_imm( - ctx: &mut C, - arg0: Type, - arg1: Reg, - arg2: Imm12, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/aarch64/inst.isle line 1640. - let expr0_0 = ALUOp::Add; - let expr1_0 = constructor_alu_rr_imm12(ctx, &expr0_0, pattern0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term add_extend. -pub fn constructor_add_extend( - ctx: &mut C, - arg0: Type, - arg1: Reg, - arg2: &ExtendedValue, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/aarch64/inst.isle line 1643. - let expr0_0 = ALUOp::Add; - let expr1_0 = constructor_alu_rr_extend_reg(ctx, &expr0_0, pattern0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term add_shift. -pub fn constructor_add_shift( - ctx: &mut C, - arg0: Type, - arg1: Reg, - arg2: Reg, - arg3: ShiftOpAndAmt, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - let pattern3_0 = arg3; - // Rule at src/isa/aarch64/inst.isle line 1646. - let expr0_0 = ALUOp::Add; - let expr1_0 = constructor_alu_rrr_shift( - ctx, &expr0_0, pattern0_0, pattern1_0, pattern2_0, pattern3_0, - )?; - return Some(expr1_0); -} - -// Generated as internal constructor for term add_vec. -pub fn constructor_add_vec( - ctx: &mut C, - arg0: Reg, - arg1: Reg, - arg2: &VectorSize, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/aarch64/inst.isle line 1649. - let expr0_0 = VecALUOp::Add; - let expr1_0 = constructor_vec_rrr(ctx, &expr0_0, pattern0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term sub. -pub fn constructor_sub(ctx: &mut C, arg0: Type, arg1: Reg, arg2: Reg) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/aarch64/inst.isle line 1654. - let expr0_0 = ALUOp::Sub; - let expr1_0 = constructor_alu_rrr(ctx, &expr0_0, pattern0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term sub_imm. -pub fn constructor_sub_imm( - ctx: &mut C, - arg0: Type, - arg1: Reg, - arg2: Imm12, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/aarch64/inst.isle line 1657. - let expr0_0 = ALUOp::Sub; - let expr1_0 = constructor_alu_rr_imm12(ctx, &expr0_0, pattern0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term sub_extend. -pub fn constructor_sub_extend( - ctx: &mut C, - arg0: Type, - arg1: Reg, - arg2: &ExtendedValue, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/aarch64/inst.isle line 1660. - let expr0_0 = ALUOp::Sub; - let expr1_0 = constructor_alu_rr_extend_reg(ctx, &expr0_0, pattern0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term sub_shift. -pub fn constructor_sub_shift( - ctx: &mut C, - arg0: Type, - arg1: Reg, - arg2: Reg, - arg3: ShiftOpAndAmt, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - let pattern3_0 = arg3; - // Rule at src/isa/aarch64/inst.isle line 1663. - let expr0_0 = ALUOp::Sub; - let expr1_0 = constructor_alu_rrr_shift( - ctx, &expr0_0, pattern0_0, pattern1_0, pattern2_0, pattern3_0, - )?; - return Some(expr1_0); -} - -// Generated as internal constructor for term sub_vec. -pub fn constructor_sub_vec( - ctx: &mut C, - arg0: Reg, - arg1: Reg, - arg2: &VectorSize, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/aarch64/inst.isle line 1666. - let expr0_0 = VecALUOp::Sub; - let expr1_0 = constructor_vec_rrr(ctx, &expr0_0, pattern0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term madd. -pub fn constructor_madd( - ctx: &mut C, - arg0: Type, - arg1: Reg, - arg2: Reg, - arg3: Reg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - let pattern3_0 = arg3; - // Rule at src/isa/aarch64/inst.isle line 1671. - let expr0_0 = ALUOp3::MAdd; - let expr1_0 = constructor_alu_rrrr( - ctx, &expr0_0, pattern0_0, pattern1_0, pattern2_0, pattern3_0, - )?; - return Some(expr1_0); -} - -// Generated as internal constructor for term msub. -pub fn constructor_msub( - ctx: &mut C, - arg0: Type, - arg1: Reg, - arg2: Reg, - arg3: Reg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - let pattern3_0 = arg3; - // Rule at src/isa/aarch64/inst.isle line 1676. - let expr0_0 = ALUOp3::MSub; - let expr1_0 = constructor_alu_rrrr( - ctx, &expr0_0, pattern0_0, pattern1_0, pattern2_0, pattern3_0, - )?; - return Some(expr1_0); -} - -// Generated as internal constructor for term uqadd. -pub fn constructor_uqadd( - ctx: &mut C, - arg0: Reg, - arg1: Reg, - arg2: &VectorSize, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/aarch64/inst.isle line 1680. - let expr0_0 = VecALUOp::Uqadd; - let expr1_0 = constructor_vec_rrr(ctx, &expr0_0, pattern0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term sqadd. -pub fn constructor_sqadd( - ctx: &mut C, - arg0: Reg, - arg1: Reg, - arg2: &VectorSize, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/aarch64/inst.isle line 1684. - let expr0_0 = VecALUOp::Sqadd; - let expr1_0 = constructor_vec_rrr(ctx, &expr0_0, pattern0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term uqsub. -pub fn constructor_uqsub( - ctx: &mut C, - arg0: Reg, - arg1: Reg, - arg2: &VectorSize, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/aarch64/inst.isle line 1688. - let expr0_0 = VecALUOp::Uqsub; - let expr1_0 = constructor_vec_rrr(ctx, &expr0_0, pattern0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term sqsub. -pub fn constructor_sqsub( - ctx: &mut C, - arg0: Reg, - arg1: Reg, - arg2: &VectorSize, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/aarch64/inst.isle line 1692. - let expr0_0 = VecALUOp::Sqsub; - let expr1_0 = constructor_vec_rrr(ctx, &expr0_0, pattern0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term umulh. -pub fn constructor_umulh(ctx: &mut C, arg0: Type, arg1: Reg, arg2: Reg) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/aarch64/inst.isle line 1696. - let expr0_0 = ALUOp::UMulH; - let expr1_0 = constructor_alu_rrr(ctx, &expr0_0, pattern0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term smulh. -pub fn constructor_smulh(ctx: &mut C, arg0: Type, arg1: Reg, arg2: Reg) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/aarch64/inst.isle line 1700. - let expr0_0 = ALUOp::SMulH; - let expr1_0 = constructor_alu_rrr(ctx, &expr0_0, pattern0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term mul. -pub fn constructor_mul( - ctx: &mut C, - arg0: Reg, - arg1: Reg, - arg2: &VectorSize, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/aarch64/inst.isle line 1704. - let expr0_0 = VecALUOp::Mul; - let expr1_0 = constructor_vec_rrr(ctx, &expr0_0, pattern0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term neg. -pub fn constructor_neg(ctx: &mut C, arg0: Reg, arg1: &VectorSize) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/aarch64/inst.isle line 1708. - let expr0_0 = VecMisc2::Neg; - let expr1_0 = constructor_vec_misc(ctx, &expr0_0, pattern0_0, pattern1_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term rev64. -pub fn constructor_rev64(ctx: &mut C, arg0: Reg, arg1: &VectorSize) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/aarch64/inst.isle line 1712. - let expr0_0 = VecMisc2::Rev64; - let expr1_0 = constructor_vec_misc(ctx, &expr0_0, pattern0_0, pattern1_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term xtn64. -pub fn constructor_xtn64(ctx: &mut C, arg0: Reg, arg1: bool) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/aarch64/inst.isle line 1716. - let expr0_0 = VecRRNarrowOp::Xtn64; - let expr1_0 = constructor_vec_rr_narrow(ctx, &expr0_0, pattern0_0, pattern1_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term addp. -pub fn constructor_addp( - ctx: &mut C, - arg0: Reg, - arg1: Reg, - arg2: &VectorSize, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/aarch64/inst.isle line 1720. - let expr0_0 = VecALUOp::Addp; - let expr1_0 = constructor_vec_rrr(ctx, &expr0_0, pattern0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term addv. -pub fn constructor_addv(ctx: &mut C, arg0: Reg, arg1: &VectorSize) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/aarch64/inst.isle line 1724. - let expr0_0 = VecLanesOp::Addv; - let expr1_0 = constructor_vec_lanes(ctx, &expr0_0, pattern0_0, pattern1_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term shll32. -pub fn constructor_shll32(ctx: &mut C, arg0: Reg, arg1: bool) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/aarch64/inst.isle line 1728. - let expr0_0 = VecRRLongOp::Shll32; - let expr1_0 = constructor_vec_rr_long(ctx, &expr0_0, pattern0_0, pattern1_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term umlal32. -pub fn constructor_umlal32( - ctx: &mut C, - arg0: Reg, - arg1: Reg, - arg2: Reg, - arg3: bool, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - let pattern3_0 = arg3; - // Rule at src/isa/aarch64/inst.isle line 1732. - let expr0_0 = VecRRRLongOp::Umlal32; - let expr1_0 = constructor_vec_rrrr_long( - ctx, &expr0_0, pattern0_0, pattern1_0, pattern2_0, pattern3_0, - )?; - return Some(expr1_0); -} - -// Generated as internal constructor for term smull8. -pub fn constructor_smull8( - ctx: &mut C, - arg0: Reg, - arg1: Reg, - arg2: bool, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/aarch64/inst.isle line 1736. - let expr0_0 = VecRRRLongOp::Smull8; - let expr1_0 = constructor_vec_rrr_long(ctx, &expr0_0, pattern0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term umull8. -pub fn constructor_umull8( - ctx: &mut C, - arg0: Reg, - arg1: Reg, - arg2: bool, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/aarch64/inst.isle line 1740. - let expr0_0 = VecRRRLongOp::Umull8; - let expr1_0 = constructor_vec_rrr_long(ctx, &expr0_0, pattern0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term smull16. -pub fn constructor_smull16( - ctx: &mut C, - arg0: Reg, - arg1: Reg, - arg2: bool, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/aarch64/inst.isle line 1744. - let expr0_0 = VecRRRLongOp::Smull16; - let expr1_0 = constructor_vec_rrr_long(ctx, &expr0_0, pattern0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term umull16. -pub fn constructor_umull16( - ctx: &mut C, - arg0: Reg, - arg1: Reg, - arg2: bool, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/aarch64/inst.isle line 1748. - let expr0_0 = VecRRRLongOp::Umull16; - let expr1_0 = constructor_vec_rrr_long(ctx, &expr0_0, pattern0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term smull32. -pub fn constructor_smull32( - ctx: &mut C, - arg0: Reg, - arg1: Reg, - arg2: bool, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/aarch64/inst.isle line 1752. - let expr0_0 = VecRRRLongOp::Smull32; - let expr1_0 = constructor_vec_rrr_long(ctx, &expr0_0, pattern0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term umull32. -pub fn constructor_umull32( - ctx: &mut C, - arg0: Reg, - arg1: Reg, - arg2: bool, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/aarch64/inst.isle line 1756. - let expr0_0 = VecRRRLongOp::Umull32; - let expr1_0 = constructor_vec_rrr_long(ctx, &expr0_0, pattern0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term asr. -pub fn constructor_asr(ctx: &mut C, arg0: Type, arg1: Reg, arg2: Reg) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/aarch64/inst.isle line 1760. - let expr0_0 = ALUOp::Asr; - let expr1_0 = constructor_alu_rrr(ctx, &expr0_0, pattern0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term asr_imm. -pub fn constructor_asr_imm( - ctx: &mut C, - arg0: Type, - arg1: Reg, - arg2: ImmShift, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/aarch64/inst.isle line 1763. - let expr0_0 = ALUOp::Asr; - let expr1_0 = constructor_alu_rr_imm_shift(ctx, &expr0_0, pattern0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term lsr. -pub fn constructor_lsr(ctx: &mut C, arg0: Type, arg1: Reg, arg2: Reg) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/aarch64/inst.isle line 1767. - let expr0_0 = ALUOp::Lsr; - let expr1_0 = constructor_alu_rrr(ctx, &expr0_0, pattern0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term lsr_imm. -pub fn constructor_lsr_imm( - ctx: &mut C, - arg0: Type, - arg1: Reg, - arg2: ImmShift, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/aarch64/inst.isle line 1770. - let expr0_0 = ALUOp::Lsr; - let expr1_0 = constructor_alu_rr_imm_shift(ctx, &expr0_0, pattern0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term lsl. -pub fn constructor_lsl(ctx: &mut C, arg0: Type, arg1: Reg, arg2: Reg) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/aarch64/inst.isle line 1774. - let expr0_0 = ALUOp::Lsl; - let expr1_0 = constructor_alu_rrr(ctx, &expr0_0, pattern0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term lsl_imm. -pub fn constructor_lsl_imm( - ctx: &mut C, - arg0: Type, - arg1: Reg, - arg2: ImmShift, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/aarch64/inst.isle line 1777. - let expr0_0 = ALUOp::Lsl; - let expr1_0 = constructor_alu_rr_imm_shift(ctx, &expr0_0, pattern0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term a64_udiv. -pub fn constructor_a64_udiv( - ctx: &mut C, - arg0: Type, - arg1: Reg, - arg2: Reg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/aarch64/inst.isle line 1781. - let expr0_0 = ALUOp::UDiv; - let expr1_0 = constructor_alu_rrr(ctx, &expr0_0, pattern0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term a64_sdiv. -pub fn constructor_a64_sdiv( - ctx: &mut C, - arg0: Type, - arg1: Reg, - arg2: Reg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/aarch64/inst.isle line 1785. - let expr0_0 = ALUOp::SDiv; - let expr1_0 = constructor_alu_rrr(ctx, &expr0_0, pattern0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term not. -pub fn constructor_not(ctx: &mut C, arg0: Reg, arg1: &VectorSize) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/aarch64/inst.isle line 1789. - let expr0_0 = VecMisc2::Not; - let expr1_0 = constructor_vec_misc(ctx, &expr0_0, pattern0_0, pattern1_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term orr_not. -pub fn constructor_orr_not( - ctx: &mut C, - arg0: Type, - arg1: Reg, - arg2: Reg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/aarch64/inst.isle line 1794. - let expr0_0 = ALUOp::OrrNot; - let expr1_0 = constructor_alu_rrr(ctx, &expr0_0, pattern0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term orr_not_shift. -pub fn constructor_orr_not_shift( - ctx: &mut C, - arg0: Type, - arg1: Reg, - arg2: Reg, - arg3: ShiftOpAndAmt, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - let pattern3_0 = arg3; - // Rule at src/isa/aarch64/inst.isle line 1797. - let expr0_0 = ALUOp::OrrNot; - let expr1_0 = constructor_alu_rrr_shift( - ctx, &expr0_0, pattern0_0, pattern1_0, pattern2_0, pattern3_0, - )?; - return Some(expr1_0); -} - -// Generated as internal constructor for term orr. -pub fn constructor_orr(ctx: &mut C, arg0: Type, arg1: Reg, arg2: Reg) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/aarch64/inst.isle line 1802. - let expr0_0 = ALUOp::Orr; - let expr1_0 = constructor_alu_rrr(ctx, &expr0_0, pattern0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term orr_imm. -pub fn constructor_orr_imm( - ctx: &mut C, - arg0: Type, - arg1: Reg, - arg2: ImmLogic, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/aarch64/inst.isle line 1805. - let expr0_0 = ALUOp::Orr; - let expr1_0 = constructor_alu_rr_imm_logic(ctx, &expr0_0, pattern0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term orr_vec. -pub fn constructor_orr_vec( - ctx: &mut C, - arg0: Reg, - arg1: Reg, - arg2: &VectorSize, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/aarch64/inst.isle line 1808. - let expr0_0 = VecALUOp::Orr; - let expr1_0 = constructor_vec_rrr(ctx, &expr0_0, pattern0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term and_imm. -pub fn constructor_and_imm( - ctx: &mut C, - arg0: Type, - arg1: Reg, - arg2: ImmLogic, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/aarch64/inst.isle line 1813. - let expr0_0 = ALUOp::And; - let expr1_0 = constructor_alu_rr_imm_logic(ctx, &expr0_0, pattern0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term and_vec. -pub fn constructor_and_vec( - ctx: &mut C, - arg0: Reg, - arg1: Reg, - arg2: &VectorSize, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/aarch64/inst.isle line 1816. - let expr0_0 = VecALUOp::And; - let expr1_0 = constructor_vec_rrr(ctx, &expr0_0, pattern0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term eor_vec. -pub fn constructor_eor_vec( - ctx: &mut C, - arg0: Reg, - arg1: Reg, - arg2: &VectorSize, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/aarch64/inst.isle line 1820. - let expr0_0 = VecALUOp::Eor; - let expr1_0 = constructor_vec_rrr(ctx, &expr0_0, pattern0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term bic_vec. -pub fn constructor_bic_vec( - ctx: &mut C, - arg0: Reg, - arg1: Reg, - arg2: &VectorSize, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/aarch64/inst.isle line 1824. - let expr0_0 = VecALUOp::Bic; - let expr1_0 = constructor_vec_rrr(ctx, &expr0_0, pattern0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term sshl. -pub fn constructor_sshl( - ctx: &mut C, - arg0: Reg, - arg1: Reg, - arg2: &VectorSize, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/aarch64/inst.isle line 1828. - let expr0_0 = VecALUOp::Sshl; - let expr1_0 = constructor_vec_rrr(ctx, &expr0_0, pattern0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term ushl. -pub fn constructor_ushl( - ctx: &mut C, - arg0: Reg, - arg1: Reg, - arg2: &VectorSize, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/aarch64/inst.isle line 1832. - let expr0_0 = VecALUOp::Ushl; - let expr1_0 = constructor_vec_rrr(ctx, &expr0_0, pattern0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term a64_rotr. -pub fn constructor_a64_rotr( - ctx: &mut C, - arg0: Type, - arg1: Reg, - arg2: Reg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/aarch64/inst.isle line 1837. - let expr0_0 = ALUOp::RotR; - let expr1_0 = constructor_alu_rrr(ctx, &expr0_0, pattern0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term a64_rotr_imm. -pub fn constructor_a64_rotr_imm( - ctx: &mut C, - arg0: Type, - arg1: Reg, - arg2: ImmShift, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/aarch64/inst.isle line 1840. - let expr0_0 = ALUOp::RotR; - let expr1_0 = constructor_alu_rr_imm_shift(ctx, &expr0_0, pattern0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term rbit. -pub fn constructor_rbit(ctx: &mut C, arg0: Type, arg1: Reg) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/aarch64/inst.isle line 1845. - let expr0_0 = BitOp::RBit; - let expr1_0 = constructor_bit_rr(ctx, &expr0_0, pattern0_0, pattern1_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term a64_clz. -pub fn constructor_a64_clz(ctx: &mut C, arg0: Type, arg1: Reg) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/aarch64/inst.isle line 1850. - let expr0_0 = BitOp::Clz; - let expr1_0 = constructor_bit_rr(ctx, &expr0_0, pattern0_0, pattern1_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term a64_cls. -pub fn constructor_a64_cls(ctx: &mut C, arg0: Type, arg1: Reg) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/aarch64/inst.isle line 1855. - let expr0_0 = BitOp::Cls; - let expr1_0 = constructor_bit_rr(ctx, &expr0_0, pattern0_0, pattern1_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term eon. -pub fn constructor_eon(ctx: &mut C, arg0: Type, arg1: Reg, arg2: Reg) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/aarch64/inst.isle line 1860. - let expr0_0 = ALUOp::EorNot; - let expr1_0 = constructor_alu_rrr(ctx, &expr0_0, pattern0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term vec_cnt. -pub fn constructor_vec_cnt(ctx: &mut C, arg0: Reg, arg1: &VectorSize) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/aarch64/inst.isle line 1865. - let expr0_0 = VecMisc2::Cnt; - let expr1_0 = constructor_vec_misc(ctx, &expr0_0, pattern0_0, pattern1_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term imm. -pub fn constructor_imm(ctx: &mut C, arg0: Type, arg1: u64) -> Option { - let pattern0_0 = arg0; - if let Some(pattern1_0) = C::integral_ty(ctx, pattern0_0) { - let pattern2_0 = arg1; - let mut closure3 = || { - let expr0_0: Type = I64; - let expr1_0 = C::imm_logic_from_u64(ctx, expr0_0, pattern2_0)?; - return Some(expr1_0); - }; - if let Some(pattern3_0) = closure3() { - // Rule at src/isa/aarch64/inst.isle line 1880. - let expr0_0: Type = I64; - let expr1_0 = C::zero_reg(ctx); - let expr2_0 = constructor_orr_imm(ctx, expr0_0, expr1_0, pattern3_0)?; - return Some(expr2_0); - } - if let Some(pattern3_0) = C::move_wide_const_from_u64(ctx, pattern2_0) { - // Rule at src/isa/aarch64/inst.isle line 1872. - let expr0_0 = OperandSize::Size64; - let expr1_0 = constructor_movz(ctx, pattern3_0, &expr0_0)?; - return Some(expr1_0); - } - if let Some(pattern3_0) = C::move_wide_const_from_negated_u64(ctx, pattern2_0) { - // Rule at src/isa/aarch64/inst.isle line 1876. - let expr0_0 = OperandSize::Size64; - let expr1_0 = constructor_movn(ctx, pattern3_0, &expr0_0)?; - return Some(expr1_0); - } - // Rule at src/isa/aarch64/inst.isle line 1888. - let expr0_0 = C::load_constant64_full(ctx, pattern2_0); - return Some(expr0_0); - } - return None; -} - -// Generated as internal constructor for term put_in_reg_sext32. -pub fn constructor_put_in_reg_sext32(ctx: &mut C, arg0: Value) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = C::value_type(ctx, pattern0_0); - if pattern1_0 == I32 { - // Rule at src/isa/aarch64/inst.isle line 1899. - let expr0_0 = C::put_in_reg(ctx, pattern0_0); - return Some(expr0_0); - } - if pattern1_0 == I64 { - // Rule at src/isa/aarch64/inst.isle line 1900. - let expr0_0 = C::put_in_reg(ctx, pattern0_0); - return Some(expr0_0); - } - if let Some(pattern2_0) = C::fits_in_32(ctx, pattern1_0) { - // Rule at src/isa/aarch64/inst.isle line 1895. - let expr0_0 = C::put_in_reg(ctx, pattern0_0); - let expr1_0: bool = true; - let expr2_0 = C::ty_bits(ctx, pattern2_0)?; - let expr3_0: u8 = 32; - let expr4_0 = constructor_extend(ctx, expr0_0, expr1_0, expr2_0, expr3_0)?; - return Some(expr4_0); - } - return None; -} - -// Generated as internal constructor for term put_in_reg_zext32. -pub fn constructor_put_in_reg_zext32(ctx: &mut C, arg0: Value) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = C::value_type(ctx, pattern0_0); - if pattern1_0 == I32 { - // Rule at src/isa/aarch64/inst.isle line 1908. - let expr0_0 = C::put_in_reg(ctx, pattern0_0); - return Some(expr0_0); - } - if pattern1_0 == I64 { - // Rule at src/isa/aarch64/inst.isle line 1909. - let expr0_0 = C::put_in_reg(ctx, pattern0_0); - return Some(expr0_0); - } - if let Some(pattern2_0) = C::fits_in_32(ctx, pattern1_0) { - // Rule at src/isa/aarch64/inst.isle line 1904. - let expr0_0 = C::put_in_reg(ctx, pattern0_0); - let expr1_0: bool = false; - let expr2_0 = C::ty_bits(ctx, pattern2_0)?; - let expr3_0: u8 = 32; - let expr4_0 = constructor_extend(ctx, expr0_0, expr1_0, expr2_0, expr3_0)?; - return Some(expr4_0); - } - return None; -} - -// Generated as internal constructor for term put_in_reg_sext64. -pub fn constructor_put_in_reg_sext64(ctx: &mut C, arg0: Value) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = C::value_type(ctx, pattern0_0); - if pattern1_0 == I64 { - // Rule at src/isa/aarch64/inst.isle line 1917. - let expr0_0 = C::put_in_reg(ctx, pattern0_0); - return Some(expr0_0); - } - if let Some(pattern2_0) = C::fits_in_32(ctx, pattern1_0) { - // Rule at src/isa/aarch64/inst.isle line 1913. - let expr0_0 = C::put_in_reg(ctx, pattern0_0); - let expr1_0: bool = true; - let expr2_0 = C::ty_bits(ctx, pattern2_0)?; - let expr3_0: u8 = 64; - let expr4_0 = constructor_extend(ctx, expr0_0, expr1_0, expr2_0, expr3_0)?; - return Some(expr4_0); - } - return None; -} - -// Generated as internal constructor for term put_in_reg_zext64. -pub fn constructor_put_in_reg_zext64(ctx: &mut C, arg0: Value) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = C::value_type(ctx, pattern0_0); - if pattern1_0 == I64 { - // Rule at src/isa/aarch64/inst.isle line 1925. - let expr0_0 = C::put_in_reg(ctx, pattern0_0); - return Some(expr0_0); - } - if let Some(pattern2_0) = C::fits_in_32(ctx, pattern1_0) { - // Rule at src/isa/aarch64/inst.isle line 1921. - let expr0_0 = C::put_in_reg(ctx, pattern0_0); - let expr1_0: bool = false; - let expr2_0 = C::ty_bits(ctx, pattern2_0)?; - let expr3_0: u8 = 64; - let expr4_0 = constructor_extend(ctx, expr0_0, expr1_0, expr2_0, expr3_0)?; - return Some(expr4_0); - } - return None; -} - -// Generated as internal constructor for term trap_if_zero_divisor. -pub fn constructor_trap_if_zero_divisor(ctx: &mut C, arg0: Reg) -> Option { - let pattern0_0 = arg0; - // Rule at src/isa/aarch64/inst.isle line 1930. - let expr0_0 = C::cond_br_zero(ctx, pattern0_0); - let expr1_0 = C::trap_code_division_by_zero(ctx); - let expr2_0 = MInst::TrapIf { - kind: expr0_0, - trap_code: expr1_0, - }; - let expr3_0 = C::emit(ctx, &expr2_0); - return Some(pattern0_0); -} - -// Generated as internal constructor for term size_from_ty. -pub fn constructor_size_from_ty(ctx: &mut C, arg0: Type) -> Option { - let pattern0_0 = arg0; - if pattern0_0 == I64 { - // Rule at src/isa/aarch64/inst.isle line 1936. - let expr0_0 = OperandSize::Size64; - return Some(expr0_0); - } - if let Some(pattern1_0) = C::fits_in_32(ctx, pattern0_0) { - // Rule at src/isa/aarch64/inst.isle line 1935. - let expr0_0 = OperandSize::Size32; - return Some(expr0_0); - } - return None; -} - -// Generated as internal constructor for term trap_if_div_overflow. -pub fn constructor_trap_if_div_overflow( - ctx: &mut C, - arg0: Type, - arg1: Reg, - arg2: Reg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/aarch64/inst.isle line 1942. - let expr0_0 = ALUOp::AddS; - let expr1_0 = constructor_operand_size(ctx, pattern0_0)?; - let expr2_0 = C::writable_zero_reg(ctx); - let expr3_0: u8 = 1; - let expr4_0 = C::u8_into_imm12(ctx, expr3_0); - let expr5_0 = MInst::AluRRImm12 { - alu_op: expr0_0, - size: expr1_0, - rd: expr2_0, - rn: pattern2_0, - imm12: expr4_0, - }; - let expr6_0 = C::emit(ctx, &expr5_0); - let expr7_0 = constructor_size_from_ty(ctx, pattern0_0)?; - let expr8_0: u8 = 1; - let expr9_0 = C::u8_into_uimm5(ctx, expr8_0); - let expr10_0: bool = false; - let expr11_0: bool = false; - let expr12_0: bool = false; - let expr13_0: bool = false; - let expr14_0 = C::nzcv(ctx, expr10_0, expr11_0, expr12_0, expr13_0); - let expr15_0 = Cond::Eq; - let expr16_0 = MInst::CCmpImm { - size: expr7_0, - rn: pattern1_0, - imm: expr9_0, - nzcv: expr14_0, - cond: expr15_0, - }; - let expr17_0 = C::emit(ctx, &expr16_0); - let expr18_0 = Cond::Vs; - let expr19_0 = C::cond_br_cond(ctx, &expr18_0); - let expr20_0 = C::trap_code_integer_overflow(ctx); - let expr21_0 = MInst::TrapIf { - kind: expr19_0, - trap_code: expr20_0, - }; - let expr22_0 = C::emit(ctx, &expr21_0); - return Some(pattern1_0); -} - -// Generated as internal constructor for term alu_rs_imm_logic_commutative. -pub fn constructor_alu_rs_imm_logic_commutative( - ctx: &mut C, - arg0: &ALUOp, - arg1: Type, - arg2: Value, - arg3: Value, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - if let Some(pattern3_0) = C::def_inst(ctx, pattern2_0) { - let pattern4_0 = C::inst_data(ctx, pattern3_0); - match &pattern4_0 { - &InstructionData::UnaryImm { - opcode: ref pattern5_0, - imm: pattern5_1, - } => { - if let &Opcode::Iconst = pattern5_0 { - let pattern7_0 = arg3; - let mut closure8 = || { - let expr0_0 = C::imm_logic_from_imm64(ctx, pattern1_0, pattern5_1)?; - return Some(expr0_0); - }; - if let Some(pattern8_0) = closure8() { - // Rule at src/isa/aarch64/inst.isle line 1988. - let expr0_0 = C::put_in_reg(ctx, pattern7_0); - let expr1_0 = constructor_alu_rr_imm_logic( - ctx, pattern0_0, pattern1_0, expr0_0, pattern8_0, - )?; - return Some(expr1_0); - } - } - } - &InstructionData::Binary { - opcode: ref pattern5_0, - args: ref pattern5_1, - } => { - if let &Opcode::Ishl = pattern5_0 { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - if let Some(pattern8_0) = C::def_inst(ctx, pattern7_1) { - let pattern9_0 = C::inst_data(ctx, pattern8_0); - if let &InstructionData::UnaryImm { - opcode: ref pattern10_0, - imm: pattern10_1, - } = &pattern9_0 - { - if let &Opcode::Iconst = pattern10_0 { - let pattern12_0 = arg3; - let mut closure13 = || { - let expr0_0 = C::lshl_from_imm64(ctx, pattern1_0, pattern10_1)?; - return Some(expr0_0); - }; - if let Some(pattern13_0) = closure13() { - // Rule at src/isa/aarch64/inst.isle line 1996. - let expr0_0 = C::put_in_reg(ctx, pattern12_0); - let expr1_0 = C::put_in_reg(ctx, pattern7_0); - let expr2_0 = constructor_alu_rrr_shift( - ctx, - pattern0_0, - pattern1_0, - expr0_0, - expr1_0, - pattern13_0, - )?; - return Some(expr2_0); - } - } - } - } - } - } - _ => {} - } - } - let pattern3_0 = arg3; - if let Some(pattern4_0) = C::def_inst(ctx, pattern3_0) { - let pattern5_0 = C::inst_data(ctx, pattern4_0); - match &pattern5_0 { - &InstructionData::UnaryImm { - opcode: ref pattern6_0, - imm: pattern6_1, - } => { - if let &Opcode::Iconst = pattern6_0 { - let mut closure8 = || { - let expr0_0 = C::imm_logic_from_imm64(ctx, pattern1_0, pattern6_1)?; - return Some(expr0_0); - }; - if let Some(pattern8_0) = closure8() { - // Rule at src/isa/aarch64/inst.isle line 1985. - let expr0_0 = C::put_in_reg(ctx, pattern2_0); - let expr1_0 = constructor_alu_rr_imm_logic( - ctx, pattern0_0, pattern1_0, expr0_0, pattern8_0, - )?; - return Some(expr1_0); - } - } - } - &InstructionData::Binary { - opcode: ref pattern6_0, - args: ref pattern6_1, - } => { - if let &Opcode::Ishl = pattern6_0 { - let (pattern8_0, pattern8_1) = C::unpack_value_array_2(ctx, pattern6_1); - if let Some(pattern9_0) = C::def_inst(ctx, pattern8_1) { - let pattern10_0 = C::inst_data(ctx, pattern9_0); - if let &InstructionData::UnaryImm { - opcode: ref pattern11_0, - imm: pattern11_1, - } = &pattern10_0 - { - if let &Opcode::Iconst = pattern11_0 { - let mut closure13 = || { - let expr0_0 = C::lshl_from_imm64(ctx, pattern1_0, pattern11_1)?; - return Some(expr0_0); - }; - if let Some(pattern13_0) = closure13() { - // Rule at src/isa/aarch64/inst.isle line 1993. - let expr0_0 = C::put_in_reg(ctx, pattern2_0); - let expr1_0 = C::put_in_reg(ctx, pattern8_0); - let expr2_0 = constructor_alu_rrr_shift( - ctx, - pattern0_0, - pattern1_0, - expr0_0, - expr1_0, - pattern13_0, - )?; - return Some(expr2_0); - } - } - } - } - } - } - _ => {} - } - } - // Rule at src/isa/aarch64/inst.isle line 1981. - let expr0_0 = C::put_in_reg(ctx, pattern2_0); - let expr1_0 = C::put_in_reg(ctx, pattern3_0); - let expr2_0 = constructor_alu_rrr(ctx, pattern0_0, pattern1_0, expr0_0, expr1_0)?; - return Some(expr2_0); -} - -// Generated as internal constructor for term alu_rs_imm_logic. -pub fn constructor_alu_rs_imm_logic( - ctx: &mut C, - arg0: &ALUOp, - arg1: Type, - arg2: Value, - arg3: Value, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - let pattern3_0 = arg3; - if let Some(pattern4_0) = C::def_inst(ctx, pattern3_0) { - let pattern5_0 = C::inst_data(ctx, pattern4_0); - match &pattern5_0 { - &InstructionData::UnaryImm { - opcode: ref pattern6_0, - imm: pattern6_1, - } => { - if let &Opcode::Iconst = pattern6_0 { - let mut closure8 = || { - let expr0_0 = C::imm_logic_from_imm64(ctx, pattern1_0, pattern6_1)?; - return Some(expr0_0); - }; - if let Some(pattern8_0) = closure8() { - // Rule at src/isa/aarch64/inst.isle line 2005. - let expr0_0 = C::put_in_reg(ctx, pattern2_0); - let expr1_0 = constructor_alu_rr_imm_logic( - ctx, pattern0_0, pattern1_0, expr0_0, pattern8_0, - )?; - return Some(expr1_0); - } - } - } - &InstructionData::Binary { - opcode: ref pattern6_0, - args: ref pattern6_1, - } => { - if let &Opcode::Ishl = pattern6_0 { - let (pattern8_0, pattern8_1) = C::unpack_value_array_2(ctx, pattern6_1); - if let Some(pattern9_0) = C::def_inst(ctx, pattern8_1) { - let pattern10_0 = C::inst_data(ctx, pattern9_0); - if let &InstructionData::UnaryImm { - opcode: ref pattern11_0, - imm: pattern11_1, - } = &pattern10_0 - { - if let &Opcode::Iconst = pattern11_0 { - let mut closure13 = || { - let expr0_0 = C::lshl_from_imm64(ctx, pattern1_0, pattern11_1)?; - return Some(expr0_0); - }; - if let Some(pattern13_0) = closure13() { - // Rule at src/isa/aarch64/inst.isle line 2008. - let expr0_0 = C::put_in_reg(ctx, pattern2_0); - let expr1_0 = C::put_in_reg(ctx, pattern8_0); - let expr2_0 = constructor_alu_rrr_shift( - ctx, - pattern0_0, - pattern1_0, - expr0_0, - expr1_0, - pattern13_0, - )?; - return Some(expr2_0); - } - } - } - } - } - } - _ => {} - } - } - // Rule at src/isa/aarch64/inst.isle line 2003. - let expr0_0 = C::put_in_reg(ctx, pattern2_0); - let expr1_0 = C::put_in_reg(ctx, pattern3_0); - let expr2_0 = constructor_alu_rrr(ctx, pattern0_0, pattern1_0, expr0_0, expr1_0)?; - return Some(expr2_0); -} - -// Generated as internal constructor for term i128_alu_bitop. -pub fn constructor_i128_alu_bitop( - ctx: &mut C, - arg0: &ALUOp, - arg1: Type, - arg2: Value, - arg3: Value, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - let pattern3_0 = arg3; - // Rule at src/isa/aarch64/inst.isle line 2017. - let expr0_0 = C::put_in_regs(ctx, pattern2_0); - let expr1_0: usize = 0; - let expr2_0 = C::value_regs_get(ctx, expr0_0, expr1_0); - let expr3_0: usize = 1; - let expr4_0 = C::value_regs_get(ctx, expr0_0, expr3_0); - let expr5_0 = C::put_in_regs(ctx, pattern3_0); - let expr6_0: usize = 0; - let expr7_0 = C::value_regs_get(ctx, expr5_0, expr6_0); - let expr8_0: usize = 1; - let expr9_0 = C::value_regs_get(ctx, expr5_0, expr8_0); - let expr10_0 = constructor_alu_rrr(ctx, pattern0_0, pattern1_0, expr2_0, expr7_0)?; - let expr11_0 = constructor_alu_rrr(ctx, pattern0_0, pattern1_0, expr4_0, expr9_0)?; - let expr12_0 = C::value_regs(ctx, expr10_0, expr11_0); - return Some(expr12_0); -} - -// Generated as internal constructor for term float_cmp_zero. -pub fn constructor_float_cmp_zero( - ctx: &mut C, - arg0: &FloatCC, - arg1: Reg, - arg2: &VectorSize, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/aarch64/inst.isle line 2057. - let expr0_0 = C::float_cc_cmp_zero_to_vec_misc_op(ctx, pattern0_0); - let expr1_0 = constructor_vec_misc(ctx, &expr0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term float_cmp_zero_swap. -pub fn constructor_float_cmp_zero_swap( - ctx: &mut C, - arg0: &FloatCC, - arg1: Reg, - arg2: &VectorSize, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/aarch64/inst.isle line 2062. - let expr0_0 = C::float_cc_cmp_zero_to_vec_misc_op_swap(ctx, pattern0_0); - let expr1_0 = constructor_vec_misc(ctx, &expr0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term fcmeq0. -pub fn constructor_fcmeq0(ctx: &mut C, arg0: Reg, arg1: &VectorSize) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/aarch64/inst.isle line 2067. - let expr0_0 = VecMisc2::Fcmeq0; - let expr1_0 = constructor_vec_misc(ctx, &expr0_0, pattern0_0, pattern1_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term int_cmp_zero. -pub fn constructor_int_cmp_zero( - ctx: &mut C, - arg0: &IntCC, - arg1: Reg, - arg2: &VectorSize, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/aarch64/inst.isle line 2093. - let expr0_0 = C::int_cc_cmp_zero_to_vec_misc_op(ctx, pattern0_0); - let expr1_0 = constructor_vec_misc(ctx, &expr0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term int_cmp_zero_swap. -pub fn constructor_int_cmp_zero_swap( - ctx: &mut C, - arg0: &IntCC, - arg1: Reg, - arg2: &VectorSize, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/aarch64/inst.isle line 2098. - let expr0_0 = C::int_cc_cmp_zero_to_vec_misc_op_swap(ctx, pattern0_0); - let expr1_0 = constructor_vec_misc(ctx, &expr0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term cmeq0. -pub fn constructor_cmeq0(ctx: &mut C, arg0: Reg, arg1: &VectorSize) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/aarch64/inst.isle line 2103. - let expr0_0 = VecMisc2::Cmeq0; - let expr1_0 = constructor_vec_misc(ctx, &expr0_0, pattern0_0, pattern1_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term lse_atomic_rmw. -pub fn constructor_lse_atomic_rmw( - ctx: &mut C, - arg0: &AtomicRMWOp, - arg1: Value, - arg2: Reg, - arg3: Type, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - let pattern3_0 = arg3; - // Rule at src/isa/aarch64/inst.isle line 2108. - let expr0_0 = C::put_in_reg(ctx, pattern1_0); - let expr1_0 = C::temp_writable_reg(ctx, pattern3_0); - let expr2_0 = MInst::AtomicRMW { - op: pattern0_0.clone(), - rs: pattern2_0, - rt: expr1_0, - rn: expr0_0, - ty: pattern3_0, - }; - let expr3_0 = C::emit(ctx, &expr2_0); - let expr4_0 = C::writable_reg_to_reg(ctx, expr1_0); - return Some(expr4_0); -} - -// Generated as internal constructor for term atomic_rmw_loop. -pub fn constructor_atomic_rmw_loop( - ctx: &mut C, - arg0: &AtomicRMWLoopOp, - arg1: Value, - arg2: Value, - arg3: Type, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - let pattern3_0 = arg3; - // Rule at src/isa/aarch64/inst.isle line 2123. - let expr0_0 = C::put_in_reg(ctx, pattern1_0); - let expr1_0: Type = I64; - let expr2_0 = C::ensure_in_vreg(ctx, expr0_0, expr1_0); - let expr3_0 = C::put_in_reg(ctx, pattern2_0); - let expr4_0: Type = I64; - let expr5_0 = C::ensure_in_vreg(ctx, expr3_0, expr4_0); - let expr6_0: u8 = 25; - let expr7_0 = constructor_mov64_to_real(ctx, expr6_0, expr2_0)?; - let expr8_0: u8 = 26; - let expr9_0 = constructor_mov64_to_real(ctx, expr8_0, expr5_0)?; - let expr10_0 = MInst::AtomicRMWLoop { - ty: pattern3_0, - op: pattern0_0.clone(), - }; - let expr11_0 = C::emit(ctx, &expr10_0); - let expr12_0: u8 = 27; - let expr13_0 = constructor_mov64_from_real(ctx, expr12_0)?; - return Some(expr13_0); -} - -// Generated as internal constructor for term lower. -pub fn constructor_lower(ctx: &mut C, arg0: Inst) -> Option { - let pattern0_0 = arg0; - if let Some(()) = C::use_lse(ctx, pattern0_0) { - if let Some(pattern2_0) = C::first_result(ctx, pattern0_0) { - let pattern3_0 = C::value_type(ctx, pattern2_0); - if let Some(pattern4_0) = C::valid_atomic_transaction(ctx, pattern3_0) { - let pattern5_0 = C::inst_data(ctx, pattern0_0); - if let &InstructionData::AtomicRmw { - opcode: ref pattern6_0, - args: ref pattern6_1, - flags: pattern6_2, - op: ref pattern6_3, - } = &pattern5_0 - { - if let &Opcode::AtomicRmw = pattern6_0 { - let (pattern8_0, pattern8_1) = C::unpack_value_array_2(ctx, pattern6_1); - match pattern6_3 { - &AtomicRmwOp::Add => { - // Rule at src/isa/aarch64/lower.isle line 1213. - let expr0_0 = AtomicRMWOp::Add; - let expr1_0 = C::put_in_reg(ctx, pattern8_1); - let expr2_0 = constructor_lse_atomic_rmw( - ctx, &expr0_0, pattern8_0, expr1_0, pattern4_0, - )?; - let expr3_0 = constructor_output_reg(ctx, expr2_0)?; - return Some(expr3_0); - } - &AtomicRmwOp::And => { - // Rule at src/isa/aarch64/lower.isle line 1245. - let expr0_0 = AtomicRMWOp::Clr; - let expr1_0 = C::put_in_reg(ctx, pattern8_1); - let expr2_0 = C::zero_reg(ctx); - let expr3_0 = constructor_eon(ctx, pattern4_0, expr1_0, expr2_0)?; - let expr4_0 = constructor_lse_atomic_rmw( - ctx, &expr0_0, pattern8_0, expr3_0, pattern4_0, - )?; - let expr5_0 = constructor_output_reg(ctx, expr4_0)?; - return Some(expr5_0); - } - &AtomicRmwOp::Or => { - // Rule at src/isa/aarch64/lower.isle line 1221. - let expr0_0 = AtomicRMWOp::Set; - let expr1_0 = C::put_in_reg(ctx, pattern8_1); - let expr2_0 = constructor_lse_atomic_rmw( - ctx, &expr0_0, pattern8_0, expr1_0, pattern4_0, - )?; - let expr3_0 = constructor_output_reg(ctx, expr2_0)?; - return Some(expr3_0); - } - &AtomicRmwOp::Smax => { - // Rule at src/isa/aarch64/lower.isle line 1225. - let expr0_0 = AtomicRMWOp::Smax; - let expr1_0 = C::put_in_reg(ctx, pattern8_1); - let expr2_0 = constructor_lse_atomic_rmw( - ctx, &expr0_0, pattern8_0, expr1_0, pattern4_0, - )?; - let expr3_0 = constructor_output_reg(ctx, expr2_0)?; - return Some(expr3_0); - } - &AtomicRmwOp::Smin => { - // Rule at src/isa/aarch64/lower.isle line 1229. - let expr0_0 = AtomicRMWOp::Smin; - let expr1_0 = C::put_in_reg(ctx, pattern8_1); - let expr2_0 = constructor_lse_atomic_rmw( - ctx, &expr0_0, pattern8_0, expr1_0, pattern4_0, - )?; - let expr3_0 = constructor_output_reg(ctx, expr2_0)?; - return Some(expr3_0); - } - &AtomicRmwOp::Sub => { - // Rule at src/isa/aarch64/lower.isle line 1241. - let expr0_0 = AtomicRMWOp::Add; - let expr1_0 = C::zero_reg(ctx); - let expr2_0 = C::put_in_reg(ctx, pattern8_1); - let expr3_0 = constructor_sub(ctx, pattern4_0, expr1_0, expr2_0)?; - let expr4_0 = constructor_lse_atomic_rmw( - ctx, &expr0_0, pattern8_0, expr3_0, pattern4_0, - )?; - let expr5_0 = constructor_output_reg(ctx, expr4_0)?; - return Some(expr5_0); - } - &AtomicRmwOp::Umax => { - // Rule at src/isa/aarch64/lower.isle line 1233. - let expr0_0 = AtomicRMWOp::Umax; - let expr1_0 = C::put_in_reg(ctx, pattern8_1); - let expr2_0 = constructor_lse_atomic_rmw( - ctx, &expr0_0, pattern8_0, expr1_0, pattern4_0, - )?; - let expr3_0 = constructor_output_reg(ctx, expr2_0)?; - return Some(expr3_0); - } - &AtomicRmwOp::Umin => { - // Rule at src/isa/aarch64/lower.isle line 1237. - let expr0_0 = AtomicRMWOp::Umin; - let expr1_0 = C::put_in_reg(ctx, pattern8_1); - let expr2_0 = constructor_lse_atomic_rmw( - ctx, &expr0_0, pattern8_0, expr1_0, pattern4_0, - )?; - let expr3_0 = constructor_output_reg(ctx, expr2_0)?; - return Some(expr3_0); - } - &AtomicRmwOp::Xor => { - // Rule at src/isa/aarch64/lower.isle line 1217. - let expr0_0 = AtomicRMWOp::Eor; - let expr1_0 = C::put_in_reg(ctx, pattern8_1); - let expr2_0 = constructor_lse_atomic_rmw( - ctx, &expr0_0, pattern8_0, expr1_0, pattern4_0, - )?; - let expr3_0 = constructor_output_reg(ctx, expr2_0)?; - return Some(expr3_0); - } - _ => {} - } - } - } - } - } - } - if let Some(pattern1_0) = C::first_result(ctx, pattern0_0) { - let pattern2_0 = C::value_type(ctx, pattern1_0); - if pattern2_0 == I8 { - let pattern4_0 = C::inst_data(ctx, pattern0_0); - if let &InstructionData::Unary { - opcode: ref pattern5_0, - arg: pattern5_1, - } = &pattern4_0 - { - match pattern5_0 { - &Opcode::Bitrev => { - // Rule at src/isa/aarch64/lower.isle line 991. - let expr0_0: Type = I32; - let expr1_0: Type = I32; - let expr2_0 = C::put_in_reg(ctx, pattern5_1); - let expr3_0 = constructor_rbit(ctx, expr1_0, expr2_0)?; - let expr4_0: u8 = 24; - let expr5_0 = C::imm_shift_from_u8(ctx, expr4_0); - let expr6_0 = constructor_lsr_imm(ctx, expr0_0, expr3_0, expr5_0)?; - let expr7_0 = constructor_output_reg(ctx, expr6_0)?; - return Some(expr7_0); - } - &Opcode::Clz => { - // Rule at src/isa/aarch64/lower.isle line 1012. - let expr0_0: Type = I32; - let expr1_0: Type = I32; - let expr2_0 = constructor_put_in_reg_zext32(ctx, pattern5_1)?; - let expr3_0 = constructor_a64_clz(ctx, expr1_0, expr2_0)?; - let expr4_0: u8 = 24; - let expr5_0 = C::u8_into_imm12(ctx, expr4_0); - let expr6_0 = constructor_sub_imm(ctx, expr0_0, expr3_0, expr5_0)?; - let expr7_0 = constructor_output_reg(ctx, expr6_0)?; - return Some(expr7_0); - } - &Opcode::Cls => { - // Rule at src/isa/aarch64/lower.isle line 1059. - let expr0_0: Type = I32; - let expr1_0: Type = I32; - let expr2_0 = constructor_put_in_reg_zext32(ctx, pattern5_1)?; - let expr3_0 = constructor_a64_cls(ctx, expr1_0, expr2_0)?; - let expr4_0: u8 = 24; - let expr5_0 = C::u8_into_imm12(ctx, expr4_0); - let expr6_0 = constructor_sub_imm(ctx, expr0_0, expr3_0, expr5_0)?; - let expr7_0 = constructor_output_reg(ctx, expr6_0)?; - return Some(expr7_0); - } - &Opcode::Ctz => { - // Rule at src/isa/aarch64/lower.isle line 1042. - let expr0_0: Type = I32; - let expr1_0: Type = I32; - let expr2_0: Type = I32; - let expr3_0 = C::put_in_reg(ctx, pattern5_1); - let expr4_0 = constructor_rbit(ctx, expr2_0, expr3_0)?; - let expr5_0: Type = I32; - let expr6_0: u64 = 8388608; - let expr7_0 = C::u64_into_imm_logic(ctx, expr5_0, expr6_0); - let expr8_0 = constructor_orr_imm(ctx, expr1_0, expr4_0, expr7_0)?; - let expr9_0 = constructor_a64_clz(ctx, expr0_0, expr8_0)?; - let expr10_0 = constructor_output_reg(ctx, expr9_0)?; - return Some(expr10_0); - } - &Opcode::Popcnt => { - // Rule at src/isa/aarch64/lower.isle line 1110. - let expr0_0 = C::put_in_reg(ctx, pattern5_1); - let expr1_0 = ScalarSize::Size32; - let expr2_0 = constructor_mov_to_fpu(ctx, expr0_0, &expr1_0)?; - let expr3_0 = VectorSize::Size8x8; - let expr4_0 = constructor_vec_cnt(ctx, expr2_0, &expr3_0)?; - let expr5_0: u8 = 0; - let expr6_0 = VectorSize::Size8x16; - let expr7_0 = constructor_mov_from_vec(ctx, expr4_0, expr5_0, &expr6_0)?; - let expr8_0 = constructor_output_reg(ctx, expr7_0)?; - return Some(expr8_0); - } - _ => {} - } - } - } - if pattern2_0 == I16 { - let pattern4_0 = C::inst_data(ctx, pattern0_0); - if let &InstructionData::Unary { - opcode: ref pattern5_0, - arg: pattern5_1, - } = &pattern4_0 - { - match pattern5_0 { - &Opcode::Bitrev => { - // Rule at src/isa/aarch64/lower.isle line 997. - let expr0_0: Type = I32; - let expr1_0: Type = I32; - let expr2_0 = C::put_in_reg(ctx, pattern5_1); - let expr3_0 = constructor_rbit(ctx, expr1_0, expr2_0)?; - let expr4_0: u8 = 16; - let expr5_0 = C::imm_shift_from_u8(ctx, expr4_0); - let expr6_0 = constructor_lsr_imm(ctx, expr0_0, expr3_0, expr5_0)?; - let expr7_0 = constructor_output_reg(ctx, expr6_0)?; - return Some(expr7_0); - } - &Opcode::Clz => { - // Rule at src/isa/aarch64/lower.isle line 1015. - let expr0_0: Type = I32; - let expr1_0: Type = I32; - let expr2_0 = constructor_put_in_reg_zext32(ctx, pattern5_1)?; - let expr3_0 = constructor_a64_clz(ctx, expr1_0, expr2_0)?; - let expr4_0: u8 = 16; - let expr5_0 = C::u8_into_imm12(ctx, expr4_0); - let expr6_0 = constructor_sub_imm(ctx, expr0_0, expr3_0, expr5_0)?; - let expr7_0 = constructor_output_reg(ctx, expr6_0)?; - return Some(expr7_0); - } - &Opcode::Cls => { - // Rule at src/isa/aarch64/lower.isle line 1062. - let expr0_0: Type = I32; - let expr1_0: Type = I32; - let expr2_0 = constructor_put_in_reg_zext32(ctx, pattern5_1)?; - let expr3_0 = constructor_a64_cls(ctx, expr1_0, expr2_0)?; - let expr4_0: u8 = 16; - let expr5_0 = C::u8_into_imm12(ctx, expr4_0); - let expr6_0 = constructor_sub_imm(ctx, expr0_0, expr3_0, expr5_0)?; - let expr7_0 = constructor_output_reg(ctx, expr6_0)?; - return Some(expr7_0); - } - &Opcode::Ctz => { - // Rule at src/isa/aarch64/lower.isle line 1045. - let expr0_0: Type = I32; - let expr1_0: Type = I32; - let expr2_0: Type = I32; - let expr3_0 = C::put_in_reg(ctx, pattern5_1); - let expr4_0 = constructor_rbit(ctx, expr2_0, expr3_0)?; - let expr5_0: Type = I32; - let expr6_0: u64 = 32768; - let expr7_0 = C::u64_into_imm_logic(ctx, expr5_0, expr6_0); - let expr8_0 = constructor_orr_imm(ctx, expr1_0, expr4_0, expr7_0)?; - let expr9_0 = constructor_a64_clz(ctx, expr0_0, expr8_0)?; - let expr10_0 = constructor_output_reg(ctx, expr9_0)?; - return Some(expr10_0); - } - &Opcode::Popcnt => { - // Rule at src/isa/aarch64/lower.isle line 1116. - let expr0_0 = C::put_in_reg(ctx, pattern5_1); - let expr1_0 = ScalarSize::Size32; - let expr2_0 = constructor_mov_to_fpu(ctx, expr0_0, &expr1_0)?; - let expr3_0 = VectorSize::Size8x8; - let expr4_0 = constructor_vec_cnt(ctx, expr2_0, &expr3_0)?; - let expr5_0 = VectorSize::Size8x8; - let expr6_0 = constructor_addp(ctx, expr4_0, expr4_0, &expr5_0)?; - let expr7_0: u8 = 0; - let expr8_0 = VectorSize::Size8x16; - let expr9_0 = constructor_mov_from_vec(ctx, expr6_0, expr7_0, &expr8_0)?; - let expr10_0 = constructor_output_reg(ctx, expr9_0)?; - return Some(expr10_0); - } - _ => {} - } - } - } - if pattern2_0 == I32 { - let pattern4_0 = C::inst_data(ctx, pattern0_0); - match &pattern4_0 { - &InstructionData::Binary { - opcode: ref pattern5_0, - args: ref pattern5_1, - } => { - match pattern5_0 { - &Opcode::Rotl => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - if let Some(pattern8_0) = C::def_inst(ctx, pattern7_1) { - let pattern9_0 = C::inst_data(ctx, pattern8_0); - if let &InstructionData::UnaryImm { - opcode: ref pattern10_0, - imm: pattern10_1, - } = &pattern9_0 - { - if let &Opcode::Iconst = pattern10_0 { - let mut closure12 = || { - let expr0_0: Type = I32; - let expr1_0 = - C::imm_shift_from_imm64(ctx, expr0_0, pattern10_1)?; - return Some(expr1_0); - }; - if let Some(pattern12_0) = closure12() { - // Rule at src/isa/aarch64/lower.isle line 877. - let expr0_0: Type = I32; - let expr1_0 = C::put_in_reg(ctx, pattern7_0); - let expr2_0: Type = I32; - let expr3_0 = - C::negate_imm_shift(ctx, expr2_0, pattern12_0); - let expr4_0 = constructor_a64_rotr_imm( - ctx, expr0_0, expr1_0, expr3_0, - )?; - let expr5_0 = constructor_output_reg(ctx, expr4_0)?; - return Some(expr5_0); - } - } - } - } - // Rule at src/isa/aarch64/lower.isle line 867. - let expr0_0: Type = I32; - let expr1_0 = C::zero_reg(ctx); - let expr2_0 = C::put_in_reg(ctx, pattern7_1); - let expr3_0 = constructor_sub(ctx, expr0_0, expr1_0, expr2_0)?; - let expr4_0: Type = I32; - let expr5_0 = C::put_in_reg(ctx, pattern7_0); - let expr6_0 = constructor_a64_rotr(ctx, expr4_0, expr5_0, expr3_0)?; - let expr7_0 = constructor_output_reg(ctx, expr6_0)?; - return Some(expr7_0); - } - &Opcode::Rotr => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - if let Some(pattern8_0) = C::def_inst(ctx, pattern7_1) { - let pattern9_0 = C::inst_data(ctx, pattern8_0); - if let &InstructionData::UnaryImm { - opcode: ref pattern10_0, - imm: pattern10_1, - } = &pattern9_0 - { - if let &Opcode::Iconst = pattern10_0 { - let mut closure12 = || { - let expr0_0: Type = I32; - let expr1_0 = - C::imm_shift_from_imm64(ctx, expr0_0, pattern10_1)?; - return Some(expr1_0); - }; - if let Some(pattern12_0) = closure12() { - // Rule at src/isa/aarch64/lower.isle line 922. - let expr0_0: Type = I32; - let expr1_0 = C::put_in_reg(ctx, pattern7_0); - let expr2_0 = constructor_a64_rotr_imm( - ctx, - expr0_0, - expr1_0, - pattern12_0, - )?; - let expr3_0 = constructor_output_reg(ctx, expr2_0)?; - return Some(expr3_0); - } - } - } - } - // Rule at src/isa/aarch64/lower.isle line 909. - let expr0_0: Type = I32; - let expr1_0 = C::put_in_reg(ctx, pattern7_0); - let expr2_0 = C::put_in_reg(ctx, pattern7_1); - let expr3_0 = constructor_a64_rotr(ctx, expr0_0, expr1_0, expr2_0)?; - let expr4_0 = constructor_output_reg(ctx, expr3_0)?; - return Some(expr4_0); - } - _ => {} - } - } - &InstructionData::Unary { - opcode: ref pattern5_0, - arg: pattern5_1, - } => { - if let &Opcode::Popcnt = pattern5_0 { - // Rule at src/isa/aarch64/lower.isle line 1122. - let expr0_0 = C::put_in_reg(ctx, pattern5_1); - let expr1_0 = ScalarSize::Size32; - let expr2_0 = constructor_mov_to_fpu(ctx, expr0_0, &expr1_0)?; - let expr3_0 = VectorSize::Size8x8; - let expr4_0 = constructor_vec_cnt(ctx, expr2_0, &expr3_0)?; - let expr5_0 = VectorSize::Size8x8; - let expr6_0 = constructor_addv(ctx, expr4_0, &expr5_0)?; - let expr7_0: u8 = 0; - let expr8_0 = VectorSize::Size8x16; - let expr9_0 = constructor_mov_from_vec(ctx, expr6_0, expr7_0, &expr8_0)?; - let expr10_0 = constructor_output_reg(ctx, expr9_0)?; - return Some(expr10_0); - } - } - _ => {} - } - } - if pattern2_0 == I64 { - let pattern4_0 = C::inst_data(ctx, pattern0_0); - match &pattern4_0 { - &InstructionData::Binary { - opcode: ref pattern5_0, - args: ref pattern5_1, - } => { - match pattern5_0 { - &Opcode::Umulhi => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/aarch64/lower.isle line 374. - let expr0_0: Type = I64; - let expr1_0 = C::put_in_reg(ctx, pattern7_0); - let expr2_0 = C::put_in_reg(ctx, pattern7_1); - let expr3_0 = constructor_umulh(ctx, expr0_0, expr1_0, expr2_0)?; - let expr4_0 = constructor_output_reg(ctx, expr3_0)?; - return Some(expr4_0); - } - &Opcode::Smulhi => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/aarch64/lower.isle line 362. - let expr0_0: Type = I64; - let expr1_0 = C::put_in_reg(ctx, pattern7_0); - let expr2_0 = C::put_in_reg(ctx, pattern7_1); - let expr3_0 = constructor_smulh(ctx, expr0_0, expr1_0, expr2_0)?; - let expr4_0 = constructor_output_reg(ctx, expr3_0)?; - return Some(expr4_0); - } - &Opcode::Band => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/aarch64/lower.isle line 596. - let expr0_0 = ALUOp::And; - let expr1_0: Type = I64; - let expr2_0 = constructor_alu_rs_imm_logic_commutative( - ctx, &expr0_0, expr1_0, pattern7_0, pattern7_1, - )?; - let expr3_0 = constructor_output_reg(ctx, expr2_0)?; - return Some(expr3_0); - } - &Opcode::Bor => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/aarch64/lower.isle line 609. - let expr0_0 = ALUOp::Orr; - let expr1_0: Type = I64; - let expr2_0 = constructor_alu_rs_imm_logic_commutative( - ctx, &expr0_0, expr1_0, pattern7_0, pattern7_1, - )?; - let expr3_0 = constructor_output_reg(ctx, expr2_0)?; - return Some(expr3_0); - } - &Opcode::Bxor => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/aarch64/lower.isle line 622. - let expr0_0 = ALUOp::Eor; - let expr1_0: Type = I64; - let expr2_0 = constructor_alu_rs_imm_logic_commutative( - ctx, &expr0_0, expr1_0, pattern7_0, pattern7_1, - )?; - let expr3_0 = constructor_output_reg(ctx, expr2_0)?; - return Some(expr3_0); - } - &Opcode::BandNot => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/aarch64/lower.isle line 635. - let expr0_0 = ALUOp::AndNot; - let expr1_0: Type = I64; - let expr2_0 = constructor_alu_rs_imm_logic( - ctx, &expr0_0, expr1_0, pattern7_0, pattern7_1, - )?; - let expr3_0 = constructor_output_reg(ctx, expr2_0)?; - return Some(expr3_0); - } - &Opcode::BorNot => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/aarch64/lower.isle line 648. - let expr0_0 = ALUOp::OrrNot; - let expr1_0: Type = I64; - let expr2_0 = constructor_alu_rs_imm_logic( - ctx, &expr0_0, expr1_0, pattern7_0, pattern7_1, - )?; - let expr3_0 = constructor_output_reg(ctx, expr2_0)?; - return Some(expr3_0); - } - &Opcode::BxorNot => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/aarch64/lower.isle line 658. - let expr0_0 = ALUOp::EorNot; - let expr1_0: Type = I64; - let expr2_0 = constructor_alu_rs_imm_logic( - ctx, &expr0_0, expr1_0, pattern7_0, pattern7_1, - )?; - let expr3_0 = constructor_output_reg(ctx, expr2_0)?; - return Some(expr3_0); - } - &Opcode::Rotl => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - if let Some(pattern8_0) = C::def_inst(ctx, pattern7_1) { - let pattern9_0 = C::inst_data(ctx, pattern8_0); - if let &InstructionData::UnaryImm { - opcode: ref pattern10_0, - imm: pattern10_1, - } = &pattern9_0 - { - if let &Opcode::Iconst = pattern10_0 { - let mut closure12 = || { - let expr0_0: Type = I64; - let expr1_0 = - C::imm_shift_from_imm64(ctx, expr0_0, pattern10_1)?; - return Some(expr1_0); - }; - if let Some(pattern12_0) = closure12() { - // Rule at src/isa/aarch64/lower.isle line 882. - let expr0_0: Type = I64; - let expr1_0 = C::put_in_reg(ctx, pattern7_0); - let expr2_0: Type = I64; - let expr3_0 = - C::negate_imm_shift(ctx, expr2_0, pattern12_0); - let expr4_0 = constructor_a64_rotr_imm( - ctx, expr0_0, expr1_0, expr3_0, - )?; - let expr5_0 = constructor_output_reg(ctx, expr4_0)?; - return Some(expr5_0); - } - } - } - } - // Rule at src/isa/aarch64/lower.isle line 872. - let expr0_0: Type = I64; - let expr1_0 = C::zero_reg(ctx); - let expr2_0 = C::put_in_reg(ctx, pattern7_1); - let expr3_0 = constructor_sub(ctx, expr0_0, expr1_0, expr2_0)?; - let expr4_0: Type = I64; - let expr5_0 = C::put_in_reg(ctx, pattern7_0); - let expr6_0 = constructor_a64_rotr(ctx, expr4_0, expr5_0, expr3_0)?; - let expr7_0 = constructor_output_reg(ctx, expr6_0)?; - return Some(expr7_0); - } - &Opcode::Rotr => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - if let Some(pattern8_0) = C::def_inst(ctx, pattern7_1) { - let pattern9_0 = C::inst_data(ctx, pattern8_0); - if let &InstructionData::UnaryImm { - opcode: ref pattern10_0, - imm: pattern10_1, - } = &pattern9_0 - { - if let &Opcode::Iconst = pattern10_0 { - let mut closure12 = || { - let expr0_0: Type = I64; - let expr1_0 = - C::imm_shift_from_imm64(ctx, expr0_0, pattern10_1)?; - return Some(expr1_0); - }; - if let Some(pattern12_0) = closure12() { - // Rule at src/isa/aarch64/lower.isle line 927. - let expr0_0: Type = I64; - let expr1_0 = C::put_in_reg(ctx, pattern7_0); - let expr2_0 = constructor_a64_rotr_imm( - ctx, - expr0_0, - expr1_0, - pattern12_0, - )?; - let expr3_0 = constructor_output_reg(ctx, expr2_0)?; - return Some(expr3_0); - } - } - } - } - // Rule at src/isa/aarch64/lower.isle line 913. - let expr0_0: Type = I64; - let expr1_0 = C::put_in_reg(ctx, pattern7_0); - let expr2_0 = C::put_in_reg(ctx, pattern7_1); - let expr3_0 = constructor_a64_rotr(ctx, expr0_0, expr1_0, expr2_0)?; - let expr4_0 = constructor_output_reg(ctx, expr3_0)?; - return Some(expr4_0); - } - &Opcode::Ishl => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/aarch64/lower.isle line 670. - let expr0_0 = ALUOp::Lsl; - let expr1_0: Type = I64; - let expr2_0 = C::put_in_reg(ctx, pattern7_0); - let expr3_0 = - constructor_do_shift(ctx, &expr0_0, expr1_0, expr2_0, pattern7_1)?; - let expr4_0 = constructor_output_reg(ctx, expr3_0)?; - return Some(expr4_0); - } - &Opcode::Ushr => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/aarch64/lower.isle line 755. - let expr0_0 = ALUOp::Lsr; - let expr1_0: Type = I64; - let expr2_0 = constructor_put_in_reg_zext64(ctx, pattern7_0)?; - let expr3_0 = - constructor_do_shift(ctx, &expr0_0, expr1_0, expr2_0, pattern7_1)?; - let expr4_0 = constructor_output_reg(ctx, expr3_0)?; - return Some(expr4_0); - } - &Opcode::Sshr => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/aarch64/lower.isle line 802. - let expr0_0 = ALUOp::Asr; - let expr1_0: Type = I64; - let expr2_0 = constructor_put_in_reg_sext64(ctx, pattern7_0)?; - let expr3_0 = - constructor_do_shift(ctx, &expr0_0, expr1_0, expr2_0, pattern7_1)?; - let expr4_0 = constructor_output_reg(ctx, expr3_0)?; - return Some(expr4_0); - } - _ => {} - } - } - &InstructionData::Unary { - opcode: ref pattern5_0, - arg: pattern5_1, - } => { - if let &Opcode::Popcnt = pattern5_0 { - // Rule at src/isa/aarch64/lower.isle line 1128. - let expr0_0 = C::put_in_reg(ctx, pattern5_1); - let expr1_0 = ScalarSize::Size64; - let expr2_0 = constructor_mov_to_fpu(ctx, expr0_0, &expr1_0)?; - let expr3_0 = VectorSize::Size8x8; - let expr4_0 = constructor_vec_cnt(ctx, expr2_0, &expr3_0)?; - let expr5_0 = VectorSize::Size8x8; - let expr6_0 = constructor_addv(ctx, expr4_0, &expr5_0)?; - let expr7_0: u8 = 0; - let expr8_0 = VectorSize::Size8x16; - let expr9_0 = constructor_mov_from_vec(ctx, expr6_0, expr7_0, &expr8_0)?; - let expr10_0 = constructor_output_reg(ctx, expr9_0)?; - return Some(expr10_0); - } - } - _ => {} - } - } - if pattern2_0 == I128 { - let pattern4_0 = C::inst_data(ctx, pattern0_0); - match &pattern4_0 { - &InstructionData::Binary { - opcode: ref pattern5_0, - args: ref pattern5_1, - } => { - match pattern5_0 { - &Opcode::Iadd => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/aarch64/lower.isle line 85. - let expr0_0 = C::put_in_regs(ctx, pattern7_0); - let expr1_0: usize = 0; - let expr2_0 = C::value_regs_get(ctx, expr0_0, expr1_0); - let expr3_0: usize = 1; - let expr4_0 = C::value_regs_get(ctx, expr0_0, expr3_0); - let expr5_0 = C::put_in_regs(ctx, pattern7_1); - let expr6_0: usize = 0; - let expr7_0 = C::value_regs_get(ctx, expr5_0, expr6_0); - let expr8_0: usize = 1; - let expr9_0 = C::value_regs_get(ctx, expr5_0, expr8_0); - let expr10_0: Type = I64; - let expr11_0 = - constructor_add_with_flags_paired(ctx, expr10_0, expr2_0, expr7_0)?; - let expr12_0: Type = I64; - let expr13_0 = constructor_adc_paired(ctx, expr12_0, expr4_0, expr9_0)?; - let expr14_0 = constructor_with_flags(ctx, &expr11_0, &expr13_0)?; - let expr15_0 = C::output(ctx, expr14_0); - return Some(expr15_0); - } - &Opcode::Isub => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/aarch64/lower.isle line 136. - let expr0_0 = C::put_in_regs(ctx, pattern7_0); - let expr1_0: usize = 0; - let expr2_0 = C::value_regs_get(ctx, expr0_0, expr1_0); - let expr3_0: usize = 1; - let expr4_0 = C::value_regs_get(ctx, expr0_0, expr3_0); - let expr5_0 = C::put_in_regs(ctx, pattern7_1); - let expr6_0: usize = 0; - let expr7_0 = C::value_regs_get(ctx, expr5_0, expr6_0); - let expr8_0: usize = 1; - let expr9_0 = C::value_regs_get(ctx, expr5_0, expr8_0); - let expr10_0: Type = I64; - let expr11_0 = - constructor_sub_with_flags_paired(ctx, expr10_0, expr2_0, expr7_0)?; - let expr12_0: Type = I64; - let expr13_0 = constructor_sbc_paired(ctx, expr12_0, expr4_0, expr9_0)?; - let expr14_0 = constructor_with_flags(ctx, &expr11_0, &expr13_0)?; - let expr15_0 = C::output(ctx, expr14_0); - return Some(expr15_0); - } - &Opcode::Imul => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/aarch64/lower.isle line 190. - let expr0_0 = C::put_in_regs(ctx, pattern7_0); - let expr1_0: usize = 0; - let expr2_0 = C::value_regs_get(ctx, expr0_0, expr1_0); - let expr3_0: usize = 1; - let expr4_0 = C::value_regs_get(ctx, expr0_0, expr3_0); - let expr5_0 = C::put_in_regs(ctx, pattern7_1); - let expr6_0: usize = 0; - let expr7_0 = C::value_regs_get(ctx, expr5_0, expr6_0); - let expr8_0: usize = 1; - let expr9_0 = C::value_regs_get(ctx, expr5_0, expr8_0); - let expr10_0: Type = I64; - let expr11_0 = constructor_umulh(ctx, expr10_0, expr2_0, expr7_0)?; - let expr12_0: Type = I64; - let expr13_0 = - constructor_madd(ctx, expr12_0, expr2_0, expr9_0, expr11_0)?; - let expr14_0: Type = I64; - let expr15_0 = - constructor_madd(ctx, expr14_0, expr4_0, expr7_0, expr13_0)?; - let expr16_0: Type = I64; - let expr17_0 = C::zero_reg(ctx); - let expr18_0 = - constructor_madd(ctx, expr16_0, expr2_0, expr7_0, expr17_0)?; - let expr19_0 = C::value_regs(ctx, expr18_0, expr15_0); - let expr20_0 = C::output(ctx, expr19_0); - return Some(expr20_0); - } - &Opcode::Band => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/aarch64/lower.isle line 599. - let expr0_0 = ALUOp::And; - let expr1_0: Type = I64; - let expr2_0 = constructor_i128_alu_bitop( - ctx, &expr0_0, expr1_0, pattern7_0, pattern7_1, - )?; - let expr3_0 = C::output(ctx, expr2_0); - return Some(expr3_0); - } - &Opcode::Bor => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/aarch64/lower.isle line 612. - let expr0_0 = ALUOp::Orr; - let expr1_0: Type = I64; - let expr2_0 = constructor_i128_alu_bitop( - ctx, &expr0_0, expr1_0, pattern7_0, pattern7_1, - )?; - let expr3_0 = C::output(ctx, expr2_0); - return Some(expr3_0); - } - &Opcode::Bxor => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/aarch64/lower.isle line 625. - let expr0_0 = ALUOp::Eor; - let expr1_0: Type = I64; - let expr2_0 = constructor_i128_alu_bitop( - ctx, &expr0_0, expr1_0, pattern7_0, pattern7_1, - )?; - let expr3_0 = C::output(ctx, expr2_0); - return Some(expr3_0); - } - &Opcode::BandNot => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/aarch64/lower.isle line 638. - let expr0_0 = ALUOp::AndNot; - let expr1_0: Type = I64; - let expr2_0 = constructor_i128_alu_bitop( - ctx, &expr0_0, expr1_0, pattern7_0, pattern7_1, - )?; - let expr3_0 = C::output(ctx, expr2_0); - return Some(expr3_0); - } - &Opcode::BorNot => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/aarch64/lower.isle line 651. - let expr0_0 = ALUOp::OrrNot; - let expr1_0: Type = I64; - let expr2_0 = constructor_i128_alu_bitop( - ctx, &expr0_0, expr1_0, pattern7_0, pattern7_1, - )?; - let expr3_0 = C::output(ctx, expr2_0); - return Some(expr3_0); - } - &Opcode::BxorNot => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/aarch64/lower.isle line 661. - let expr0_0 = ALUOp::EorNot; - let expr1_0: Type = I64; - let expr2_0 = constructor_i128_alu_bitop( - ctx, &expr0_0, expr1_0, pattern7_0, pattern7_1, - )?; - let expr3_0 = C::output(ctx, expr2_0); - return Some(expr3_0); - } - &Opcode::Rotl => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/aarch64/lower.isle line 892. - let expr0_0 = C::put_in_regs(ctx, pattern7_0); - let expr1_0 = C::put_in_regs(ctx, pattern7_1); - let expr2_0: usize = 0; - let expr3_0 = C::value_regs_get(ctx, expr1_0, expr2_0); - let expr4_0: Type = I64; - let expr5_0: Type = I64; - let expr6_0: u64 = 128; - let expr7_0 = constructor_imm(ctx, expr5_0, expr6_0)?; - let expr8_0 = constructor_sub(ctx, expr4_0, expr7_0, expr3_0)?; - let expr9_0 = constructor_lower_shl128(ctx, expr0_0, expr3_0)?; - let expr10_0 = constructor_lower_ushr128(ctx, expr0_0, expr8_0)?; - let expr11_0: Type = I64; - let expr12_0: usize = 0; - let expr13_0 = C::value_regs_get(ctx, expr9_0, expr12_0); - let expr14_0: usize = 0; - let expr15_0 = C::value_regs_get(ctx, expr10_0, expr14_0); - let expr16_0 = constructor_orr(ctx, expr11_0, expr13_0, expr15_0)?; - let expr17_0: Type = I64; - let expr18_0: usize = 1; - let expr19_0 = C::value_regs_get(ctx, expr9_0, expr18_0); - let expr20_0: usize = 1; - let expr21_0 = C::value_regs_get(ctx, expr10_0, expr20_0); - let expr22_0 = constructor_orr(ctx, expr17_0, expr19_0, expr21_0)?; - let expr23_0 = C::value_regs(ctx, expr16_0, expr22_0); - let expr24_0 = C::output(ctx, expr23_0); - return Some(expr24_0); - } - &Opcode::Rotr => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/aarch64/lower.isle line 976. - let expr0_0 = C::put_in_regs(ctx, pattern7_0); - let expr1_0 = C::put_in_regs(ctx, pattern7_1); - let expr2_0: usize = 0; - let expr3_0 = C::value_regs_get(ctx, expr1_0, expr2_0); - let expr4_0: Type = I64; - let expr5_0: Type = I64; - let expr6_0: u64 = 128; - let expr7_0 = constructor_imm(ctx, expr5_0, expr6_0)?; - let expr8_0 = constructor_sub(ctx, expr4_0, expr7_0, expr3_0)?; - let expr9_0 = constructor_lower_ushr128(ctx, expr0_0, expr3_0)?; - let expr10_0 = constructor_lower_shl128(ctx, expr0_0, expr8_0)?; - let expr11_0: Type = I64; - let expr12_0: usize = 1; - let expr13_0 = C::value_regs_get(ctx, expr9_0, expr12_0); - let expr14_0: usize = 1; - let expr15_0 = C::value_regs_get(ctx, expr10_0, expr14_0); - let expr16_0 = constructor_orr(ctx, expr11_0, expr13_0, expr15_0)?; - let expr17_0: Type = I64; - let expr18_0: usize = 0; - let expr19_0 = C::value_regs_get(ctx, expr9_0, expr18_0); - let expr20_0: usize = 0; - let expr21_0 = C::value_regs_get(ctx, expr10_0, expr20_0); - let expr22_0 = constructor_orr(ctx, expr17_0, expr19_0, expr21_0)?; - let expr23_0 = C::value_regs(ctx, expr22_0, expr16_0); - let expr24_0 = C::output(ctx, expr23_0); - return Some(expr24_0); - } - &Opcode::Ishl => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/aarch64/lower.isle line 674. - let expr0_0 = C::put_in_regs(ctx, pattern7_0); - let expr1_0 = C::put_in_regs(ctx, pattern7_1); - let expr2_0: usize = 0; - let expr3_0 = C::value_regs_get(ctx, expr1_0, expr2_0); - let expr4_0 = constructor_lower_shl128(ctx, expr0_0, expr3_0)?; - let expr5_0 = C::output(ctx, expr4_0); - return Some(expr5_0); - } - &Opcode::Ushr => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/aarch64/lower.isle line 759. - let expr0_0 = C::put_in_regs(ctx, pattern7_0); - let expr1_0 = C::put_in_regs(ctx, pattern7_1); - let expr2_0: usize = 0; - let expr3_0 = C::value_regs_get(ctx, expr1_0, expr2_0); - let expr4_0 = constructor_lower_ushr128(ctx, expr0_0, expr3_0)?; - let expr5_0 = C::output(ctx, expr4_0); - return Some(expr5_0); - } - &Opcode::Sshr => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/aarch64/lower.isle line 806. - let expr0_0 = C::put_in_regs(ctx, pattern7_0); - let expr1_0 = C::put_in_regs(ctx, pattern7_1); - let expr2_0: usize = 0; - let expr3_0 = C::value_regs_get(ctx, expr1_0, expr2_0); - let expr4_0 = constructor_lower_sshr128(ctx, expr0_0, expr3_0)?; - let expr5_0 = C::output(ctx, expr4_0); - return Some(expr5_0); - } - _ => {} - } - } - &InstructionData::Unary { - opcode: ref pattern5_0, - arg: pattern5_1, - } => { - match pattern5_0 { - &Opcode::Bnot => { - // Rule at src/isa/aarch64/lower.isle line 579. - let expr0_0 = C::put_in_regs(ctx, pattern5_1); - let expr1_0: usize = 0; - let expr2_0 = C::value_regs_get(ctx, expr0_0, expr1_0); - let expr3_0: usize = 1; - let expr4_0 = C::value_regs_get(ctx, expr0_0, expr3_0); - let expr5_0: Type = I64; - let expr6_0 = C::zero_reg(ctx); - let expr7_0 = constructor_orr_not(ctx, expr5_0, expr6_0, expr2_0)?; - let expr8_0: Type = I64; - let expr9_0 = C::zero_reg(ctx); - let expr10_0 = constructor_orr_not(ctx, expr8_0, expr9_0, expr4_0)?; - let expr11_0 = C::value_regs(ctx, expr7_0, expr10_0); - let expr12_0 = C::output(ctx, expr11_0); - return Some(expr12_0); - } - &Opcode::Bitrev => { - // Rule at src/isa/aarch64/lower.isle line 1000. - let expr0_0 = C::put_in_regs(ctx, pattern5_1); - let expr1_0: Type = I64; - let expr2_0: usize = 0; - let expr3_0 = C::value_regs_get(ctx, expr0_0, expr2_0); - let expr4_0 = constructor_rbit(ctx, expr1_0, expr3_0)?; - let expr5_0: Type = I64; - let expr6_0: usize = 1; - let expr7_0 = C::value_regs_get(ctx, expr0_0, expr6_0); - let expr8_0 = constructor_rbit(ctx, expr5_0, expr7_0)?; - let expr9_0 = C::value_regs(ctx, expr8_0, expr4_0); - let expr10_0 = C::output(ctx, expr9_0); - return Some(expr10_0); - } - &Opcode::Clz => { - // Rule at src/isa/aarch64/lower.isle line 1018. - let expr0_0 = C::put_in_regs(ctx, pattern5_1); - let expr1_0 = constructor_lower_clz128(ctx, expr0_0)?; - let expr2_0 = C::output(ctx, expr1_0); - return Some(expr2_0); - } - &Opcode::Cls => { - // Rule at src/isa/aarch64/lower.isle line 1074. - let expr0_0 = C::put_in_regs(ctx, pattern5_1); - let expr1_0: usize = 0; - let expr2_0 = C::value_regs_get(ctx, expr0_0, expr1_0); - let expr3_0: usize = 1; - let expr4_0 = C::value_regs_get(ctx, expr0_0, expr3_0); - let expr5_0: Type = I64; - let expr6_0 = constructor_a64_cls(ctx, expr5_0, expr2_0)?; - let expr7_0: Type = I64; - let expr8_0 = constructor_a64_cls(ctx, expr7_0, expr4_0)?; - let expr9_0: Type = I64; - let expr10_0 = constructor_eon(ctx, expr9_0, expr4_0, expr2_0)?; - let expr11_0: Type = I64; - let expr12_0: u8 = 63; - let expr13_0 = C::imm_shift_from_u8(ctx, expr12_0); - let expr14_0 = constructor_lsr_imm(ctx, expr11_0, expr10_0, expr13_0)?; - let expr15_0: Type = I64; - let expr16_0 = - constructor_madd(ctx, expr15_0, expr6_0, expr14_0, expr14_0)?; - let expr17_0: u8 = 63; - let expr18_0 = C::u8_into_imm12(ctx, expr17_0); - let expr19_0 = constructor_cmp64_imm(ctx, expr8_0, expr18_0)?; - let expr20_0 = Cond::Eq; - let expr21_0 = C::zero_reg(ctx); - let expr22_0 = constructor_csel(ctx, &expr20_0, expr16_0, expr21_0)?; - let expr23_0 = constructor_with_flags_reg(ctx, &expr19_0, &expr22_0)?; - let expr24_0: Type = I64; - let expr25_0 = constructor_add(ctx, expr24_0, expr23_0, expr8_0)?; - let expr26_0: Type = I64; - let expr27_0: u64 = 0; - let expr28_0 = constructor_imm(ctx, expr26_0, expr27_0)?; - let expr29_0 = C::value_regs(ctx, expr25_0, expr28_0); - let expr30_0 = C::output(ctx, expr29_0); - return Some(expr30_0); - } - &Opcode::Ctz => { - // Rule at src/isa/aarch64/lower.isle line 1048. - let expr0_0 = C::put_in_regs(ctx, pattern5_1); - let expr1_0: Type = I64; - let expr2_0: usize = 0; - let expr3_0 = C::value_regs_get(ctx, expr0_0, expr2_0); - let expr4_0 = constructor_rbit(ctx, expr1_0, expr3_0)?; - let expr5_0: Type = I64; - let expr6_0: usize = 1; - let expr7_0 = C::value_regs_get(ctx, expr0_0, expr6_0); - let expr8_0 = constructor_rbit(ctx, expr5_0, expr7_0)?; - let expr9_0 = C::value_regs(ctx, expr8_0, expr4_0); - let expr10_0 = constructor_lower_clz128(ctx, expr9_0)?; - let expr11_0 = C::output(ctx, expr10_0); - return Some(expr11_0); - } - &Opcode::Popcnt => { - // Rule at src/isa/aarch64/lower.isle line 1134. - let expr0_0 = C::put_in_regs(ctx, pattern5_1); - let expr1_0: usize = 0; - let expr2_0 = C::value_regs_get(ctx, expr0_0, expr1_0); - let expr3_0 = ScalarSize::Size64; - let expr4_0 = constructor_mov_to_fpu(ctx, expr2_0, &expr3_0)?; - let expr5_0: usize = 1; - let expr6_0 = C::value_regs_get(ctx, expr0_0, expr5_0); - let expr7_0: u8 = 1; - let expr8_0 = VectorSize::Size64x2; - let expr9_0 = - constructor_mov_to_vec(ctx, expr4_0, expr6_0, expr7_0, &expr8_0)?; - let expr10_0 = VectorSize::Size8x16; - let expr11_0 = constructor_vec_cnt(ctx, expr9_0, &expr10_0)?; - let expr12_0 = VectorSize::Size8x16; - let expr13_0 = constructor_addv(ctx, expr11_0, &expr12_0)?; - let expr14_0: u8 = 0; - let expr15_0 = VectorSize::Size8x16; - let expr16_0 = - constructor_mov_from_vec(ctx, expr13_0, expr14_0, &expr15_0)?; - let expr17_0: Type = I64; - let expr18_0: u64 = 0; - let expr19_0 = constructor_imm(ctx, expr17_0, expr18_0)?; - let expr20_0 = C::value_regs(ctx, expr16_0, expr19_0); - let expr21_0 = C::output(ctx, expr20_0); - return Some(expr21_0); - } - &Opcode::Uextend => { - if let Some(pattern7_0) = C::def_inst(ctx, pattern5_1) { - let pattern8_0 = C::inst_data(ctx, pattern7_0); - if let &InstructionData::BinaryImm8 { - opcode: ref pattern9_0, - arg: pattern9_1, - imm: pattern9_2, - } = &pattern8_0 - { - if let &Opcode::Extractlane = pattern9_0 { - let pattern11_0 = C::value_type(ctx, pattern9_1); - let pattern12_0 = C::u8_from_uimm8(ctx, pattern9_2); - // Rule at src/isa/aarch64/lower.isle line 508. - let expr0_0 = C::put_in_reg(ctx, pattern9_1); - let expr1_0 = constructor_vector_size(ctx, pattern11_0)?; - let expr2_0 = constructor_mov_from_vec( - ctx, - expr0_0, - pattern12_0, - &expr1_0, - )?; - let expr3_0: Type = I64; - let expr4_0: u64 = 0; - let expr5_0 = constructor_imm(ctx, expr3_0, expr4_0)?; - let expr6_0 = C::value_regs(ctx, expr2_0, expr5_0); - let expr7_0 = C::output(ctx, expr6_0); - return Some(expr7_0); - } - } - } - // Rule at src/isa/aarch64/lower.isle line 503. - let expr0_0 = constructor_put_in_reg_zext64(ctx, pattern5_1)?; - let expr1_0: Type = I64; - let expr2_0: u64 = 0; - let expr3_0 = constructor_imm(ctx, expr1_0, expr2_0)?; - let expr4_0 = C::value_regs(ctx, expr0_0, expr3_0); - let expr5_0 = C::output(ctx, expr4_0); - return Some(expr5_0); - } - &Opcode::Sextend => { - if let Some(pattern7_0) = C::def_inst(ctx, pattern5_1) { - let pattern8_0 = C::inst_data(ctx, pattern7_0); - if let &InstructionData::BinaryImm8 { - opcode: ref pattern9_0, - arg: pattern9_1, - imm: pattern9_2, - } = &pattern8_0 - { - if let &Opcode::Extractlane = pattern9_0 { - let pattern11_0 = C::value_type(ctx, pattern9_1); - if pattern11_0 == I64X2 { - let pattern13_0 = C::u8_from_uimm8(ctx, pattern9_2); - // Rule at src/isa/aarch64/lower.isle line 552. - let expr0_0 = C::put_in_reg(ctx, pattern9_1); - let expr1_0 = VectorSize::Size64x2; - let expr2_0 = constructor_mov_from_vec( - ctx, - expr0_0, - pattern13_0, - &expr1_0, - )?; - let expr3_0: Type = I64; - let expr4_0: u8 = 63; - let expr5_0 = C::imm_shift_from_u8(ctx, expr4_0); - let expr6_0 = constructor_asr_imm( - ctx, expr3_0, expr2_0, expr5_0, - )?; - let expr7_0 = C::value_regs(ctx, expr2_0, expr6_0); - let expr8_0 = C::output(ctx, expr7_0); - return Some(expr8_0); - } - if let Some(()) = C::not_i64x2(ctx, pattern11_0) { - let pattern13_0 = C::u8_from_uimm8(ctx, pattern9_2); - // Rule at src/isa/aarch64/lower.isle line 541. - let expr0_0 = C::put_in_reg(ctx, pattern9_1); - let expr1_0 = - constructor_vector_size(ctx, pattern11_0)?; - let expr2_0: Type = I64; - let expr3_0 = constructor_size_from_ty(ctx, expr2_0)?; - let expr4_0 = constructor_mov_from_vec_signed( - ctx, - expr0_0, - pattern13_0, - &expr1_0, - &expr3_0, - )?; - let expr5_0: Type = I64; - let expr6_0: u8 = 63; - let expr7_0 = C::imm_shift_from_u8(ctx, expr6_0); - let expr8_0 = constructor_asr_imm( - ctx, expr5_0, expr4_0, expr7_0, - )?; - let expr9_0 = C::value_regs(ctx, expr4_0, expr8_0); - let expr10_0 = C::output(ctx, expr9_0); - return Some(expr10_0); - } - } - } - } - // Rule at src/isa/aarch64/lower.isle line 531. - let expr0_0 = constructor_put_in_reg_sext64(ctx, pattern5_1)?; - let expr1_0: Type = I64; - let expr2_0: u8 = 63; - let expr3_0 = C::imm_shift_from_u8(ctx, expr2_0); - let expr4_0 = constructor_asr_imm(ctx, expr1_0, expr0_0, expr3_0)?; - let expr5_0 = C::value_regs(ctx, expr0_0, expr4_0); - let expr6_0 = C::output(ctx, expr5_0); - return Some(expr6_0); - } - _ => {} - } - } - _ => {} - } - } - if pattern2_0 == I8X16 { - let pattern4_0 = C::inst_data(ctx, pattern0_0); - if let &InstructionData::Unary { - opcode: ref pattern5_0, - arg: pattern5_1, - } = &pattern4_0 - { - if let &Opcode::Popcnt = pattern5_0 { - // Rule at src/isa/aarch64/lower.isle line 1142. - let expr0_0 = C::put_in_reg(ctx, pattern5_1); - let expr1_0 = VectorSize::Size8x16; - let expr2_0 = constructor_vec_cnt(ctx, expr0_0, &expr1_0)?; - let expr3_0 = constructor_output_reg(ctx, expr2_0)?; - return Some(expr3_0); - } - } - } - if pattern2_0 == I16X8 { - let pattern4_0 = C::inst_data(ctx, pattern0_0); - if let &InstructionData::Binary { - opcode: ref pattern5_0, - args: ref pattern5_1, - } = &pattern4_0 - { - if let &Opcode::Imul = pattern5_0 { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - if let Some(pattern8_0) = C::def_inst(ctx, pattern7_0) { - let pattern9_0 = C::inst_data(ctx, pattern8_0); - if let &InstructionData::Unary { - opcode: ref pattern10_0, - arg: pattern10_1, - } = &pattern9_0 - { - match pattern10_0 { - &Opcode::SwidenLow => { - let pattern12_0 = C::value_type(ctx, pattern10_1); - if pattern12_0 == I8X16 { - if let Some(pattern14_0) = C::def_inst(ctx, pattern7_1) { - let pattern15_0 = C::inst_data(ctx, pattern14_0); - if let &InstructionData::Unary { - opcode: ref pattern16_0, - arg: pattern16_1, - } = &pattern15_0 - { - if let &Opcode::SwidenLow = pattern16_0 { - let pattern18_0 = - C::value_type(ctx, pattern16_1); - if pattern18_0 == I8X16 { - // Rule at src/isa/aarch64/lower.isle line 289. - let expr0_0 = - C::put_in_reg(ctx, pattern10_1); - let expr1_0 = - C::put_in_reg(ctx, pattern16_1); - let expr2_0: bool = false; - let expr3_0 = constructor_smull8( - ctx, expr0_0, expr1_0, expr2_0, - )?; - let expr4_0 = - constructor_output_reg(ctx, expr3_0)?; - return Some(expr4_0); - } - } - } - } - } - } - &Opcode::SwidenHigh => { - let pattern12_0 = C::value_type(ctx, pattern10_1); - if pattern12_0 == I8X16 { - if let Some(pattern14_0) = C::def_inst(ctx, pattern7_1) { - let pattern15_0 = C::inst_data(ctx, pattern14_0); - if let &InstructionData::Unary { - opcode: ref pattern16_0, - arg: pattern16_1, - } = &pattern15_0 - { - if let &Opcode::SwidenHigh = pattern16_0 { - let pattern18_0 = - C::value_type(ctx, pattern16_1); - if pattern18_0 == I8X16 { - // Rule at src/isa/aarch64/lower.isle line 295. - let expr0_0 = - C::put_in_reg(ctx, pattern10_1); - let expr1_0 = - C::put_in_reg(ctx, pattern16_1); - let expr2_0: bool = true; - let expr3_0 = constructor_smull8( - ctx, expr0_0, expr1_0, expr2_0, - )?; - let expr4_0 = - constructor_output_reg(ctx, expr3_0)?; - return Some(expr4_0); - } - } - } - } - } - } - &Opcode::UwidenLow => { - let pattern12_0 = C::value_type(ctx, pattern10_1); - if pattern12_0 == I8X16 { - if let Some(pattern14_0) = C::def_inst(ctx, pattern7_1) { - let pattern15_0 = C::inst_data(ctx, pattern14_0); - if let &InstructionData::Unary { - opcode: ref pattern16_0, - arg: pattern16_1, - } = &pattern15_0 - { - if let &Opcode::UwidenLow = pattern16_0 { - let pattern18_0 = - C::value_type(ctx, pattern16_1); - if pattern18_0 == I8X16 { - // Rule at src/isa/aarch64/lower.isle line 301. - let expr0_0 = - C::put_in_reg(ctx, pattern10_1); - let expr1_0 = - C::put_in_reg(ctx, pattern16_1); - let expr2_0: bool = false; - let expr3_0 = constructor_umull8( - ctx, expr0_0, expr1_0, expr2_0, - )?; - let expr4_0 = - constructor_output_reg(ctx, expr3_0)?; - return Some(expr4_0); - } - } - } - } - } - } - &Opcode::UwidenHigh => { - let pattern12_0 = C::value_type(ctx, pattern10_1); - if pattern12_0 == I8X16 { - if let Some(pattern14_0) = C::def_inst(ctx, pattern7_1) { - let pattern15_0 = C::inst_data(ctx, pattern14_0); - if let &InstructionData::Unary { - opcode: ref pattern16_0, - arg: pattern16_1, - } = &pattern15_0 - { - if let &Opcode::UwidenHigh = pattern16_0 { - let pattern18_0 = - C::value_type(ctx, pattern16_1); - if pattern18_0 == I8X16 { - // Rule at src/isa/aarch64/lower.isle line 307. - let expr0_0 = - C::put_in_reg(ctx, pattern10_1); - let expr1_0 = - C::put_in_reg(ctx, pattern16_1); - let expr2_0: bool = true; - let expr3_0 = constructor_umull8( - ctx, expr0_0, expr1_0, expr2_0, - )?; - let expr4_0 = - constructor_output_reg(ctx, expr3_0)?; - return Some(expr4_0); - } - } - } - } - } - } - _ => {} - } - } - } - } - } - } - if pattern2_0 == I32X4 { - let pattern4_0 = C::inst_data(ctx, pattern0_0); - if let &InstructionData::Binary { - opcode: ref pattern5_0, - args: ref pattern5_1, - } = &pattern4_0 - { - if let &Opcode::Imul = pattern5_0 { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - if let Some(pattern8_0) = C::def_inst(ctx, pattern7_0) { - let pattern9_0 = C::inst_data(ctx, pattern8_0); - if let &InstructionData::Unary { - opcode: ref pattern10_0, - arg: pattern10_1, - } = &pattern9_0 - { - match pattern10_0 { - &Opcode::SwidenLow => { - let pattern12_0 = C::value_type(ctx, pattern10_1); - if pattern12_0 == I16X8 { - if let Some(pattern14_0) = C::def_inst(ctx, pattern7_1) { - let pattern15_0 = C::inst_data(ctx, pattern14_0); - if let &InstructionData::Unary { - opcode: ref pattern16_0, - arg: pattern16_1, - } = &pattern15_0 - { - if let &Opcode::SwidenLow = pattern16_0 { - let pattern18_0 = - C::value_type(ctx, pattern16_1); - if pattern18_0 == I16X8 { - // Rule at src/isa/aarch64/lower.isle line 313. - let expr0_0 = - C::put_in_reg(ctx, pattern10_1); - let expr1_0 = - C::put_in_reg(ctx, pattern16_1); - let expr2_0: bool = false; - let expr3_0 = constructor_smull16( - ctx, expr0_0, expr1_0, expr2_0, - )?; - let expr4_0 = - constructor_output_reg(ctx, expr3_0)?; - return Some(expr4_0); - } - } - } - } - } - } - &Opcode::SwidenHigh => { - let pattern12_0 = C::value_type(ctx, pattern10_1); - if pattern12_0 == I16X8 { - if let Some(pattern14_0) = C::def_inst(ctx, pattern7_1) { - let pattern15_0 = C::inst_data(ctx, pattern14_0); - if let &InstructionData::Unary { - opcode: ref pattern16_0, - arg: pattern16_1, - } = &pattern15_0 - { - if let &Opcode::SwidenHigh = pattern16_0 { - let pattern18_0 = - C::value_type(ctx, pattern16_1); - if pattern18_0 == I16X8 { - // Rule at src/isa/aarch64/lower.isle line 319. - let expr0_0 = - C::put_in_reg(ctx, pattern10_1); - let expr1_0 = - C::put_in_reg(ctx, pattern16_1); - let expr2_0: bool = true; - let expr3_0 = constructor_smull16( - ctx, expr0_0, expr1_0, expr2_0, - )?; - let expr4_0 = - constructor_output_reg(ctx, expr3_0)?; - return Some(expr4_0); - } - } - } - } - } - } - &Opcode::UwidenLow => { - let pattern12_0 = C::value_type(ctx, pattern10_1); - if pattern12_0 == I16X8 { - if let Some(pattern14_0) = C::def_inst(ctx, pattern7_1) { - let pattern15_0 = C::inst_data(ctx, pattern14_0); - if let &InstructionData::Unary { - opcode: ref pattern16_0, - arg: pattern16_1, - } = &pattern15_0 - { - if let &Opcode::UwidenLow = pattern16_0 { - let pattern18_0 = - C::value_type(ctx, pattern16_1); - if pattern18_0 == I16X8 { - // Rule at src/isa/aarch64/lower.isle line 325. - let expr0_0 = - C::put_in_reg(ctx, pattern10_1); - let expr1_0 = - C::put_in_reg(ctx, pattern16_1); - let expr2_0: bool = false; - let expr3_0 = constructor_umull16( - ctx, expr0_0, expr1_0, expr2_0, - )?; - let expr4_0 = - constructor_output_reg(ctx, expr3_0)?; - return Some(expr4_0); - } - } - } - } - } - } - &Opcode::UwidenHigh => { - let pattern12_0 = C::value_type(ctx, pattern10_1); - if pattern12_0 == I16X8 { - if let Some(pattern14_0) = C::def_inst(ctx, pattern7_1) { - let pattern15_0 = C::inst_data(ctx, pattern14_0); - if let &InstructionData::Unary { - opcode: ref pattern16_0, - arg: pattern16_1, - } = &pattern15_0 - { - if let &Opcode::UwidenHigh = pattern16_0 { - let pattern18_0 = - C::value_type(ctx, pattern16_1); - if pattern18_0 == I16X8 { - // Rule at src/isa/aarch64/lower.isle line 331. - let expr0_0 = - C::put_in_reg(ctx, pattern10_1); - let expr1_0 = - C::put_in_reg(ctx, pattern16_1); - let expr2_0: bool = true; - let expr3_0 = constructor_umull16( - ctx, expr0_0, expr1_0, expr2_0, - )?; - let expr4_0 = - constructor_output_reg(ctx, expr3_0)?; - return Some(expr4_0); - } - } - } - } - } - } - _ => {} - } - } - } - } - } - } - if pattern2_0 == I64X2 { - let pattern4_0 = C::inst_data(ctx, pattern0_0); - if let &InstructionData::Binary { - opcode: ref pattern5_0, - args: ref pattern5_1, - } = &pattern4_0 - { - if let &Opcode::Imul = pattern5_0 { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - if let Some(pattern8_0) = C::def_inst(ctx, pattern7_0) { - let pattern9_0 = C::inst_data(ctx, pattern8_0); - if let &InstructionData::Unary { - opcode: ref pattern10_0, - arg: pattern10_1, - } = &pattern9_0 - { - match pattern10_0 { - &Opcode::SwidenLow => { - let pattern12_0 = C::value_type(ctx, pattern10_1); - if pattern12_0 == I32X4 { - if let Some(pattern14_0) = C::def_inst(ctx, pattern7_1) { - let pattern15_0 = C::inst_data(ctx, pattern14_0); - if let &InstructionData::Unary { - opcode: ref pattern16_0, - arg: pattern16_1, - } = &pattern15_0 - { - if let &Opcode::SwidenLow = pattern16_0 { - let pattern18_0 = - C::value_type(ctx, pattern16_1); - if pattern18_0 == I32X4 { - // Rule at src/isa/aarch64/lower.isle line 337. - let expr0_0 = - C::put_in_reg(ctx, pattern10_1); - let expr1_0 = - C::put_in_reg(ctx, pattern16_1); - let expr2_0: bool = false; - let expr3_0 = constructor_smull32( - ctx, expr0_0, expr1_0, expr2_0, - )?; - let expr4_0 = - constructor_output_reg(ctx, expr3_0)?; - return Some(expr4_0); - } - } - } - } - } - } - &Opcode::SwidenHigh => { - let pattern12_0 = C::value_type(ctx, pattern10_1); - if pattern12_0 == I32X4 { - if let Some(pattern14_0) = C::def_inst(ctx, pattern7_1) { - let pattern15_0 = C::inst_data(ctx, pattern14_0); - if let &InstructionData::Unary { - opcode: ref pattern16_0, - arg: pattern16_1, - } = &pattern15_0 - { - if let &Opcode::SwidenHigh = pattern16_0 { - let pattern18_0 = - C::value_type(ctx, pattern16_1); - if pattern18_0 == I32X4 { - // Rule at src/isa/aarch64/lower.isle line 343. - let expr0_0 = - C::put_in_reg(ctx, pattern10_1); - let expr1_0 = - C::put_in_reg(ctx, pattern16_1); - let expr2_0: bool = true; - let expr3_0 = constructor_smull32( - ctx, expr0_0, expr1_0, expr2_0, - )?; - let expr4_0 = - constructor_output_reg(ctx, expr3_0)?; - return Some(expr4_0); - } - } - } - } - } - } - &Opcode::UwidenLow => { - let pattern12_0 = C::value_type(ctx, pattern10_1); - if pattern12_0 == I32X4 { - if let Some(pattern14_0) = C::def_inst(ctx, pattern7_1) { - let pattern15_0 = C::inst_data(ctx, pattern14_0); - if let &InstructionData::Unary { - opcode: ref pattern16_0, - arg: pattern16_1, - } = &pattern15_0 - { - if let &Opcode::UwidenLow = pattern16_0 { - let pattern18_0 = - C::value_type(ctx, pattern16_1); - if pattern18_0 == I32X4 { - // Rule at src/isa/aarch64/lower.isle line 349. - let expr0_0 = - C::put_in_reg(ctx, pattern10_1); - let expr1_0 = - C::put_in_reg(ctx, pattern16_1); - let expr2_0: bool = false; - let expr3_0 = constructor_umull32( - ctx, expr0_0, expr1_0, expr2_0, - )?; - let expr4_0 = - constructor_output_reg(ctx, expr3_0)?; - return Some(expr4_0); - } - } - } - } - } - } - &Opcode::UwidenHigh => { - let pattern12_0 = C::value_type(ctx, pattern10_1); - if pattern12_0 == I32X4 { - if let Some(pattern14_0) = C::def_inst(ctx, pattern7_1) { - let pattern15_0 = C::inst_data(ctx, pattern14_0); - if let &InstructionData::Unary { - opcode: ref pattern16_0, - arg: pattern16_1, - } = &pattern15_0 - { - if let &Opcode::UwidenHigh = pattern16_0 { - let pattern18_0 = - C::value_type(ctx, pattern16_1); - if pattern18_0 == I32X4 { - // Rule at src/isa/aarch64/lower.isle line 355. - let expr0_0 = - C::put_in_reg(ctx, pattern10_1); - let expr1_0 = - C::put_in_reg(ctx, pattern16_1); - let expr2_0: bool = true; - let expr3_0 = constructor_umull32( - ctx, expr0_0, expr1_0, expr2_0, - )?; - let expr4_0 = - constructor_output_reg(ctx, expr3_0)?; - return Some(expr4_0); - } - } - } - } - } - } - _ => {} - } - } - } - // Rule at src/isa/aarch64/lower.isle line 250. - let expr0_0 = C::put_in_reg(ctx, pattern7_0); - let expr1_0 = C::put_in_reg(ctx, pattern7_1); - let expr2_0 = VectorSize::Size32x4; - let expr3_0 = constructor_rev64(ctx, expr1_0, &expr2_0)?; - let expr4_0 = VectorSize::Size32x4; - let expr5_0 = constructor_mul(ctx, expr3_0, expr0_0, &expr4_0)?; - let expr6_0: bool = false; - let expr7_0 = constructor_xtn64(ctx, expr0_0, expr6_0)?; - let expr8_0 = VectorSize::Size32x4; - let expr9_0 = constructor_addp(ctx, expr5_0, expr5_0, &expr8_0)?; - let expr10_0: bool = false; - let expr11_0 = constructor_xtn64(ctx, expr1_0, expr10_0)?; - let expr12_0: bool = false; - let expr13_0 = constructor_shll32(ctx, expr9_0, expr12_0)?; - let expr14_0: bool = false; - let expr15_0 = constructor_umlal32(ctx, expr13_0, expr11_0, expr7_0, expr14_0)?; - let expr16_0 = constructor_output_reg(ctx, expr15_0)?; - return Some(expr16_0); - } - } - } - let pattern3_0 = C::inst_data(ctx, pattern0_0); - match &pattern3_0 { - &InstructionData::NullAry { - opcode: ref pattern4_0, - } => { - if let &Opcode::Null = pattern4_0 { - // Rule at src/isa/aarch64/lower.isle line 22. - let expr0_0: u64 = 0; - let expr1_0 = constructor_imm(ctx, pattern2_0, expr0_0)?; - let expr2_0 = constructor_output_reg(ctx, expr1_0)?; - return Some(expr2_0); - } - } - &InstructionData::UnaryImm { - opcode: ref pattern4_0, - imm: pattern4_1, - } => { - if let &Opcode::Iconst = pattern4_0 { - let pattern6_0 = C::u64_from_imm64(ctx, pattern4_1); - // Rule at src/isa/aarch64/lower.isle line 9. - let expr0_0 = constructor_imm(ctx, pattern2_0, pattern6_0)?; - let expr1_0 = constructor_output_reg(ctx, expr0_0)?; - return Some(expr1_0); - } - } - &InstructionData::UnaryBool { - opcode: ref pattern4_0, - imm: pattern4_1, - } => { - if let &Opcode::Bconst = pattern4_0 { - if pattern4_1 == true { - // Rule at src/isa/aarch64/lower.isle line 17. - let expr0_0: u64 = 1; - let expr1_0 = constructor_imm(ctx, pattern2_0, expr0_0)?; - let expr2_0 = constructor_output_reg(ctx, expr1_0)?; - return Some(expr2_0); - } - if pattern4_1 == false { - // Rule at src/isa/aarch64/lower.isle line 14. - let expr0_0: u64 = 0; - let expr1_0 = constructor_imm(ctx, pattern2_0, expr0_0)?; - let expr2_0 = constructor_output_reg(ctx, expr1_0)?; - return Some(expr2_0); - } - } - } - &InstructionData::Unary { - opcode: ref pattern4_0, - arg: pattern4_1, - } => { - match pattern4_0 { - &Opcode::Bitrev => { - // Rule at src/isa/aarch64/lower.isle line 1006. - let expr0_0 = C::put_in_reg(ctx, pattern4_1); - let expr1_0 = constructor_rbit(ctx, pattern2_0, expr0_0)?; - let expr2_0 = constructor_output_reg(ctx, expr1_0)?; - return Some(expr2_0); - } - &Opcode::Clz => { - // Rule at src/isa/aarch64/lower.isle line 1021. - let expr0_0 = C::put_in_reg(ctx, pattern4_1); - let expr1_0 = constructor_a64_clz(ctx, pattern2_0, expr0_0)?; - let expr2_0 = constructor_output_reg(ctx, expr1_0)?; - return Some(expr2_0); - } - &Opcode::Cls => { - // Rule at src/isa/aarch64/lower.isle line 1088. - let expr0_0 = C::put_in_reg(ctx, pattern4_1); - let expr1_0 = constructor_a64_cls(ctx, pattern2_0, expr0_0)?; - let expr2_0 = constructor_output_reg(ctx, expr1_0)?; - return Some(expr2_0); - } - &Opcode::Ctz => { - // Rule at src/isa/aarch64/lower.isle line 1054. - let expr0_0 = C::put_in_reg(ctx, pattern4_1); - let expr1_0 = constructor_rbit(ctx, pattern2_0, expr0_0)?; - let expr2_0 = constructor_a64_clz(ctx, pattern2_0, expr1_0)?; - let expr3_0 = constructor_output_reg(ctx, expr2_0)?; - return Some(expr3_0); - } - _ => {} - } - } - _ => {} - } - if let Some((pattern3_0, pattern3_1)) = C::multi_lane(ctx, pattern2_0) { - let pattern4_0 = C::inst_data(ctx, pattern0_0); - match &pattern4_0 { - &InstructionData::Binary { - opcode: ref pattern5_0, - args: ref pattern5_1, - } => { - match pattern5_0 { - &Opcode::Iadd => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/aarch64/lower.isle line 81. - let expr0_0 = C::put_in_reg(ctx, pattern7_0); - let expr1_0 = C::put_in_reg(ctx, pattern7_1); - let expr2_0 = constructor_vector_size(ctx, pattern2_0)?; - let expr3_0 = constructor_add_vec(ctx, expr0_0, expr1_0, &expr2_0)?; - let expr4_0 = constructor_output_reg(ctx, expr3_0)?; - return Some(expr4_0); - } - &Opcode::Isub => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/aarch64/lower.isle line 132. - let expr0_0 = C::put_in_reg(ctx, pattern7_0); - let expr1_0 = C::put_in_reg(ctx, pattern7_1); - let expr2_0 = constructor_vector_size(ctx, pattern2_0)?; - let expr3_0 = constructor_sub_vec(ctx, expr0_0, expr1_0, &expr2_0)?; - let expr4_0 = constructor_output_reg(ctx, expr3_0)?; - return Some(expr4_0); - } - _ => {} - } - } - &InstructionData::FloatCompare { - opcode: ref pattern5_0, - args: ref pattern5_1, - cond: ref pattern5_2, - } => { - if let &Opcode::Fcmp = pattern5_0 { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - if let Some(pattern8_0) = C::def_inst(ctx, pattern7_0) { - let pattern9_0 = C::inst_data(ctx, pattern8_0); - if let &InstructionData::Unary { - opcode: ref pattern10_0, - arg: pattern10_1, - } = &pattern9_0 - { - if let &Opcode::Splat = pattern10_0 { - if let Some(pattern12_0) = C::def_inst(ctx, pattern10_1) { - let pattern13_0 = C::inst_data(ctx, pattern12_0); - match &pattern13_0 { - &InstructionData::UnaryIeee32 { - opcode: ref pattern14_0, - imm: pattern14_1, - } => { - if let &Opcode::F32const = pattern14_0 { - if let Some(pattern16_0) = - C::zero_value_f32(ctx, pattern14_1) - { - if let Some(pattern17_0) = - C::fcmp_zero_cond(ctx, pattern5_2) - { - // Rule at src/isa/aarch64/lower.isle line 1162. - let expr0_0 = - C::put_in_reg(ctx, pattern7_1); - let expr1_0 = constructor_vector_size( - ctx, pattern2_0, - )?; - let expr2_0 = - constructor_float_cmp_zero_swap( - ctx, - &pattern17_0, - expr0_0, - &expr1_0, - )?; - let expr3_0 = - C::value_reg(ctx, expr2_0); - let expr4_0 = C::output(ctx, expr3_0); - return Some(expr4_0); - } - if let Some(pattern17_0) = - C::fcmp_zero_cond_not_eq( - ctx, pattern5_2, - ) - { - // Rule at src/isa/aarch64/lower.isle line 1157. - let expr0_0 = - C::put_in_reg(ctx, pattern7_1); - let expr1_0 = constructor_vector_size( - ctx, pattern2_0, - )?; - let expr2_0 = constructor_fcmeq0( - ctx, expr0_0, &expr1_0, - )?; - let expr3_0 = constructor_not( - ctx, expr2_0, &expr1_0, - )?; - let expr4_0 = - C::value_reg(ctx, expr3_0); - let expr5_0 = C::output(ctx, expr4_0); - return Some(expr5_0); - } - } - } - } - &InstructionData::UnaryIeee64 { - opcode: ref pattern14_0, - imm: pattern14_1, - } => { - if let &Opcode::F64const = pattern14_0 { - if let Some(pattern16_0) = - C::zero_value_f64(ctx, pattern14_1) - { - if let Some(pattern17_0) = - C::fcmp_zero_cond(ctx, pattern5_2) - { - // Rule at src/isa/aarch64/lower.isle line 1184. - let expr0_0 = - C::put_in_reg(ctx, pattern7_1); - let expr1_0 = constructor_vector_size( - ctx, pattern2_0, - )?; - let expr2_0 = - constructor_float_cmp_zero_swap( - ctx, - &pattern17_0, - expr0_0, - &expr1_0, - )?; - let expr3_0 = - C::value_reg(ctx, expr2_0); - let expr4_0 = C::output(ctx, expr3_0); - return Some(expr4_0); - } - if let Some(pattern17_0) = - C::fcmp_zero_cond_not_eq( - ctx, pattern5_2, - ) - { - // Rule at src/isa/aarch64/lower.isle line 1179. - let expr0_0 = - C::put_in_reg(ctx, pattern7_1); - let expr1_0 = constructor_vector_size( - ctx, pattern2_0, - )?; - let expr2_0 = constructor_fcmeq0( - ctx, expr0_0, &expr1_0, - )?; - let expr3_0 = constructor_not( - ctx, expr2_0, &expr1_0, - )?; - let expr4_0 = - C::value_reg(ctx, expr3_0); - let expr5_0 = C::output(ctx, expr4_0); - return Some(expr5_0); - } - } - } - } - _ => {} - } - } - } - } - } - if let Some(pattern8_0) = C::def_inst(ctx, pattern7_1) { - let pattern9_0 = C::inst_data(ctx, pattern8_0); - if let &InstructionData::Unary { - opcode: ref pattern10_0, - arg: pattern10_1, - } = &pattern9_0 - { - if let &Opcode::Splat = pattern10_0 { - if let Some(pattern12_0) = C::def_inst(ctx, pattern10_1) { - let pattern13_0 = C::inst_data(ctx, pattern12_0); - match &pattern13_0 { - &InstructionData::UnaryIeee32 { - opcode: ref pattern14_0, - imm: pattern14_1, - } => { - if let &Opcode::F32const = pattern14_0 { - if let Some(pattern16_0) = - C::zero_value_f32(ctx, pattern14_1) - { - if let Some(pattern17_0) = - C::fcmp_zero_cond(ctx, pattern5_2) - { - // Rule at src/isa/aarch64/lower.isle line 1152. - let expr0_0 = - C::put_in_reg(ctx, pattern7_0); - let expr1_0 = constructor_vector_size( - ctx, pattern2_0, - )?; - let expr2_0 = - constructor_float_cmp_zero( - ctx, - &pattern17_0, - expr0_0, - &expr1_0, - )?; - let expr3_0 = - C::value_reg(ctx, expr2_0); - let expr4_0 = C::output(ctx, expr3_0); - return Some(expr4_0); - } - if let Some(pattern17_0) = - C::fcmp_zero_cond_not_eq( - ctx, pattern5_2, - ) - { - // Rule at src/isa/aarch64/lower.isle line 1147. - let expr0_0 = - C::put_in_reg(ctx, pattern7_0); - let expr1_0 = constructor_vector_size( - ctx, pattern2_0, - )?; - let expr2_0 = constructor_fcmeq0( - ctx, expr0_0, &expr1_0, - )?; - let expr3_0 = constructor_not( - ctx, expr2_0, &expr1_0, - )?; - let expr4_0 = - C::value_reg(ctx, expr3_0); - let expr5_0 = C::output(ctx, expr4_0); - return Some(expr5_0); - } - } - } - } - &InstructionData::UnaryIeee64 { - opcode: ref pattern14_0, - imm: pattern14_1, - } => { - if let &Opcode::F64const = pattern14_0 { - if let Some(pattern16_0) = - C::zero_value_f64(ctx, pattern14_1) - { - if let Some(pattern17_0) = - C::fcmp_zero_cond(ctx, pattern5_2) - { - // Rule at src/isa/aarch64/lower.isle line 1174. - let expr0_0 = - C::put_in_reg(ctx, pattern7_0); - let expr1_0 = constructor_vector_size( - ctx, pattern2_0, - )?; - let expr2_0 = - constructor_float_cmp_zero( - ctx, - &pattern17_0, - expr0_0, - &expr1_0, - )?; - let expr3_0 = - C::value_reg(ctx, expr2_0); - let expr4_0 = C::output(ctx, expr3_0); - return Some(expr4_0); - } - if let Some(pattern17_0) = - C::fcmp_zero_cond_not_eq( - ctx, pattern5_2, - ) - { - // Rule at src/isa/aarch64/lower.isle line 1169. - let expr0_0 = - C::put_in_reg(ctx, pattern7_0); - let expr1_0 = constructor_vector_size( - ctx, pattern2_0, - )?; - let expr2_0 = constructor_fcmeq0( - ctx, expr0_0, &expr1_0, - )?; - let expr3_0 = constructor_not( - ctx, expr2_0, &expr1_0, - )?; - let expr4_0 = - C::value_reg(ctx, expr3_0); - let expr5_0 = C::output(ctx, expr4_0); - return Some(expr5_0); - } - } - } - } - _ => {} - } - } - } - } - } - } - } - &InstructionData::IntCompare { - opcode: ref pattern5_0, - args: ref pattern5_1, - cond: ref pattern5_2, - } => { - if let &Opcode::Icmp = pattern5_0 { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - if let Some(pattern8_0) = C::def_inst(ctx, pattern7_0) { - let pattern9_0 = C::inst_data(ctx, pattern8_0); - if let &InstructionData::Unary { - opcode: ref pattern10_0, - arg: pattern10_1, - } = &pattern9_0 - { - if let &Opcode::Splat = pattern10_0 { - if let Some(pattern12_0) = C::def_inst(ctx, pattern10_1) { - let pattern13_0 = C::inst_data(ctx, pattern12_0); - if let &InstructionData::UnaryImm { - opcode: ref pattern14_0, - imm: pattern14_1, - } = &pattern13_0 - { - if let &Opcode::Iconst = pattern14_0 { - if let Some(pattern16_0) = - C::zero_value(ctx, pattern14_1) - { - if let Some(pattern17_0) = - C::icmp_zero_cond(ctx, pattern5_2) - { - // Rule at src/isa/aarch64/lower.isle line 1206. - let expr0_0 = - C::put_in_reg(ctx, pattern7_1); - let expr1_0 = constructor_vector_size( - ctx, pattern2_0, - )?; - let expr2_0 = - constructor_int_cmp_zero_swap( - ctx, - &pattern17_0, - expr0_0, - &expr1_0, - )?; - let expr3_0 = C::value_reg(ctx, expr2_0); - let expr4_0 = C::output(ctx, expr3_0); - return Some(expr4_0); - } - if let Some(pattern17_0) = - C::icmp_zero_cond_not_eq(ctx, pattern5_2) - { - // Rule at src/isa/aarch64/lower.isle line 1201. - let expr0_0 = - C::put_in_reg(ctx, pattern7_1); - let expr1_0 = constructor_vector_size( - ctx, pattern2_0, - )?; - let expr2_0 = constructor_cmeq0( - ctx, expr0_0, &expr1_0, - )?; - let expr3_0 = constructor_not( - ctx, expr2_0, &expr1_0, - )?; - let expr4_0 = C::value_reg(ctx, expr3_0); - let expr5_0 = C::output(ctx, expr4_0); - return Some(expr5_0); - } - } - } - } - } - } - } - } - if let Some(pattern8_0) = C::def_inst(ctx, pattern7_1) { - let pattern9_0 = C::inst_data(ctx, pattern8_0); - if let &InstructionData::Unary { - opcode: ref pattern10_0, - arg: pattern10_1, - } = &pattern9_0 - { - if let &Opcode::Splat = pattern10_0 { - if let Some(pattern12_0) = C::def_inst(ctx, pattern10_1) { - let pattern13_0 = C::inst_data(ctx, pattern12_0); - if let &InstructionData::UnaryImm { - opcode: ref pattern14_0, - imm: pattern14_1, - } = &pattern13_0 - { - if let &Opcode::Iconst = pattern14_0 { - if let Some(pattern16_0) = - C::zero_value(ctx, pattern14_1) - { - if let Some(pattern17_0) = - C::icmp_zero_cond(ctx, pattern5_2) - { - // Rule at src/isa/aarch64/lower.isle line 1196. - let expr0_0 = - C::put_in_reg(ctx, pattern7_0); - let expr1_0 = constructor_vector_size( - ctx, pattern2_0, - )?; - let expr2_0 = constructor_int_cmp_zero( - ctx, - &pattern17_0, - expr0_0, - &expr1_0, - )?; - let expr3_0 = C::value_reg(ctx, expr2_0); - let expr4_0 = C::output(ctx, expr3_0); - return Some(expr4_0); - } - if let Some(pattern17_0) = - C::icmp_zero_cond_not_eq(ctx, pattern5_2) - { - // Rule at src/isa/aarch64/lower.isle line 1191. - let expr0_0 = - C::put_in_reg(ctx, pattern7_0); - let expr1_0 = constructor_vector_size( - ctx, pattern2_0, - )?; - let expr2_0 = constructor_cmeq0( - ctx, expr0_0, &expr1_0, - )?; - let expr3_0 = constructor_not( - ctx, expr2_0, &expr1_0, - )?; - let expr4_0 = C::value_reg(ctx, expr3_0); - let expr5_0 = C::output(ctx, expr4_0); - return Some(expr5_0); - } - } - } - } - } - } - } - } - } - } - _ => {} - } - } - if let Some(pattern3_0) = C::fits_in_16(ctx, pattern2_0) { - let pattern4_0 = C::inst_data(ctx, pattern0_0); - if let &InstructionData::Binary { - opcode: ref pattern5_0, - args: ref pattern5_1, - } = &pattern4_0 - { - match pattern5_0 { - &Opcode::Rotl => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - if let Some(pattern8_0) = C::def_inst(ctx, pattern7_1) { - let pattern9_0 = C::inst_data(ctx, pattern8_0); - if let &InstructionData::UnaryImm { - opcode: ref pattern10_0, - imm: pattern10_1, - } = &pattern9_0 - { - if let &Opcode::Iconst = pattern10_0 { - let mut closure12 = || { - let expr0_0 = - C::imm_shift_from_imm64(ctx, pattern3_0, pattern10_1)?; - return Some(expr0_0); - }; - if let Some(pattern12_0) = closure12() { - // Rule at src/isa/aarch64/lower.isle line 854. - let expr0_0 = - constructor_put_in_reg_zext32(ctx, pattern7_0)?; - let expr1_0 = - C::negate_imm_shift(ctx, pattern3_0, pattern12_0); - let expr2_0 = constructor_small_rotr_imm( - ctx, pattern3_0, expr0_0, expr1_0, - )?; - let expr3_0 = constructor_output_reg(ctx, expr2_0)?; - return Some(expr3_0); - } - } - } - } - // Rule at src/isa/aarch64/lower.isle line 849. - let expr0_0: Type = I32; - let expr1_0 = C::zero_reg(ctx); - let expr2_0 = C::put_in_reg(ctx, pattern7_1); - let expr3_0 = constructor_sub(ctx, expr0_0, expr1_0, expr2_0)?; - let expr4_0 = constructor_put_in_reg_zext32(ctx, pattern7_0)?; - let expr5_0 = constructor_small_rotr(ctx, pattern3_0, expr4_0, expr3_0)?; - let expr6_0 = constructor_output_reg(ctx, expr5_0)?; - return Some(expr6_0); - } - &Opcode::Rotr => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - if let Some(pattern8_0) = C::def_inst(ctx, pattern7_1) { - let pattern9_0 = C::inst_data(ctx, pattern8_0); - if let &InstructionData::UnaryImm { - opcode: ref pattern10_0, - imm: pattern10_1, - } = &pattern9_0 - { - if let &Opcode::Iconst = pattern10_0 { - let mut closure12 = || { - let expr0_0 = - C::imm_shift_from_imm64(ctx, pattern3_0, pattern10_1)?; - return Some(expr0_0); - }; - if let Some(pattern12_0) = closure12() { - // Rule at src/isa/aarch64/lower.isle line 917. - let expr0_0 = - constructor_put_in_reg_zext32(ctx, pattern7_0)?; - let expr1_0 = constructor_small_rotr_imm( - ctx, - pattern3_0, - expr0_0, - pattern12_0, - )?; - let expr2_0 = constructor_output_reg(ctx, expr1_0)?; - return Some(expr2_0); - } - } - } - } - // Rule at src/isa/aarch64/lower.isle line 905. - let expr0_0 = constructor_put_in_reg_zext32(ctx, pattern7_0)?; - let expr1_0 = C::put_in_reg(ctx, pattern7_1); - let expr2_0 = constructor_small_rotr(ctx, pattern3_0, expr0_0, expr1_0)?; - let expr3_0 = constructor_output_reg(ctx, expr2_0)?; - return Some(expr3_0); - } - _ => {} - } - } - } - if let Some(pattern3_0) = C::fits_in_32(ctx, pattern2_0) { - let pattern4_0 = C::inst_data(ctx, pattern0_0); - if let &InstructionData::Binary { - opcode: ref pattern5_0, - args: ref pattern5_1, - } = &pattern4_0 - { - match pattern5_0 { - &Opcode::Umulhi => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/aarch64/lower.isle line 377. - let expr0_0 = constructor_put_in_reg_zext64(ctx, pattern7_0)?; - let expr1_0 = constructor_put_in_reg_zext64(ctx, pattern7_1)?; - let expr2_0: Type = I64; - let expr3_0 = C::zero_reg(ctx); - let expr4_0 = constructor_madd(ctx, expr2_0, expr0_0, expr1_0, expr3_0)?; - let expr5_0: Type = I64; - let expr6_0 = C::ty_bits(ctx, pattern3_0)?; - let expr7_0 = C::imm_shift_from_u8(ctx, expr6_0); - let expr8_0 = constructor_lsr_imm(ctx, expr5_0, expr4_0, expr7_0)?; - let expr9_0 = C::value_reg(ctx, expr8_0); - let expr10_0 = C::output(ctx, expr9_0); - return Some(expr10_0); - } - &Opcode::Smulhi => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/aarch64/lower.isle line 365. - let expr0_0 = constructor_put_in_reg_sext64(ctx, pattern7_0)?; - let expr1_0 = constructor_put_in_reg_sext64(ctx, pattern7_1)?; - let expr2_0: Type = I64; - let expr3_0 = C::zero_reg(ctx); - let expr4_0 = constructor_madd(ctx, expr2_0, expr0_0, expr1_0, expr3_0)?; - let expr5_0: Type = I64; - let expr6_0 = C::ty_bits(ctx, pattern3_0)?; - let expr7_0 = C::imm_shift_from_u8(ctx, expr6_0); - let expr8_0 = constructor_asr_imm(ctx, expr5_0, expr4_0, expr7_0)?; - let expr9_0 = constructor_output_reg(ctx, expr8_0)?; - return Some(expr9_0); - } - &Opcode::Band => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/aarch64/lower.isle line 593. - let expr0_0 = ALUOp::And; - let expr1_0 = constructor_alu_rs_imm_logic_commutative( - ctx, &expr0_0, pattern3_0, pattern7_0, pattern7_1, - )?; - let expr2_0 = constructor_output_reg(ctx, expr1_0)?; - return Some(expr2_0); - } - &Opcode::Bor => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/aarch64/lower.isle line 606. - let expr0_0 = ALUOp::Orr; - let expr1_0 = constructor_alu_rs_imm_logic_commutative( - ctx, &expr0_0, pattern3_0, pattern7_0, pattern7_1, - )?; - let expr2_0 = constructor_output_reg(ctx, expr1_0)?; - return Some(expr2_0); - } - &Opcode::Bxor => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/aarch64/lower.isle line 619. - let expr0_0 = ALUOp::Eor; - let expr1_0 = constructor_alu_rs_imm_logic_commutative( - ctx, &expr0_0, pattern3_0, pattern7_0, pattern7_1, - )?; - let expr2_0 = constructor_output_reg(ctx, expr1_0)?; - return Some(expr2_0); - } - &Opcode::BandNot => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/aarch64/lower.isle line 632. - let expr0_0 = ALUOp::AndNot; - let expr1_0 = constructor_alu_rs_imm_logic( - ctx, &expr0_0, pattern3_0, pattern7_0, pattern7_1, - )?; - let expr2_0 = constructor_output_reg(ctx, expr1_0)?; - return Some(expr2_0); - } - &Opcode::BorNot => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/aarch64/lower.isle line 645. - let expr0_0 = ALUOp::OrrNot; - let expr1_0 = constructor_alu_rs_imm_logic( - ctx, &expr0_0, pattern3_0, pattern7_0, pattern7_1, - )?; - let expr2_0 = constructor_output_reg(ctx, expr1_0)?; - return Some(expr2_0); - } - &Opcode::BxorNot => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/aarch64/lower.isle line 655. - let expr0_0 = ALUOp::EorNot; - let expr1_0: Type = I32; - let expr2_0 = constructor_alu_rs_imm_logic( - ctx, &expr0_0, expr1_0, pattern7_0, pattern7_1, - )?; - let expr3_0 = constructor_output_reg(ctx, expr2_0)?; - return Some(expr3_0); - } - &Opcode::Ishl => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/aarch64/lower.isle line 666. - let expr0_0 = ALUOp::Lsl; - let expr1_0 = C::put_in_reg(ctx, pattern7_0); - let expr2_0 = - constructor_do_shift(ctx, &expr0_0, pattern3_0, expr1_0, pattern7_1)?; - let expr3_0 = constructor_output_reg(ctx, expr2_0)?; - return Some(expr3_0); - } - &Opcode::Ushr => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/aarch64/lower.isle line 751. - let expr0_0 = ALUOp::Lsr; - let expr1_0 = constructor_put_in_reg_zext32(ctx, pattern7_0)?; - let expr2_0 = - constructor_do_shift(ctx, &expr0_0, pattern3_0, expr1_0, pattern7_1)?; - let expr3_0 = constructor_output_reg(ctx, expr2_0)?; - return Some(expr3_0); - } - &Opcode::Sshr => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/aarch64/lower.isle line 798. - let expr0_0 = ALUOp::Asr; - let expr1_0 = constructor_put_in_reg_sext32(ctx, pattern7_0)?; - let expr2_0 = - constructor_do_shift(ctx, &expr0_0, pattern3_0, expr1_0, pattern7_1)?; - let expr3_0 = constructor_output_reg(ctx, expr2_0)?; - return Some(expr3_0); - } - _ => {} - } - } - } - if let Some(pattern3_0) = C::fits_in_64(ctx, pattern2_0) { - let pattern4_0 = C::inst_data(ctx, pattern0_0); - match &pattern4_0 { - &InstructionData::Binary { - opcode: ref pattern5_0, - args: ref pattern5_1, - } => { - match pattern5_0 { - &Opcode::Iadd => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - if let Some(pattern8_0) = C::def_inst(ctx, pattern7_0) { - let pattern9_0 = C::inst_data(ctx, pattern8_0); - match &pattern9_0 { - &InstructionData::UnaryImm { - opcode: ref pattern10_0, - imm: pattern10_1, - } => { - if let &Opcode::Iconst = pattern10_0 { - let pattern12_0 = C::u64_from_imm64(ctx, pattern10_1); - if let Some(pattern13_0) = - C::imm12_from_u64(ctx, pattern12_0) - { - // Rule at src/isa/aarch64/lower.isle line 37. - let expr0_0 = C::put_in_reg(ctx, pattern7_1); - let expr1_0 = constructor_add_imm( - ctx, - pattern3_0, - expr0_0, - pattern13_0, - )?; - let expr2_0 = constructor_output_reg(ctx, expr1_0)?; - return Some(expr2_0); - } - if let Some(pattern13_0) = - C::imm12_from_negated_u64(ctx, pattern12_0) - { - // Rule at src/isa/aarch64/lower.isle line 45. - let expr0_0 = C::put_in_reg(ctx, pattern7_1); - let expr1_0 = constructor_sub_imm( - ctx, - pattern3_0, - expr0_0, - pattern13_0, - )?; - let expr2_0 = constructor_output_reg(ctx, expr1_0)?; - return Some(expr2_0); - } - } - } - &InstructionData::Binary { - opcode: ref pattern10_0, - args: ref pattern10_1, - } => { - match pattern10_0 { - &Opcode::Imul => { - let (pattern12_0, pattern12_1) = - C::unpack_value_array_2(ctx, pattern10_1); - // Rule at src/isa/aarch64/lower.isle line 72. - let expr0_0 = C::put_in_reg(ctx, pattern12_0); - let expr1_0 = C::put_in_reg(ctx, pattern12_1); - let expr2_0 = C::put_in_reg(ctx, pattern7_1); - let expr3_0 = constructor_madd( - ctx, pattern3_0, expr0_0, expr1_0, expr2_0, - )?; - let expr4_0 = constructor_output_reg(ctx, expr3_0)?; - return Some(expr4_0); - } - &Opcode::Ishl => { - let (pattern12_0, pattern12_1) = - C::unpack_value_array_2(ctx, pattern10_1); - if let Some(pattern13_0) = - C::def_inst(ctx, pattern12_1) - { - let pattern14_0 = - C::inst_data(ctx, pattern13_0); - if let &InstructionData::UnaryImm { - opcode: ref pattern15_0, - imm: pattern15_1, - } = &pattern14_0 - { - if let &Opcode::Iconst = pattern15_0 { - let mut closure17 = || { - let expr0_0 = C::lshl_from_imm64( - ctx, - pattern3_0, - pattern15_1, - )?; - return Some(expr0_0); - }; - if let Some(pattern17_0) = closure17() { - // Rule at src/isa/aarch64/lower.isle line 63. - let expr0_0 = - C::put_in_reg(ctx, pattern7_1); - let expr1_0 = - C::put_in_reg(ctx, pattern12_0); - let expr2_0 = - constructor_add_shift( - ctx, - pattern3_0, - expr0_0, - expr1_0, - pattern17_0, - )?; - let expr3_0 = - constructor_output_reg( - ctx, expr2_0, - )?; - return Some(expr3_0); - } - } - } - } - } - _ => {} - } - } - _ => {} - } - } - if let Some(pattern8_0) = C::extended_value_from_value(ctx, pattern7_0) - { - // Rule at src/isa/aarch64/lower.isle line 53. - let expr0_0 = C::put_in_reg(ctx, pattern7_1); - let expr1_0 = - constructor_add_extend(ctx, pattern3_0, expr0_0, &pattern8_0)?; - let expr2_0 = constructor_output_reg(ctx, expr1_0)?; - return Some(expr2_0); - } - if let Some(pattern8_0) = C::def_inst(ctx, pattern7_1) { - let pattern9_0 = C::inst_data(ctx, pattern8_0); - match &pattern9_0 { - &InstructionData::UnaryImm { - opcode: ref pattern10_0, - imm: pattern10_1, - } => { - if let &Opcode::Iconst = pattern10_0 { - let pattern12_0 = C::u64_from_imm64(ctx, pattern10_1); - if let Some(pattern13_0) = - C::imm12_from_u64(ctx, pattern12_0) - { - // Rule at src/isa/aarch64/lower.isle line 34. - let expr0_0 = C::put_in_reg(ctx, pattern7_0); - let expr1_0 = constructor_add_imm( - ctx, - pattern3_0, - expr0_0, - pattern13_0, - )?; - let expr2_0 = constructor_output_reg(ctx, expr1_0)?; - return Some(expr2_0); - } - if let Some(pattern13_0) = - C::imm12_from_negated_u64(ctx, pattern12_0) - { - // Rule at src/isa/aarch64/lower.isle line 42. - let expr0_0 = C::put_in_reg(ctx, pattern7_0); - let expr1_0 = constructor_sub_imm( - ctx, - pattern3_0, - expr0_0, - pattern13_0, - )?; - let expr2_0 = constructor_output_reg(ctx, expr1_0)?; - return Some(expr2_0); - } - } - } - &InstructionData::Binary { - opcode: ref pattern10_0, - args: ref pattern10_1, - } => { - match pattern10_0 { - &Opcode::Imul => { - let (pattern12_0, pattern12_1) = - C::unpack_value_array_2(ctx, pattern10_1); - // Rule at src/isa/aarch64/lower.isle line 69. - let expr0_0 = C::put_in_reg(ctx, pattern12_0); - let expr1_0 = C::put_in_reg(ctx, pattern12_1); - let expr2_0 = C::put_in_reg(ctx, pattern7_0); - let expr3_0 = constructor_madd( - ctx, pattern3_0, expr0_0, expr1_0, expr2_0, - )?; - let expr4_0 = constructor_output_reg(ctx, expr3_0)?; - return Some(expr4_0); - } - &Opcode::Ishl => { - let (pattern12_0, pattern12_1) = - C::unpack_value_array_2(ctx, pattern10_1); - if let Some(pattern13_0) = - C::def_inst(ctx, pattern12_1) - { - let pattern14_0 = - C::inst_data(ctx, pattern13_0); - if let &InstructionData::UnaryImm { - opcode: ref pattern15_0, - imm: pattern15_1, - } = &pattern14_0 - { - if let &Opcode::Iconst = pattern15_0 { - let mut closure17 = || { - let expr0_0 = C::lshl_from_imm64( - ctx, - pattern3_0, - pattern15_1, - )?; - return Some(expr0_0); - }; - if let Some(pattern17_0) = closure17() { - // Rule at src/isa/aarch64/lower.isle line 58. - let expr0_0 = - C::put_in_reg(ctx, pattern7_0); - let expr1_0 = - C::put_in_reg(ctx, pattern12_0); - let expr2_0 = - constructor_add_shift( - ctx, - pattern3_0, - expr0_0, - expr1_0, - pattern17_0, - )?; - let expr3_0 = - constructor_output_reg( - ctx, expr2_0, - )?; - return Some(expr3_0); - } - } - } - } - } - _ => {} - } - } - _ => {} - } - } - if let Some(pattern8_0) = C::extended_value_from_value(ctx, pattern7_1) - { - // Rule at src/isa/aarch64/lower.isle line 50. - let expr0_0 = C::put_in_reg(ctx, pattern7_0); - let expr1_0 = - constructor_add_extend(ctx, pattern3_0, expr0_0, &pattern8_0)?; - let expr2_0 = constructor_output_reg(ctx, expr1_0)?; - return Some(expr2_0); - } - // Rule at src/isa/aarch64/lower.isle line 30. - let expr0_0 = C::put_in_reg(ctx, pattern7_0); - let expr1_0 = C::put_in_reg(ctx, pattern7_1); - let expr2_0 = constructor_add(ctx, pattern3_0, expr0_0, expr1_0)?; - let expr3_0 = constructor_output_reg(ctx, expr2_0)?; - return Some(expr3_0); - } - &Opcode::Isub => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - if let Some(pattern8_0) = C::def_inst(ctx, pattern7_1) { - let pattern9_0 = C::inst_data(ctx, pattern8_0); - match &pattern9_0 { - &InstructionData::UnaryImm { - opcode: ref pattern10_0, - imm: pattern10_1, - } => { - if let &Opcode::Iconst = pattern10_0 { - let pattern12_0 = C::u64_from_imm64(ctx, pattern10_1); - if let Some(pattern13_0) = - C::imm12_from_u64(ctx, pattern12_0) - { - // Rule at src/isa/aarch64/lower.isle line 111. - let expr0_0 = C::put_in_reg(ctx, pattern7_0); - let expr1_0 = constructor_sub_imm( - ctx, - pattern3_0, - expr0_0, - pattern13_0, - )?; - let expr2_0 = constructor_output_reg(ctx, expr1_0)?; - return Some(expr2_0); - } - if let Some(pattern13_0) = - C::imm12_from_negated_u64(ctx, pattern12_0) - { - // Rule at src/isa/aarch64/lower.isle line 116. - let expr0_0 = C::put_in_reg(ctx, pattern7_0); - let expr1_0 = constructor_add_imm( - ctx, - pattern3_0, - expr0_0, - pattern13_0, - )?; - let expr2_0 = constructor_output_reg(ctx, expr1_0)?; - return Some(expr2_0); - } - } - } - &InstructionData::Binary { - opcode: ref pattern10_0, - args: ref pattern10_1, - } => { - match pattern10_0 { - &Opcode::Imul => { - let (pattern12_0, pattern12_1) = - C::unpack_value_array_2(ctx, pattern10_1); - // Rule at src/isa/aarch64/lower.isle line 76. - let expr0_0 = C::put_in_reg(ctx, pattern12_0); - let expr1_0 = C::put_in_reg(ctx, pattern12_1); - let expr2_0 = C::put_in_reg(ctx, pattern7_0); - let expr3_0 = constructor_msub( - ctx, pattern3_0, expr0_0, expr1_0, expr2_0, - )?; - let expr4_0 = constructor_output_reg(ctx, expr3_0)?; - return Some(expr4_0); - } - &Opcode::Ishl => { - let (pattern12_0, pattern12_1) = - C::unpack_value_array_2(ctx, pattern10_1); - if let Some(pattern13_0) = - C::def_inst(ctx, pattern12_1) - { - let pattern14_0 = - C::inst_data(ctx, pattern13_0); - if let &InstructionData::UnaryImm { - opcode: ref pattern15_0, - imm: pattern15_1, - } = &pattern14_0 - { - if let &Opcode::Iconst = pattern15_0 { - let mut closure17 = || { - let expr0_0 = C::lshl_from_imm64( - ctx, - pattern3_0, - pattern15_1, - )?; - return Some(expr0_0); - }; - if let Some(pattern17_0) = closure17() { - // Rule at src/isa/aarch64/lower.isle line 126. - let expr0_0 = - C::put_in_reg(ctx, pattern7_0); - let expr1_0 = - C::put_in_reg(ctx, pattern12_0); - let expr2_0 = - constructor_sub_shift( - ctx, - pattern3_0, - expr0_0, - expr1_0, - pattern17_0, - )?; - let expr3_0 = - constructor_output_reg( - ctx, expr2_0, - )?; - return Some(expr3_0); - } - } - } - } - } - _ => {} - } - } - _ => {} - } - } - if let Some(pattern8_0) = C::extended_value_from_value(ctx, pattern7_1) - { - // Rule at src/isa/aarch64/lower.isle line 121. - let expr0_0 = C::put_in_reg(ctx, pattern7_0); - let expr1_0 = - constructor_sub_extend(ctx, pattern3_0, expr0_0, &pattern8_0)?; - let expr2_0 = constructor_output_reg(ctx, expr1_0)?; - return Some(expr2_0); - } - // Rule at src/isa/aarch64/lower.isle line 107. - let expr0_0 = C::put_in_reg(ctx, pattern7_0); - let expr1_0 = C::put_in_reg(ctx, pattern7_1); - let expr2_0 = constructor_sub(ctx, pattern3_0, expr0_0, expr1_0)?; - let expr3_0 = constructor_output_reg(ctx, expr2_0)?; - return Some(expr3_0); - } - &Opcode::Imul => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/aarch64/lower.isle line 186. - let expr0_0 = C::put_in_reg(ctx, pattern7_0); - let expr1_0 = C::put_in_reg(ctx, pattern7_1); - let expr2_0 = C::zero_reg(ctx); - let expr3_0 = - constructor_madd(ctx, pattern3_0, expr0_0, expr1_0, expr2_0)?; - let expr4_0 = constructor_output_reg(ctx, expr3_0)?; - return Some(expr4_0); - } - &Opcode::Udiv => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/aarch64/lower.isle line 393. - let expr0_0: Type = I64; - let expr1_0 = constructor_put_in_reg_zext64(ctx, pattern7_0)?; - let expr2_0 = constructor_put_nonzero_in_reg_zext64(ctx, pattern7_1)?; - let expr3_0 = constructor_a64_udiv(ctx, expr0_0, expr1_0, expr2_0)?; - let expr4_0 = constructor_output_reg(ctx, expr3_0)?; - return Some(expr4_0); - } - &Opcode::Sdiv => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - if let Some(pattern8_0) = C::def_inst(ctx, pattern7_1) { - let pattern9_0 = C::inst_data(ctx, pattern8_0); - if let &InstructionData::UnaryImm { - opcode: ref pattern10_0, - imm: pattern10_1, - } = &pattern9_0 - { - if let &Opcode::Iconst = pattern10_0 { - if let Some(pattern12_0) = - C::safe_divisor_from_imm64(ctx, pattern10_1) - { - // Rule at src/isa/aarch64/lower.isle line 439. - let expr0_0: Type = I64; - let expr1_0 = - constructor_put_in_reg_sext64(ctx, pattern7_0)?; - let expr2_0 = - constructor_imm(ctx, pattern3_0, pattern12_0)?; - let expr3_0 = constructor_a64_sdiv( - ctx, expr0_0, expr1_0, expr2_0, - )?; - let expr4_0 = constructor_output_reg(ctx, expr3_0)?; - return Some(expr4_0); - } - } - } - } - // Rule at src/isa/aarch64/lower.isle line 426. - let expr0_0 = constructor_put_in_reg_sext64(ctx, pattern7_0)?; - let expr1_0 = constructor_put_nonzero_in_reg_sext64(ctx, pattern7_1)?; - let expr2_0 = constructor_trap_if_div_overflow( - ctx, pattern3_0, expr0_0, expr1_0, - )?; - let expr3_0: Type = I64; - let expr4_0 = constructor_a64_sdiv(ctx, expr3_0, expr2_0, expr1_0)?; - let expr5_0 = constructor_output_reg(ctx, expr4_0)?; - return Some(expr5_0); - } - &Opcode::Urem => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/aarch64/lower.isle line 467. - let expr0_0 = constructor_put_in_reg_zext64(ctx, pattern7_0)?; - let expr1_0 = constructor_put_nonzero_in_reg_zext64(ctx, pattern7_1)?; - let expr2_0: Type = I64; - let expr3_0 = constructor_a64_udiv(ctx, expr2_0, expr0_0, expr1_0)?; - let expr4_0: Type = I64; - let expr5_0 = - constructor_msub(ctx, expr4_0, expr3_0, expr1_0, expr0_0)?; - let expr6_0 = constructor_output_reg(ctx, expr5_0)?; - return Some(expr6_0); - } - &Opcode::Srem => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/aarch64/lower.isle line 474. - let expr0_0 = constructor_put_in_reg_sext64(ctx, pattern7_0)?; - let expr1_0 = constructor_put_nonzero_in_reg_sext64(ctx, pattern7_1)?; - let expr2_0: Type = I64; - let expr3_0 = constructor_a64_sdiv(ctx, expr2_0, expr0_0, expr1_0)?; - let expr4_0: Type = I64; - let expr5_0 = - constructor_msub(ctx, expr4_0, expr3_0, expr1_0, expr0_0)?; - let expr6_0 = constructor_output_reg(ctx, expr5_0)?; - return Some(expr6_0); - } - _ => {} - } - } - &InstructionData::Unary { - opcode: ref pattern5_0, - arg: pattern5_1, - } => { - match pattern5_0 { - &Opcode::Ineg => { - // Rule at src/isa/aarch64/lower.isle line 176. - let expr0_0 = C::zero_reg(ctx); - let expr1_0 = C::put_in_reg(ctx, pattern5_1); - let expr2_0 = constructor_sub(ctx, pattern3_0, expr0_0, expr1_0)?; - let expr3_0 = constructor_output_reg(ctx, expr2_0)?; - return Some(expr3_0); - } - &Opcode::Bnot => { - if let Some(pattern7_0) = C::def_inst(ctx, pattern5_1) { - let pattern8_0 = C::inst_data(ctx, pattern7_0); - if let &InstructionData::Binary { - opcode: ref pattern9_0, - args: ref pattern9_1, - } = &pattern8_0 - { - if let &Opcode::Ishl = pattern9_0 { - let (pattern11_0, pattern11_1) = - C::unpack_value_array_2(ctx, pattern9_1); - if let Some(pattern12_0) = C::def_inst(ctx, pattern11_1) { - let pattern13_0 = C::inst_data(ctx, pattern12_0); - if let &InstructionData::UnaryImm { - opcode: ref pattern14_0, - imm: pattern14_1, - } = &pattern13_0 - { - if let &Opcode::Iconst = pattern14_0 { - let mut closure16 = || { - let expr0_0 = C::lshl_from_imm64( - ctx, - pattern3_0, - pattern14_1, - )?; - return Some(expr0_0); - }; - if let Some(pattern16_0) = closure16() { - // Rule at src/isa/aarch64/lower.isle line 573. - let expr0_0 = C::zero_reg(ctx); - let expr1_0 = - C::put_in_reg(ctx, pattern11_0); - let expr2_0 = constructor_orr_not_shift( - ctx, - pattern3_0, - expr0_0, - expr1_0, - pattern16_0, - )?; - let expr3_0 = - constructor_output_reg(ctx, expr2_0)?; - return Some(expr3_0); - } - } - } - } - } - } - } - // Rule at src/isa/aarch64/lower.isle line 568. - let expr0_0 = C::zero_reg(ctx); - let expr1_0 = C::put_in_reg(ctx, pattern5_1); - let expr2_0 = constructor_orr_not(ctx, pattern3_0, expr0_0, expr1_0)?; - let expr3_0 = constructor_output_reg(ctx, expr2_0)?; - return Some(expr3_0); - } - &Opcode::Uextend => { - if let Some(pattern7_0) = C::def_inst(ctx, pattern5_1) { - let pattern8_0 = C::inst_data(ctx, pattern7_0); - if let &InstructionData::BinaryImm8 { - opcode: ref pattern9_0, - arg: pattern9_1, - imm: pattern9_2, - } = &pattern8_0 - { - if let &Opcode::Extractlane = pattern9_0 { - let pattern11_0 = C::value_type(ctx, pattern9_1); - let pattern12_0 = C::u8_from_uimm8(ctx, pattern9_2); - // Rule at src/isa/aarch64/lower.isle line 490. - let expr0_0 = C::put_in_reg(ctx, pattern9_1); - let expr1_0 = constructor_vector_size(ctx, pattern11_0)?; - let expr2_0 = constructor_mov_from_vec( - ctx, - expr0_0, - pattern12_0, - &expr1_0, - )?; - let expr3_0 = constructor_output_reg(ctx, expr2_0)?; - return Some(expr3_0); - } - } - } - let pattern7_0 = C::value_type(ctx, pattern5_1); - if let Some(pattern8_0) = C::sinkable_atomic_load(ctx, pattern5_1) { - // Rule at src/isa/aarch64/lower.isle line 497. - let expr0_0 = C::sink_atomic_load(ctx, &pattern8_0); - let expr1_0 = constructor_load_acquire(ctx, pattern7_0, expr0_0)?; - let expr2_0 = constructor_output_reg(ctx, expr1_0)?; - return Some(expr2_0); - } - // Rule at src/isa/aarch64/lower.isle line 485. - let expr0_0 = C::put_in_reg(ctx, pattern5_1); - let expr1_0: bool = false; - let expr2_0 = C::ty_bits(ctx, pattern7_0)?; - let expr3_0 = C::ty_bits(ctx, pattern3_0)?; - let expr4_0 = - constructor_extend(ctx, expr0_0, expr1_0, expr2_0, expr3_0)?; - let expr5_0 = constructor_output_reg(ctx, expr4_0)?; - return Some(expr5_0); - } - &Opcode::Sextend => { - if let Some(pattern7_0) = C::def_inst(ctx, pattern5_1) { - let pattern8_0 = C::inst_data(ctx, pattern7_0); - if let &InstructionData::BinaryImm8 { - opcode: ref pattern9_0, - arg: pattern9_1, - imm: pattern9_2, - } = &pattern8_0 - { - if let &Opcode::Extractlane = pattern9_0 { - let pattern11_0 = C::value_type(ctx, pattern9_1); - let pattern12_0 = C::u8_from_uimm8(ctx, pattern9_2); - // Rule at src/isa/aarch64/lower.isle line 522. - let expr0_0 = C::put_in_reg(ctx, pattern9_1); - let expr1_0 = constructor_vector_size(ctx, pattern11_0)?; - let expr2_0 = constructor_size_from_ty(ctx, pattern3_0)?; - let expr3_0 = constructor_mov_from_vec_signed( - ctx, - expr0_0, - pattern12_0, - &expr1_0, - &expr2_0, - )?; - let expr4_0 = constructor_output_reg(ctx, expr3_0)?; - return Some(expr4_0); - } - } - } - let pattern7_0 = C::value_type(ctx, pattern5_1); - // Rule at src/isa/aarch64/lower.isle line 517. - let expr0_0 = C::put_in_reg(ctx, pattern5_1); - let expr1_0: bool = true; - let expr2_0 = C::ty_bits(ctx, pattern7_0)?; - let expr3_0 = C::ty_bits(ctx, pattern3_0)?; - let expr4_0 = - constructor_extend(ctx, expr0_0, expr1_0, expr2_0, expr3_0)?; - let expr5_0 = constructor_output_reg(ctx, expr4_0)?; - return Some(expr5_0); - } - _ => {} - } - } - _ => {} - } - } - if let Some(pattern3_0) = C::ty_vec128(ctx, pattern2_0) { - let pattern4_0 = C::inst_data(ctx, pattern0_0); - match &pattern4_0 { - &InstructionData::Binary { - opcode: ref pattern5_0, - args: ref pattern5_1, - } => { - match pattern5_0 { - &Opcode::UaddSat => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/aarch64/lower.isle line 155. - let expr0_0 = C::put_in_reg(ctx, pattern7_0); - let expr1_0 = C::put_in_reg(ctx, pattern7_1); - let expr2_0 = constructor_vector_size(ctx, pattern3_0)?; - let expr3_0 = constructor_uqadd(ctx, expr0_0, expr1_0, &expr2_0)?; - let expr4_0 = constructor_output_reg(ctx, expr3_0)?; - return Some(expr4_0); - } - &Opcode::SaddSat => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/aarch64/lower.isle line 160. - let expr0_0 = C::put_in_reg(ctx, pattern7_0); - let expr1_0 = C::put_in_reg(ctx, pattern7_1); - let expr2_0 = constructor_vector_size(ctx, pattern3_0)?; - let expr3_0 = constructor_sqadd(ctx, expr0_0, expr1_0, &expr2_0)?; - let expr4_0 = constructor_output_reg(ctx, expr3_0)?; - return Some(expr4_0); - } - &Opcode::UsubSat => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/aarch64/lower.isle line 165. - let expr0_0 = C::put_in_reg(ctx, pattern7_0); - let expr1_0 = C::put_in_reg(ctx, pattern7_1); - let expr2_0 = constructor_vector_size(ctx, pattern3_0)?; - let expr3_0 = constructor_uqsub(ctx, expr0_0, expr1_0, &expr2_0)?; - let expr4_0 = constructor_output_reg(ctx, expr3_0)?; - return Some(expr4_0); - } - &Opcode::SsubSat => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/aarch64/lower.isle line 170. - let expr0_0 = C::put_in_reg(ctx, pattern7_0); - let expr1_0 = C::put_in_reg(ctx, pattern7_1); - let expr2_0 = constructor_vector_size(ctx, pattern3_0)?; - let expr3_0 = constructor_sqsub(ctx, expr0_0, expr1_0, &expr2_0)?; - let expr4_0 = constructor_output_reg(ctx, expr3_0)?; - return Some(expr4_0); - } - &Opcode::Band => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/aarch64/lower.isle line 601. - let expr0_0 = C::put_in_reg(ctx, pattern7_0); - let expr1_0 = C::put_in_reg(ctx, pattern7_1); - let expr2_0 = constructor_vector_size(ctx, pattern3_0)?; - let expr3_0 = constructor_and_vec(ctx, expr0_0, expr1_0, &expr2_0)?; - let expr4_0 = constructor_output_reg(ctx, expr3_0)?; - return Some(expr4_0); - } - &Opcode::Bor => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/aarch64/lower.isle line 614. - let expr0_0 = C::put_in_reg(ctx, pattern7_0); - let expr1_0 = C::put_in_reg(ctx, pattern7_1); - let expr2_0 = constructor_vector_size(ctx, pattern3_0)?; - let expr3_0 = constructor_orr_vec(ctx, expr0_0, expr1_0, &expr2_0)?; - let expr4_0 = constructor_output_reg(ctx, expr3_0)?; - return Some(expr4_0); - } - &Opcode::Bxor => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/aarch64/lower.isle line 627. - let expr0_0 = C::put_in_reg(ctx, pattern7_0); - let expr1_0 = C::put_in_reg(ctx, pattern7_1); - let expr2_0 = constructor_vector_size(ctx, pattern3_0)?; - let expr3_0 = constructor_eor_vec(ctx, expr0_0, expr1_0, &expr2_0)?; - let expr4_0 = constructor_output_reg(ctx, expr3_0)?; - return Some(expr4_0); - } - &Opcode::BandNot => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/aarch64/lower.isle line 640. - let expr0_0 = C::put_in_reg(ctx, pattern7_0); - let expr1_0 = C::put_in_reg(ctx, pattern7_1); - let expr2_0 = constructor_vector_size(ctx, pattern3_0)?; - let expr3_0 = constructor_bic_vec(ctx, expr0_0, expr1_0, &expr2_0)?; - let expr4_0 = constructor_output_reg(ctx, expr3_0)?; - return Some(expr4_0); - } - &Opcode::Ishl => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/aarch64/lower.isle line 704. - let expr0_0 = constructor_vector_size(ctx, pattern3_0)?; - let expr1_0 = C::put_in_reg(ctx, pattern7_1); - let expr2_0 = constructor_vec_dup(ctx, expr1_0, &expr0_0)?; - let expr3_0 = C::put_in_reg(ctx, pattern7_0); - let expr4_0 = constructor_sshl(ctx, expr3_0, expr2_0, &expr0_0)?; - let expr5_0 = constructor_output_reg(ctx, expr4_0)?; - return Some(expr5_0); - } - &Opcode::Ushr => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/aarch64/lower.isle line 763. - let expr0_0 = constructor_vector_size(ctx, pattern3_0)?; - let expr1_0: Type = I32; - let expr2_0 = C::zero_reg(ctx); - let expr3_0 = C::put_in_reg(ctx, pattern7_1); - let expr4_0 = constructor_sub(ctx, expr1_0, expr2_0, expr3_0)?; - let expr5_0 = constructor_vec_dup(ctx, expr4_0, &expr0_0)?; - let expr6_0 = C::put_in_reg(ctx, pattern7_0); - let expr7_0 = constructor_ushl(ctx, expr6_0, expr5_0, &expr0_0)?; - let expr8_0 = constructor_output_reg(ctx, expr7_0)?; - return Some(expr8_0); - } - &Opcode::Sshr => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/aarch64/lower.isle line 812. - let expr0_0 = constructor_vector_size(ctx, pattern3_0)?; - let expr1_0: Type = I32; - let expr2_0 = C::zero_reg(ctx); - let expr3_0 = C::put_in_reg(ctx, pattern7_1); - let expr4_0 = constructor_sub(ctx, expr1_0, expr2_0, expr3_0)?; - let expr5_0 = constructor_vec_dup(ctx, expr4_0, &expr0_0)?; - let expr6_0 = C::put_in_reg(ctx, pattern7_0); - let expr7_0 = constructor_sshl(ctx, expr6_0, expr5_0, &expr0_0)?; - let expr8_0 = constructor_output_reg(ctx, expr7_0)?; - return Some(expr8_0); - } - _ => {} - } - } - &InstructionData::Unary { - opcode: ref pattern5_0, - arg: pattern5_1, - } => { - match pattern5_0 { - &Opcode::Ineg => { - // Rule at src/isa/aarch64/lower.isle line 180. - let expr0_0 = C::put_in_reg(ctx, pattern5_1); - let expr1_0 = constructor_vector_size(ctx, pattern3_0)?; - let expr2_0 = constructor_neg(ctx, expr0_0, &expr1_0)?; - let expr3_0 = constructor_output_reg(ctx, expr2_0)?; - return Some(expr3_0); - } - &Opcode::Bnot => { - // Rule at src/isa/aarch64/lower.isle line 588. - let expr0_0 = C::put_in_reg(ctx, pattern5_1); - let expr1_0 = constructor_vector_size(ctx, pattern3_0)?; - let expr2_0 = constructor_not(ctx, expr0_0, &expr1_0)?; - let expr3_0 = constructor_output_reg(ctx, expr2_0)?; - return Some(expr3_0); - } - _ => {} - } - } - _ => {} - } - if let Some(()) = C::not_i64x2(ctx, pattern3_0) { - let pattern5_0 = C::inst_data(ctx, pattern0_0); - if let &InstructionData::Binary { - opcode: ref pattern6_0, - args: ref pattern6_1, - } = &pattern5_0 - { - if let &Opcode::Imul = pattern6_0 { - let (pattern8_0, pattern8_1) = C::unpack_value_array_2(ctx, pattern6_1); - // Rule at src/isa/aarch64/lower.isle line 218. - let expr0_0 = C::put_in_reg(ctx, pattern8_0); - let expr1_0 = C::put_in_reg(ctx, pattern8_1); - let expr2_0 = constructor_vector_size(ctx, pattern3_0)?; - let expr3_0 = constructor_mul(ctx, expr0_0, expr1_0, &expr2_0)?; - let expr4_0 = constructor_output_reg(ctx, expr3_0)?; - return Some(expr4_0); - } - } - } - } - if let Some(pattern3_0) = C::valid_atomic_transaction(ctx, pattern2_0) { - let pattern4_0 = C::inst_data(ctx, pattern0_0); - if let &InstructionData::AtomicRmw { - opcode: ref pattern5_0, - args: ref pattern5_1, - flags: pattern5_2, - op: ref pattern5_3, - } = &pattern4_0 - { - if let &Opcode::AtomicRmw = pattern5_0 { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - match pattern5_3 { - &AtomicRmwOp::Add => { - // Rule at src/isa/aarch64/lower.isle line 1251. - let expr0_0 = AtomicRMWLoopOp::Add; - let expr1_0 = constructor_atomic_rmw_loop( - ctx, &expr0_0, pattern7_0, pattern7_1, pattern3_0, - )?; - let expr2_0 = constructor_output_reg(ctx, expr1_0)?; - return Some(expr2_0); - } - &AtomicRmwOp::And => { - // Rule at src/isa/aarch64/lower.isle line 1257. - let expr0_0 = AtomicRMWLoopOp::And; - let expr1_0 = constructor_atomic_rmw_loop( - ctx, &expr0_0, pattern7_0, pattern7_1, pattern3_0, - )?; - let expr2_0 = constructor_output_reg(ctx, expr1_0)?; - return Some(expr2_0); - } - &AtomicRmwOp::Nand => { - // Rule at src/isa/aarch64/lower.isle line 1260. - let expr0_0 = AtomicRMWLoopOp::Nand; - let expr1_0 = constructor_atomic_rmw_loop( - ctx, &expr0_0, pattern7_0, pattern7_1, pattern3_0, - )?; - let expr2_0 = constructor_output_reg(ctx, expr1_0)?; - return Some(expr2_0); - } - &AtomicRmwOp::Or => { - // Rule at src/isa/aarch64/lower.isle line 1263. - let expr0_0 = AtomicRMWLoopOp::Orr; - let expr1_0 = constructor_atomic_rmw_loop( - ctx, &expr0_0, pattern7_0, pattern7_1, pattern3_0, - )?; - let expr2_0 = constructor_output_reg(ctx, expr1_0)?; - return Some(expr2_0); - } - &AtomicRmwOp::Smax => { - // Rule at src/isa/aarch64/lower.isle line 1272. - let expr0_0 = AtomicRMWLoopOp::Smax; - let expr1_0 = constructor_atomic_rmw_loop( - ctx, &expr0_0, pattern7_0, pattern7_1, pattern3_0, - )?; - let expr2_0 = constructor_output_reg(ctx, expr1_0)?; - return Some(expr2_0); - } - &AtomicRmwOp::Smin => { - // Rule at src/isa/aarch64/lower.isle line 1269. - let expr0_0 = AtomicRMWLoopOp::Smin; - let expr1_0 = constructor_atomic_rmw_loop( - ctx, &expr0_0, pattern7_0, pattern7_1, pattern3_0, - )?; - let expr2_0 = constructor_output_reg(ctx, expr1_0)?; - return Some(expr2_0); - } - &AtomicRmwOp::Sub => { - // Rule at src/isa/aarch64/lower.isle line 1254. - let expr0_0 = AtomicRMWLoopOp::Sub; - let expr1_0 = constructor_atomic_rmw_loop( - ctx, &expr0_0, pattern7_0, pattern7_1, pattern3_0, - )?; - let expr2_0 = constructor_output_reg(ctx, expr1_0)?; - return Some(expr2_0); - } - &AtomicRmwOp::Umax => { - // Rule at src/isa/aarch64/lower.isle line 1278. - let expr0_0 = AtomicRMWLoopOp::Umax; - let expr1_0 = constructor_atomic_rmw_loop( - ctx, &expr0_0, pattern7_0, pattern7_1, pattern3_0, - )?; - let expr2_0 = constructor_output_reg(ctx, expr1_0)?; - return Some(expr2_0); - } - &AtomicRmwOp::Umin => { - // Rule at src/isa/aarch64/lower.isle line 1275. - let expr0_0 = AtomicRMWLoopOp::Umin; - let expr1_0 = constructor_atomic_rmw_loop( - ctx, &expr0_0, pattern7_0, pattern7_1, pattern3_0, - )?; - let expr2_0 = constructor_output_reg(ctx, expr1_0)?; - return Some(expr2_0); - } - &AtomicRmwOp::Xchg => { - // Rule at src/isa/aarch64/lower.isle line 1281. - let expr0_0 = AtomicRMWLoopOp::Xchg; - let expr1_0 = constructor_atomic_rmw_loop( - ctx, &expr0_0, pattern7_0, pattern7_1, pattern3_0, - )?; - let expr2_0 = constructor_output_reg(ctx, expr1_0)?; - return Some(expr2_0); - } - &AtomicRmwOp::Xor => { - // Rule at src/isa/aarch64/lower.isle line 1266. - let expr0_0 = AtomicRMWLoopOp::Eor; - let expr1_0 = constructor_atomic_rmw_loop( - ctx, &expr0_0, pattern7_0, pattern7_1, pattern3_0, - )?; - let expr2_0 = constructor_output_reg(ctx, expr1_0)?; - return Some(expr2_0); - } - _ => {} - } - } - } - } - } - return None; -} - -// Generated as internal constructor for term put_nonzero_in_reg_zext64. -pub fn constructor_put_nonzero_in_reg_zext64(ctx: &mut C, arg0: Value) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = C::value_type(ctx, pattern0_0); - if let Some(pattern2_0) = C::def_inst(ctx, pattern0_0) { - let pattern3_0 = C::inst_data(ctx, pattern2_0); - if let &InstructionData::UnaryImm { - opcode: ref pattern4_0, - imm: pattern4_1, - } = &pattern3_0 - { - if let &Opcode::Iconst = pattern4_0 { - if let Some(pattern6_0) = C::nonzero_u64_from_imm64(ctx, pattern4_1) { - // Rule at src/isa/aarch64/lower.isle line 403. - let expr0_0 = constructor_imm(ctx, pattern1_0, pattern6_0)?; - return Some(expr0_0); - } - } - } - } - // Rule at src/isa/aarch64/lower.isle line 398. - let expr0_0 = constructor_put_in_reg_zext64(ctx, pattern0_0)?; - let expr1_0 = constructor_trap_if_zero_divisor(ctx, expr0_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term put_nonzero_in_reg_sext64. -pub fn constructor_put_nonzero_in_reg_sext64(ctx: &mut C, arg0: Value) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = C::value_type(ctx, pattern0_0); - if let Some(pattern2_0) = C::def_inst(ctx, pattern0_0) { - let pattern3_0 = C::inst_data(ctx, pattern2_0); - if let &InstructionData::UnaryImm { - opcode: ref pattern4_0, - imm: pattern4_1, - } = &pattern3_0 - { - if let &Opcode::Iconst = pattern4_0 { - if let Some(pattern6_0) = C::nonzero_u64_from_imm64(ctx, pattern4_1) { - // Rule at src/isa/aarch64/lower.isle line 449. - let expr0_0 = constructor_imm(ctx, pattern1_0, pattern6_0)?; - return Some(expr0_0); - } - } - } - } - // Rule at src/isa/aarch64/lower.isle line 444. - let expr0_0 = constructor_put_in_reg_sext64(ctx, pattern0_0)?; - let expr1_0 = constructor_trap_if_zero_divisor(ctx, expr0_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term lower_shl128. -pub fn constructor_lower_shl128( - ctx: &mut C, - arg0: ValueRegs, - arg1: Reg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/aarch64/lower.isle line 687. - let expr0_0: usize = 0; - let expr1_0 = C::value_regs_get(ctx, pattern0_0, expr0_0); - let expr2_0: usize = 1; - let expr3_0 = C::value_regs_get(ctx, pattern0_0, expr2_0); - let expr4_0: Type = I64; - let expr5_0 = constructor_lsl(ctx, expr4_0, expr1_0, pattern1_0)?; - let expr6_0: Type = I64; - let expr7_0 = constructor_lsl(ctx, expr6_0, expr3_0, pattern1_0)?; - let expr8_0: Type = I32; - let expr9_0 = C::zero_reg(ctx); - let expr10_0 = constructor_orr_not(ctx, expr8_0, expr9_0, pattern1_0)?; - let expr11_0: Type = I64; - let expr12_0: Type = I64; - let expr13_0: u8 = 1; - let expr14_0 = C::imm_shift_from_u8(ctx, expr13_0); - let expr15_0 = constructor_lsr_imm(ctx, expr12_0, expr1_0, expr14_0)?; - let expr16_0 = constructor_lsr(ctx, expr11_0, expr15_0, expr10_0)?; - let expr17_0: Type = I64; - let expr18_0 = constructor_orr(ctx, expr17_0, expr7_0, expr16_0)?; - let expr19_0: Type = I64; - let expr20_0: Type = I64; - let expr21_0: u64 = 64; - let expr22_0 = C::u64_into_imm_logic(ctx, expr20_0, expr21_0); - let expr23_0 = constructor_tst_imm(ctx, expr19_0, pattern1_0, expr22_0)?; - let expr24_0 = Cond::Ne; - let expr25_0 = C::zero_reg(ctx); - let expr26_0 = constructor_csel(ctx, &expr24_0, expr25_0, expr5_0)?; - let expr27_0 = Cond::Ne; - let expr28_0 = constructor_csel(ctx, &expr27_0, expr5_0, expr18_0)?; - let expr29_0 = constructor_consumes_flags_concat(ctx, &expr26_0, &expr28_0)?; - let expr30_0 = constructor_with_flags(ctx, &expr23_0, &expr29_0)?; - return Some(expr30_0); -} - -// Generated as internal constructor for term do_shift. -pub fn constructor_do_shift( - ctx: &mut C, - arg0: &ALUOp, - arg1: Type, - arg2: Reg, - arg3: Value, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - let pattern3_0 = arg3; - if let Some(pattern4_0) = C::def_inst(ctx, pattern3_0) { - let pattern5_0 = C::inst_data(ctx, pattern4_0); - if let &InstructionData::UnaryImm { - opcode: ref pattern6_0, - imm: pattern6_1, - } = &pattern5_0 - { - if let &Opcode::Iconst = pattern6_0 { - let mut closure8 = || { - let expr0_0 = C::imm_shift_from_imm64(ctx, pattern1_0, pattern6_1)?; - return Some(expr0_0); - }; - if let Some(pattern8_0) = closure8() { - // Rule at src/isa/aarch64/lower.isle line 744. - let expr0_0 = constructor_alu_rr_imm_shift( - ctx, pattern0_0, pattern1_0, pattern2_0, pattern8_0, - )?; - return Some(expr0_0); - } - } - } - } - let pattern0_0 = arg0; - let pattern1_0 = arg1; - if pattern1_0 == I32 { - let pattern3_0 = arg2; - let pattern4_0 = arg3; - // Rule at src/isa/aarch64/lower.isle line 735. - let expr0_0: Type = I32; - let expr1_0 = C::put_in_regs(ctx, pattern4_0); - let expr2_0: usize = 0; - let expr3_0 = C::value_regs_get(ctx, expr1_0, expr2_0); - let expr4_0 = constructor_alu_rrr(ctx, pattern0_0, expr0_0, pattern3_0, expr3_0)?; - return Some(expr4_0); - } - if pattern1_0 == I64 { - let pattern3_0 = arg2; - let pattern4_0 = arg3; - // Rule at src/isa/aarch64/lower.isle line 736. - let expr0_0: Type = I64; - let expr1_0 = C::put_in_regs(ctx, pattern4_0); - let expr2_0: usize = 0; - let expr3_0 = C::value_regs_get(ctx, expr1_0, expr2_0); - let expr4_0 = constructor_alu_rrr(ctx, pattern0_0, expr0_0, pattern3_0, expr3_0)?; - return Some(expr4_0); - } - if let Some(pattern2_0) = C::fits_in_16(ctx, pattern1_0) { - let pattern3_0 = arg2; - let pattern4_0 = arg3; - // Rule at src/isa/aarch64/lower.isle line 726. - let expr0_0 = C::put_in_regs(ctx, pattern4_0); - let expr1_0: usize = 0; - let expr2_0 = C::value_regs_get(ctx, expr0_0, expr1_0); - let expr3_0: Type = I32; - let expr4_0 = C::shift_mask(ctx, pattern2_0); - let expr5_0 = constructor_and_imm(ctx, expr3_0, expr2_0, expr4_0)?; - let expr6_0: Type = I32; - let expr7_0 = constructor_alu_rrr(ctx, pattern0_0, expr6_0, pattern3_0, expr5_0)?; - return Some(expr7_0); - } - return None; -} - -// Generated as internal constructor for term lower_ushr128. -pub fn constructor_lower_ushr128( - ctx: &mut C, - arg0: ValueRegs, - arg1: Reg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/aarch64/lower.isle line 778. - let expr0_0: usize = 0; - let expr1_0 = C::value_regs_get(ctx, pattern0_0, expr0_0); - let expr2_0: usize = 1; - let expr3_0 = C::value_regs_get(ctx, pattern0_0, expr2_0); - let expr4_0: Type = I64; - let expr5_0 = constructor_lsr(ctx, expr4_0, expr1_0, pattern1_0)?; - let expr6_0: Type = I64; - let expr7_0 = constructor_lsr(ctx, expr6_0, expr3_0, pattern1_0)?; - let expr8_0: Type = I32; - let expr9_0 = C::zero_reg(ctx); - let expr10_0 = constructor_orr_not(ctx, expr8_0, expr9_0, pattern1_0)?; - let expr11_0: Type = I64; - let expr12_0: Type = I64; - let expr13_0: u8 = 1; - let expr14_0 = C::imm_shift_from_u8(ctx, expr13_0); - let expr15_0 = constructor_lsl_imm(ctx, expr12_0, expr3_0, expr14_0)?; - let expr16_0 = constructor_lsl(ctx, expr11_0, expr15_0, expr10_0)?; - let expr17_0: Type = I64; - let expr18_0 = constructor_orr(ctx, expr17_0, expr5_0, expr16_0)?; - let expr19_0: Type = I64; - let expr20_0: Type = I64; - let expr21_0: u64 = 64; - let expr22_0 = C::u64_into_imm_logic(ctx, expr20_0, expr21_0); - let expr23_0 = constructor_tst_imm(ctx, expr19_0, pattern1_0, expr22_0)?; - let expr24_0 = Cond::Ne; - let expr25_0 = constructor_csel(ctx, &expr24_0, expr7_0, expr18_0)?; - let expr26_0 = Cond::Ne; - let expr27_0 = C::zero_reg(ctx); - let expr28_0 = constructor_csel(ctx, &expr26_0, expr27_0, expr7_0)?; - let expr29_0 = constructor_consumes_flags_concat(ctx, &expr25_0, &expr28_0)?; - let expr30_0 = constructor_with_flags(ctx, &expr23_0, &expr29_0)?; - return Some(expr30_0); -} - -// Generated as internal constructor for term lower_sshr128. -pub fn constructor_lower_sshr128( - ctx: &mut C, - arg0: ValueRegs, - arg1: Reg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/aarch64/lower.isle line 828. - let expr0_0: usize = 0; - let expr1_0 = C::value_regs_get(ctx, pattern0_0, expr0_0); - let expr2_0: usize = 1; - let expr3_0 = C::value_regs_get(ctx, pattern0_0, expr2_0); - let expr4_0: Type = I64; - let expr5_0 = constructor_lsr(ctx, expr4_0, expr1_0, pattern1_0)?; - let expr6_0: Type = I64; - let expr7_0 = constructor_asr(ctx, expr6_0, expr3_0, pattern1_0)?; - let expr8_0: Type = I32; - let expr9_0 = C::zero_reg(ctx); - let expr10_0 = constructor_orr_not(ctx, expr8_0, expr9_0, pattern1_0)?; - let expr11_0: Type = I64; - let expr12_0: Type = I64; - let expr13_0: u8 = 1; - let expr14_0 = C::imm_shift_from_u8(ctx, expr13_0); - let expr15_0 = constructor_lsl_imm(ctx, expr12_0, expr3_0, expr14_0)?; - let expr16_0 = constructor_lsl(ctx, expr11_0, expr15_0, expr10_0)?; - let expr17_0: Type = I64; - let expr18_0: u8 = 63; - let expr19_0 = C::imm_shift_from_u8(ctx, expr18_0); - let expr20_0 = constructor_asr_imm(ctx, expr17_0, expr3_0, expr19_0)?; - let expr21_0: Type = I64; - let expr22_0 = constructor_orr(ctx, expr21_0, expr5_0, expr16_0)?; - let expr23_0: Type = I64; - let expr24_0: Type = I64; - let expr25_0: u64 = 64; - let expr26_0 = C::u64_into_imm_logic(ctx, expr24_0, expr25_0); - let expr27_0 = constructor_tst_imm(ctx, expr23_0, pattern1_0, expr26_0)?; - let expr28_0 = Cond::Ne; - let expr29_0 = constructor_csel(ctx, &expr28_0, expr7_0, expr22_0)?; - let expr30_0 = Cond::Ne; - let expr31_0 = constructor_csel(ctx, &expr30_0, expr20_0, expr7_0)?; - let expr32_0 = constructor_consumes_flags_concat(ctx, &expr29_0, &expr31_0)?; - let expr33_0 = constructor_with_flags(ctx, &expr27_0, &expr32_0)?; - return Some(expr33_0); -} - -// Generated as internal constructor for term small_rotr. -pub fn constructor_small_rotr( - ctx: &mut C, - arg0: Type, - arg1: Reg, - arg2: Reg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/aarch64/lower.isle line 944. - let expr0_0: Type = I32; - let expr1_0 = C::rotr_mask(ctx, pattern0_0); - let expr2_0 = constructor_and_imm(ctx, expr0_0, pattern2_0, expr1_0)?; - let expr3_0: Type = I32; - let expr4_0 = C::ty_bits(ctx, pattern0_0)?; - let expr5_0 = C::u8_into_imm12(ctx, expr4_0); - let expr6_0 = constructor_sub_imm(ctx, expr3_0, expr2_0, expr5_0)?; - let expr7_0: Type = I32; - let expr8_0 = C::zero_reg(ctx); - let expr9_0 = constructor_sub(ctx, expr7_0, expr8_0, expr6_0)?; - let expr10_0: Type = I32; - let expr11_0 = constructor_lsr(ctx, expr10_0, pattern1_0, expr2_0)?; - let expr12_0: Type = I32; - let expr13_0 = constructor_lsl(ctx, expr12_0, pattern1_0, expr9_0)?; - let expr14_0: Type = I32; - let expr15_0 = constructor_orr(ctx, expr14_0, expr13_0, expr11_0)?; - return Some(expr15_0); -} - -// Generated as internal constructor for term small_rotr_imm. -pub fn constructor_small_rotr_imm( - ctx: &mut C, - arg0: Type, - arg1: Reg, - arg2: ImmShift, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/aarch64/lower.isle line 965. - let expr0_0: Type = I32; - let expr1_0 = constructor_lsr_imm(ctx, expr0_0, pattern1_0, pattern2_0)?; - let expr2_0: Type = I32; - let expr3_0 = C::rotr_opposite_amount(ctx, pattern0_0, pattern2_0); - let expr4_0 = constructor_lsl_imm(ctx, expr2_0, pattern1_0, expr3_0)?; - let expr5_0: Type = I32; - let expr6_0 = constructor_orr(ctx, expr5_0, expr4_0, expr1_0)?; - return Some(expr6_0); -} - -// Generated as internal constructor for term lower_clz128. -pub fn constructor_lower_clz128(ctx: &mut C, arg0: ValueRegs) -> Option { - let pattern0_0 = arg0; - // Rule at src/isa/aarch64/lower.isle line 1030. - let expr0_0: Type = I64; - let expr1_0: usize = 1; - let expr2_0 = C::value_regs_get(ctx, pattern0_0, expr1_0); - let expr3_0 = constructor_a64_clz(ctx, expr0_0, expr2_0)?; - let expr4_0: Type = I64; - let expr5_0: usize = 0; - let expr6_0 = C::value_regs_get(ctx, pattern0_0, expr5_0); - let expr7_0 = constructor_a64_clz(ctx, expr4_0, expr6_0)?; - let expr8_0: Type = I64; - let expr9_0: u8 = 6; - let expr10_0 = C::imm_shift_from_u8(ctx, expr9_0); - let expr11_0 = constructor_lsr_imm(ctx, expr8_0, expr3_0, expr10_0)?; - let expr12_0: Type = I64; - let expr13_0 = constructor_madd(ctx, expr12_0, expr7_0, expr11_0, expr3_0)?; - let expr14_0: Type = I64; - let expr15_0: u64 = 0; - let expr16_0 = constructor_imm(ctx, expr14_0, expr15_0)?; - let expr17_0 = C::value_regs(ctx, expr13_0, expr16_0); - return Some(expr17_0); -} +include!(concat!(env!("ISLE_DIR"), "/isle_aarch64.rs")); diff --git a/cranelift/codegen/src/isa/s390x/lower/isle/generated_code.manifest b/cranelift/codegen/src/isa/s390x/lower/isle/generated_code.manifest deleted file mode 100644 index 08c3d848f3..0000000000 --- a/cranelift/codegen/src/isa/s390x/lower/isle/generated_code.manifest +++ /dev/null @@ -1,4 +0,0 @@ -src/clif.isle 443b34b797fc8ace -src/prelude.isle e6c91b0115343ab9 -src/isa/s390x/inst.isle 36c2500563cdd4e6 -src/isa/s390x/lower.isle e5c946ab8a265b77 diff --git a/cranelift/codegen/src/isa/s390x/lower/isle/generated_code.rs b/cranelift/codegen/src/isa/s390x/lower/isle/generated_code.rs index b1ecd915fc..f9e3a767a3 100644 --- a/cranelift/codegen/src/isa/s390x/lower/isle/generated_code.rs +++ b/cranelift/codegen/src/isa/s390x/lower/isle/generated_code.rs @@ -1,13834 +1,9 @@ -// GENERATED BY ISLE. DO NOT EDIT! -// -// Generated automatically from the instruction-selection DSL code in: -// - src/clif.isle -// - src/prelude.isle -// - src/isa/s390x/inst.isle -// - src/isa/s390x/lower.isle - +// See https://github.com/rust-lang/rust/issues/47995: we cannot use `#![...]` attributes inside of +// the generated ISLE source below because we include!() it. We must include!() it because its path +// depends on an environment variable; and also because of this, we can't do the `#[path = "..."] +// mod generated_code;` trick either. #![allow(dead_code, unreachable_code, unreachable_patterns)] #![allow(unused_imports, unused_variables, non_snake_case, unused_mut)] #![allow(irrefutable_let_patterns)] -use super::*; // Pulls in all external types. - -/// Context during lowering: an implementation of this trait -/// must be provided with all external constructors and extractors. -/// A mutable borrow is passed along through all lowering logic. -pub trait Context { - fn unpack_value_array_2(&mut self, arg0: &ValueArray2) -> (Value, Value); - fn pack_value_array_2(&mut self, arg0: Value, arg1: Value) -> ValueArray2; - fn unpack_value_array_3(&mut self, arg0: &ValueArray3) -> (Value, Value, Value); - fn pack_value_array_3(&mut self, arg0: Value, arg1: Value, arg2: Value) -> ValueArray3; - fn u32_add(&mut self, arg0: u32, arg1: u32) -> u32; - fn s32_add_fallible(&mut self, arg0: u32, arg1: u32) -> Option; - fn u32_nonnegative(&mut self, arg0: u32) -> Option; - fn offset32(&mut self, arg0: Offset32) -> Option; - fn u32_lteq(&mut self, arg0: u32, arg1: u32) -> Option; - fn simm32(&mut self, arg0: Imm64) -> Option; - fn uimm8(&mut self, arg0: Imm64) -> Option; - fn u8_and(&mut self, arg0: u8, arg1: u8) -> u8; - fn value_reg(&mut self, arg0: Reg) -> ValueRegs; - fn value_regs(&mut self, arg0: Reg, arg1: Reg) -> ValueRegs; - fn value_regs_invalid(&mut self) -> ValueRegs; - fn output_none(&mut self) -> InstOutput; - fn output(&mut self, arg0: ValueRegs) -> InstOutput; - fn output_pair(&mut self, arg0: ValueRegs, arg1: ValueRegs) -> InstOutput; - fn output_builder_new(&mut self) -> InstOutputBuilder; - fn output_builder_push(&mut self, arg0: &InstOutputBuilder, arg1: ValueRegs) -> Unit; - fn output_builder_finish(&mut self, arg0: &InstOutputBuilder) -> InstOutput; - fn temp_writable_reg(&mut self, arg0: Type) -> WritableReg; - fn invalid_reg_etor(&mut self, arg0: Reg) -> Option<()>; - fn invalid_reg(&mut self) -> Reg; - fn valid_reg(&mut self, arg0: Reg) -> Option<()>; - fn put_in_reg(&mut self, arg0: Value) -> Reg; - fn put_in_regs(&mut self, arg0: Value) -> ValueRegs; - fn ensure_in_vreg(&mut self, arg0: Reg, arg1: Type) -> Reg; - fn value_regs_get(&mut self, arg0: ValueRegs, arg1: usize) -> Reg; - fn u8_as_u32(&mut self, arg0: u8) -> Option; - fn u8_as_u64(&mut self, arg0: u8) -> Option; - fn u16_as_u64(&mut self, arg0: u16) -> Option; - fn u32_as_u64(&mut self, arg0: u32) -> Option; - fn i64_as_u64(&mut self, arg0: i64) -> Option; - fn u64_add(&mut self, arg0: u64, arg1: u64) -> Option; - fn u64_sub(&mut self, arg0: u64, arg1: u64) -> Option; - fn u64_and(&mut self, arg0: u64, arg1: u64) -> Option; - fn ty_bits(&mut self, arg0: Type) -> Option; - fn ty_bits_u16(&mut self, arg0: Type) -> u16; - fn ty_bits_u64(&mut self, arg0: Type) -> u64; - fn ty_mask(&mut self, arg0: Type) -> u64; - fn ty_bytes(&mut self, arg0: Type) -> u16; - fn lane_type(&mut self, arg0: Type) -> Type; - fn fits_in_16(&mut self, arg0: Type) -> Option; - fn fits_in_32(&mut self, arg0: Type) -> Option; - fn fits_in_64(&mut self, arg0: Type) -> Option; - fn ty_32_or_64(&mut self, arg0: Type) -> Option; - fn ty_8_or_16(&mut self, arg0: Type) -> Option; - fn ty_int_bool_64(&mut self, arg0: Type) -> Option; - fn ty_int_bool_ref_64(&mut self, arg0: Type) -> Option; - fn ty_int_bool_128(&mut self, arg0: Type) -> Option; - fn ty_scalar_float(&mut self, arg0: Type) -> Option; - fn ty_vec128(&mut self, arg0: Type) -> Option; - fn ty_vec128_int(&mut self, arg0: Type) -> Option; - fn not_i64x2(&mut self, arg0: Type) -> Option<()>; - fn value_list_slice(&mut self, arg0: ValueList) -> ValueSlice; - fn value_slice_empty(&mut self, arg0: ValueSlice) -> Option<()>; - fn value_slice_unwrap(&mut self, arg0: ValueSlice) -> Option<(Value, ValueSlice)>; - fn value_slice_len(&mut self, arg0: ValueSlice) -> usize; - fn value_slice_get(&mut self, arg0: ValueSlice, arg1: usize) -> Value; - fn writable_reg_to_reg(&mut self, arg0: WritableReg) -> Reg; - fn u8_from_uimm8(&mut self, arg0: Uimm8) -> u8; - fn u64_from_imm64(&mut self, arg0: Imm64) -> u64; - fn nonzero_u64_from_imm64(&mut self, arg0: Imm64) -> Option; - fn u64_from_ieee32(&mut self, arg0: Ieee32) -> u64; - fn u64_from_ieee64(&mut self, arg0: Ieee64) -> u64; - fn inst_results(&mut self, arg0: Inst) -> ValueSlice; - fn first_result(&mut self, arg0: Inst) -> Option; - fn inst_data(&mut self, arg0: Inst) -> InstructionData; - fn value_type(&mut self, arg0: Value) -> Type; - fn multi_lane(&mut self, arg0: Type) -> Option<(u8, u16)>; - fn def_inst(&mut self, arg0: Value) -> Option; - fn offset32_to_u32(&mut self, arg0: Offset32) -> u32; - fn emit(&mut self, arg0: &MInst) -> Unit; - fn emit_u64_le_const(&mut self, arg0: u64) -> VCodeConstant; - fn trap_code_division_by_zero(&mut self) -> TrapCode; - fn trap_code_integer_overflow(&mut self) -> TrapCode; - fn trap_code_bad_conversion_to_integer(&mut self) -> TrapCode; - fn avoid_div_traps(&mut self, arg0: Type) -> Option<()>; - fn func_ref_data(&mut self, arg0: FuncRef) -> (SigRef, ExternalName, RelocDistance); - fn symbol_value_data( - &mut self, - arg0: GlobalValue, - ) -> Option<(ExternalName, RelocDistance, i64)>; - fn reloc_distance_near(&mut self, arg0: RelocDistance) -> Option<()>; - fn mie2_enabled(&mut self, arg0: Type) -> Option<()>; - fn mie2_disabled(&mut self, arg0: Type) -> Option<()>; - fn vxrs_ext2_enabled(&mut self, arg0: Type) -> Option<()>; - fn vxrs_ext2_disabled(&mut self, arg0: Type) -> Option<()>; - fn allow_div_traps(&mut self, arg0: Type) -> Option<()>; - fn writable_gpr(&mut self, arg0: u8) -> WritableReg; - fn zero_reg(&mut self) -> Reg; - fn gpr32_ty(&mut self, arg0: Type) -> Option; - fn gpr64_ty(&mut self, arg0: Type) -> Option; - fn uimm32shifted(&mut self, arg0: u32, arg1: u8) -> UImm32Shifted; - fn uimm16shifted(&mut self, arg0: u16, arg1: u8) -> UImm16Shifted; - fn i64_nonequal(&mut self, arg0: i64, arg1: i64) -> Option; - fn u8_as_u16(&mut self, arg0: u8) -> u16; - fn u64_as_u32(&mut self, arg0: u64) -> u32; - fn u64_as_i16(&mut self, arg0: u64) -> i16; - fn u64_nonzero_hipart(&mut self, arg0: u64) -> Option; - fn u64_nonzero_lopart(&mut self, arg0: u64) -> Option; - fn i32_from_u64(&mut self, arg0: u64) -> Option; - fn i16_from_u64(&mut self, arg0: u64) -> Option; - fn uimm32shifted_from_u64(&mut self, arg0: u64) -> Option; - fn uimm16shifted_from_u64(&mut self, arg0: u64) -> Option; - fn u64_from_value(&mut self, arg0: Value) -> Option; - fn u32_from_value(&mut self, arg0: Value) -> Option; - fn u8_from_value(&mut self, arg0: Value) -> Option; - fn u64_from_signed_value(&mut self, arg0: Value) -> Option; - fn i64_from_value(&mut self, arg0: Value) -> Option; - fn i32_from_value(&mut self, arg0: Value) -> Option; - fn i16_from_value(&mut self, arg0: Value) -> Option; - fn i16_from_swapped_value(&mut self, arg0: Value) -> Option; - fn i64_from_negated_value(&mut self, arg0: Value) -> Option; - fn i32_from_negated_value(&mut self, arg0: Value) -> Option; - fn i16_from_negated_value(&mut self, arg0: Value) -> Option; - fn uimm16shifted_from_value(&mut self, arg0: Value) -> Option; - fn uimm32shifted_from_value(&mut self, arg0: Value) -> Option; - fn uimm16shifted_from_inverted_value(&mut self, arg0: Value) -> Option; - fn uimm32shifted_from_inverted_value(&mut self, arg0: Value) -> Option; - fn mask_amt_imm(&mut self, arg0: Type, arg1: i64) -> u8; - fn mask_as_cond(&mut self, arg0: u8) -> Cond; - fn intcc_as_cond(&mut self, arg0: &IntCC) -> Cond; - fn floatcc_as_cond(&mut self, arg0: &FloatCC) -> Cond; - fn invert_cond(&mut self, arg0: &Cond) -> Cond; - fn signed(&mut self, arg0: &IntCC) -> Option<()>; - fn unsigned(&mut self, arg0: &IntCC) -> Option<()>; - fn vec_length_minus1(&mut self, arg0: &VecMachLabel) -> u32; - fn vec_element(&mut self, arg0: &VecMachLabel, arg1: u8) -> MachLabel; - fn zero_offset(&mut self) -> Offset32; - fn i64_from_offset(&mut self, arg0: Offset32) -> i64; - fn box_external_name(&mut self, arg0: ExternalName) -> BoxExternalName; - fn littleendian(&mut self, arg0: MemFlags) -> Option<()>; - fn bigendian(&mut self, arg0: MemFlags) -> Option<()>; - fn memflags_trusted(&mut self) -> MemFlags; - fn memarg_reg_plus_reg(&mut self, arg0: Reg, arg1: Reg, arg2: MemFlags) -> MemArg; - fn memarg_reg_plus_off(&mut self, arg0: Reg, arg1: i64, arg2: MemFlags) -> MemArg; - fn memarg_symbol(&mut self, arg0: ExternalName, arg1: i32, arg2: MemFlags) -> MemArg; - fn memarg_symbol_offset_sum(&mut self, arg0: i64, arg1: i64) -> Option; - fn abi_stackslot_addr(&mut self, arg0: WritableReg, arg1: StackSlot, arg2: Offset32) -> MInst; - fn sinkable_inst(&mut self, arg0: Value) -> Option; - fn sink_inst(&mut self, arg0: Inst) -> Unit; - fn inst_builder_new(&mut self) -> VecMInstBuilder; - fn inst_builder_push(&mut self, arg0: &VecMInstBuilder, arg1: &MInst) -> Unit; - fn inst_builder_finish(&mut self, arg0: &VecMInstBuilder) -> VecMInst; - fn real_reg(&mut self, arg0: WritableReg) -> Option; - fn same_reg(&mut self, arg0: WritableReg, arg1: Reg) -> Option; -} - -/// Internal type SideEffectNoResult: defined at src/prelude.isle line 457. -#[derive(Clone, Debug)] -pub enum SideEffectNoResult { - Inst { inst: MInst }, - Inst2 { inst1: MInst, inst2: MInst }, -} - -/// Internal type ProducesFlags: defined at src/prelude.isle line 484. -#[derive(Clone, Debug)] -pub enum ProducesFlags { - ProducesFlagsSideEffect { inst: MInst }, - ProducesFlagsReturnsReg { inst: MInst, result: Reg }, - ProducesFlagsReturnsResultWithConsumer { inst: MInst, result: Reg }, -} - -/// Internal type ConsumesFlags: defined at src/prelude.isle line 495. -#[derive(Clone, Debug)] -pub enum ConsumesFlags { - ConsumesFlagsReturnsResultWithProducer { - inst: MInst, - result: Reg, - }, - ConsumesFlagsReturnsReg { - inst: MInst, - result: Reg, - }, - ConsumesFlagsTwiceReturnsValueRegs { - inst1: MInst, - inst2: MInst, - result: ValueRegs, - }, - ConsumesFlagsFourTimesReturnsValueRegs { - inst1: MInst, - inst2: MInst, - inst3: MInst, - inst4: MInst, - result: ValueRegs, - }, -} - -/// Internal type MInst: defined at src/isa/s390x/inst.isle line 2. -#[derive(Clone, Debug)] -pub enum MInst { - Nop0, - Nop2, - AluRRR { - alu_op: ALUOp, - rd: WritableReg, - rn: Reg, - rm: Reg, - }, - AluRRSImm16 { - alu_op: ALUOp, - rd: WritableReg, - rn: Reg, - imm: i16, - }, - AluRR { - alu_op: ALUOp, - rd: WritableReg, - rm: Reg, - }, - AluRX { - alu_op: ALUOp, - rd: WritableReg, - mem: MemArg, - }, - AluRSImm16 { - alu_op: ALUOp, - rd: WritableReg, - imm: i16, - }, - AluRSImm32 { - alu_op: ALUOp, - rd: WritableReg, - imm: i32, - }, - AluRUImm32 { - alu_op: ALUOp, - rd: WritableReg, - imm: u32, - }, - AluRUImm16Shifted { - alu_op: ALUOp, - rd: WritableReg, - imm: UImm16Shifted, - }, - AluRUImm32Shifted { - alu_op: ALUOp, - rd: WritableReg, - imm: UImm32Shifted, - }, - SMulWide { - rn: Reg, - rm: Reg, - }, - UMulWide { - rn: Reg, - }, - SDivMod32 { - rn: Reg, - }, - SDivMod64 { - rn: Reg, - }, - UDivMod32 { - rn: Reg, - }, - UDivMod64 { - rn: Reg, - }, - Flogr { - rn: Reg, - }, - ShiftRR { - shift_op: ShiftOp, - rd: WritableReg, - rn: Reg, - shift_imm: u8, - shift_reg: Reg, - }, - RxSBG { - op: RxSBGOp, - rd: WritableReg, - rn: Reg, - start_bit: u8, - end_bit: u8, - rotate_amt: i8, - }, - RxSBGTest { - op: RxSBGOp, - rd: Reg, - rn: Reg, - start_bit: u8, - end_bit: u8, - rotate_amt: i8, - }, - UnaryRR { - op: UnaryOp, - rd: WritableReg, - rn: Reg, - }, - CmpRR { - op: CmpOp, - rn: Reg, - rm: Reg, - }, - CmpRX { - op: CmpOp, - rn: Reg, - mem: MemArg, - }, - CmpRSImm16 { - op: CmpOp, - rn: Reg, - imm: i16, - }, - CmpRSImm32 { - op: CmpOp, - rn: Reg, - imm: i32, - }, - CmpRUImm32 { - op: CmpOp, - rn: Reg, - imm: u32, - }, - CmpTrapRR { - op: CmpOp, - rn: Reg, - rm: Reg, - cond: Cond, - trap_code: TrapCode, - }, - CmpTrapRSImm16 { - op: CmpOp, - rn: Reg, - imm: i16, - cond: Cond, - trap_code: TrapCode, - }, - CmpTrapRUImm16 { - op: CmpOp, - rn: Reg, - imm: u16, - cond: Cond, - trap_code: TrapCode, - }, - AtomicRmw { - alu_op: ALUOp, - rd: WritableReg, - rn: Reg, - mem: MemArg, - }, - AtomicCas32 { - rd: WritableReg, - rn: Reg, - mem: MemArg, - }, - AtomicCas64 { - rd: WritableReg, - rn: Reg, - mem: MemArg, - }, - Fence, - Load32 { - rd: WritableReg, - mem: MemArg, - }, - Load32ZExt8 { - rd: WritableReg, - mem: MemArg, - }, - Load32SExt8 { - rd: WritableReg, - mem: MemArg, - }, - Load32ZExt16 { - rd: WritableReg, - mem: MemArg, - }, - Load32SExt16 { - rd: WritableReg, - mem: MemArg, - }, - Load64 { - rd: WritableReg, - mem: MemArg, - }, - Load64ZExt8 { - rd: WritableReg, - mem: MemArg, - }, - Load64SExt8 { - rd: WritableReg, - mem: MemArg, - }, - Load64ZExt16 { - rd: WritableReg, - mem: MemArg, - }, - Load64SExt16 { - rd: WritableReg, - mem: MemArg, - }, - Load64ZExt32 { - rd: WritableReg, - mem: MemArg, - }, - Load64SExt32 { - rd: WritableReg, - mem: MemArg, - }, - LoadRev16 { - rd: WritableReg, - mem: MemArg, - }, - LoadRev32 { - rd: WritableReg, - mem: MemArg, - }, - LoadRev64 { - rd: WritableReg, - mem: MemArg, - }, - Store8 { - rd: Reg, - mem: MemArg, - }, - Store16 { - rd: Reg, - mem: MemArg, - }, - Store32 { - rd: Reg, - mem: MemArg, - }, - Store64 { - rd: Reg, - mem: MemArg, - }, - StoreImm8 { - imm: u8, - mem: MemArg, - }, - StoreImm16 { - imm: i16, - mem: MemArg, - }, - StoreImm32SExt16 { - imm: i16, - mem: MemArg, - }, - StoreImm64SExt16 { - imm: i16, - mem: MemArg, - }, - StoreRev16 { - rd: Reg, - mem: MemArg, - }, - StoreRev32 { - rd: Reg, - mem: MemArg, - }, - StoreRev64 { - rd: Reg, - mem: MemArg, - }, - LoadMultiple64 { - rt: WritableReg, - rt2: WritableReg, - mem: MemArg, - }, - StoreMultiple64 { - rt: Reg, - rt2: Reg, - mem: MemArg, - }, - Mov32 { - rd: WritableReg, - rm: Reg, - }, - Mov64 { - rd: WritableReg, - rm: Reg, - }, - Mov32Imm { - rd: WritableReg, - imm: u32, - }, - Mov32SImm16 { - rd: WritableReg, - imm: i16, - }, - Mov64SImm16 { - rd: WritableReg, - imm: i16, - }, - Mov64SImm32 { - rd: WritableReg, - imm: i32, - }, - Mov64UImm16Shifted { - rd: WritableReg, - imm: UImm16Shifted, - }, - Mov64UImm32Shifted { - rd: WritableReg, - imm: UImm32Shifted, - }, - Insert64UImm16Shifted { - rd: WritableReg, - imm: UImm16Shifted, - }, - Insert64UImm32Shifted { - rd: WritableReg, - imm: UImm32Shifted, - }, - Extend { - rd: WritableReg, - rn: Reg, - signed: bool, - from_bits: u8, - to_bits: u8, - }, - CMov32 { - rd: WritableReg, - cond: Cond, - rm: Reg, - }, - CMov64 { - rd: WritableReg, - cond: Cond, - rm: Reg, - }, - CMov32SImm16 { - rd: WritableReg, - cond: Cond, - imm: i16, - }, - CMov64SImm16 { - rd: WritableReg, - cond: Cond, - imm: i16, - }, - FpuMove32 { - rd: WritableReg, - rn: Reg, - }, - FpuMove64 { - rd: WritableReg, - rn: Reg, - }, - FpuCMov32 { - rd: WritableReg, - cond: Cond, - rm: Reg, - }, - FpuCMov64 { - rd: WritableReg, - cond: Cond, - rm: Reg, - }, - MovToFpr { - rd: WritableReg, - rn: Reg, - }, - MovFromFpr { - rd: WritableReg, - rn: Reg, - }, - FpuRR { - fpu_op: FPUOp1, - rd: WritableReg, - rn: Reg, - }, - FpuRRR { - fpu_op: FPUOp2, - rd: WritableReg, - rm: Reg, - }, - FpuRRRR { - fpu_op: FPUOp3, - rd: WritableReg, - rn: Reg, - rm: Reg, - }, - FpuCopysign { - rd: WritableReg, - rn: Reg, - rm: Reg, - }, - FpuCmp32 { - rn: Reg, - rm: Reg, - }, - FpuCmp64 { - rn: Reg, - rm: Reg, - }, - FpuLoad32 { - rd: WritableReg, - mem: MemArg, - }, - FpuStore32 { - rd: Reg, - mem: MemArg, - }, - FpuLoad64 { - rd: WritableReg, - mem: MemArg, - }, - FpuStore64 { - rd: Reg, - mem: MemArg, - }, - FpuLoadRev32 { - rd: WritableReg, - mem: MemArg, - }, - FpuStoreRev32 { - rd: Reg, - mem: MemArg, - }, - FpuLoadRev64 { - rd: WritableReg, - mem: MemArg, - }, - FpuStoreRev64 { - rd: Reg, - mem: MemArg, - }, - LoadFpuConst32 { - rd: WritableReg, - const_data: u32, - }, - LoadFpuConst64 { - rd: WritableReg, - const_data: u64, - }, - FpuToInt { - op: FpuToIntOp, - rd: WritableReg, - rn: Reg, - }, - IntToFpu { - op: IntToFpuOp, - rd: WritableReg, - rn: Reg, - }, - FpuRound { - op: FpuRoundMode, - rd: WritableReg, - rn: Reg, - }, - FpuVecRRR { - fpu_op: FPUOp2, - rd: WritableReg, - rn: Reg, - rm: Reg, - }, - Call { - link: WritableReg, - info: BoxCallInfo, - }, - CallInd { - link: WritableReg, - info: BoxCallIndInfo, - }, - Ret { - link: Reg, - rets: VecReg, - }, - EpiloguePlaceholder, - Jump { - dest: MachLabel, - }, - CondBr { - taken: MachLabel, - not_taken: MachLabel, - cond: Cond, - }, - TrapIf { - cond: Cond, - trap_code: TrapCode, - }, - OneWayCondBr { - target: MachLabel, - cond: Cond, - }, - IndirectBr { - rn: Reg, - targets: VecMachLabel, - }, - Debugtrap, - Trap { - trap_code: TrapCode, - }, - JTSequence { - ridx: Reg, - targets: VecMachLabel, - }, - LoadExtNameFar { - rd: WritableReg, - name: BoxExternalName, - offset: i64, - }, - LoadAddr { - rd: WritableReg, - mem: MemArg, - }, - Loop { - body: VecMInst, - cond: Cond, - }, - CondBreak { - cond: Cond, - }, - VirtualSPOffsetAdj { - offset: i64, - }, - DummyUse { - reg: Reg, - }, - Unwind { - inst: UnwindInst, - }, -} - -/// Internal type ALUOp: defined at src/isa/s390x/inst.isle line 717. -#[derive(Copy, Clone, PartialEq, Eq, Debug)] -pub enum ALUOp { - Add32, - Add32Ext16, - Add64, - Add64Ext16, - Add64Ext32, - AddLogical32, - AddLogical64, - AddLogical64Ext32, - Sub32, - Sub32Ext16, - Sub64, - Sub64Ext16, - Sub64Ext32, - SubLogical32, - SubLogical64, - SubLogical64Ext32, - Mul32, - Mul32Ext16, - Mul64, - Mul64Ext16, - Mul64Ext32, - And32, - And64, - Orr32, - Orr64, - Xor32, - Xor64, - AndNot32, - AndNot64, - OrrNot32, - OrrNot64, - XorNot32, - XorNot64, -} - -/// Internal type UnaryOp: defined at src/isa/s390x/inst.isle line 758. -#[derive(Copy, Clone, PartialEq, Eq, Debug)] -pub enum UnaryOp { - Abs32, - Abs64, - Abs64Ext32, - Neg32, - Neg64, - Neg64Ext32, - PopcntByte, - PopcntReg, - BSwap32, - BSwap64, -} - -/// Internal type ShiftOp: defined at src/isa/s390x/inst.isle line 773. -#[derive(Copy, Clone, PartialEq, Eq, Debug)] -pub enum ShiftOp { - RotL32, - RotL64, - LShL32, - LShL64, - LShR32, - LShR64, - AShR32, - AShR64, -} - -/// Internal type RxSBGOp: defined at src/isa/s390x/inst.isle line 786. -#[derive(Copy, Clone, PartialEq, Eq, Debug)] -pub enum RxSBGOp { - Insert, - And, - Or, - Xor, -} - -/// Internal type CmpOp: defined at src/isa/s390x/inst.isle line 795. -#[derive(Copy, Clone, PartialEq, Eq, Debug)] -pub enum CmpOp { - CmpS32, - CmpS32Ext16, - CmpS64, - CmpS64Ext16, - CmpS64Ext32, - CmpL32, - CmpL32Ext16, - CmpL64, - CmpL64Ext16, - CmpL64Ext32, -} - -/// Internal type FPUOp1: defined at src/isa/s390x/inst.isle line 810. -#[derive(Copy, Clone, PartialEq, Eq, Debug)] -pub enum FPUOp1 { - Abs32, - Abs64, - Neg32, - Neg64, - NegAbs32, - NegAbs64, - Sqrt32, - Sqrt64, - Cvt32To64, - Cvt64To32, -} - -/// Internal type FPUOp2: defined at src/isa/s390x/inst.isle line 825. -#[derive(Copy, Clone, PartialEq, Eq, Debug)] -pub enum FPUOp2 { - Add32, - Add64, - Sub32, - Sub64, - Mul32, - Mul64, - Div32, - Div64, - Max32, - Max64, - Min32, - Min64, -} - -/// Internal type FPUOp3: defined at src/isa/s390x/inst.isle line 842. -#[derive(Copy, Clone, PartialEq, Eq, Debug)] -pub enum FPUOp3 { - MAdd32, - MAdd64, - MSub32, - MSub64, -} - -/// Internal type FpuToIntOp: defined at src/isa/s390x/inst.isle line 851. -#[derive(Copy, Clone, PartialEq, Eq, Debug)] -pub enum FpuToIntOp { - F32ToU32, - F32ToI32, - F32ToU64, - F32ToI64, - F64ToU32, - F64ToI32, - F64ToU64, - F64ToI64, -} - -/// Internal type IntToFpuOp: defined at src/isa/s390x/inst.isle line 864. -#[derive(Copy, Clone, PartialEq, Eq, Debug)] -pub enum IntToFpuOp { - U32ToF32, - I32ToF32, - U32ToF64, - I32ToF64, - U64ToF32, - I64ToF32, - U64ToF64, - I64ToF64, -} - -/// Internal type FpuRoundMode: defined at src/isa/s390x/inst.isle line 878. -#[derive(Copy, Clone, PartialEq, Eq, Debug)] -pub enum FpuRoundMode { - Minus32, - Minus64, - Plus32, - Plus64, - Zero32, - Zero64, - Nearest32, - Nearest64, -} - -/// Internal type WritableRegPair: defined at src/isa/s390x/inst.isle line 1278. -#[derive(Clone, Debug)] -pub enum WritableRegPair { - WritableRegPair { hi: WritableReg, lo: WritableReg }, -} - -/// Internal type RegPair: defined at src/isa/s390x/inst.isle line 1300. -#[derive(Clone, Debug)] -pub enum RegPair { - RegPair { hi: Reg, lo: Reg }, -} - -/// Internal type ProducesBool: defined at src/isa/s390x/inst.isle line 2327. -#[derive(Clone, Debug)] -pub enum ProducesBool { - ProducesBool { producer: ProducesFlags, cond: Cond }, -} - -// Generated as internal constructor for term output_reg. -pub fn constructor_output_reg(ctx: &mut C, arg0: Reg) -> Option { - let pattern0_0 = arg0; - // Rule at src/prelude.isle line 113. - let expr0_0 = C::value_reg(ctx, pattern0_0); - let expr1_0 = C::output(ctx, expr0_0); - return Some(expr1_0); -} - -// Generated as internal constructor for term output_value. -pub fn constructor_output_value(ctx: &mut C, arg0: Value) -> Option { - let pattern0_0 = arg0; - // Rule at src/prelude.isle line 117. - let expr0_0 = C::put_in_regs(ctx, pattern0_0); - let expr1_0 = C::output(ctx, expr0_0); - return Some(expr1_0); -} - -// Generated as internal constructor for term temp_reg. -pub fn constructor_temp_reg(ctx: &mut C, arg0: Type) -> Option { - let pattern0_0 = arg0; - // Rule at src/prelude.isle line 137. - let expr0_0 = C::temp_writable_reg(ctx, pattern0_0); - let expr1_0 = C::writable_reg_to_reg(ctx, expr0_0); - return Some(expr1_0); -} - -// Generated as internal constructor for term lo_reg. -pub fn constructor_lo_reg(ctx: &mut C, arg0: Value) -> Option { - let pattern0_0 = arg0; - // Rule at src/prelude.isle line 182. - let expr0_0 = C::put_in_regs(ctx, pattern0_0); - let expr1_0: usize = 0; - let expr2_0 = C::value_regs_get(ctx, expr0_0, expr1_0); - return Some(expr2_0); -} - -// Generated as internal constructor for term side_effect. -pub fn constructor_side_effect( - ctx: &mut C, - arg0: &SideEffectNoResult, -) -> Option { - let pattern0_0 = arg0; - match pattern0_0 { - &SideEffectNoResult::Inst { - inst: ref pattern1_0, - } => { - // Rule at src/prelude.isle line 465. - let expr0_0 = C::emit(ctx, pattern1_0); - let expr1_0 = C::output_none(ctx); - return Some(expr1_0); - } - &SideEffectNoResult::Inst2 { - inst1: ref pattern1_0, - inst2: ref pattern1_1, - } => { - // Rule at src/prelude.isle line 468. - let expr0_0 = C::emit(ctx, pattern1_0); - let expr1_0 = C::emit(ctx, pattern1_1); - let expr2_0 = C::output_none(ctx); - return Some(expr2_0); - } - _ => {} - } - return None; -} - -// Generated as internal constructor for term side_effect_concat. -pub fn constructor_side_effect_concat( - ctx: &mut C, - arg0: &SideEffectNoResult, - arg1: &SideEffectNoResult, -) -> Option { - let pattern0_0 = arg0; - if let &SideEffectNoResult::Inst { - inst: ref pattern1_0, - } = pattern0_0 - { - let pattern2_0 = arg1; - if let &SideEffectNoResult::Inst { - inst: ref pattern3_0, - } = pattern2_0 - { - // Rule at src/prelude.isle line 474. - let expr0_0 = SideEffectNoResult::Inst2 { - inst1: pattern1_0.clone(), - inst2: pattern3_0.clone(), - }; - return Some(expr0_0); - } - } - return None; -} - -// Generated as internal constructor for term produces_flags_get_reg. -pub fn constructor_produces_flags_get_reg( - ctx: &mut C, - arg0: &ProducesFlags, -) -> Option { - let pattern0_0 = arg0; - if let &ProducesFlags::ProducesFlagsReturnsReg { - inst: ref pattern1_0, - result: pattern1_1, - } = pattern0_0 - { - // Rule at src/prelude.isle line 511. - return Some(pattern1_1); - } - return None; -} - -// Generated as internal constructor for term produces_flags_ignore. -pub fn constructor_produces_flags_ignore( - ctx: &mut C, - arg0: &ProducesFlags, -) -> Option { - let pattern0_0 = arg0; - match pattern0_0 { - &ProducesFlags::ProducesFlagsReturnsReg { - inst: ref pattern1_0, - result: pattern1_1, - } => { - // Rule at src/prelude.isle line 516. - let expr0_0 = ProducesFlags::ProducesFlagsSideEffect { - inst: pattern1_0.clone(), - }; - return Some(expr0_0); - } - &ProducesFlags::ProducesFlagsReturnsResultWithConsumer { - inst: ref pattern1_0, - result: pattern1_1, - } => { - // Rule at src/prelude.isle line 518. - let expr0_0 = ProducesFlags::ProducesFlagsSideEffect { - inst: pattern1_0.clone(), - }; - return Some(expr0_0); - } - _ => {} - } - return None; -} - -// Generated as internal constructor for term consumes_flags_concat. -pub fn constructor_consumes_flags_concat( - ctx: &mut C, - arg0: &ConsumesFlags, - arg1: &ConsumesFlags, -) -> Option { - let pattern0_0 = arg0; - if let &ConsumesFlags::ConsumesFlagsReturnsReg { - inst: ref pattern1_0, - result: pattern1_1, - } = pattern0_0 - { - let pattern2_0 = arg1; - if let &ConsumesFlags::ConsumesFlagsReturnsReg { - inst: ref pattern3_0, - result: pattern3_1, - } = pattern2_0 - { - // Rule at src/prelude.isle line 525. - let expr0_0 = C::value_regs(ctx, pattern1_1, pattern3_1); - let expr1_0 = ConsumesFlags::ConsumesFlagsTwiceReturnsValueRegs { - inst1: pattern1_0.clone(), - inst2: pattern3_0.clone(), - result: expr0_0, - }; - return Some(expr1_0); - } - } - return None; -} - -// Generated as internal constructor for term with_flags. -pub fn constructor_with_flags( - ctx: &mut C, - arg0: &ProducesFlags, - arg1: &ConsumesFlags, -) -> Option { - let pattern0_0 = arg0; - match pattern0_0 { - &ProducesFlags::ProducesFlagsSideEffect { - inst: ref pattern1_0, - } => { - let pattern2_0 = arg1; - match pattern2_0 { - &ConsumesFlags::ConsumesFlagsReturnsReg { - inst: ref pattern3_0, - result: pattern3_1, - } => { - // Rule at src/prelude.isle line 550. - let expr0_0 = C::emit(ctx, pattern1_0); - let expr1_0 = C::emit(ctx, pattern3_0); - let expr2_0 = C::value_reg(ctx, pattern3_1); - return Some(expr2_0); - } - &ConsumesFlags::ConsumesFlagsTwiceReturnsValueRegs { - inst1: ref pattern3_0, - inst2: ref pattern3_1, - result: pattern3_2, - } => { - // Rule at src/prelude.isle line 556. - let expr0_0 = C::emit(ctx, pattern1_0); - let expr1_0 = C::emit(ctx, pattern3_0); - let expr2_0 = C::emit(ctx, pattern3_1); - return Some(pattern3_2); - } - &ConsumesFlags::ConsumesFlagsFourTimesReturnsValueRegs { - inst1: ref pattern3_0, - inst2: ref pattern3_1, - inst3: ref pattern3_2, - inst4: ref pattern3_3, - result: pattern3_4, - } => { - // Rule at src/prelude.isle line 568. - let expr0_0 = C::emit(ctx, pattern1_0); - let expr1_0 = C::emit(ctx, pattern3_0); - let expr2_0 = C::emit(ctx, pattern3_1); - let expr3_0 = C::emit(ctx, pattern3_2); - let expr4_0 = C::emit(ctx, pattern3_3); - return Some(pattern3_4); - } - _ => {} - } - } - &ProducesFlags::ProducesFlagsReturnsResultWithConsumer { - inst: ref pattern1_0, - result: pattern1_1, - } => { - let pattern2_0 = arg1; - if let &ConsumesFlags::ConsumesFlagsReturnsResultWithProducer { - inst: ref pattern3_0, - result: pattern3_1, - } = pattern2_0 - { - // Rule at src/prelude.isle line 544. - let expr0_0 = C::emit(ctx, pattern1_0); - let expr1_0 = C::emit(ctx, pattern3_0); - let expr2_0 = C::value_regs(ctx, pattern1_1, pattern3_1); - return Some(expr2_0); - } - } - _ => {} - } - return None; -} - -// Generated as internal constructor for term with_flags_reg. -pub fn constructor_with_flags_reg( - ctx: &mut C, - arg0: &ProducesFlags, - arg1: &ConsumesFlags, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/prelude.isle line 585. - let expr0_0 = constructor_with_flags(ctx, pattern0_0, pattern1_0)?; - let expr1_0: usize = 0; - let expr2_0 = C::value_regs_get(ctx, expr0_0, expr1_0); - return Some(expr2_0); -} - -// Generated as internal constructor for term i64_nonzero. -pub fn constructor_i64_nonzero(ctx: &mut C, arg0: i64) -> Option { - let pattern0_0 = arg0; - let mut closure1 = || { - let expr0_0: i64 = 0; - let expr1_0 = C::i64_nonequal(ctx, pattern0_0, expr0_0)?; - return Some(expr1_0); - }; - if let Some(pattern1_0) = closure1() { - // Rule at src/isa/s390x/inst.isle line 944. - return Some(pattern0_0); - } - return None; -} - -// Generated as internal constructor for term i64_not_neg1. -pub fn constructor_i64_not_neg1(ctx: &mut C, arg0: i64) -> Option { - let pattern0_0 = arg0; - let mut closure1 = || { - let expr0_0: i64 = -1; - let expr1_0 = C::i64_nonequal(ctx, pattern0_0, expr0_0)?; - return Some(expr1_0); - }; - if let Some(pattern1_0) = closure1() { - // Rule at src/isa/s390x/inst.isle line 949. - return Some(pattern0_0); - } - return None; -} - -// Generated as internal constructor for term mask_amt_reg. -pub fn constructor_mask_amt_reg(ctx: &mut C, arg0: Type, arg1: Reg) -> Option { - let pattern0_0 = arg0; - if let Some(pattern1_0) = C::gpr32_ty(ctx, pattern0_0) { - let pattern2_0 = arg1; - // Rule at src/isa/s390x/inst.isle line 1044. - let expr0_0: i64 = -1; - let expr1_0 = C::mask_amt_imm(ctx, pattern1_0, expr0_0); - let expr2_0 = C::u8_as_u16(ctx, expr1_0); - let expr3_0: u8 = 0; - let expr4_0 = C::uimm16shifted(ctx, expr2_0, expr3_0); - let expr5_0 = constructor_and_uimm16shifted(ctx, pattern1_0, pattern2_0, expr4_0)?; - return Some(expr5_0); - } - if let Some(pattern1_0) = C::gpr64_ty(ctx, pattern0_0) { - let pattern2_0 = arg1; - // Rule at src/isa/s390x/inst.isle line 1047. - return Some(pattern2_0); - } - return None; -} - -// Generated as internal constructor for term memarg_symbol_offset. -pub fn constructor_memarg_symbol_offset(ctx: &mut C, arg0: i64) -> Option { - let pattern0_0 = arg0; - // Rule at src/isa/s390x/inst.isle line 1128. - let expr0_0: i64 = 0; - let expr1_0 = C::memarg_symbol_offset_sum(ctx, pattern0_0, expr0_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term lower_address. -pub fn constructor_lower_address( - ctx: &mut C, - arg0: MemFlags, - arg1: Value, - arg2: Offset32, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - if let Some(pattern2_0) = C::def_inst(ctx, pattern1_0) { - let pattern3_0 = C::inst_data(ctx, pattern2_0); - match &pattern3_0 { - &InstructionData::UnaryGlobalValue { - opcode: ref pattern4_0, - global_value: pattern4_1, - } => { - if let &Opcode::SymbolValue = pattern4_0 { - if let Some((pattern6_0, pattern6_1, pattern6_2)) = - C::symbol_value_data(ctx, pattern4_1) - { - if let Some(()) = C::reloc_distance_near(ctx, pattern6_1) { - let pattern8_0 = arg2; - let pattern9_0 = C::i64_from_offset(ctx, pattern8_0); - let mut closure10 = || { - let expr0_0 = - C::memarg_symbol_offset_sum(ctx, pattern9_0, pattern6_2)?; - return Some(expr0_0); - }; - if let Some(pattern10_0) = closure10() { - // Rule at src/isa/s390x/inst.isle line 1141. - let expr0_0 = - C::memarg_symbol(ctx, pattern6_0, pattern10_0, pattern0_0); - return Some(expr0_0); - } - } - } - } - } - &InstructionData::Binary { - opcode: ref pattern4_0, - args: ref pattern4_1, - } => { - if let &Opcode::Iadd = pattern4_0 { - let (pattern6_0, pattern6_1) = C::unpack_value_array_2(ctx, pattern4_1); - let pattern7_0 = arg2; - let pattern8_0 = C::i64_from_offset(ctx, pattern7_0); - if pattern8_0 == 0 { - // Rule at src/isa/s390x/inst.isle line 1138. - let expr0_0 = C::put_in_reg(ctx, pattern6_0); - let expr1_0 = C::put_in_reg(ctx, pattern6_1); - let expr2_0 = C::memarg_reg_plus_reg(ctx, expr0_0, expr1_0, pattern0_0); - return Some(expr2_0); - } - } - } - _ => {} - } - } - let pattern2_0 = arg2; - let pattern3_0 = C::i64_from_offset(ctx, pattern2_0); - // Rule at src/isa/s390x/inst.isle line 1135. - let expr0_0 = C::put_in_reg(ctx, pattern1_0); - let expr1_0 = C::memarg_reg_plus_off(ctx, expr0_0, pattern3_0, pattern0_0); - return Some(expr1_0); -} - -// Generated as internal constructor for term load_sym. -pub fn constructor_load_sym(ctx: &mut C, arg0: Inst) -> Option { - let pattern0_0 = arg0; - let mut closure1 = || { - return Some(pattern0_0); - }; - if let Some(pattern1_0) = closure1() { - let pattern2_0 = C::inst_data(ctx, pattern1_0); - if let &InstructionData::Load { - opcode: ref pattern3_0, - arg: pattern3_1, - flags: pattern3_2, - offset: pattern3_3, - } = &pattern2_0 - { - if let &Opcode::Load = pattern3_0 { - if let Some(pattern5_0) = C::def_inst(ctx, pattern3_1) { - let pattern6_0 = C::inst_data(ctx, pattern5_0); - if let &InstructionData::UnaryGlobalValue { - opcode: ref pattern7_0, - global_value: pattern7_1, - } = &pattern6_0 - { - if let &Opcode::SymbolValue = pattern7_0 { - if let Some((pattern9_0, pattern9_1, pattern9_2)) = - C::symbol_value_data(ctx, pattern7_1) - { - if let Some(()) = C::reloc_distance_near(ctx, pattern9_1) { - let pattern11_0 = C::i64_from_offset(ctx, pattern3_3); - let mut closure12 = || { - let expr0_0 = C::memarg_symbol_offset_sum( - ctx, - pattern9_2, - pattern11_0, - )?; - return Some(expr0_0); - }; - if let Some(pattern12_0) = closure12() { - // Rule at src/isa/s390x/inst.isle line 1151. - return Some(pattern0_0); - } - } - } - } - } - } - } - } - } - return None; -} - -// Generated as internal constructor for term uload16_sym. -pub fn constructor_uload16_sym(ctx: &mut C, arg0: Inst) -> Option { - let pattern0_0 = arg0; - let mut closure1 = || { - return Some(pattern0_0); - }; - if let Some(pattern1_0) = closure1() { - let pattern2_0 = C::inst_data(ctx, pattern1_0); - if let &InstructionData::Load { - opcode: ref pattern3_0, - arg: pattern3_1, - flags: pattern3_2, - offset: pattern3_3, - } = &pattern2_0 - { - if let &Opcode::Uload16 = pattern3_0 { - if let Some(pattern5_0) = C::def_inst(ctx, pattern3_1) { - let pattern6_0 = C::inst_data(ctx, pattern5_0); - if let &InstructionData::UnaryGlobalValue { - opcode: ref pattern7_0, - global_value: pattern7_1, - } = &pattern6_0 - { - if let &Opcode::SymbolValue = pattern7_0 { - if let Some((pattern9_0, pattern9_1, pattern9_2)) = - C::symbol_value_data(ctx, pattern7_1) - { - if let Some(()) = C::reloc_distance_near(ctx, pattern9_1) { - let pattern11_0 = C::i64_from_offset(ctx, pattern3_3); - let mut closure12 = || { - let expr0_0 = C::memarg_symbol_offset_sum( - ctx, - pattern9_2, - pattern11_0, - )?; - return Some(expr0_0); - }; - if let Some(pattern12_0) = closure12() { - // Rule at src/isa/s390x/inst.isle line 1159. - return Some(pattern0_0); - } - } - } - } - } - } - } - } - } - return None; -} - -// Generated as internal constructor for term stack_addr_impl. -pub fn constructor_stack_addr_impl( - ctx: &mut C, - arg0: Type, - arg1: StackSlot, - arg2: Offset32, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 1172. - let expr0_0 = C::temp_writable_reg(ctx, pattern0_0); - let expr1_0 = C::abi_stackslot_addr(ctx, expr0_0, pattern1_0, pattern2_0); - let expr2_0 = C::emit(ctx, &expr1_0); - let expr3_0 = C::writable_reg_to_reg(ctx, expr0_0); - return Some(expr3_0); -} - -// Generated as internal constructor for term sink_load. -pub fn constructor_sink_load(ctx: &mut C, arg0: Inst) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = C::inst_data(ctx, pattern0_0); - if let &InstructionData::Load { - opcode: ref pattern2_0, - arg: pattern2_1, - flags: pattern2_2, - offset: pattern2_3, - } = &pattern1_0 - { - if let &Opcode::Load = pattern2_0 { - // Rule at src/isa/s390x/inst.isle line 1242. - let expr0_0 = C::sink_inst(ctx, pattern0_0); - let expr1_0 = constructor_lower_address(ctx, pattern2_2, pattern2_1, pattern2_3)?; - return Some(expr1_0); - } - } - return None; -} - -// Generated as internal constructor for term sink_sload16. -pub fn constructor_sink_sload16(ctx: &mut C, arg0: Inst) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = C::inst_data(ctx, pattern0_0); - if let &InstructionData::Load { - opcode: ref pattern2_0, - arg: pattern2_1, - flags: pattern2_2, - offset: pattern2_3, - } = &pattern1_0 - { - if let &Opcode::Sload16 = pattern2_0 { - // Rule at src/isa/s390x/inst.isle line 1249. - let expr0_0 = C::sink_inst(ctx, pattern0_0); - let expr1_0 = constructor_lower_address(ctx, pattern2_2, pattern2_1, pattern2_3)?; - return Some(expr1_0); - } - } - return None; -} - -// Generated as internal constructor for term sink_sload32. -pub fn constructor_sink_sload32(ctx: &mut C, arg0: Inst) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = C::inst_data(ctx, pattern0_0); - if let &InstructionData::Load { - opcode: ref pattern2_0, - arg: pattern2_1, - flags: pattern2_2, - offset: pattern2_3, - } = &pattern1_0 - { - if let &Opcode::Sload32 = pattern2_0 { - // Rule at src/isa/s390x/inst.isle line 1256. - let expr0_0 = C::sink_inst(ctx, pattern0_0); - let expr1_0 = constructor_lower_address(ctx, pattern2_2, pattern2_1, pattern2_3)?; - return Some(expr1_0); - } - } - return None; -} - -// Generated as internal constructor for term sink_uload16. -pub fn constructor_sink_uload16(ctx: &mut C, arg0: Inst) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = C::inst_data(ctx, pattern0_0); - if let &InstructionData::Load { - opcode: ref pattern2_0, - arg: pattern2_1, - flags: pattern2_2, - offset: pattern2_3, - } = &pattern1_0 - { - if let &Opcode::Uload16 = pattern2_0 { - // Rule at src/isa/s390x/inst.isle line 1263. - let expr0_0 = C::sink_inst(ctx, pattern0_0); - let expr1_0 = constructor_lower_address(ctx, pattern2_2, pattern2_1, pattern2_3)?; - return Some(expr1_0); - } - } - return None; -} - -// Generated as internal constructor for term sink_uload32. -pub fn constructor_sink_uload32(ctx: &mut C, arg0: Inst) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = C::inst_data(ctx, pattern0_0); - if let &InstructionData::Load { - opcode: ref pattern2_0, - arg: pattern2_1, - flags: pattern2_2, - offset: pattern2_3, - } = &pattern1_0 - { - if let &Opcode::Uload32 = pattern2_0 { - // Rule at src/isa/s390x/inst.isle line 1270. - let expr0_0 = C::sink_inst(ctx, pattern0_0); - let expr1_0 = constructor_lower_address(ctx, pattern2_2, pattern2_1, pattern2_3)?; - return Some(expr1_0); - } - } - return None; -} - -// Generated as internal constructor for term temp_writable_regpair. -pub fn constructor_temp_writable_regpair(ctx: &mut C) -> Option { - // Rule at src/isa/s390x/inst.isle line 1283. - let expr0_0: u8 = 0; - let expr1_0 = C::writable_gpr(ctx, expr0_0); - let expr2_0: u8 = 1; - let expr3_0 = C::writable_gpr(ctx, expr2_0); - let expr4_0 = WritableRegPair::WritableRegPair { - hi: expr1_0, - lo: expr3_0, - }; - return Some(expr4_0); -} - -// Generated as internal constructor for term copy_writable_regpair. -pub fn constructor_copy_writable_regpair( - ctx: &mut C, - arg0: &RegPair, -) -> Option { - let pattern0_0 = arg0; - // Rule at src/isa/s390x/inst.isle line 1289. - let expr0_0 = constructor_temp_writable_regpair(ctx)?; - return Some(expr0_0); -} - -// Generated as internal constructor for term writable_regpair_hi. -pub fn constructor_writable_regpair_hi( - ctx: &mut C, - arg0: &WritableRegPair, -) -> Option { - let pattern0_0 = arg0; - if let &WritableRegPair::WritableRegPair { - hi: pattern1_0, - lo: pattern1_1, - } = pattern0_0 - { - // Rule at src/isa/s390x/inst.isle line 1293. - return Some(pattern1_0); - } - return None; -} - -// Generated as internal constructor for term writable_regpair_lo. -pub fn constructor_writable_regpair_lo( - ctx: &mut C, - arg0: &WritableRegPair, -) -> Option { - let pattern0_0 = arg0; - if let &WritableRegPair::WritableRegPair { - hi: pattern1_0, - lo: pattern1_1, - } = pattern0_0 - { - // Rule at src/isa/s390x/inst.isle line 1297. - return Some(pattern1_1); - } - return None; -} - -// Generated as internal constructor for term writable_regpair_to_regpair. -pub fn constructor_writable_regpair_to_regpair( - ctx: &mut C, - arg0: &WritableRegPair, -) -> Option { - let pattern0_0 = arg0; - if let &WritableRegPair::WritableRegPair { - hi: pattern1_0, - lo: pattern1_1, - } = pattern0_0 - { - // Rule at src/isa/s390x/inst.isle line 1304. - let expr0_0 = C::writable_reg_to_reg(ctx, pattern1_0); - let expr1_0 = C::writable_reg_to_reg(ctx, pattern1_1); - let expr2_0 = RegPair::RegPair { - hi: expr0_0, - lo: expr1_0, - }; - return Some(expr2_0); - } - return None; -} - -// Generated as internal constructor for term uninitialized_regpair. -pub fn constructor_uninitialized_regpair(ctx: &mut C) -> Option { - // Rule at src/isa/s390x/inst.isle line 1309. - let expr0_0 = constructor_temp_writable_regpair(ctx)?; - let expr1_0 = constructor_writable_regpair_to_regpair(ctx, &expr0_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term regpair_hi. -pub fn constructor_regpair_hi(ctx: &mut C, arg0: &RegPair) -> Option { - let pattern0_0 = arg0; - if let &RegPair::RegPair { - hi: pattern1_0, - lo: pattern1_1, - } = pattern0_0 - { - // Rule at src/isa/s390x/inst.isle line 1314. - return Some(pattern1_0); - } - return None; -} - -// Generated as internal constructor for term regpair_lo. -pub fn constructor_regpair_lo(ctx: &mut C, arg0: &RegPair) -> Option { - let pattern0_0 = arg0; - if let &RegPair::RegPair { - hi: pattern1_0, - lo: pattern1_1, - } = pattern0_0 - { - // Rule at src/isa/s390x/inst.isle line 1318. - return Some(pattern1_1); - } - return None; -} - -// Generated as internal constructor for term alu_rrr. -pub fn constructor_alu_rrr( - ctx: &mut C, - arg0: Type, - arg1: &ALUOp, - arg2: Reg, - arg3: Reg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - let pattern3_0 = arg3; - // Rule at src/isa/s390x/inst.isle line 1325. - let expr0_0 = C::temp_writable_reg(ctx, pattern0_0); - let expr1_0 = MInst::AluRRR { - alu_op: pattern1_0.clone(), - rd: expr0_0, - rn: pattern2_0, - rm: pattern3_0, - }; - let expr2_0 = C::emit(ctx, &expr1_0); - let expr3_0 = C::writable_reg_to_reg(ctx, expr0_0); - return Some(expr3_0); -} - -// Generated as internal constructor for term alu_rrsimm16. -pub fn constructor_alu_rrsimm16( - ctx: &mut C, - arg0: Type, - arg1: &ALUOp, - arg2: Reg, - arg3: i16, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - let pattern3_0 = arg3; - // Rule at src/isa/s390x/inst.isle line 1332. - let expr0_0 = C::temp_writable_reg(ctx, pattern0_0); - let expr1_0 = MInst::AluRRSImm16 { - alu_op: pattern1_0.clone(), - rd: expr0_0, - rn: pattern2_0, - imm: pattern3_0, - }; - let expr2_0 = C::emit(ctx, &expr1_0); - let expr3_0 = C::writable_reg_to_reg(ctx, expr0_0); - return Some(expr3_0); -} - -// Generated as internal constructor for term alu_rr. -pub fn constructor_alu_rr( - ctx: &mut C, - arg0: Type, - arg1: &ALUOp, - arg2: Reg, - arg3: Reg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - let pattern3_0 = arg3; - // Rule at src/isa/s390x/inst.isle line 1339. - let expr0_0 = constructor_copy_writable_reg(ctx, pattern0_0, pattern2_0)?; - let expr1_0 = MInst::AluRR { - alu_op: pattern1_0.clone(), - rd: expr0_0, - rm: pattern3_0, - }; - let expr2_0 = C::emit(ctx, &expr1_0); - let expr3_0 = C::writable_reg_to_reg(ctx, expr0_0); - return Some(expr3_0); -} - -// Generated as internal constructor for term alu_rx. -pub fn constructor_alu_rx( - ctx: &mut C, - arg0: Type, - arg1: &ALUOp, - arg2: Reg, - arg3: &MemArg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - let pattern3_0 = arg3; - // Rule at src/isa/s390x/inst.isle line 1346. - let expr0_0 = constructor_copy_writable_reg(ctx, pattern0_0, pattern2_0)?; - let expr1_0 = MInst::AluRX { - alu_op: pattern1_0.clone(), - rd: expr0_0, - mem: pattern3_0.clone(), - }; - let expr2_0 = C::emit(ctx, &expr1_0); - let expr3_0 = C::writable_reg_to_reg(ctx, expr0_0); - return Some(expr3_0); -} - -// Generated as internal constructor for term alu_rsimm16. -pub fn constructor_alu_rsimm16( - ctx: &mut C, - arg0: Type, - arg1: &ALUOp, - arg2: Reg, - arg3: i16, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - let pattern3_0 = arg3; - // Rule at src/isa/s390x/inst.isle line 1353. - let expr0_0 = constructor_copy_writable_reg(ctx, pattern0_0, pattern2_0)?; - let expr1_0 = MInst::AluRSImm16 { - alu_op: pattern1_0.clone(), - rd: expr0_0, - imm: pattern3_0, - }; - let expr2_0 = C::emit(ctx, &expr1_0); - let expr3_0 = C::writable_reg_to_reg(ctx, expr0_0); - return Some(expr3_0); -} - -// Generated as internal constructor for term alu_rsimm32. -pub fn constructor_alu_rsimm32( - ctx: &mut C, - arg0: Type, - arg1: &ALUOp, - arg2: Reg, - arg3: i32, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - let pattern3_0 = arg3; - // Rule at src/isa/s390x/inst.isle line 1360. - let expr0_0 = constructor_copy_writable_reg(ctx, pattern0_0, pattern2_0)?; - let expr1_0 = MInst::AluRSImm32 { - alu_op: pattern1_0.clone(), - rd: expr0_0, - imm: pattern3_0, - }; - let expr2_0 = C::emit(ctx, &expr1_0); - let expr3_0 = C::writable_reg_to_reg(ctx, expr0_0); - return Some(expr3_0); -} - -// Generated as internal constructor for term alu_ruimm32. -pub fn constructor_alu_ruimm32( - ctx: &mut C, - arg0: Type, - arg1: &ALUOp, - arg2: Reg, - arg3: u32, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - let pattern3_0 = arg3; - // Rule at src/isa/s390x/inst.isle line 1367. - let expr0_0 = constructor_copy_writable_reg(ctx, pattern0_0, pattern2_0)?; - let expr1_0 = MInst::AluRUImm32 { - alu_op: pattern1_0.clone(), - rd: expr0_0, - imm: pattern3_0, - }; - let expr2_0 = C::emit(ctx, &expr1_0); - let expr3_0 = C::writable_reg_to_reg(ctx, expr0_0); - return Some(expr3_0); -} - -// Generated as internal constructor for term alu_ruimm16shifted. -pub fn constructor_alu_ruimm16shifted( - ctx: &mut C, - arg0: Type, - arg1: &ALUOp, - arg2: Reg, - arg3: UImm16Shifted, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - let pattern3_0 = arg3; - // Rule at src/isa/s390x/inst.isle line 1374. - let expr0_0 = constructor_copy_writable_reg(ctx, pattern0_0, pattern2_0)?; - let expr1_0 = MInst::AluRUImm16Shifted { - alu_op: pattern1_0.clone(), - rd: expr0_0, - imm: pattern3_0, - }; - let expr2_0 = C::emit(ctx, &expr1_0); - let expr3_0 = C::writable_reg_to_reg(ctx, expr0_0); - return Some(expr3_0); -} - -// Generated as internal constructor for term alu_ruimm32shifted. -pub fn constructor_alu_ruimm32shifted( - ctx: &mut C, - arg0: Type, - arg1: &ALUOp, - arg2: Reg, - arg3: UImm32Shifted, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - let pattern3_0 = arg3; - // Rule at src/isa/s390x/inst.isle line 1381. - let expr0_0 = constructor_copy_writable_reg(ctx, pattern0_0, pattern2_0)?; - let expr1_0 = MInst::AluRUImm32Shifted { - alu_op: pattern1_0.clone(), - rd: expr0_0, - imm: pattern3_0, - }; - let expr2_0 = C::emit(ctx, &expr1_0); - let expr3_0 = C::writable_reg_to_reg(ctx, expr0_0); - return Some(expr3_0); -} - -// Generated as internal constructor for term smul_wide. -pub fn constructor_smul_wide(ctx: &mut C, arg0: Reg, arg1: Reg) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/s390x/inst.isle line 1388. - let expr0_0 = constructor_temp_writable_regpair(ctx)?; - let expr1_0 = MInst::SMulWide { - rn: pattern0_0, - rm: pattern1_0, - }; - let expr2_0 = C::emit(ctx, &expr1_0); - let expr3_0 = constructor_writable_regpair_to_regpair(ctx, &expr0_0)?; - return Some(expr3_0); -} - -// Generated as internal constructor for term umul_wide. -pub fn constructor_umul_wide(ctx: &mut C, arg0: Reg, arg1: Reg) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/s390x/inst.isle line 1395. - let expr0_0 = constructor_temp_writable_regpair(ctx)?; - let expr1_0 = constructor_writable_regpair_lo(ctx, &expr0_0)?; - let expr2_0 = MInst::Mov64 { - rd: expr1_0, - rm: pattern1_0, - }; - let expr3_0 = C::emit(ctx, &expr2_0); - let expr4_0 = MInst::UMulWide { rn: pattern0_0 }; - let expr5_0 = C::emit(ctx, &expr4_0); - let expr6_0 = constructor_writable_regpair_to_regpair(ctx, &expr0_0)?; - return Some(expr6_0); -} - -// Generated as internal constructor for term sdivmod32. -pub fn constructor_sdivmod32( - ctx: &mut C, - arg0: &RegPair, - arg1: Reg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/s390x/inst.isle line 1403. - let expr0_0 = constructor_copy_writable_regpair(ctx, pattern0_0)?; - let expr1_0 = MInst::SDivMod32 { rn: pattern1_0 }; - let expr2_0 = C::emit(ctx, &expr1_0); - let expr3_0 = constructor_writable_regpair_to_regpair(ctx, &expr0_0)?; - return Some(expr3_0); -} - -// Generated as internal constructor for term sdivmod64. -pub fn constructor_sdivmod64( - ctx: &mut C, - arg0: &RegPair, - arg1: Reg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/s390x/inst.isle line 1410. - let expr0_0 = constructor_copy_writable_regpair(ctx, pattern0_0)?; - let expr1_0 = MInst::SDivMod64 { rn: pattern1_0 }; - let expr2_0 = C::emit(ctx, &expr1_0); - let expr3_0 = constructor_writable_regpair_to_regpair(ctx, &expr0_0)?; - return Some(expr3_0); -} - -// Generated as internal constructor for term udivmod32. -pub fn constructor_udivmod32( - ctx: &mut C, - arg0: &RegPair, - arg1: Reg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/s390x/inst.isle line 1417. - let expr0_0 = constructor_copy_writable_regpair(ctx, pattern0_0)?; - let expr1_0 = MInst::UDivMod32 { rn: pattern1_0 }; - let expr2_0 = C::emit(ctx, &expr1_0); - let expr3_0 = constructor_writable_regpair_to_regpair(ctx, &expr0_0)?; - return Some(expr3_0); -} - -// Generated as internal constructor for term udivmod64. -pub fn constructor_udivmod64( - ctx: &mut C, - arg0: &RegPair, - arg1: Reg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/s390x/inst.isle line 1424. - let expr0_0 = constructor_copy_writable_regpair(ctx, pattern0_0)?; - let expr1_0 = MInst::UDivMod64 { rn: pattern1_0 }; - let expr2_0 = C::emit(ctx, &expr1_0); - let expr3_0 = constructor_writable_regpair_to_regpair(ctx, &expr0_0)?; - return Some(expr3_0); -} - -// Generated as internal constructor for term shift_rr. -pub fn constructor_shift_rr( - ctx: &mut C, - arg0: Type, - arg1: &ShiftOp, - arg2: Reg, - arg3: u8, - arg4: Reg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - let pattern3_0 = arg3; - let pattern4_0 = arg4; - // Rule at src/isa/s390x/inst.isle line 1431. - let expr0_0 = C::temp_writable_reg(ctx, pattern0_0); - let expr1_0 = MInst::ShiftRR { - shift_op: pattern1_0.clone(), - rd: expr0_0, - rn: pattern2_0, - shift_imm: pattern3_0, - shift_reg: pattern4_0, - }; - let expr2_0 = C::emit(ctx, &expr1_0); - let expr3_0 = C::writable_reg_to_reg(ctx, expr0_0); - return Some(expr3_0); -} - -// Generated as internal constructor for term rxsbg_test. -pub fn constructor_rxsbg_test( - ctx: &mut C, - arg0: &RxSBGOp, - arg1: Reg, - arg2: Reg, - arg3: u8, - arg4: u8, - arg5: i8, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - let pattern3_0 = arg3; - let pattern4_0 = arg4; - let pattern5_0 = arg5; - // Rule at src/isa/s390x/inst.isle line 1438. - let expr0_0 = MInst::RxSBGTest { - op: pattern0_0.clone(), - rd: pattern1_0, - rn: pattern2_0, - start_bit: pattern3_0, - end_bit: pattern4_0, - rotate_amt: pattern5_0, - }; - let expr1_0 = ProducesFlags::ProducesFlagsSideEffect { inst: expr0_0 }; - return Some(expr1_0); -} - -// Generated as internal constructor for term unary_rr. -pub fn constructor_unary_rr( - ctx: &mut C, - arg0: Type, - arg1: &UnaryOp, - arg2: Reg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 1444. - let expr0_0 = C::temp_writable_reg(ctx, pattern0_0); - let expr1_0 = MInst::UnaryRR { - op: pattern1_0.clone(), - rd: expr0_0, - rn: pattern2_0, - }; - let expr2_0 = C::emit(ctx, &expr1_0); - let expr3_0 = C::writable_reg_to_reg(ctx, expr0_0); - return Some(expr3_0); -} - -// Generated as internal constructor for term cmp_rr. -pub fn constructor_cmp_rr( - ctx: &mut C, - arg0: &CmpOp, - arg1: Reg, - arg2: Reg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 1451. - let expr0_0 = MInst::CmpRR { - op: pattern0_0.clone(), - rn: pattern1_0, - rm: pattern2_0, - }; - let expr1_0 = ProducesFlags::ProducesFlagsSideEffect { inst: expr0_0 }; - return Some(expr1_0); -} - -// Generated as internal constructor for term cmp_rx. -pub fn constructor_cmp_rx( - ctx: &mut C, - arg0: &CmpOp, - arg1: Reg, - arg2: &MemArg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 1456. - let expr0_0 = MInst::CmpRX { - op: pattern0_0.clone(), - rn: pattern1_0, - mem: pattern2_0.clone(), - }; - let expr1_0 = ProducesFlags::ProducesFlagsSideEffect { inst: expr0_0 }; - return Some(expr1_0); -} - -// Generated as internal constructor for term cmp_rsimm16. -pub fn constructor_cmp_rsimm16( - ctx: &mut C, - arg0: &CmpOp, - arg1: Reg, - arg2: i16, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 1461. - let expr0_0 = MInst::CmpRSImm16 { - op: pattern0_0.clone(), - rn: pattern1_0, - imm: pattern2_0, - }; - let expr1_0 = ProducesFlags::ProducesFlagsSideEffect { inst: expr0_0 }; - return Some(expr1_0); -} - -// Generated as internal constructor for term cmp_rsimm32. -pub fn constructor_cmp_rsimm32( - ctx: &mut C, - arg0: &CmpOp, - arg1: Reg, - arg2: i32, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 1466. - let expr0_0 = MInst::CmpRSImm32 { - op: pattern0_0.clone(), - rn: pattern1_0, - imm: pattern2_0, - }; - let expr1_0 = ProducesFlags::ProducesFlagsSideEffect { inst: expr0_0 }; - return Some(expr1_0); -} - -// Generated as internal constructor for term cmp_ruimm32. -pub fn constructor_cmp_ruimm32( - ctx: &mut C, - arg0: &CmpOp, - arg1: Reg, - arg2: u32, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 1471. - let expr0_0 = MInst::CmpRUImm32 { - op: pattern0_0.clone(), - rn: pattern1_0, - imm: pattern2_0, - }; - let expr1_0 = ProducesFlags::ProducesFlagsSideEffect { inst: expr0_0 }; - return Some(expr1_0); -} - -// Generated as internal constructor for term atomic_rmw_impl. -pub fn constructor_atomic_rmw_impl( - ctx: &mut C, - arg0: Type, - arg1: &ALUOp, - arg2: Reg, - arg3: &MemArg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - let pattern3_0 = arg3; - // Rule at src/isa/s390x/inst.isle line 1476. - let expr0_0 = C::temp_writable_reg(ctx, pattern0_0); - let expr1_0 = MInst::AtomicRmw { - alu_op: pattern1_0.clone(), - rd: expr0_0, - rn: pattern2_0, - mem: pattern3_0.clone(), - }; - let expr2_0 = C::emit(ctx, &expr1_0); - let expr3_0 = C::writable_reg_to_reg(ctx, expr0_0); - return Some(expr3_0); -} - -// Generated as internal constructor for term atomic_cas32. -pub fn constructor_atomic_cas32( - ctx: &mut C, - arg0: Reg, - arg1: Reg, - arg2: &MemArg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 1483. - let expr0_0: Type = I32; - let expr1_0 = constructor_copy_writable_reg(ctx, expr0_0, pattern0_0)?; - let expr2_0 = MInst::AtomicCas32 { - rd: expr1_0, - rn: pattern1_0, - mem: pattern2_0.clone(), - }; - let expr3_0 = C::emit(ctx, &expr2_0); - let expr4_0 = C::writable_reg_to_reg(ctx, expr1_0); - return Some(expr4_0); -} - -// Generated as internal constructor for term atomic_cas64. -pub fn constructor_atomic_cas64( - ctx: &mut C, - arg0: Reg, - arg1: Reg, - arg2: &MemArg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 1490. - let expr0_0: Type = I64; - let expr1_0 = constructor_copy_writable_reg(ctx, expr0_0, pattern0_0)?; - let expr2_0 = MInst::AtomicCas64 { - rd: expr1_0, - rn: pattern1_0, - mem: pattern2_0.clone(), - }; - let expr3_0 = C::emit(ctx, &expr2_0); - let expr4_0 = C::writable_reg_to_reg(ctx, expr1_0); - return Some(expr4_0); -} - -// Generated as internal constructor for term fence_impl. -pub fn constructor_fence_impl(ctx: &mut C) -> Option { - // Rule at src/isa/s390x/inst.isle line 1497. - let expr0_0 = MInst::Fence; - let expr1_0 = SideEffectNoResult::Inst { inst: expr0_0 }; - return Some(expr1_0); -} - -// Generated as internal constructor for term load32. -pub fn constructor_load32(ctx: &mut C, arg0: &MemArg) -> Option { - let pattern0_0 = arg0; - // Rule at src/isa/s390x/inst.isle line 1502. - let expr0_0: Type = I32; - let expr1_0 = C::temp_writable_reg(ctx, expr0_0); - let expr2_0 = MInst::Load32 { - rd: expr1_0, - mem: pattern0_0.clone(), - }; - let expr3_0 = C::emit(ctx, &expr2_0); - let expr4_0 = C::writable_reg_to_reg(ctx, expr1_0); - return Some(expr4_0); -} - -// Generated as internal constructor for term load64. -pub fn constructor_load64(ctx: &mut C, arg0: &MemArg) -> Option { - let pattern0_0 = arg0; - // Rule at src/isa/s390x/inst.isle line 1509. - let expr0_0: Type = I64; - let expr1_0 = C::temp_writable_reg(ctx, expr0_0); - let expr2_0 = MInst::Load64 { - rd: expr1_0, - mem: pattern0_0.clone(), - }; - let expr3_0 = C::emit(ctx, &expr2_0); - let expr4_0 = C::writable_reg_to_reg(ctx, expr1_0); - return Some(expr4_0); -} - -// Generated as internal constructor for term loadrev16. -pub fn constructor_loadrev16(ctx: &mut C, arg0: &MemArg) -> Option { - let pattern0_0 = arg0; - // Rule at src/isa/s390x/inst.isle line 1516. - let expr0_0: Type = I32; - let expr1_0 = C::temp_writable_reg(ctx, expr0_0); - let expr2_0 = MInst::LoadRev16 { - rd: expr1_0, - mem: pattern0_0.clone(), - }; - let expr3_0 = C::emit(ctx, &expr2_0); - let expr4_0 = C::writable_reg_to_reg(ctx, expr1_0); - return Some(expr4_0); -} - -// Generated as internal constructor for term loadrev32. -pub fn constructor_loadrev32(ctx: &mut C, arg0: &MemArg) -> Option { - let pattern0_0 = arg0; - // Rule at src/isa/s390x/inst.isle line 1523. - let expr0_0: Type = I32; - let expr1_0 = C::temp_writable_reg(ctx, expr0_0); - let expr2_0 = MInst::LoadRev32 { - rd: expr1_0, - mem: pattern0_0.clone(), - }; - let expr3_0 = C::emit(ctx, &expr2_0); - let expr4_0 = C::writable_reg_to_reg(ctx, expr1_0); - return Some(expr4_0); -} - -// Generated as internal constructor for term loadrev64. -pub fn constructor_loadrev64(ctx: &mut C, arg0: &MemArg) -> Option { - let pattern0_0 = arg0; - // Rule at src/isa/s390x/inst.isle line 1530. - let expr0_0: Type = I64; - let expr1_0 = C::temp_writable_reg(ctx, expr0_0); - let expr2_0 = MInst::LoadRev64 { - rd: expr1_0, - mem: pattern0_0.clone(), - }; - let expr3_0 = C::emit(ctx, &expr2_0); - let expr4_0 = C::writable_reg_to_reg(ctx, expr1_0); - return Some(expr4_0); -} - -// Generated as internal constructor for term store8. -pub fn constructor_store8( - ctx: &mut C, - arg0: Reg, - arg1: &MemArg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/s390x/inst.isle line 1537. - let expr0_0 = MInst::Store8 { - rd: pattern0_0, - mem: pattern1_0.clone(), - }; - let expr1_0 = SideEffectNoResult::Inst { inst: expr0_0 }; - return Some(expr1_0); -} - -// Generated as internal constructor for term store16. -pub fn constructor_store16( - ctx: &mut C, - arg0: Reg, - arg1: &MemArg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/s390x/inst.isle line 1542. - let expr0_0 = MInst::Store16 { - rd: pattern0_0, - mem: pattern1_0.clone(), - }; - let expr1_0 = SideEffectNoResult::Inst { inst: expr0_0 }; - return Some(expr1_0); -} - -// Generated as internal constructor for term store32. -pub fn constructor_store32( - ctx: &mut C, - arg0: Reg, - arg1: &MemArg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/s390x/inst.isle line 1547. - let expr0_0 = MInst::Store32 { - rd: pattern0_0, - mem: pattern1_0.clone(), - }; - let expr1_0 = SideEffectNoResult::Inst { inst: expr0_0 }; - return Some(expr1_0); -} - -// Generated as internal constructor for term store64. -pub fn constructor_store64( - ctx: &mut C, - arg0: Reg, - arg1: &MemArg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/s390x/inst.isle line 1552. - let expr0_0 = MInst::Store64 { - rd: pattern0_0, - mem: pattern1_0.clone(), - }; - let expr1_0 = SideEffectNoResult::Inst { inst: expr0_0 }; - return Some(expr1_0); -} - -// Generated as internal constructor for term store8_imm. -pub fn constructor_store8_imm( - ctx: &mut C, - arg0: u8, - arg1: &MemArg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/s390x/inst.isle line 1557. - let expr0_0 = MInst::StoreImm8 { - imm: pattern0_0, - mem: pattern1_0.clone(), - }; - let expr1_0 = SideEffectNoResult::Inst { inst: expr0_0 }; - return Some(expr1_0); -} - -// Generated as internal constructor for term store16_imm. -pub fn constructor_store16_imm( - ctx: &mut C, - arg0: i16, - arg1: &MemArg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/s390x/inst.isle line 1562. - let expr0_0 = MInst::StoreImm16 { - imm: pattern0_0, - mem: pattern1_0.clone(), - }; - let expr1_0 = SideEffectNoResult::Inst { inst: expr0_0 }; - return Some(expr1_0); -} - -// Generated as internal constructor for term store32_simm16. -pub fn constructor_store32_simm16( - ctx: &mut C, - arg0: i16, - arg1: &MemArg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/s390x/inst.isle line 1567. - let expr0_0 = MInst::StoreImm32SExt16 { - imm: pattern0_0, - mem: pattern1_0.clone(), - }; - let expr1_0 = SideEffectNoResult::Inst { inst: expr0_0 }; - return Some(expr1_0); -} - -// Generated as internal constructor for term store64_simm16. -pub fn constructor_store64_simm16( - ctx: &mut C, - arg0: i16, - arg1: &MemArg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/s390x/inst.isle line 1572. - let expr0_0 = MInst::StoreImm64SExt16 { - imm: pattern0_0, - mem: pattern1_0.clone(), - }; - let expr1_0 = SideEffectNoResult::Inst { inst: expr0_0 }; - return Some(expr1_0); -} - -// Generated as internal constructor for term storerev16. -pub fn constructor_storerev16( - ctx: &mut C, - arg0: Reg, - arg1: &MemArg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/s390x/inst.isle line 1577. - let expr0_0 = MInst::StoreRev16 { - rd: pattern0_0, - mem: pattern1_0.clone(), - }; - let expr1_0 = SideEffectNoResult::Inst { inst: expr0_0 }; - return Some(expr1_0); -} - -// Generated as internal constructor for term storerev32. -pub fn constructor_storerev32( - ctx: &mut C, - arg0: Reg, - arg1: &MemArg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/s390x/inst.isle line 1582. - let expr0_0 = MInst::StoreRev32 { - rd: pattern0_0, - mem: pattern1_0.clone(), - }; - let expr1_0 = SideEffectNoResult::Inst { inst: expr0_0 }; - return Some(expr1_0); -} - -// Generated as internal constructor for term storerev64. -pub fn constructor_storerev64( - ctx: &mut C, - arg0: Reg, - arg1: &MemArg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/s390x/inst.isle line 1587. - let expr0_0 = MInst::StoreRev64 { - rd: pattern0_0, - mem: pattern1_0.clone(), - }; - let expr1_0 = SideEffectNoResult::Inst { inst: expr0_0 }; - return Some(expr1_0); -} - -// Generated as internal constructor for term fpu_rr. -pub fn constructor_fpu_rr( - ctx: &mut C, - arg0: Type, - arg1: &FPUOp1, - arg2: Reg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 1592. - let expr0_0 = C::temp_writable_reg(ctx, pattern0_0); - let expr1_0 = MInst::FpuRR { - fpu_op: pattern1_0.clone(), - rd: expr0_0, - rn: pattern2_0, - }; - let expr2_0 = C::emit(ctx, &expr1_0); - let expr3_0 = C::writable_reg_to_reg(ctx, expr0_0); - return Some(expr3_0); -} - -// Generated as internal constructor for term fpu_rrr. -pub fn constructor_fpu_rrr( - ctx: &mut C, - arg0: Type, - arg1: &FPUOp2, - arg2: Reg, - arg3: Reg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - let pattern3_0 = arg3; - // Rule at src/isa/s390x/inst.isle line 1599. - let expr0_0 = constructor_copy_writable_reg(ctx, pattern0_0, pattern2_0)?; - let expr1_0 = MInst::FpuRRR { - fpu_op: pattern1_0.clone(), - rd: expr0_0, - rm: pattern3_0, - }; - let expr2_0 = C::emit(ctx, &expr1_0); - let expr3_0 = C::writable_reg_to_reg(ctx, expr0_0); - return Some(expr3_0); -} - -// Generated as internal constructor for term fpu_rrrr. -pub fn constructor_fpu_rrrr( - ctx: &mut C, - arg0: Type, - arg1: &FPUOp3, - arg2: Reg, - arg3: Reg, - arg4: Reg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - let pattern3_0 = arg3; - let pattern4_0 = arg4; - // Rule at src/isa/s390x/inst.isle line 1606. - let expr0_0 = constructor_copy_writable_reg(ctx, pattern0_0, pattern2_0)?; - let expr1_0 = MInst::FpuRRRR { - fpu_op: pattern1_0.clone(), - rd: expr0_0, - rn: pattern3_0, - rm: pattern4_0, - }; - let expr2_0 = C::emit(ctx, &expr1_0); - let expr3_0 = C::writable_reg_to_reg(ctx, expr0_0); - return Some(expr3_0); -} - -// Generated as internal constructor for term fpu_copysign. -pub fn constructor_fpu_copysign( - ctx: &mut C, - arg0: Type, - arg1: Reg, - arg2: Reg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 1613. - let expr0_0 = C::temp_writable_reg(ctx, pattern0_0); - let expr1_0 = MInst::FpuCopysign { - rd: expr0_0, - rn: pattern1_0, - rm: pattern2_0, - }; - let expr2_0 = C::emit(ctx, &expr1_0); - let expr3_0 = C::writable_reg_to_reg(ctx, expr0_0); - return Some(expr3_0); -} - -// Generated as internal constructor for term fpu_cmp32. -pub fn constructor_fpu_cmp32( - ctx: &mut C, - arg0: Reg, - arg1: Reg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/s390x/inst.isle line 1620. - let expr0_0 = MInst::FpuCmp32 { - rn: pattern0_0, - rm: pattern1_0, - }; - let expr1_0 = ProducesFlags::ProducesFlagsSideEffect { inst: expr0_0 }; - return Some(expr1_0); -} - -// Generated as internal constructor for term fpu_cmp64. -pub fn constructor_fpu_cmp64( - ctx: &mut C, - arg0: Reg, - arg1: Reg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/s390x/inst.isle line 1625. - let expr0_0 = MInst::FpuCmp64 { - rn: pattern0_0, - rm: pattern1_0, - }; - let expr1_0 = ProducesFlags::ProducesFlagsSideEffect { inst: expr0_0 }; - return Some(expr1_0); -} - -// Generated as internal constructor for term fpu_to_int. -pub fn constructor_fpu_to_int( - ctx: &mut C, - arg0: Type, - arg1: &FpuToIntOp, - arg2: Reg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 1630. - let expr0_0 = C::temp_writable_reg(ctx, pattern0_0); - let expr1_0 = MInst::FpuToInt { - op: pattern1_0.clone(), - rd: expr0_0, - rn: pattern2_0, - }; - let expr2_0 = C::writable_reg_to_reg(ctx, expr0_0); - let expr3_0 = ProducesFlags::ProducesFlagsReturnsReg { - inst: expr1_0, - result: expr2_0, - }; - return Some(expr3_0); -} - -// Generated as internal constructor for term int_to_fpu. -pub fn constructor_int_to_fpu( - ctx: &mut C, - arg0: Type, - arg1: &IntToFpuOp, - arg2: Reg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 1637. - let expr0_0 = C::temp_writable_reg(ctx, pattern0_0); - let expr1_0 = MInst::IntToFpu { - op: pattern1_0.clone(), - rd: expr0_0, - rn: pattern2_0, - }; - let expr2_0 = C::emit(ctx, &expr1_0); - let expr3_0 = C::writable_reg_to_reg(ctx, expr0_0); - return Some(expr3_0); -} - -// Generated as internal constructor for term fpu_round. -pub fn constructor_fpu_round( - ctx: &mut C, - arg0: Type, - arg1: &FpuRoundMode, - arg2: Reg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 1644. - let expr0_0 = C::temp_writable_reg(ctx, pattern0_0); - let expr1_0 = MInst::FpuRound { - op: pattern1_0.clone(), - rd: expr0_0, - rn: pattern2_0, - }; - let expr2_0 = C::emit(ctx, &expr1_0); - let expr3_0 = C::writable_reg_to_reg(ctx, expr0_0); - return Some(expr3_0); -} - -// Generated as internal constructor for term fpuvec_rrr. -pub fn constructor_fpuvec_rrr( - ctx: &mut C, - arg0: Type, - arg1: &FPUOp2, - arg2: Reg, - arg3: Reg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - let pattern3_0 = arg3; - // Rule at src/isa/s390x/inst.isle line 1651. - let expr0_0 = C::temp_writable_reg(ctx, pattern0_0); - let expr1_0 = MInst::FpuVecRRR { - fpu_op: pattern1_0.clone(), - rd: expr0_0, - rn: pattern2_0, - rm: pattern3_0, - }; - let expr2_0 = C::emit(ctx, &expr1_0); - let expr3_0 = C::writable_reg_to_reg(ctx, expr0_0); - return Some(expr3_0); -} - -// Generated as internal constructor for term mov_to_fpr. -pub fn constructor_mov_to_fpr(ctx: &mut C, arg0: Reg) -> Option { - let pattern0_0 = arg0; - // Rule at src/isa/s390x/inst.isle line 1658. - let expr0_0: Type = F64; - let expr1_0 = C::temp_writable_reg(ctx, expr0_0); - let expr2_0 = MInst::MovToFpr { - rd: expr1_0, - rn: pattern0_0, - }; - let expr3_0 = C::emit(ctx, &expr2_0); - let expr4_0 = C::writable_reg_to_reg(ctx, expr1_0); - return Some(expr4_0); -} - -// Generated as internal constructor for term mov_from_fpr. -pub fn constructor_mov_from_fpr(ctx: &mut C, arg0: Reg) -> Option { - let pattern0_0 = arg0; - // Rule at src/isa/s390x/inst.isle line 1665. - let expr0_0: Type = I64; - let expr1_0 = C::temp_writable_reg(ctx, expr0_0); - let expr2_0 = MInst::MovFromFpr { - rd: expr1_0, - rn: pattern0_0, - }; - let expr3_0 = C::emit(ctx, &expr2_0); - let expr4_0 = C::writable_reg_to_reg(ctx, expr1_0); - return Some(expr4_0); -} - -// Generated as internal constructor for term fpu_load32. -pub fn constructor_fpu_load32(ctx: &mut C, arg0: &MemArg) -> Option { - let pattern0_0 = arg0; - // Rule at src/isa/s390x/inst.isle line 1672. - let expr0_0: Type = F32; - let expr1_0 = C::temp_writable_reg(ctx, expr0_0); - let expr2_0 = MInst::FpuLoad32 { - rd: expr1_0, - mem: pattern0_0.clone(), - }; - let expr3_0 = C::emit(ctx, &expr2_0); - let expr4_0 = C::writable_reg_to_reg(ctx, expr1_0); - return Some(expr4_0); -} - -// Generated as internal constructor for term fpu_load64. -pub fn constructor_fpu_load64(ctx: &mut C, arg0: &MemArg) -> Option { - let pattern0_0 = arg0; - // Rule at src/isa/s390x/inst.isle line 1679. - let expr0_0: Type = F64; - let expr1_0 = C::temp_writable_reg(ctx, expr0_0); - let expr2_0 = MInst::FpuLoad64 { - rd: expr1_0, - mem: pattern0_0.clone(), - }; - let expr3_0 = C::emit(ctx, &expr2_0); - let expr4_0 = C::writable_reg_to_reg(ctx, expr1_0); - return Some(expr4_0); -} - -// Generated as internal constructor for term fpu_loadrev32. -pub fn constructor_fpu_loadrev32(ctx: &mut C, arg0: &MemArg) -> Option { - let pattern0_0 = arg0; - // Rule at src/isa/s390x/inst.isle line 1686. - let expr0_0: Type = F32; - let expr1_0 = C::temp_writable_reg(ctx, expr0_0); - let expr2_0 = MInst::FpuLoadRev32 { - rd: expr1_0, - mem: pattern0_0.clone(), - }; - let expr3_0 = C::emit(ctx, &expr2_0); - let expr4_0 = C::writable_reg_to_reg(ctx, expr1_0); - return Some(expr4_0); -} - -// Generated as internal constructor for term fpu_loadrev64. -pub fn constructor_fpu_loadrev64(ctx: &mut C, arg0: &MemArg) -> Option { - let pattern0_0 = arg0; - // Rule at src/isa/s390x/inst.isle line 1693. - let expr0_0: Type = F64; - let expr1_0 = C::temp_writable_reg(ctx, expr0_0); - let expr2_0 = MInst::FpuLoadRev64 { - rd: expr1_0, - mem: pattern0_0.clone(), - }; - let expr3_0 = C::emit(ctx, &expr2_0); - let expr4_0 = C::writable_reg_to_reg(ctx, expr1_0); - return Some(expr4_0); -} - -// Generated as internal constructor for term fpu_store32. -pub fn constructor_fpu_store32( - ctx: &mut C, - arg0: Reg, - arg1: &MemArg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/s390x/inst.isle line 1700. - let expr0_0 = MInst::FpuStore32 { - rd: pattern0_0, - mem: pattern1_0.clone(), - }; - let expr1_0 = SideEffectNoResult::Inst { inst: expr0_0 }; - return Some(expr1_0); -} - -// Generated as internal constructor for term fpu_store64. -pub fn constructor_fpu_store64( - ctx: &mut C, - arg0: Reg, - arg1: &MemArg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/s390x/inst.isle line 1705. - let expr0_0 = MInst::FpuStore64 { - rd: pattern0_0, - mem: pattern1_0.clone(), - }; - let expr1_0 = SideEffectNoResult::Inst { inst: expr0_0 }; - return Some(expr1_0); -} - -// Generated as internal constructor for term fpu_storerev32. -pub fn constructor_fpu_storerev32( - ctx: &mut C, - arg0: Reg, - arg1: &MemArg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/s390x/inst.isle line 1710. - let expr0_0 = MInst::FpuStoreRev32 { - rd: pattern0_0, - mem: pattern1_0.clone(), - }; - let expr1_0 = SideEffectNoResult::Inst { inst: expr0_0 }; - return Some(expr1_0); -} - -// Generated as internal constructor for term fpu_storerev64. -pub fn constructor_fpu_storerev64( - ctx: &mut C, - arg0: Reg, - arg1: &MemArg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/s390x/inst.isle line 1715. - let expr0_0 = MInst::FpuStoreRev64 { - rd: pattern0_0, - mem: pattern1_0.clone(), - }; - let expr1_0 = SideEffectNoResult::Inst { inst: expr0_0 }; - return Some(expr1_0); -} - -// Generated as internal constructor for term load_ext_name_far. -pub fn constructor_load_ext_name_far( - ctx: &mut C, - arg0: ExternalName, - arg1: i64, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/s390x/inst.isle line 1720. - let expr0_0: Type = I64; - let expr1_0 = C::temp_writable_reg(ctx, expr0_0); - let expr2_0 = C::box_external_name(ctx, pattern0_0); - let expr3_0 = MInst::LoadExtNameFar { - rd: expr1_0, - name: expr2_0, - offset: pattern1_0, - }; - let expr4_0 = C::emit(ctx, &expr3_0); - let expr5_0 = C::writable_reg_to_reg(ctx, expr1_0); - return Some(expr5_0); -} - -// Generated as internal constructor for term load_addr. -pub fn constructor_load_addr(ctx: &mut C, arg0: &MemArg) -> Option { - let pattern0_0 = arg0; - // Rule at src/isa/s390x/inst.isle line 1728. - let expr0_0: Type = I64; - let expr1_0 = C::temp_writable_reg(ctx, expr0_0); - let expr2_0 = MInst::LoadAddr { - rd: expr1_0, - mem: pattern0_0.clone(), - }; - let expr3_0 = C::emit(ctx, &expr2_0); - let expr4_0 = C::writable_reg_to_reg(ctx, expr1_0); - return Some(expr4_0); -} - -// Generated as internal constructor for term jump_impl. -pub fn constructor_jump_impl( - ctx: &mut C, - arg0: MachLabel, -) -> Option { - let pattern0_0 = arg0; - // Rule at src/isa/s390x/inst.isle line 1735. - let expr0_0 = MInst::Jump { dest: pattern0_0 }; - let expr1_0 = SideEffectNoResult::Inst { inst: expr0_0 }; - return Some(expr1_0); -} - -// Generated as internal constructor for term cond_br. -pub fn constructor_cond_br( - ctx: &mut C, - arg0: MachLabel, - arg1: MachLabel, - arg2: &Cond, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 1740. - let expr0_0 = MInst::CondBr { - taken: pattern0_0, - not_taken: pattern1_0, - cond: pattern2_0.clone(), - }; - let expr1_0 = SideEffectNoResult::Inst { inst: expr0_0 }; - return Some(expr1_0); -} - -// Generated as internal constructor for term oneway_cond_br. -pub fn constructor_oneway_cond_br( - ctx: &mut C, - arg0: MachLabel, - arg1: &Cond, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/s390x/inst.isle line 1745. - let expr0_0 = MInst::OneWayCondBr { - target: pattern0_0, - cond: pattern1_0.clone(), - }; - let expr1_0 = SideEffectNoResult::Inst { inst: expr0_0 }; - return Some(expr1_0); -} - -// Generated as internal constructor for term jt_sequence. -pub fn constructor_jt_sequence( - ctx: &mut C, - arg0: Reg, - arg1: &VecMachLabel, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/s390x/inst.isle line 1750. - let expr0_0 = MInst::JTSequence { - ridx: pattern0_0, - targets: pattern1_0.clone(), - }; - let expr1_0 = SideEffectNoResult::Inst { inst: expr0_0 }; - return Some(expr1_0); -} - -// Generated as internal constructor for term drop_flags. -pub fn constructor_drop_flags(ctx: &mut C, arg0: &ProducesFlags) -> Option { - let pattern0_0 = arg0; - if let &ProducesFlags::ProducesFlagsReturnsReg { - inst: ref pattern1_0, - result: pattern1_1, - } = pattern0_0 - { - // Rule at src/isa/s390x/inst.isle line 1755. - let expr0_0 = C::emit(ctx, pattern1_0); - return Some(pattern1_1); - } - return None; -} - -// Generated as internal constructor for term push_alu_reg. -pub fn constructor_push_alu_reg( - ctx: &mut C, - arg0: &VecMInstBuilder, - arg1: &ALUOp, - arg2: WritableReg, - arg3: Reg, - arg4: Reg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - if let Some(pattern3_0) = C::real_reg(ctx, pattern2_0) { - let pattern4_0 = arg3; - let pattern5_0 = arg4; - // Rule at src/isa/s390x/inst.isle line 1794. - let expr0_0 = MInst::AluRRR { - alu_op: pattern1_0.clone(), - rd: pattern3_0, - rn: pattern4_0, - rm: pattern5_0, - }; - let expr1_0 = C::inst_builder_push(ctx, pattern0_0, &expr0_0); - let expr2_0 = C::writable_reg_to_reg(ctx, pattern3_0); - return Some(expr2_0); - } - return None; -} - -// Generated as internal constructor for term push_alu_uimm32shifted. -pub fn constructor_push_alu_uimm32shifted( - ctx: &mut C, - arg0: &VecMInstBuilder, - arg1: &ALUOp, - arg2: WritableReg, - arg3: Reg, - arg4: UImm32Shifted, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - if let Some(pattern3_0) = C::real_reg(ctx, pattern2_0) { - let pattern4_0 = arg3; - let pattern5_0 = arg4; - let mut closure6 = || { - let expr0_0 = C::same_reg(ctx, pattern3_0, pattern4_0)?; - return Some(expr0_0); - }; - if let Some(pattern6_0) = closure6() { - // Rule at src/isa/s390x/inst.isle line 1800. - let expr0_0 = MInst::AluRUImm32Shifted { - alu_op: pattern1_0.clone(), - rd: pattern3_0, - imm: pattern5_0, - }; - let expr1_0 = C::inst_builder_push(ctx, pattern0_0, &expr0_0); - let expr2_0 = C::writable_reg_to_reg(ctx, pattern3_0); - return Some(expr2_0); - } - } - return None; -} - -// Generated as internal constructor for term push_shift. -pub fn constructor_push_shift( - ctx: &mut C, - arg0: &VecMInstBuilder, - arg1: &ShiftOp, - arg2: WritableReg, - arg3: Reg, - arg4: u8, - arg5: Reg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - if let Some(pattern3_0) = C::real_reg(ctx, pattern2_0) { - let pattern4_0 = arg3; - let pattern5_0 = arg4; - let pattern6_0 = arg5; - // Rule at src/isa/s390x/inst.isle line 1807. - let expr0_0 = MInst::ShiftRR { - shift_op: pattern1_0.clone(), - rd: pattern3_0, - rn: pattern4_0, - shift_imm: pattern5_0, - shift_reg: pattern6_0, - }; - let expr1_0 = C::inst_builder_push(ctx, pattern0_0, &expr0_0); - let expr2_0 = C::writable_reg_to_reg(ctx, pattern3_0); - return Some(expr2_0); - } - return None; -} - -// Generated as internal constructor for term push_rxsbg. -pub fn constructor_push_rxsbg( - ctx: &mut C, - arg0: &VecMInstBuilder, - arg1: &RxSBGOp, - arg2: WritableReg, - arg3: Reg, - arg4: Reg, - arg5: u8, - arg6: u8, - arg7: i8, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - if let Some(pattern3_0) = C::real_reg(ctx, pattern2_0) { - let pattern4_0 = arg3; - let pattern5_0 = arg4; - let pattern6_0 = arg5; - let pattern7_0 = arg6; - let pattern8_0 = arg7; - let mut closure9 = || { - let expr0_0 = C::same_reg(ctx, pattern3_0, pattern4_0)?; - return Some(expr0_0); - }; - if let Some(pattern9_0) = closure9() { - // Rule at src/isa/s390x/inst.isle line 1814. - let expr0_0 = MInst::RxSBG { - op: pattern1_0.clone(), - rd: pattern3_0, - rn: pattern5_0, - start_bit: pattern6_0, - end_bit: pattern7_0, - rotate_amt: pattern8_0, - }; - let expr1_0 = C::inst_builder_push(ctx, pattern0_0, &expr0_0); - let expr2_0 = C::writable_reg_to_reg(ctx, pattern3_0); - return Some(expr2_0); - } - } - return None; -} - -// Generated as internal constructor for term push_unary. -pub fn constructor_push_unary( - ctx: &mut C, - arg0: &VecMInstBuilder, - arg1: &UnaryOp, - arg2: WritableReg, - arg3: Reg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - if let Some(pattern3_0) = C::real_reg(ctx, pattern2_0) { - let pattern4_0 = arg3; - // Rule at src/isa/s390x/inst.isle line 1822. - let expr0_0 = MInst::UnaryRR { - op: pattern1_0.clone(), - rd: pattern3_0, - rn: pattern4_0, - }; - let expr1_0 = C::inst_builder_push(ctx, pattern0_0, &expr0_0); - let expr2_0 = C::writable_reg_to_reg(ctx, pattern3_0); - return Some(expr2_0); - } - return None; -} - -// Generated as internal constructor for term push_atomic_cas32. -pub fn constructor_push_atomic_cas32( - ctx: &mut C, - arg0: &VecMInstBuilder, - arg1: WritableReg, - arg2: Reg, - arg3: &MemArg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - if let Some(pattern2_0) = C::real_reg(ctx, pattern1_0) { - let pattern3_0 = arg2; - let pattern4_0 = arg3; - // Rule at src/isa/s390x/inst.isle line 1828. - let expr0_0 = MInst::AtomicCas32 { - rd: pattern2_0, - rn: pattern3_0, - mem: pattern4_0.clone(), - }; - let expr1_0 = C::inst_builder_push(ctx, pattern0_0, &expr0_0); - let expr2_0 = C::writable_reg_to_reg(ctx, pattern2_0); - return Some(expr2_0); - } - return None; -} - -// Generated as internal constructor for term push_atomic_cas64. -pub fn constructor_push_atomic_cas64( - ctx: &mut C, - arg0: &VecMInstBuilder, - arg1: WritableReg, - arg2: Reg, - arg3: &MemArg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - if let Some(pattern2_0) = C::real_reg(ctx, pattern1_0) { - let pattern3_0 = arg2; - let pattern4_0 = arg3; - // Rule at src/isa/s390x/inst.isle line 1834. - let expr0_0 = MInst::AtomicCas64 { - rd: pattern2_0, - rn: pattern3_0, - mem: pattern4_0.clone(), - }; - let expr1_0 = C::inst_builder_push(ctx, pattern0_0, &expr0_0); - let expr2_0 = C::writable_reg_to_reg(ctx, pattern2_0); - return Some(expr2_0); - } - return None; -} - -// Generated as internal constructor for term push_break_if. -pub fn constructor_push_break_if( - ctx: &mut C, - arg0: &VecMInstBuilder, - arg1: &ProducesFlags, - arg2: &Cond, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - if let &ProducesFlags::ProducesFlagsSideEffect { - inst: ref pattern2_0, - } = pattern1_0 - { - let pattern3_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 1840. - let expr0_0 = C::inst_builder_push(ctx, pattern0_0, pattern2_0); - let expr1_0 = MInst::CondBreak { - cond: pattern3_0.clone(), - }; - let expr2_0 = C::inst_builder_push(ctx, pattern0_0, &expr1_0); - let expr3_0 = C::invalid_reg(ctx); - return Some(expr3_0); - } - return None; -} - -// Generated as internal constructor for term emit_loop. -pub fn constructor_emit_loop( - ctx: &mut C, - arg0: &VecMInstBuilder, - arg1: &Cond, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/s390x/inst.isle line 1847. - let expr0_0 = C::inst_builder_finish(ctx, pattern0_0); - let expr1_0 = MInst::Loop { - body: expr0_0, - cond: pattern1_0.clone(), - }; - let expr2_0 = C::emit(ctx, &expr1_0); - return Some(expr2_0); -} - -// Generated as internal constructor for term emit_mov. -pub fn constructor_emit_mov( - ctx: &mut C, - arg0: Type, - arg1: WritableReg, - arg2: Reg, -) -> Option { - let pattern0_0 = arg0; - if pattern0_0 == F32 { - let pattern2_0 = arg1; - let pattern3_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 1862. - let expr0_0 = MInst::FpuMove32 { - rd: pattern2_0, - rn: pattern3_0, - }; - let expr1_0 = C::emit(ctx, &expr0_0); - return Some(expr1_0); - } - if pattern0_0 == F64 { - let pattern2_0 = arg1; - let pattern3_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 1865. - let expr0_0 = MInst::FpuMove64 { - rd: pattern2_0, - rn: pattern3_0, - }; - let expr1_0 = C::emit(ctx, &expr0_0); - return Some(expr1_0); - } - if let Some(pattern1_0) = C::gpr32_ty(ctx, pattern0_0) { - let pattern2_0 = arg1; - let pattern3_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 1856. - let expr0_0 = MInst::Mov32 { - rd: pattern2_0, - rm: pattern3_0, - }; - let expr1_0 = C::emit(ctx, &expr0_0); - return Some(expr1_0); - } - if let Some(pattern1_0) = C::gpr64_ty(ctx, pattern0_0) { - let pattern2_0 = arg1; - let pattern3_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 1859. - let expr0_0 = MInst::Mov64 { - rd: pattern2_0, - rm: pattern3_0, - }; - let expr1_0 = C::emit(ctx, &expr0_0); - return Some(expr1_0); - } - return None; -} - -// Generated as internal constructor for term copy_writable_reg. -pub fn constructor_copy_writable_reg( - ctx: &mut C, - arg0: Type, - arg1: Reg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/s390x/inst.isle line 1870. - let expr0_0 = C::temp_writable_reg(ctx, pattern0_0); - let expr1_0 = constructor_emit_mov(ctx, pattern0_0, expr0_0, pattern1_0)?; - return Some(expr0_0); -} - -// Generated as internal constructor for term copy_reg. -pub fn constructor_copy_reg(ctx: &mut C, arg0: Type, arg1: Reg) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/s390x/inst.isle line 1877. - let expr0_0 = constructor_copy_writable_reg(ctx, pattern0_0, pattern1_0)?; - let expr1_0 = C::writable_reg_to_reg(ctx, expr0_0); - return Some(expr1_0); -} - -// Generated as internal constructor for term emit_load. -pub fn constructor_emit_load( - ctx: &mut C, - arg0: Type, - arg1: WritableReg, - arg2: &MemArg, -) -> Option { - let pattern0_0 = arg0; - if pattern0_0 == I32 { - let pattern2_0 = arg1; - let pattern3_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 1881. - let expr0_0 = MInst::Load32 { - rd: pattern2_0, - mem: pattern3_0.clone(), - }; - let expr1_0 = C::emit(ctx, &expr0_0); - return Some(expr1_0); - } - if pattern0_0 == I64 { - let pattern2_0 = arg1; - let pattern3_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 1883. - let expr0_0 = MInst::Load64 { - rd: pattern2_0, - mem: pattern3_0.clone(), - }; - let expr1_0 = C::emit(ctx, &expr0_0); - return Some(expr1_0); - } - return None; -} - -// Generated as internal constructor for term emit_imm. -pub fn constructor_emit_imm( - ctx: &mut C, - arg0: Type, - arg1: WritableReg, - arg2: u64, -) -> Option { - let pattern0_0 = arg0; - if pattern0_0 == F32 { - let pattern2_0 = arg1; - let pattern3_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 1939. - let expr0_0 = C::u64_as_u32(ctx, pattern3_0); - let expr1_0 = MInst::LoadFpuConst32 { - rd: pattern2_0, - const_data: expr0_0, - }; - let expr2_0 = C::emit(ctx, &expr1_0); - return Some(expr2_0); - } - if pattern0_0 == F64 { - let pattern2_0 = arg1; - let pattern3_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 1944. - let expr0_0 = MInst::LoadFpuConst64 { - rd: pattern2_0, - const_data: pattern3_0, - }; - let expr1_0 = C::emit(ctx, &expr0_0); - return Some(expr1_0); - } - if let Some(pattern1_0) = C::fits_in_16(ctx, pattern0_0) { - let pattern2_0 = arg1; - let pattern3_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 1893. - let expr0_0 = C::u64_as_i16(ctx, pattern3_0); - let expr1_0 = MInst::Mov32SImm16 { - rd: pattern2_0, - imm: expr0_0, - }; - let expr2_0 = C::emit(ctx, &expr1_0); - return Some(expr2_0); - } - if let Some(pattern1_0) = C::gpr32_ty(ctx, pattern0_0) { - let pattern2_0 = arg1; - let pattern3_0 = arg2; - if let Some(pattern4_0) = C::i16_from_u64(ctx, pattern3_0) { - // Rule at src/isa/s390x/inst.isle line 1897. - let expr0_0 = MInst::Mov32SImm16 { - rd: pattern2_0, - imm: pattern4_0, - }; - let expr1_0 = C::emit(ctx, &expr0_0); - return Some(expr1_0); - } - // Rule at src/isa/s390x/inst.isle line 1901. - let expr0_0 = C::u64_as_u32(ctx, pattern3_0); - let expr1_0 = MInst::Mov32Imm { - rd: pattern2_0, - imm: expr0_0, - }; - let expr2_0 = C::emit(ctx, &expr1_0); - return Some(expr2_0); - } - if let Some(pattern1_0) = C::gpr64_ty(ctx, pattern0_0) { - let pattern2_0 = arg1; - let pattern3_0 = arg2; - if let Some(pattern4_0) = C::u64_nonzero_hipart(ctx, pattern3_0) { - if let Some(pattern5_0) = C::u64_nonzero_lopart(ctx, pattern3_0) { - // Rule at src/isa/s390x/inst.isle line 1921. - let expr0_0 = constructor_emit_imm(ctx, pattern1_0, pattern2_0, pattern4_0)?; - let expr1_0 = constructor_emit_insert_imm(ctx, pattern2_0, pattern5_0)?; - return Some(expr1_0); - } - } - if let Some(pattern4_0) = C::i16_from_u64(ctx, pattern3_0) { - // Rule at src/isa/s390x/inst.isle line 1905. - let expr0_0 = MInst::Mov64SImm16 { - rd: pattern2_0, - imm: pattern4_0, - }; - let expr1_0 = C::emit(ctx, &expr0_0); - return Some(expr1_0); - } - if let Some(pattern4_0) = C::i32_from_u64(ctx, pattern3_0) { - // Rule at src/isa/s390x/inst.isle line 1909. - let expr0_0 = MInst::Mov64SImm32 { - rd: pattern2_0, - imm: pattern4_0, - }; - let expr1_0 = C::emit(ctx, &expr0_0); - return Some(expr1_0); - } - if let Some(pattern4_0) = C::uimm32shifted_from_u64(ctx, pattern3_0) { - // Rule at src/isa/s390x/inst.isle line 1917. - let expr0_0 = MInst::Mov64UImm32Shifted { - rd: pattern2_0, - imm: pattern4_0, - }; - let expr1_0 = C::emit(ctx, &expr0_0); - return Some(expr1_0); - } - if let Some(pattern4_0) = C::uimm16shifted_from_u64(ctx, pattern3_0) { - // Rule at src/isa/s390x/inst.isle line 1913. - let expr0_0 = MInst::Mov64UImm16Shifted { - rd: pattern2_0, - imm: pattern4_0, - }; - let expr1_0 = C::emit(ctx, &expr0_0); - return Some(expr1_0); - } - } - return None; -} - -// Generated as internal constructor for term emit_insert_imm. -pub fn constructor_emit_insert_imm( - ctx: &mut C, - arg0: WritableReg, - arg1: u64, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - if let Some(pattern2_0) = C::uimm32shifted_from_u64(ctx, pattern1_0) { - // Rule at src/isa/s390x/inst.isle line 1934. - let expr0_0 = MInst::Insert64UImm32Shifted { - rd: pattern0_0, - imm: pattern2_0, - }; - let expr1_0 = C::emit(ctx, &expr0_0); - return Some(expr1_0); - } - if let Some(pattern2_0) = C::uimm16shifted_from_u64(ctx, pattern1_0) { - // Rule at src/isa/s390x/inst.isle line 1930. - let expr0_0 = MInst::Insert64UImm16Shifted { - rd: pattern0_0, - imm: pattern2_0, - }; - let expr1_0 = C::emit(ctx, &expr0_0); - return Some(expr1_0); - } - return None; -} - -// Generated as internal constructor for term imm. -pub fn constructor_imm(ctx: &mut C, arg0: Type, arg1: u64) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/s390x/inst.isle line 1949. - let expr0_0 = C::temp_writable_reg(ctx, pattern0_0); - let expr1_0 = constructor_emit_imm(ctx, pattern0_0, expr0_0, pattern1_0)?; - let expr2_0 = C::writable_reg_to_reg(ctx, expr0_0); - return Some(expr2_0); -} - -// Generated as internal constructor for term imm_regpair_lo. -pub fn constructor_imm_regpair_lo( - ctx: &mut C, - arg0: Type, - arg1: u64, - arg2: &RegPair, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 1957. - let expr0_0 = constructor_copy_writable_regpair(ctx, pattern2_0)?; - let expr1_0 = constructor_writable_regpair_lo(ctx, &expr0_0)?; - let expr2_0 = constructor_emit_imm(ctx, pattern0_0, expr1_0, pattern1_0)?; - let expr3_0 = constructor_writable_regpair_to_regpair(ctx, &expr0_0)?; - return Some(expr3_0); -} - -// Generated as internal constructor for term imm_regpair_hi. -pub fn constructor_imm_regpair_hi( - ctx: &mut C, - arg0: Type, - arg1: u64, - arg2: &RegPair, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 1965. - let expr0_0 = constructor_copy_writable_regpair(ctx, pattern2_0)?; - let expr1_0 = constructor_writable_regpair_hi(ctx, &expr0_0)?; - let expr2_0 = constructor_emit_imm(ctx, pattern0_0, expr1_0, pattern1_0)?; - let expr3_0 = constructor_writable_regpair_to_regpair(ctx, &expr0_0)?; - return Some(expr3_0); -} - -// Generated as internal constructor for term ty_ext32. -pub fn constructor_ty_ext32(ctx: &mut C, arg0: Type) -> Option { - let pattern0_0 = arg0; - if pattern0_0 == I8 { - // Rule at src/isa/s390x/inst.isle line 1975. - let expr0_0: Type = I32; - return Some(expr0_0); - } - if pattern0_0 == I16 { - // Rule at src/isa/s390x/inst.isle line 1976. - let expr0_0: Type = I32; - return Some(expr0_0); - } - if pattern0_0 == I32 { - // Rule at src/isa/s390x/inst.isle line 1977. - let expr0_0: Type = I32; - return Some(expr0_0); - } - if pattern0_0 == I64 { - // Rule at src/isa/s390x/inst.isle line 1978. - let expr0_0: Type = I64; - return Some(expr0_0); - } - return None; -} - -// Generated as internal constructor for term ty_ext64. -pub fn constructor_ty_ext64(ctx: &mut C, arg0: Type) -> Option { - let pattern0_0 = arg0; - if pattern0_0 == I8 { - // Rule at src/isa/s390x/inst.isle line 1982. - let expr0_0: Type = I64; - return Some(expr0_0); - } - if pattern0_0 == I16 { - // Rule at src/isa/s390x/inst.isle line 1983. - let expr0_0: Type = I64; - return Some(expr0_0); - } - if pattern0_0 == I32 { - // Rule at src/isa/s390x/inst.isle line 1984. - let expr0_0: Type = I64; - return Some(expr0_0); - } - if pattern0_0 == I64 { - // Rule at src/isa/s390x/inst.isle line 1985. - let expr0_0: Type = I64; - return Some(expr0_0); - } - return None; -} - -// Generated as internal constructor for term emit_zext32_reg. -pub fn constructor_emit_zext32_reg( - ctx: &mut C, - arg0: WritableReg, - arg1: Type, - arg2: Reg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 1990. - let expr0_0: bool = false; - let expr1_0 = C::ty_bits(ctx, pattern1_0)?; - let expr2_0: u8 = 32; - let expr3_0 = MInst::Extend { - rd: pattern0_0, - rn: pattern2_0, - signed: expr0_0, - from_bits: expr1_0, - to_bits: expr2_0, - }; - let expr4_0 = C::emit(ctx, &expr3_0); - return Some(expr4_0); -} - -// Generated as internal constructor for term emit_sext32_reg. -pub fn constructor_emit_sext32_reg( - ctx: &mut C, - arg0: WritableReg, - arg1: Type, - arg2: Reg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 1996. - let expr0_0: bool = true; - let expr1_0 = C::ty_bits(ctx, pattern1_0)?; - let expr2_0: u8 = 32; - let expr3_0 = MInst::Extend { - rd: pattern0_0, - rn: pattern2_0, - signed: expr0_0, - from_bits: expr1_0, - to_bits: expr2_0, - }; - let expr4_0 = C::emit(ctx, &expr3_0); - return Some(expr4_0); -} - -// Generated as internal constructor for term emit_zext64_reg. -pub fn constructor_emit_zext64_reg( - ctx: &mut C, - arg0: WritableReg, - arg1: Type, - arg2: Reg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 2002. - let expr0_0: bool = false; - let expr1_0 = C::ty_bits(ctx, pattern1_0)?; - let expr2_0: u8 = 64; - let expr3_0 = MInst::Extend { - rd: pattern0_0, - rn: pattern2_0, - signed: expr0_0, - from_bits: expr1_0, - to_bits: expr2_0, - }; - let expr4_0 = C::emit(ctx, &expr3_0); - return Some(expr4_0); -} - -// Generated as internal constructor for term emit_sext64_reg. -pub fn constructor_emit_sext64_reg( - ctx: &mut C, - arg0: WritableReg, - arg1: Type, - arg2: Reg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 2008. - let expr0_0: bool = true; - let expr1_0 = C::ty_bits(ctx, pattern1_0)?; - let expr2_0: u8 = 64; - let expr3_0 = MInst::Extend { - rd: pattern0_0, - rn: pattern2_0, - signed: expr0_0, - from_bits: expr1_0, - to_bits: expr2_0, - }; - let expr4_0 = C::emit(ctx, &expr3_0); - return Some(expr4_0); -} - -// Generated as internal constructor for term zext32_reg. -pub fn constructor_zext32_reg(ctx: &mut C, arg0: Type, arg1: Reg) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/s390x/inst.isle line 2014. - let expr0_0: Type = I32; - let expr1_0 = C::temp_writable_reg(ctx, expr0_0); - let expr2_0 = constructor_emit_zext32_reg(ctx, expr1_0, pattern0_0, pattern1_0)?; - let expr3_0 = C::writable_reg_to_reg(ctx, expr1_0); - return Some(expr3_0); -} - -// Generated as internal constructor for term sext32_reg. -pub fn constructor_sext32_reg(ctx: &mut C, arg0: Type, arg1: Reg) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/s390x/inst.isle line 2022. - let expr0_0: Type = I32; - let expr1_0 = C::temp_writable_reg(ctx, expr0_0); - let expr2_0 = constructor_emit_sext32_reg(ctx, expr1_0, pattern0_0, pattern1_0)?; - let expr3_0 = C::writable_reg_to_reg(ctx, expr1_0); - return Some(expr3_0); -} - -// Generated as internal constructor for term zext64_reg. -pub fn constructor_zext64_reg(ctx: &mut C, arg0: Type, arg1: Reg) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/s390x/inst.isle line 2030. - let expr0_0: Type = I64; - let expr1_0 = C::temp_writable_reg(ctx, expr0_0); - let expr2_0 = constructor_emit_zext64_reg(ctx, expr1_0, pattern0_0, pattern1_0)?; - let expr3_0 = C::writable_reg_to_reg(ctx, expr1_0); - return Some(expr3_0); -} - -// Generated as internal constructor for term sext64_reg. -pub fn constructor_sext64_reg(ctx: &mut C, arg0: Type, arg1: Reg) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/s390x/inst.isle line 2038. - let expr0_0: Type = I64; - let expr1_0 = C::temp_writable_reg(ctx, expr0_0); - let expr2_0 = constructor_emit_sext64_reg(ctx, expr1_0, pattern0_0, pattern1_0)?; - let expr3_0 = C::writable_reg_to_reg(ctx, expr1_0); - return Some(expr3_0); -} - -// Generated as internal constructor for term emit_zext32_mem. -pub fn constructor_emit_zext32_mem( - ctx: &mut C, - arg0: WritableReg, - arg1: Type, - arg2: &MemArg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - if pattern1_0 == I8 { - let pattern3_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 2046. - let expr0_0 = MInst::Load32ZExt8 { - rd: pattern0_0, - mem: pattern3_0.clone(), - }; - let expr1_0 = C::emit(ctx, &expr0_0); - return Some(expr1_0); - } - if pattern1_0 == I16 { - let pattern3_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 2047. - let expr0_0 = MInst::Load32ZExt16 { - rd: pattern0_0, - mem: pattern3_0.clone(), - }; - let expr1_0 = C::emit(ctx, &expr0_0); - return Some(expr1_0); - } - return None; -} - -// Generated as internal constructor for term emit_sext32_mem. -pub fn constructor_emit_sext32_mem( - ctx: &mut C, - arg0: WritableReg, - arg1: Type, - arg2: &MemArg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - if pattern1_0 == I8 { - let pattern3_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 2051. - let expr0_0 = MInst::Load32SExt8 { - rd: pattern0_0, - mem: pattern3_0.clone(), - }; - let expr1_0 = C::emit(ctx, &expr0_0); - return Some(expr1_0); - } - if pattern1_0 == I16 { - let pattern3_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 2052. - let expr0_0 = MInst::Load32SExt16 { - rd: pattern0_0, - mem: pattern3_0.clone(), - }; - let expr1_0 = C::emit(ctx, &expr0_0); - return Some(expr1_0); - } - return None; -} - -// Generated as internal constructor for term emit_zext64_mem. -pub fn constructor_emit_zext64_mem( - ctx: &mut C, - arg0: WritableReg, - arg1: Type, - arg2: &MemArg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - if pattern1_0 == I8 { - let pattern3_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 2056. - let expr0_0 = MInst::Load64ZExt8 { - rd: pattern0_0, - mem: pattern3_0.clone(), - }; - let expr1_0 = C::emit(ctx, &expr0_0); - return Some(expr1_0); - } - if pattern1_0 == I16 { - let pattern3_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 2057. - let expr0_0 = MInst::Load64ZExt16 { - rd: pattern0_0, - mem: pattern3_0.clone(), - }; - let expr1_0 = C::emit(ctx, &expr0_0); - return Some(expr1_0); - } - if pattern1_0 == I32 { - let pattern3_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 2058. - let expr0_0 = MInst::Load64ZExt32 { - rd: pattern0_0, - mem: pattern3_0.clone(), - }; - let expr1_0 = C::emit(ctx, &expr0_0); - return Some(expr1_0); - } - return None; -} - -// Generated as internal constructor for term emit_sext64_mem. -pub fn constructor_emit_sext64_mem( - ctx: &mut C, - arg0: WritableReg, - arg1: Type, - arg2: &MemArg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - if pattern1_0 == I8 { - let pattern3_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 2062. - let expr0_0 = MInst::Load64SExt8 { - rd: pattern0_0, - mem: pattern3_0.clone(), - }; - let expr1_0 = C::emit(ctx, &expr0_0); - return Some(expr1_0); - } - if pattern1_0 == I16 { - let pattern3_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 2063. - let expr0_0 = MInst::Load64SExt16 { - rd: pattern0_0, - mem: pattern3_0.clone(), - }; - let expr1_0 = C::emit(ctx, &expr0_0); - return Some(expr1_0); - } - if pattern1_0 == I32 { - let pattern3_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 2064. - let expr0_0 = MInst::Load64SExt32 { - rd: pattern0_0, - mem: pattern3_0.clone(), - }; - let expr1_0 = C::emit(ctx, &expr0_0); - return Some(expr1_0); - } - return None; -} - -// Generated as internal constructor for term zext32_mem. -pub fn constructor_zext32_mem(ctx: &mut C, arg0: Type, arg1: &MemArg) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/s390x/inst.isle line 2068. - let expr0_0: Type = I32; - let expr1_0 = C::temp_writable_reg(ctx, expr0_0); - let expr2_0 = constructor_emit_zext32_mem(ctx, expr1_0, pattern0_0, pattern1_0)?; - let expr3_0 = C::writable_reg_to_reg(ctx, expr1_0); - return Some(expr3_0); -} - -// Generated as internal constructor for term sext32_mem. -pub fn constructor_sext32_mem(ctx: &mut C, arg0: Type, arg1: &MemArg) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/s390x/inst.isle line 2075. - let expr0_0: Type = I32; - let expr1_0 = C::temp_writable_reg(ctx, expr0_0); - let expr2_0 = constructor_emit_sext32_mem(ctx, expr1_0, pattern0_0, pattern1_0)?; - let expr3_0 = C::writable_reg_to_reg(ctx, expr1_0); - return Some(expr3_0); -} - -// Generated as internal constructor for term zext64_mem. -pub fn constructor_zext64_mem(ctx: &mut C, arg0: Type, arg1: &MemArg) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/s390x/inst.isle line 2082. - let expr0_0: Type = I64; - let expr1_0 = C::temp_writable_reg(ctx, expr0_0); - let expr2_0 = constructor_emit_zext64_mem(ctx, expr1_0, pattern0_0, pattern1_0)?; - let expr3_0 = C::writable_reg_to_reg(ctx, expr1_0); - return Some(expr3_0); -} - -// Generated as internal constructor for term sext64_mem. -pub fn constructor_sext64_mem(ctx: &mut C, arg0: Type, arg1: &MemArg) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/s390x/inst.isle line 2089. - let expr0_0: Type = I64; - let expr1_0 = C::temp_writable_reg(ctx, expr0_0); - let expr2_0 = constructor_emit_sext64_mem(ctx, expr1_0, pattern0_0, pattern1_0)?; - let expr3_0 = C::writable_reg_to_reg(ctx, expr1_0); - return Some(expr3_0); -} - -// Generated as internal constructor for term emit_put_in_reg_zext32. -pub fn constructor_emit_put_in_reg_zext32( - ctx: &mut C, - arg0: WritableReg, - arg1: Value, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = C::value_type(ctx, pattern1_0); - if let Some(pattern3_0) = C::u64_from_value(ctx, pattern1_0) { - // Rule at src/isa/s390x/inst.isle line 2097. - let expr0_0 = constructor_ty_ext32(ctx, pattern2_0)?; - let expr1_0 = constructor_emit_imm(ctx, expr0_0, pattern0_0, pattern3_0)?; - return Some(expr1_0); - } - if let Some(pattern3_0) = C::fits_in_16(ctx, pattern2_0) { - if let Some(pattern4_0) = C::sinkable_inst(ctx, pattern1_0) { - let pattern5_0 = C::inst_data(ctx, pattern4_0); - if let &InstructionData::Load { - opcode: ref pattern6_0, - arg: pattern6_1, - flags: pattern6_2, - offset: pattern6_3, - } = &pattern5_0 - { - if let &Opcode::Load = pattern6_0 { - if let Some(()) = C::bigendian(ctx, pattern6_2) { - // Rule at src/isa/s390x/inst.isle line 2099. - let expr0_0 = constructor_sink_load(ctx, pattern4_0)?; - let expr1_0 = - constructor_emit_zext32_mem(ctx, pattern0_0, pattern3_0, &expr0_0)?; - return Some(expr1_0); - } - } - } - } - // Rule at src/isa/s390x/inst.isle line 2101. - let expr0_0 = C::put_in_reg(ctx, pattern1_0); - let expr1_0 = constructor_emit_zext32_reg(ctx, pattern0_0, pattern3_0, expr0_0)?; - return Some(expr1_0); - } - if let Some(pattern3_0) = C::ty_32_or_64(ctx, pattern2_0) { - // Rule at src/isa/s390x/inst.isle line 2103. - let expr0_0 = C::put_in_reg(ctx, pattern1_0); - let expr1_0 = constructor_emit_mov(ctx, pattern3_0, pattern0_0, expr0_0)?; - return Some(expr1_0); - } - return None; -} - -// Generated as internal constructor for term emit_put_in_reg_sext32. -pub fn constructor_emit_put_in_reg_sext32( - ctx: &mut C, - arg0: WritableReg, - arg1: Value, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = C::value_type(ctx, pattern1_0); - if let Some(pattern3_0) = C::u64_from_signed_value(ctx, pattern1_0) { - // Rule at src/isa/s390x/inst.isle line 2108. - let expr0_0 = constructor_ty_ext32(ctx, pattern2_0)?; - let expr1_0 = constructor_emit_imm(ctx, expr0_0, pattern0_0, pattern3_0)?; - return Some(expr1_0); - } - if let Some(pattern3_0) = C::fits_in_16(ctx, pattern2_0) { - if let Some(pattern4_0) = C::sinkable_inst(ctx, pattern1_0) { - let pattern5_0 = C::inst_data(ctx, pattern4_0); - if let &InstructionData::Load { - opcode: ref pattern6_0, - arg: pattern6_1, - flags: pattern6_2, - offset: pattern6_3, - } = &pattern5_0 - { - if let &Opcode::Load = pattern6_0 { - if let Some(()) = C::bigendian(ctx, pattern6_2) { - // Rule at src/isa/s390x/inst.isle line 2110. - let expr0_0 = constructor_sink_load(ctx, pattern4_0)?; - let expr1_0 = - constructor_emit_sext32_mem(ctx, pattern0_0, pattern3_0, &expr0_0)?; - return Some(expr1_0); - } - } - } - } - // Rule at src/isa/s390x/inst.isle line 2112. - let expr0_0 = C::put_in_reg(ctx, pattern1_0); - let expr1_0 = constructor_emit_sext32_reg(ctx, pattern0_0, pattern3_0, expr0_0)?; - return Some(expr1_0); - } - if let Some(pattern3_0) = C::ty_32_or_64(ctx, pattern2_0) { - // Rule at src/isa/s390x/inst.isle line 2114. - let expr0_0 = C::put_in_reg(ctx, pattern1_0); - let expr1_0 = constructor_emit_mov(ctx, pattern3_0, pattern0_0, expr0_0)?; - return Some(expr1_0); - } - return None; -} - -// Generated as internal constructor for term emit_put_in_reg_zext64. -pub fn constructor_emit_put_in_reg_zext64( - ctx: &mut C, - arg0: WritableReg, - arg1: Value, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = C::value_type(ctx, pattern1_0); - if let Some(pattern3_0) = C::u64_from_value(ctx, pattern1_0) { - // Rule at src/isa/s390x/inst.isle line 2119. - let expr0_0 = constructor_ty_ext64(ctx, pattern2_0)?; - let expr1_0 = constructor_emit_imm(ctx, expr0_0, pattern0_0, pattern3_0)?; - return Some(expr1_0); - } - if let Some(pattern3_0) = C::gpr32_ty(ctx, pattern2_0) { - if let Some(pattern4_0) = C::sinkable_inst(ctx, pattern1_0) { - let pattern5_0 = C::inst_data(ctx, pattern4_0); - if let &InstructionData::Load { - opcode: ref pattern6_0, - arg: pattern6_1, - flags: pattern6_2, - offset: pattern6_3, - } = &pattern5_0 - { - if let &Opcode::Load = pattern6_0 { - if let Some(()) = C::bigendian(ctx, pattern6_2) { - // Rule at src/isa/s390x/inst.isle line 2121. - let expr0_0 = constructor_sink_load(ctx, pattern4_0)?; - let expr1_0 = - constructor_emit_zext64_mem(ctx, pattern0_0, pattern3_0, &expr0_0)?; - return Some(expr1_0); - } - } - } - } - // Rule at src/isa/s390x/inst.isle line 2123. - let expr0_0 = C::put_in_reg(ctx, pattern1_0); - let expr1_0 = constructor_emit_zext64_reg(ctx, pattern0_0, pattern3_0, expr0_0)?; - return Some(expr1_0); - } - if let Some(pattern3_0) = C::gpr64_ty(ctx, pattern2_0) { - // Rule at src/isa/s390x/inst.isle line 2125. - let expr0_0 = C::put_in_reg(ctx, pattern1_0); - let expr1_0 = constructor_emit_mov(ctx, pattern3_0, pattern0_0, expr0_0)?; - return Some(expr1_0); - } - return None; -} - -// Generated as internal constructor for term emit_put_in_reg_sext64. -pub fn constructor_emit_put_in_reg_sext64( - ctx: &mut C, - arg0: WritableReg, - arg1: Value, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = C::value_type(ctx, pattern1_0); - if let Some(pattern3_0) = C::u64_from_signed_value(ctx, pattern1_0) { - // Rule at src/isa/s390x/inst.isle line 2130. - let expr0_0 = constructor_ty_ext64(ctx, pattern2_0)?; - let expr1_0 = constructor_emit_imm(ctx, expr0_0, pattern0_0, pattern3_0)?; - return Some(expr1_0); - } - if let Some(pattern3_0) = C::gpr32_ty(ctx, pattern2_0) { - if let Some(pattern4_0) = C::sinkable_inst(ctx, pattern1_0) { - let pattern5_0 = C::inst_data(ctx, pattern4_0); - if let &InstructionData::Load { - opcode: ref pattern6_0, - arg: pattern6_1, - flags: pattern6_2, - offset: pattern6_3, - } = &pattern5_0 - { - if let &Opcode::Load = pattern6_0 { - if let Some(()) = C::bigendian(ctx, pattern6_2) { - // Rule at src/isa/s390x/inst.isle line 2132. - let expr0_0 = constructor_sink_load(ctx, pattern4_0)?; - let expr1_0 = - constructor_emit_sext64_mem(ctx, pattern0_0, pattern3_0, &expr0_0)?; - return Some(expr1_0); - } - } - } - } - // Rule at src/isa/s390x/inst.isle line 2134. - let expr0_0 = C::put_in_reg(ctx, pattern1_0); - let expr1_0 = constructor_emit_sext64_reg(ctx, pattern0_0, pattern3_0, expr0_0)?; - return Some(expr1_0); - } - if let Some(pattern3_0) = C::gpr64_ty(ctx, pattern2_0) { - // Rule at src/isa/s390x/inst.isle line 2136. - let expr0_0 = C::put_in_reg(ctx, pattern1_0); - let expr1_0 = constructor_emit_mov(ctx, pattern3_0, pattern0_0, expr0_0)?; - return Some(expr1_0); - } - return None; -} - -// Generated as internal constructor for term put_in_reg_zext32. -pub fn constructor_put_in_reg_zext32(ctx: &mut C, arg0: Value) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = C::value_type(ctx, pattern0_0); - if let Some(pattern2_0) = C::u64_from_value(ctx, pattern0_0) { - // Rule at src/isa/s390x/inst.isle line 2141. - let expr0_0 = constructor_ty_ext32(ctx, pattern1_0)?; - let expr1_0 = constructor_imm(ctx, expr0_0, pattern2_0)?; - return Some(expr1_0); - } - if let Some(pattern2_0) = C::fits_in_16(ctx, pattern1_0) { - if let Some(pattern3_0) = C::sinkable_inst(ctx, pattern0_0) { - let pattern4_0 = C::inst_data(ctx, pattern3_0); - if let &InstructionData::Load { - opcode: ref pattern5_0, - arg: pattern5_1, - flags: pattern5_2, - offset: pattern5_3, - } = &pattern4_0 - { - if let &Opcode::Load = pattern5_0 { - if let Some(()) = C::bigendian(ctx, pattern5_2) { - // Rule at src/isa/s390x/inst.isle line 2143. - let expr0_0 = constructor_sink_load(ctx, pattern3_0)?; - let expr1_0 = constructor_zext32_mem(ctx, pattern2_0, &expr0_0)?; - return Some(expr1_0); - } - } - } - } - // Rule at src/isa/s390x/inst.isle line 2145. - let expr0_0 = C::put_in_reg(ctx, pattern0_0); - let expr1_0 = constructor_zext32_reg(ctx, pattern2_0, expr0_0)?; - return Some(expr1_0); - } - if let Some(pattern2_0) = C::ty_32_or_64(ctx, pattern1_0) { - // Rule at src/isa/s390x/inst.isle line 2147. - let expr0_0 = C::put_in_reg(ctx, pattern0_0); - return Some(expr0_0); - } - return None; -} - -// Generated as internal constructor for term put_in_reg_sext32. -pub fn constructor_put_in_reg_sext32(ctx: &mut C, arg0: Value) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = C::value_type(ctx, pattern0_0); - if let Some(pattern2_0) = C::u64_from_signed_value(ctx, pattern0_0) { - // Rule at src/isa/s390x/inst.isle line 2152. - let expr0_0 = constructor_ty_ext32(ctx, pattern1_0)?; - let expr1_0 = constructor_imm(ctx, expr0_0, pattern2_0)?; - return Some(expr1_0); - } - if let Some(pattern2_0) = C::fits_in_16(ctx, pattern1_0) { - if let Some(pattern3_0) = C::sinkable_inst(ctx, pattern0_0) { - let pattern4_0 = C::inst_data(ctx, pattern3_0); - if let &InstructionData::Load { - opcode: ref pattern5_0, - arg: pattern5_1, - flags: pattern5_2, - offset: pattern5_3, - } = &pattern4_0 - { - if let &Opcode::Load = pattern5_0 { - if let Some(()) = C::bigendian(ctx, pattern5_2) { - // Rule at src/isa/s390x/inst.isle line 2154. - let expr0_0 = constructor_sink_load(ctx, pattern3_0)?; - let expr1_0 = constructor_sext32_mem(ctx, pattern2_0, &expr0_0)?; - return Some(expr1_0); - } - } - } - } - // Rule at src/isa/s390x/inst.isle line 2156. - let expr0_0 = C::put_in_reg(ctx, pattern0_0); - let expr1_0 = constructor_sext32_reg(ctx, pattern2_0, expr0_0)?; - return Some(expr1_0); - } - if let Some(pattern2_0) = C::ty_32_or_64(ctx, pattern1_0) { - // Rule at src/isa/s390x/inst.isle line 2158. - let expr0_0 = C::put_in_reg(ctx, pattern0_0); - return Some(expr0_0); - } - return None; -} - -// Generated as internal constructor for term put_in_reg_zext64. -pub fn constructor_put_in_reg_zext64(ctx: &mut C, arg0: Value) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = C::value_type(ctx, pattern0_0); - if let Some(pattern2_0) = C::u64_from_value(ctx, pattern0_0) { - // Rule at src/isa/s390x/inst.isle line 2163. - let expr0_0 = constructor_ty_ext64(ctx, pattern1_0)?; - let expr1_0 = constructor_imm(ctx, expr0_0, pattern2_0)?; - return Some(expr1_0); - } - if let Some(pattern2_0) = C::gpr32_ty(ctx, pattern1_0) { - if let Some(pattern3_0) = C::sinkable_inst(ctx, pattern0_0) { - let pattern4_0 = C::inst_data(ctx, pattern3_0); - if let &InstructionData::Load { - opcode: ref pattern5_0, - arg: pattern5_1, - flags: pattern5_2, - offset: pattern5_3, - } = &pattern4_0 - { - if let &Opcode::Load = pattern5_0 { - if let Some(()) = C::bigendian(ctx, pattern5_2) { - // Rule at src/isa/s390x/inst.isle line 2165. - let expr0_0 = constructor_sink_load(ctx, pattern3_0)?; - let expr1_0 = constructor_zext64_mem(ctx, pattern2_0, &expr0_0)?; - return Some(expr1_0); - } - } - } - } - // Rule at src/isa/s390x/inst.isle line 2167. - let expr0_0 = C::put_in_reg(ctx, pattern0_0); - let expr1_0 = constructor_zext64_reg(ctx, pattern2_0, expr0_0)?; - return Some(expr1_0); - } - if let Some(pattern2_0) = C::gpr64_ty(ctx, pattern1_0) { - // Rule at src/isa/s390x/inst.isle line 2169. - let expr0_0 = C::put_in_reg(ctx, pattern0_0); - return Some(expr0_0); - } - return None; -} - -// Generated as internal constructor for term put_in_reg_sext64. -pub fn constructor_put_in_reg_sext64(ctx: &mut C, arg0: Value) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = C::value_type(ctx, pattern0_0); - if let Some(pattern2_0) = C::u64_from_signed_value(ctx, pattern0_0) { - // Rule at src/isa/s390x/inst.isle line 2174. - let expr0_0 = constructor_ty_ext64(ctx, pattern1_0)?; - let expr1_0 = constructor_imm(ctx, expr0_0, pattern2_0)?; - return Some(expr1_0); - } - if let Some(pattern2_0) = C::gpr32_ty(ctx, pattern1_0) { - if let Some(pattern3_0) = C::sinkable_inst(ctx, pattern0_0) { - let pattern4_0 = C::inst_data(ctx, pattern3_0); - if let &InstructionData::Load { - opcode: ref pattern5_0, - arg: pattern5_1, - flags: pattern5_2, - offset: pattern5_3, - } = &pattern4_0 - { - if let &Opcode::Load = pattern5_0 { - if let Some(()) = C::bigendian(ctx, pattern5_2) { - // Rule at src/isa/s390x/inst.isle line 2176. - let expr0_0 = constructor_sink_load(ctx, pattern3_0)?; - let expr1_0 = constructor_sext64_mem(ctx, pattern2_0, &expr0_0)?; - return Some(expr1_0); - } - } - } - } - // Rule at src/isa/s390x/inst.isle line 2178. - let expr0_0 = C::put_in_reg(ctx, pattern0_0); - let expr1_0 = constructor_sext64_reg(ctx, pattern2_0, expr0_0)?; - return Some(expr1_0); - } - if let Some(pattern2_0) = C::gpr64_ty(ctx, pattern1_0) { - // Rule at src/isa/s390x/inst.isle line 2180. - let expr0_0 = C::put_in_reg(ctx, pattern0_0); - return Some(expr0_0); - } - return None; -} - -// Generated as internal constructor for term put_in_regpair_lo_zext32. -pub fn constructor_put_in_regpair_lo_zext32( - ctx: &mut C, - arg0: Value, - arg1: &RegPair, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/s390x/inst.isle line 2186. - let expr0_0 = constructor_copy_writable_regpair(ctx, pattern1_0)?; - let expr1_0 = constructor_writable_regpair_lo(ctx, &expr0_0)?; - let expr2_0 = constructor_emit_put_in_reg_zext32(ctx, expr1_0, pattern0_0)?; - let expr3_0 = constructor_writable_regpair_to_regpair(ctx, &expr0_0)?; - return Some(expr3_0); -} - -// Generated as internal constructor for term put_in_regpair_lo_sext32. -pub fn constructor_put_in_regpair_lo_sext32( - ctx: &mut C, - arg0: Value, - arg1: &RegPair, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/s390x/inst.isle line 2194. - let expr0_0 = constructor_copy_writable_regpair(ctx, pattern1_0)?; - let expr1_0 = constructor_writable_regpair_lo(ctx, &expr0_0)?; - let expr2_0 = constructor_emit_put_in_reg_sext32(ctx, expr1_0, pattern0_0)?; - let expr3_0 = constructor_writable_regpair_to_regpair(ctx, &expr0_0)?; - return Some(expr3_0); -} - -// Generated as internal constructor for term put_in_regpair_lo_zext64. -pub fn constructor_put_in_regpair_lo_zext64( - ctx: &mut C, - arg0: Value, - arg1: &RegPair, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/s390x/inst.isle line 2202. - let expr0_0 = constructor_copy_writable_regpair(ctx, pattern1_0)?; - let expr1_0 = constructor_writable_regpair_lo(ctx, &expr0_0)?; - let expr2_0 = constructor_emit_put_in_reg_zext64(ctx, expr1_0, pattern0_0)?; - let expr3_0 = constructor_writable_regpair_to_regpair(ctx, &expr0_0)?; - return Some(expr3_0); -} - -// Generated as internal constructor for term put_in_regpair_lo_sext64. -pub fn constructor_put_in_regpair_lo_sext64( - ctx: &mut C, - arg0: Value, - arg1: &RegPair, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/s390x/inst.isle line 2210. - let expr0_0 = constructor_copy_writable_regpair(ctx, pattern1_0)?; - let expr1_0 = constructor_writable_regpair_lo(ctx, &expr0_0)?; - let expr2_0 = constructor_emit_put_in_reg_sext64(ctx, expr1_0, pattern0_0)?; - let expr3_0 = constructor_writable_regpair_to_regpair(ctx, &expr0_0)?; - return Some(expr3_0); -} - -// Generated as internal constructor for term emit_cmov_imm. -pub fn constructor_emit_cmov_imm( - ctx: &mut C, - arg0: Type, - arg1: WritableReg, - arg2: &Cond, - arg3: i16, -) -> Option { - let pattern0_0 = arg0; - if let Some(pattern1_0) = C::gpr32_ty(ctx, pattern0_0) { - let pattern2_0 = arg1; - let pattern3_0 = arg2; - let pattern4_0 = arg3; - // Rule at src/isa/s390x/inst.isle line 2220. - let expr0_0 = MInst::CMov32SImm16 { - rd: pattern2_0, - cond: pattern3_0.clone(), - imm: pattern4_0, - }; - let expr1_0 = C::writable_reg_to_reg(ctx, pattern2_0); - let expr2_0 = ConsumesFlags::ConsumesFlagsReturnsReg { - inst: expr0_0, - result: expr1_0, - }; - return Some(expr2_0); - } - if let Some(pattern1_0) = C::gpr64_ty(ctx, pattern0_0) { - let pattern2_0 = arg1; - let pattern3_0 = arg2; - let pattern4_0 = arg3; - // Rule at src/isa/s390x/inst.isle line 2223. - let expr0_0 = MInst::CMov64SImm16 { - rd: pattern2_0, - cond: pattern3_0.clone(), - imm: pattern4_0, - }; - let expr1_0 = C::writable_reg_to_reg(ctx, pattern2_0); - let expr2_0 = ConsumesFlags::ConsumesFlagsReturnsReg { - inst: expr0_0, - result: expr1_0, - }; - return Some(expr2_0); - } - return None; -} - -// Generated as internal constructor for term cmov_imm. -pub fn constructor_cmov_imm( - ctx: &mut C, - arg0: Type, - arg1: &Cond, - arg2: i16, - arg3: Reg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - let pattern3_0 = arg3; - // Rule at src/isa/s390x/inst.isle line 2229. - let expr0_0 = constructor_copy_writable_reg(ctx, pattern0_0, pattern3_0)?; - let expr1_0 = constructor_emit_cmov_imm(ctx, pattern0_0, expr0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term cmov_imm_regpair_lo. -pub fn constructor_cmov_imm_regpair_lo( - ctx: &mut C, - arg0: Type, - arg1: &ProducesFlags, - arg2: &Cond, - arg3: i16, - arg4: &RegPair, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - let pattern3_0 = arg3; - let pattern4_0 = arg4; - // Rule at src/isa/s390x/inst.isle line 2236. - let expr0_0 = constructor_copy_writable_regpair(ctx, pattern4_0)?; - let expr1_0 = constructor_writable_regpair_lo(ctx, &expr0_0)?; - let expr2_0 = constructor_emit_cmov_imm(ctx, pattern0_0, expr1_0, pattern2_0, pattern3_0)?; - let expr3_0 = constructor_with_flags_reg(ctx, pattern1_0, &expr2_0)?; - let expr4_0 = constructor_writable_regpair_to_regpair(ctx, &expr0_0)?; - return Some(expr4_0); -} - -// Generated as internal constructor for term cmov_imm_regpair_hi. -pub fn constructor_cmov_imm_regpair_hi( - ctx: &mut C, - arg0: Type, - arg1: &ProducesFlags, - arg2: &Cond, - arg3: i16, - arg4: &RegPair, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - let pattern3_0 = arg3; - let pattern4_0 = arg4; - // Rule at src/isa/s390x/inst.isle line 2245. - let expr0_0 = constructor_copy_writable_regpair(ctx, pattern4_0)?; - let expr1_0 = constructor_writable_regpair_hi(ctx, &expr0_0)?; - let expr2_0 = constructor_emit_cmov_imm(ctx, pattern0_0, expr1_0, pattern2_0, pattern3_0)?; - let expr3_0 = constructor_with_flags_reg(ctx, pattern1_0, &expr2_0)?; - let expr4_0 = constructor_writable_regpair_to_regpair(ctx, &expr0_0)?; - return Some(expr4_0); -} - -// Generated as internal constructor for term emit_cmov_reg. -pub fn constructor_emit_cmov_reg( - ctx: &mut C, - arg0: Type, - arg1: WritableReg, - arg2: &Cond, - arg3: Reg, -) -> Option { - let pattern0_0 = arg0; - if pattern0_0 == F32 { - let pattern2_0 = arg1; - let pattern3_0 = arg2; - let pattern4_0 = arg3; - // Rule at src/isa/s390x/inst.isle line 2259. - let expr0_0 = MInst::FpuCMov32 { - rd: pattern2_0, - cond: pattern3_0.clone(), - rm: pattern4_0, - }; - let expr1_0 = C::writable_reg_to_reg(ctx, pattern2_0); - let expr2_0 = ConsumesFlags::ConsumesFlagsReturnsReg { - inst: expr0_0, - result: expr1_0, - }; - return Some(expr2_0); - } - if pattern0_0 == F64 { - let pattern2_0 = arg1; - let pattern3_0 = arg2; - let pattern4_0 = arg3; - // Rule at src/isa/s390x/inst.isle line 2262. - let expr0_0 = MInst::FpuCMov64 { - rd: pattern2_0, - cond: pattern3_0.clone(), - rm: pattern4_0, - }; - let expr1_0 = C::writable_reg_to_reg(ctx, pattern2_0); - let expr2_0 = ConsumesFlags::ConsumesFlagsReturnsReg { - inst: expr0_0, - result: expr1_0, - }; - return Some(expr2_0); - } - if let Some(pattern1_0) = C::gpr32_ty(ctx, pattern0_0) { - let pattern2_0 = arg1; - let pattern3_0 = arg2; - let pattern4_0 = arg3; - // Rule at src/isa/s390x/inst.isle line 2253. - let expr0_0 = MInst::CMov32 { - rd: pattern2_0, - cond: pattern3_0.clone(), - rm: pattern4_0, - }; - let expr1_0 = C::writable_reg_to_reg(ctx, pattern2_0); - let expr2_0 = ConsumesFlags::ConsumesFlagsReturnsReg { - inst: expr0_0, - result: expr1_0, - }; - return Some(expr2_0); - } - if let Some(pattern1_0) = C::gpr64_ty(ctx, pattern0_0) { - let pattern2_0 = arg1; - let pattern3_0 = arg2; - let pattern4_0 = arg3; - // Rule at src/isa/s390x/inst.isle line 2256. - let expr0_0 = MInst::CMov64 { - rd: pattern2_0, - cond: pattern3_0.clone(), - rm: pattern4_0, - }; - let expr1_0 = C::writable_reg_to_reg(ctx, pattern2_0); - let expr2_0 = ConsumesFlags::ConsumesFlagsReturnsReg { - inst: expr0_0, - result: expr1_0, - }; - return Some(expr2_0); - } - return None; -} - -// Generated as internal constructor for term cmov_reg. -pub fn constructor_cmov_reg( - ctx: &mut C, - arg0: Type, - arg1: &Cond, - arg2: Reg, - arg3: Reg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - let pattern3_0 = arg3; - // Rule at src/isa/s390x/inst.isle line 2268. - let expr0_0 = constructor_copy_writable_reg(ctx, pattern0_0, pattern3_0)?; - let expr1_0 = constructor_emit_cmov_reg(ctx, pattern0_0, expr0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term trap_if. -pub fn constructor_trap_if( - ctx: &mut C, - arg0: &ProducesFlags, - arg1: &Cond, - arg2: &TrapCode, -) -> Option { - let pattern0_0 = arg0; - match pattern0_0 { - &ProducesFlags::ProducesFlagsSideEffect { - inst: ref pattern1_0, - } => { - let pattern2_0 = arg1; - let pattern3_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 2280. - let expr0_0 = C::emit(ctx, pattern1_0); - let expr1_0 = MInst::TrapIf { - cond: pattern2_0.clone(), - trap_code: pattern3_0.clone(), - }; - let expr2_0 = C::emit(ctx, &expr1_0); - let expr3_0 = C::invalid_reg(ctx); - return Some(expr3_0); - } - &ProducesFlags::ProducesFlagsReturnsReg { - inst: ref pattern1_0, - result: pattern1_1, - } => { - let pattern2_0 = arg1; - let pattern3_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 2276. - let expr0_0 = C::emit(ctx, pattern1_0); - let expr1_0 = MInst::TrapIf { - cond: pattern2_0.clone(), - trap_code: pattern3_0.clone(), - }; - let expr2_0 = C::emit(ctx, &expr1_0); - return Some(pattern1_1); - } - _ => {} - } - return None; -} - -// Generated as internal constructor for term icmps_reg_and_trap. -pub fn constructor_icmps_reg_and_trap( - ctx: &mut C, - arg0: Type, - arg1: Reg, - arg2: Reg, - arg3: &Cond, - arg4: &TrapCode, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - let pattern3_0 = arg3; - let pattern4_0 = arg4; - // Rule at src/isa/s390x/inst.isle line 2286. - let expr0_0 = constructor_cmpop_cmps(ctx, pattern0_0)?; - let expr1_0 = MInst::CmpTrapRR { - op: expr0_0, - rn: pattern1_0, - rm: pattern2_0, - cond: pattern3_0.clone(), - trap_code: pattern4_0.clone(), - }; - let expr2_0 = C::emit(ctx, &expr1_0); - let expr3_0 = C::invalid_reg(ctx); - return Some(expr3_0); -} - -// Generated as internal constructor for term icmps_simm16_and_trap. -pub fn constructor_icmps_simm16_and_trap( - ctx: &mut C, - arg0: Type, - arg1: Reg, - arg2: i16, - arg3: &Cond, - arg4: &TrapCode, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - let pattern3_0 = arg3; - let pattern4_0 = arg4; - // Rule at src/isa/s390x/inst.isle line 2292. - let expr0_0 = constructor_cmpop_cmps(ctx, pattern0_0)?; - let expr1_0 = MInst::CmpTrapRSImm16 { - op: expr0_0, - rn: pattern1_0, - imm: pattern2_0, - cond: pattern3_0.clone(), - trap_code: pattern4_0.clone(), - }; - let expr2_0 = C::emit(ctx, &expr1_0); - let expr3_0 = C::invalid_reg(ctx); - return Some(expr3_0); -} - -// Generated as internal constructor for term icmpu_reg_and_trap. -pub fn constructor_icmpu_reg_and_trap( - ctx: &mut C, - arg0: Type, - arg1: Reg, - arg2: Reg, - arg3: &Cond, - arg4: &TrapCode, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - let pattern3_0 = arg3; - let pattern4_0 = arg4; - // Rule at src/isa/s390x/inst.isle line 2298. - let expr0_0 = constructor_cmpop_cmpu(ctx, pattern0_0)?; - let expr1_0 = MInst::CmpTrapRR { - op: expr0_0, - rn: pattern1_0, - rm: pattern2_0, - cond: pattern3_0.clone(), - trap_code: pattern4_0.clone(), - }; - let expr2_0 = C::emit(ctx, &expr1_0); - let expr3_0 = C::invalid_reg(ctx); - return Some(expr3_0); -} - -// Generated as internal constructor for term icmpu_uimm16_and_trap. -pub fn constructor_icmpu_uimm16_and_trap( - ctx: &mut C, - arg0: Type, - arg1: Reg, - arg2: u16, - arg3: &Cond, - arg4: &TrapCode, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - let pattern3_0 = arg3; - let pattern4_0 = arg4; - // Rule at src/isa/s390x/inst.isle line 2304. - let expr0_0 = constructor_cmpop_cmpu(ctx, pattern0_0)?; - let expr1_0 = MInst::CmpTrapRUImm16 { - op: expr0_0, - rn: pattern1_0, - imm: pattern2_0, - cond: pattern3_0.clone(), - trap_code: pattern4_0.clone(), - }; - let expr2_0 = C::emit(ctx, &expr1_0); - let expr3_0 = C::invalid_reg(ctx); - return Some(expr3_0); -} - -// Generated as internal constructor for term trap_impl. -pub fn constructor_trap_impl( - ctx: &mut C, - arg0: &TrapCode, -) -> Option { - let pattern0_0 = arg0; - // Rule at src/isa/s390x/inst.isle line 2310. - let expr0_0 = MInst::Trap { - trap_code: pattern0_0.clone(), - }; - let expr1_0 = SideEffectNoResult::Inst { inst: expr0_0 }; - return Some(expr1_0); -} - -// Generated as internal constructor for term trap_if_impl. -pub fn constructor_trap_if_impl( - ctx: &mut C, - arg0: &Cond, - arg1: &TrapCode, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/s390x/inst.isle line 2314. - let expr0_0 = MInst::TrapIf { - cond: pattern0_0.clone(), - trap_code: pattern1_0.clone(), - }; - let expr1_0 = SideEffectNoResult::Inst { inst: expr0_0 }; - return Some(expr1_0); -} - -// Generated as internal constructor for term debugtrap_impl. -pub fn constructor_debugtrap_impl(ctx: &mut C) -> Option { - // Rule at src/isa/s390x/inst.isle line 2318. - let expr0_0 = MInst::Debugtrap; - let expr1_0 = SideEffectNoResult::Inst { inst: expr0_0 }; - return Some(expr1_0); -} - -// Generated as internal constructor for term bool. -pub fn constructor_bool( - ctx: &mut C, - arg0: &ProducesFlags, - arg1: &Cond, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/s390x/inst.isle line 2329. - let expr0_0 = ProducesBool::ProducesBool { - producer: pattern0_0.clone(), - cond: pattern1_0.clone(), - }; - return Some(expr0_0); -} - -// Generated as internal constructor for term invert_bool. -pub fn constructor_invert_bool( - ctx: &mut C, - arg0: &ProducesBool, -) -> Option { - let pattern0_0 = arg0; - if let &ProducesBool::ProducesBool { - producer: ref pattern1_0, - cond: ref pattern1_1, - } = pattern0_0 - { - // Rule at src/isa/s390x/inst.isle line 2333. - let expr0_0 = C::invert_cond(ctx, pattern1_1); - let expr1_0 = constructor_bool(ctx, pattern1_0, &expr0_0)?; - return Some(expr1_0); - } - return None; -} - -// Generated as internal constructor for term emit_producer. -pub fn constructor_emit_producer(ctx: &mut C, arg0: &ProducesFlags) -> Option { - let pattern0_0 = arg0; - if let &ProducesFlags::ProducesFlagsSideEffect { - inst: ref pattern1_0, - } = pattern0_0 - { - // Rule at src/isa/s390x/inst.isle line 2342. - let expr0_0 = C::emit(ctx, pattern1_0); - return Some(expr0_0); - } - return None; -} - -// Generated as internal constructor for term emit_consumer. -pub fn constructor_emit_consumer(ctx: &mut C, arg0: &ConsumesFlags) -> Option { - let pattern0_0 = arg0; - if let &ConsumesFlags::ConsumesFlagsReturnsReg { - inst: ref pattern1_0, - result: pattern1_1, - } = pattern0_0 - { - // Rule at src/isa/s390x/inst.isle line 2344. - let expr0_0 = C::emit(ctx, pattern1_0); - return Some(expr0_0); - } - return None; -} - -// Generated as internal constructor for term select_bool_reg. -pub fn constructor_select_bool_reg( - ctx: &mut C, - arg0: Type, - arg1: &ProducesBool, - arg2: Reg, - arg3: Reg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - if let &ProducesBool::ProducesBool { - producer: ref pattern2_0, - cond: ref pattern2_1, - } = pattern1_0 - { - let pattern3_0 = arg2; - let pattern4_0 = arg3; - // Rule at src/isa/s390x/inst.isle line 2348. - let expr0_0 = C::temp_writable_reg(ctx, pattern0_0); - let expr1_0 = constructor_emit_producer(ctx, pattern2_0)?; - let expr2_0 = constructor_emit_mov(ctx, pattern0_0, expr0_0, pattern4_0)?; - let expr3_0 = constructor_emit_cmov_reg(ctx, pattern0_0, expr0_0, pattern2_1, pattern3_0)?; - let expr4_0 = constructor_emit_consumer(ctx, &expr3_0)?; - let expr5_0 = C::writable_reg_to_reg(ctx, expr0_0); - return Some(expr5_0); - } - return None; -} - -// Generated as internal constructor for term select_bool_imm. -pub fn constructor_select_bool_imm( - ctx: &mut C, - arg0: Type, - arg1: &ProducesBool, - arg2: i16, - arg3: u64, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - if let &ProducesBool::ProducesBool { - producer: ref pattern2_0, - cond: ref pattern2_1, - } = pattern1_0 - { - let pattern3_0 = arg2; - let pattern4_0 = arg3; - // Rule at src/isa/s390x/inst.isle line 2357. - let expr0_0 = C::temp_writable_reg(ctx, pattern0_0); - let expr1_0 = constructor_emit_producer(ctx, pattern2_0)?; - let expr2_0 = constructor_emit_imm(ctx, pattern0_0, expr0_0, pattern4_0)?; - let expr3_0 = constructor_emit_cmov_imm(ctx, pattern0_0, expr0_0, pattern2_1, pattern3_0)?; - let expr4_0 = constructor_emit_consumer(ctx, &expr3_0)?; - let expr5_0 = C::writable_reg_to_reg(ctx, expr0_0); - return Some(expr5_0); - } - return None; -} - -// Generated as internal constructor for term lower_bool. -pub fn constructor_lower_bool( - ctx: &mut C, - arg0: Type, - arg1: &ProducesBool, -) -> Option { - let pattern0_0 = arg0; - if pattern0_0 == B1 { - let pattern2_0 = arg1; - // Rule at src/isa/s390x/inst.isle line 2367. - let expr0_0: Type = B1; - let expr1_0: i16 = 1; - let expr2_0: u64 = 0; - let expr3_0 = constructor_select_bool_imm(ctx, expr0_0, pattern2_0, expr1_0, expr2_0)?; - return Some(expr3_0); - } - if pattern0_0 == B8 { - let pattern2_0 = arg1; - // Rule at src/isa/s390x/inst.isle line 2368. - let expr0_0: Type = B8; - let expr1_0: i16 = -1; - let expr2_0: u64 = 0; - let expr3_0 = constructor_select_bool_imm(ctx, expr0_0, pattern2_0, expr1_0, expr2_0)?; - return Some(expr3_0); - } - if pattern0_0 == B16 { - let pattern2_0 = arg1; - // Rule at src/isa/s390x/inst.isle line 2369. - let expr0_0: Type = B16; - let expr1_0: i16 = -1; - let expr2_0: u64 = 0; - let expr3_0 = constructor_select_bool_imm(ctx, expr0_0, pattern2_0, expr1_0, expr2_0)?; - return Some(expr3_0); - } - if pattern0_0 == B32 { - let pattern2_0 = arg1; - // Rule at src/isa/s390x/inst.isle line 2370. - let expr0_0: Type = B32; - let expr1_0: i16 = -1; - let expr2_0: u64 = 0; - let expr3_0 = constructor_select_bool_imm(ctx, expr0_0, pattern2_0, expr1_0, expr2_0)?; - return Some(expr3_0); - } - if pattern0_0 == B64 { - let pattern2_0 = arg1; - // Rule at src/isa/s390x/inst.isle line 2371. - let expr0_0: Type = B64; - let expr1_0: i16 = -1; - let expr2_0: u64 = 0; - let expr3_0 = constructor_select_bool_imm(ctx, expr0_0, pattern2_0, expr1_0, expr2_0)?; - return Some(expr3_0); - } - return None; -} - -// Generated as internal constructor for term cond_br_bool. -pub fn constructor_cond_br_bool( - ctx: &mut C, - arg0: &ProducesBool, - arg1: MachLabel, - arg2: MachLabel, -) -> Option { - let pattern0_0 = arg0; - if let &ProducesBool::ProducesBool { - producer: ref pattern1_0, - cond: ref pattern1_1, - } = pattern0_0 - { - let pattern2_0 = arg1; - let pattern3_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 2375. - let expr0_0 = constructor_emit_producer(ctx, pattern1_0)?; - let expr1_0 = constructor_cond_br(ctx, pattern2_0, pattern3_0, pattern1_1)?; - return Some(expr1_0); - } - return None; -} - -// Generated as internal constructor for term oneway_cond_br_bool. -pub fn constructor_oneway_cond_br_bool( - ctx: &mut C, - arg0: &ProducesBool, - arg1: MachLabel, -) -> Option { - let pattern0_0 = arg0; - if let &ProducesBool::ProducesBool { - producer: ref pattern1_0, - cond: ref pattern1_1, - } = pattern0_0 - { - let pattern2_0 = arg1; - // Rule at src/isa/s390x/inst.isle line 2381. - let expr0_0 = constructor_emit_producer(ctx, pattern1_0)?; - let expr1_0 = constructor_oneway_cond_br(ctx, pattern2_0, pattern1_1)?; - return Some(expr1_0); - } - return None; -} - -// Generated as internal constructor for term trap_if_bool. -pub fn constructor_trap_if_bool( - ctx: &mut C, - arg0: &ProducesBool, - arg1: &TrapCode, -) -> Option { - let pattern0_0 = arg0; - if let &ProducesBool::ProducesBool { - producer: ref pattern1_0, - cond: ref pattern1_1, - } = pattern0_0 - { - let pattern2_0 = arg1; - // Rule at src/isa/s390x/inst.isle line 2387. - let expr0_0 = constructor_emit_producer(ctx, pattern1_0)?; - let expr1_0 = constructor_trap_if_impl(ctx, pattern1_1, pattern2_0)?; - return Some(expr1_0); - } - return None; -} - -// Generated as internal constructor for term casloop_val_reg. -pub fn constructor_casloop_val_reg(ctx: &mut C) -> Option { - // Rule at src/isa/s390x/inst.isle line 2401. - let expr0_0: u8 = 0; - let expr1_0 = C::writable_gpr(ctx, expr0_0); - return Some(expr1_0); -} - -// Generated as internal constructor for term casloop_tmp_reg. -pub fn constructor_casloop_tmp_reg(ctx: &mut C) -> Option { - // Rule at src/isa/s390x/inst.isle line 2405. - let expr0_0: u8 = 1; - let expr1_0 = C::writable_gpr(ctx, expr0_0); - return Some(expr1_0); -} - -// Generated as internal constructor for term casloop_emit. -pub fn constructor_casloop_emit( - ctx: &mut C, - arg0: &VecMInstBuilder, - arg1: Type, - arg2: MemFlags, - arg3: Reg, - arg4: Reg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - let pattern3_0 = arg3; - let pattern4_0 = arg4; - // Rule at src/isa/s390x/inst.isle line 2414. - let expr0_0: i64 = 0; - let expr1_0 = C::memarg_reg_plus_off(ctx, pattern3_0, expr0_0, pattern2_0); - let expr2_0 = constructor_ty_ext32(ctx, pattern1_0)?; - let expr3_0 = constructor_casloop_val_reg(ctx)?; - let expr4_0 = - constructor_push_atomic_cas(ctx, pattern0_0, expr2_0, expr3_0, pattern4_0, &expr1_0)?; - let expr5_0 = constructor_ty_ext32(ctx, pattern1_0)?; - let expr6_0 = constructor_casloop_val_reg(ctx)?; - let expr7_0 = constructor_emit_load(ctx, expr5_0, expr6_0, &expr1_0)?; - let expr8_0 = IntCC::NotEqual; - let expr9_0 = C::intcc_as_cond(ctx, &expr8_0); - let expr10_0 = constructor_emit_loop(ctx, pattern0_0, &expr9_0)?; - return Some(expr4_0); -} - -// Generated as internal constructor for term casloop_result. -pub fn constructor_casloop_result( - ctx: &mut C, - arg0: Type, - arg1: MemFlags, - arg2: Reg, -) -> Option { - let pattern0_0 = arg0; - if let Some(pattern1_0) = C::ty_32_or_64(ctx, pattern0_0) { - let pattern2_0 = arg1; - if let Some(()) = C::littleendian(ctx, pattern2_0) { - let pattern4_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 2432. - let expr0_0 = constructor_bswap_reg(ctx, pattern1_0, pattern4_0)?; - return Some(expr0_0); - } - if let Some(()) = C::bigendian(ctx, pattern2_0) { - let pattern4_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 2430. - let expr0_0 = constructor_copy_reg(ctx, pattern1_0, pattern4_0)?; - return Some(expr0_0); - } - } - return None; -} - -// Generated as internal constructor for term casloop. -pub fn constructor_casloop( - ctx: &mut C, - arg0: &VecMInstBuilder, - arg1: Type, - arg2: MemFlags, - arg3: Reg, - arg4: Reg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - let pattern3_0 = arg3; - let pattern4_0 = arg4; - // Rule at src/isa/s390x/inst.isle line 2437. - let expr0_0 = constructor_casloop_emit( - ctx, pattern0_0, pattern1_0, pattern2_0, pattern3_0, pattern4_0, - )?; - let expr1_0 = constructor_casloop_result(ctx, pattern1_0, pattern2_0, expr0_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term casloop_bitshift. -pub fn constructor_casloop_bitshift(ctx: &mut C, arg0: Reg) -> Option { - let pattern0_0 = arg0; - // Rule at src/isa/s390x/inst.isle line 2452. - let expr0_0: Type = I32; - let expr1_0: u8 = 3; - let expr2_0 = constructor_lshl_imm(ctx, expr0_0, pattern0_0, expr1_0)?; - return Some(expr2_0); -} - -// Generated as internal constructor for term casloop_aligned_addr. -pub fn constructor_casloop_aligned_addr(ctx: &mut C, arg0: Reg) -> Option { - let pattern0_0 = arg0; - // Rule at src/isa/s390x/inst.isle line 2457. - let expr0_0: Type = I64; - let expr1_0: u16 = 65532; - let expr2_0: u8 = 0; - let expr3_0 = C::uimm16shifted(ctx, expr1_0, expr2_0); - let expr4_0 = constructor_and_uimm16shifted(ctx, expr0_0, pattern0_0, expr3_0)?; - return Some(expr4_0); -} - -// Generated as internal constructor for term casloop_rotate_in. -pub fn constructor_casloop_rotate_in( - ctx: &mut C, - arg0: &VecMInstBuilder, - arg1: Type, - arg2: MemFlags, - arg3: Reg, - arg4: Reg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - if pattern1_0 == I8 { - let pattern3_0 = arg2; - let pattern4_0 = arg3; - let pattern5_0 = arg4; - // Rule at src/isa/s390x/inst.isle line 2467. - let expr0_0: Type = I32; - let expr1_0 = constructor_casloop_tmp_reg(ctx)?; - let expr2_0: u8 = 0; - let expr3_0 = constructor_push_rot_imm_reg( - ctx, pattern0_0, expr0_0, expr1_0, pattern5_0, expr2_0, pattern4_0, - )?; - return Some(expr3_0); - } - if pattern1_0 == I16 { - let pattern3_0 = arg2; - if let Some(()) = C::littleendian(ctx, pattern3_0) { - let pattern5_0 = arg3; - let pattern6_0 = arg4; - // Rule at src/isa/s390x/inst.isle line 2471. - let expr0_0: Type = I32; - let expr1_0 = constructor_casloop_tmp_reg(ctx)?; - let expr2_0: u8 = 16; - let expr3_0 = constructor_push_rot_imm_reg( - ctx, pattern0_0, expr0_0, expr1_0, pattern6_0, expr2_0, pattern5_0, - )?; - return Some(expr3_0); - } - if let Some(()) = C::bigendian(ctx, pattern3_0) { - let pattern5_0 = arg3; - let pattern6_0 = arg4; - // Rule at src/isa/s390x/inst.isle line 2469. - let expr0_0: Type = I32; - let expr1_0 = constructor_casloop_tmp_reg(ctx)?; - let expr2_0: u8 = 0; - let expr3_0 = constructor_push_rot_imm_reg( - ctx, pattern0_0, expr0_0, expr1_0, pattern6_0, expr2_0, pattern5_0, - )?; - return Some(expr3_0); - } - } - return None; -} - -// Generated as internal constructor for term casloop_rotate_out. -pub fn constructor_casloop_rotate_out( - ctx: &mut C, - arg0: &VecMInstBuilder, - arg1: Type, - arg2: MemFlags, - arg3: Reg, - arg4: Reg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - if pattern1_0 == I8 { - let pattern3_0 = arg2; - let pattern4_0 = arg3; - let pattern5_0 = arg4; - // Rule at src/isa/s390x/inst.isle line 2480. - let expr0_0: Type = I32; - let expr1_0 = constructor_casloop_tmp_reg(ctx)?; - let expr2_0: u8 = 0; - let expr3_0: Type = I32; - let expr4_0 = constructor_neg_reg(ctx, expr3_0, pattern4_0)?; - let expr5_0 = constructor_push_rot_imm_reg( - ctx, pattern0_0, expr0_0, expr1_0, pattern5_0, expr2_0, expr4_0, - )?; - return Some(expr5_0); - } - if pattern1_0 == I16 { - let pattern3_0 = arg2; - if let Some(()) = C::littleendian(ctx, pattern3_0) { - let pattern5_0 = arg3; - let pattern6_0 = arg4; - // Rule at src/isa/s390x/inst.isle line 2484. - let expr0_0: Type = I32; - let expr1_0 = constructor_casloop_tmp_reg(ctx)?; - let expr2_0: u8 = 16; - let expr3_0 = constructor_push_rot_imm_reg( - ctx, pattern0_0, expr0_0, expr1_0, pattern6_0, expr2_0, pattern5_0, - )?; - return Some(expr3_0); - } - if let Some(()) = C::bigendian(ctx, pattern3_0) { - let pattern5_0 = arg3; - let pattern6_0 = arg4; - // Rule at src/isa/s390x/inst.isle line 2482. - let expr0_0: Type = I32; - let expr1_0 = constructor_casloop_tmp_reg(ctx)?; - let expr2_0: u8 = 0; - let expr3_0 = constructor_push_rot_imm_reg( - ctx, pattern0_0, expr0_0, expr1_0, pattern6_0, expr2_0, pattern5_0, - )?; - return Some(expr3_0); - } - } - return None; -} - -// Generated as internal constructor for term casloop_rotate_result. -pub fn constructor_casloop_rotate_result( - ctx: &mut C, - arg0: Type, - arg1: MemFlags, - arg2: Reg, - arg3: Reg, -) -> Option { - let pattern0_0 = arg0; - if pattern0_0 == I8 { - let pattern2_0 = arg1; - let pattern3_0 = arg2; - let pattern4_0 = arg3; - // Rule at src/isa/s390x/inst.isle line 2495. - let expr0_0: Type = I32; - let expr1_0: u8 = 8; - let expr2_0 = constructor_rot_imm_reg(ctx, expr0_0, pattern4_0, expr1_0, pattern3_0)?; - return Some(expr2_0); - } - if pattern0_0 == I16 { - let pattern2_0 = arg1; - if let Some(()) = C::littleendian(ctx, pattern2_0) { - let pattern4_0 = arg2; - let pattern5_0 = arg3; - // Rule at src/isa/s390x/inst.isle line 2499. - let expr0_0: Type = I32; - let expr1_0: Type = I32; - let expr2_0 = constructor_rot_reg(ctx, expr1_0, pattern5_0, pattern4_0)?; - let expr3_0 = constructor_bswap_reg(ctx, expr0_0, expr2_0)?; - return Some(expr3_0); - } - if let Some(()) = C::bigendian(ctx, pattern2_0) { - let pattern4_0 = arg2; - let pattern5_0 = arg3; - // Rule at src/isa/s390x/inst.isle line 2497. - let expr0_0: Type = I32; - let expr1_0: u8 = 16; - let expr2_0 = constructor_rot_imm_reg(ctx, expr0_0, pattern5_0, expr1_0, pattern4_0)?; - return Some(expr2_0); - } - } - return None; -} - -// Generated as internal constructor for term casloop_subword. -pub fn constructor_casloop_subword( - ctx: &mut C, - arg0: &VecMInstBuilder, - arg1: Type, - arg2: MemFlags, - arg3: Reg, - arg4: Reg, - arg5: Reg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - let pattern3_0 = arg3; - let pattern4_0 = arg4; - let pattern5_0 = arg5; - // Rule at src/isa/s390x/inst.isle line 2504. - let expr0_0 = constructor_casloop_emit( - ctx, pattern0_0, pattern1_0, pattern2_0, pattern3_0, pattern5_0, - )?; - let expr1_0 = - constructor_casloop_rotate_result(ctx, pattern1_0, pattern2_0, pattern4_0, expr0_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term clz_reg. -pub fn constructor_clz_reg(ctx: &mut C, arg0: i16, arg1: Reg) -> Option { - let pattern0_0 = arg0; - if pattern0_0 == 64 { - let pattern2_0 = arg1; - // Rule at src/isa/s390x/inst.isle line 2515. - let expr0_0 = constructor_temp_writable_regpair(ctx)?; - let expr1_0 = MInst::Flogr { rn: pattern2_0 }; - let expr2_0 = C::emit(ctx, &expr1_0); - let expr3_0 = constructor_writable_regpair_to_regpair(ctx, &expr0_0)?; - return Some(expr3_0); - } - let pattern1_0 = arg1; - // Rule at src/isa/s390x/inst.isle line 2524. - let expr0_0 = constructor_temp_writable_regpair(ctx)?; - let expr1_0 = MInst::Flogr { rn: pattern1_0 }; - let expr2_0 = C::emit(ctx, &expr1_0); - let expr3_0 = constructor_writable_regpair_hi(ctx, &expr0_0)?; - let expr4_0 = IntCC::Equal; - let expr5_0 = C::intcc_as_cond(ctx, &expr4_0); - let expr6_0 = MInst::CMov64SImm16 { - rd: expr3_0, - cond: expr5_0, - imm: pattern0_0, - }; - let expr7_0 = C::emit(ctx, &expr6_0); - let expr8_0 = constructor_writable_regpair_to_regpair(ctx, &expr0_0)?; - return Some(expr8_0); -} - -// Generated as internal constructor for term aluop_add. -pub fn constructor_aluop_add(ctx: &mut C, arg0: Type) -> Option { - let pattern0_0 = arg0; - if pattern0_0 == I8 { - // Rule at src/isa/s390x/inst.isle line 2535. - let expr0_0 = ALUOp::Add32; - return Some(expr0_0); - } - if pattern0_0 == I16 { - // Rule at src/isa/s390x/inst.isle line 2536. - let expr0_0 = ALUOp::Add32; - return Some(expr0_0); - } - if pattern0_0 == I32 { - // Rule at src/isa/s390x/inst.isle line 2537. - let expr0_0 = ALUOp::Add32; - return Some(expr0_0); - } - if pattern0_0 == I64 { - // Rule at src/isa/s390x/inst.isle line 2538. - let expr0_0 = ALUOp::Add64; - return Some(expr0_0); - } - return None; -} - -// Generated as internal constructor for term aluop_add_sext16. -pub fn constructor_aluop_add_sext16(ctx: &mut C, arg0: Type) -> Option { - let pattern0_0 = arg0; - if pattern0_0 == I16 { - // Rule at src/isa/s390x/inst.isle line 2541. - let expr0_0 = ALUOp::Add32Ext16; - return Some(expr0_0); - } - if pattern0_0 == I32 { - // Rule at src/isa/s390x/inst.isle line 2542. - let expr0_0 = ALUOp::Add32Ext16; - return Some(expr0_0); - } - if pattern0_0 == I64 { - // Rule at src/isa/s390x/inst.isle line 2543. - let expr0_0 = ALUOp::Add64Ext16; - return Some(expr0_0); - } - return None; -} - -// Generated as internal constructor for term aluop_add_sext32. -pub fn constructor_aluop_add_sext32(ctx: &mut C, arg0: Type) -> Option { - let pattern0_0 = arg0; - if pattern0_0 == I64 { - // Rule at src/isa/s390x/inst.isle line 2546. - let expr0_0 = ALUOp::Add64Ext32; - return Some(expr0_0); - } - return None; -} - -// Generated as internal constructor for term add_reg. -pub fn constructor_add_reg( - ctx: &mut C, - arg0: Type, - arg1: Reg, - arg2: Reg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 2549. - let expr0_0 = constructor_aluop_add(ctx, pattern0_0)?; - let expr1_0 = constructor_alu_rrr(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term add_reg_sext32. -pub fn constructor_add_reg_sext32( - ctx: &mut C, - arg0: Type, - arg1: Reg, - arg2: Reg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 2552. - let expr0_0 = constructor_aluop_add_sext32(ctx, pattern0_0)?; - let expr1_0 = constructor_alu_rr(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term add_simm16. -pub fn constructor_add_simm16( - ctx: &mut C, - arg0: Type, - arg1: Reg, - arg2: i16, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 2555. - let expr0_0 = constructor_aluop_add(ctx, pattern0_0)?; - let expr1_0 = constructor_alu_rrsimm16(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term add_simm32. -pub fn constructor_add_simm32( - ctx: &mut C, - arg0: Type, - arg1: Reg, - arg2: i32, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 2558. - let expr0_0 = constructor_aluop_add(ctx, pattern0_0)?; - let expr1_0 = constructor_alu_rsimm32(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term add_mem. -pub fn constructor_add_mem( - ctx: &mut C, - arg0: Type, - arg1: Reg, - arg2: &MemArg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 2561. - let expr0_0 = constructor_aluop_add(ctx, pattern0_0)?; - let expr1_0 = constructor_alu_rx(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term add_mem_sext16. -pub fn constructor_add_mem_sext16( - ctx: &mut C, - arg0: Type, - arg1: Reg, - arg2: &MemArg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 2564. - let expr0_0 = constructor_aluop_add_sext16(ctx, pattern0_0)?; - let expr1_0 = constructor_alu_rx(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term add_mem_sext32. -pub fn constructor_add_mem_sext32( - ctx: &mut C, - arg0: Type, - arg1: Reg, - arg2: &MemArg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 2567. - let expr0_0 = constructor_aluop_add_sext32(ctx, pattern0_0)?; - let expr1_0 = constructor_alu_rx(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term aluop_add_logical. -pub fn constructor_aluop_add_logical(ctx: &mut C, arg0: Type) -> Option { - let pattern0_0 = arg0; - if pattern0_0 == I32 { - // Rule at src/isa/s390x/inst.isle line 2573. - let expr0_0 = ALUOp::AddLogical32; - return Some(expr0_0); - } - if pattern0_0 == I64 { - // Rule at src/isa/s390x/inst.isle line 2574. - let expr0_0 = ALUOp::AddLogical64; - return Some(expr0_0); - } - return None; -} - -// Generated as internal constructor for term aluop_add_logical_zext32. -pub fn constructor_aluop_add_logical_zext32(ctx: &mut C, arg0: Type) -> Option { - let pattern0_0 = arg0; - if pattern0_0 == I64 { - // Rule at src/isa/s390x/inst.isle line 2577. - let expr0_0 = ALUOp::AddLogical64Ext32; - return Some(expr0_0); - } - return None; -} - -// Generated as internal constructor for term add_logical_reg. -pub fn constructor_add_logical_reg( - ctx: &mut C, - arg0: Type, - arg1: Reg, - arg2: Reg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 2580. - let expr0_0 = constructor_aluop_add_logical(ctx, pattern0_0)?; - let expr1_0 = constructor_alu_rrr(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term add_logical_reg_zext32. -pub fn constructor_add_logical_reg_zext32( - ctx: &mut C, - arg0: Type, - arg1: Reg, - arg2: Reg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 2583. - let expr0_0 = constructor_aluop_add_logical_zext32(ctx, pattern0_0)?; - let expr1_0 = constructor_alu_rr(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term add_logical_zimm32. -pub fn constructor_add_logical_zimm32( - ctx: &mut C, - arg0: Type, - arg1: Reg, - arg2: u32, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 2586. - let expr0_0 = constructor_aluop_add_logical(ctx, pattern0_0)?; - let expr1_0 = constructor_alu_ruimm32(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term add_logical_mem. -pub fn constructor_add_logical_mem( - ctx: &mut C, - arg0: Type, - arg1: Reg, - arg2: &MemArg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 2589. - let expr0_0 = constructor_aluop_add_logical(ctx, pattern0_0)?; - let expr1_0 = constructor_alu_rx(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term add_logical_mem_zext32. -pub fn constructor_add_logical_mem_zext32( - ctx: &mut C, - arg0: Type, - arg1: Reg, - arg2: &MemArg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 2592. - let expr0_0 = constructor_aluop_add_logical_zext32(ctx, pattern0_0)?; - let expr1_0 = constructor_alu_rx(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term aluop_sub. -pub fn constructor_aluop_sub(ctx: &mut C, arg0: Type) -> Option { - let pattern0_0 = arg0; - if pattern0_0 == I8 { - // Rule at src/isa/s390x/inst.isle line 2598. - let expr0_0 = ALUOp::Sub32; - return Some(expr0_0); - } - if pattern0_0 == I16 { - // Rule at src/isa/s390x/inst.isle line 2599. - let expr0_0 = ALUOp::Sub32; - return Some(expr0_0); - } - if pattern0_0 == I32 { - // Rule at src/isa/s390x/inst.isle line 2600. - let expr0_0 = ALUOp::Sub32; - return Some(expr0_0); - } - if pattern0_0 == I64 { - // Rule at src/isa/s390x/inst.isle line 2601. - let expr0_0 = ALUOp::Sub64; - return Some(expr0_0); - } - return None; -} - -// Generated as internal constructor for term aluop_sub_sext16. -pub fn constructor_aluop_sub_sext16(ctx: &mut C, arg0: Type) -> Option { - let pattern0_0 = arg0; - if pattern0_0 == I16 { - // Rule at src/isa/s390x/inst.isle line 2604. - let expr0_0 = ALUOp::Sub32Ext16; - return Some(expr0_0); - } - if pattern0_0 == I32 { - // Rule at src/isa/s390x/inst.isle line 2605. - let expr0_0 = ALUOp::Sub32Ext16; - return Some(expr0_0); - } - if pattern0_0 == I64 { - // Rule at src/isa/s390x/inst.isle line 2606. - let expr0_0 = ALUOp::Sub64Ext16; - return Some(expr0_0); - } - return None; -} - -// Generated as internal constructor for term aluop_sub_sext32. -pub fn constructor_aluop_sub_sext32(ctx: &mut C, arg0: Type) -> Option { - let pattern0_0 = arg0; - if pattern0_0 == I64 { - // Rule at src/isa/s390x/inst.isle line 2609. - let expr0_0 = ALUOp::Sub64Ext32; - return Some(expr0_0); - } - return None; -} - -// Generated as internal constructor for term sub_reg. -pub fn constructor_sub_reg( - ctx: &mut C, - arg0: Type, - arg1: Reg, - arg2: Reg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 2612. - let expr0_0 = constructor_aluop_sub(ctx, pattern0_0)?; - let expr1_0 = constructor_alu_rrr(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term sub_reg_sext32. -pub fn constructor_sub_reg_sext32( - ctx: &mut C, - arg0: Type, - arg1: Reg, - arg2: Reg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 2615. - let expr0_0 = constructor_aluop_sub_sext32(ctx, pattern0_0)?; - let expr1_0 = constructor_alu_rr(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term sub_mem. -pub fn constructor_sub_mem( - ctx: &mut C, - arg0: Type, - arg1: Reg, - arg2: &MemArg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 2618. - let expr0_0 = constructor_aluop_sub(ctx, pattern0_0)?; - let expr1_0 = constructor_alu_rx(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term sub_mem_sext16. -pub fn constructor_sub_mem_sext16( - ctx: &mut C, - arg0: Type, - arg1: Reg, - arg2: &MemArg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 2621. - let expr0_0 = constructor_aluop_sub_sext16(ctx, pattern0_0)?; - let expr1_0 = constructor_alu_rx(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term sub_mem_sext32. -pub fn constructor_sub_mem_sext32( - ctx: &mut C, - arg0: Type, - arg1: Reg, - arg2: &MemArg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 2624. - let expr0_0 = constructor_aluop_sub_sext32(ctx, pattern0_0)?; - let expr1_0 = constructor_alu_rx(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term aluop_sub_logical. -pub fn constructor_aluop_sub_logical(ctx: &mut C, arg0: Type) -> Option { - let pattern0_0 = arg0; - if pattern0_0 == I32 { - // Rule at src/isa/s390x/inst.isle line 2630. - let expr0_0 = ALUOp::SubLogical32; - return Some(expr0_0); - } - if pattern0_0 == I64 { - // Rule at src/isa/s390x/inst.isle line 2631. - let expr0_0 = ALUOp::SubLogical64; - return Some(expr0_0); - } - return None; -} - -// Generated as internal constructor for term aluop_sub_logical_zext32. -pub fn constructor_aluop_sub_logical_zext32(ctx: &mut C, arg0: Type) -> Option { - let pattern0_0 = arg0; - if pattern0_0 == I64 { - // Rule at src/isa/s390x/inst.isle line 2634. - let expr0_0 = ALUOp::SubLogical64Ext32; - return Some(expr0_0); - } - return None; -} - -// Generated as internal constructor for term sub_logical_reg. -pub fn constructor_sub_logical_reg( - ctx: &mut C, - arg0: Type, - arg1: Reg, - arg2: Reg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 2637. - let expr0_0 = constructor_aluop_sub_logical(ctx, pattern0_0)?; - let expr1_0 = constructor_alu_rrr(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term sub_logical_reg_zext32. -pub fn constructor_sub_logical_reg_zext32( - ctx: &mut C, - arg0: Type, - arg1: Reg, - arg2: Reg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 2640. - let expr0_0 = constructor_aluop_sub_logical_zext32(ctx, pattern0_0)?; - let expr1_0 = constructor_alu_rr(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term sub_logical_zimm32. -pub fn constructor_sub_logical_zimm32( - ctx: &mut C, - arg0: Type, - arg1: Reg, - arg2: u32, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 2643. - let expr0_0 = constructor_aluop_sub_logical(ctx, pattern0_0)?; - let expr1_0 = constructor_alu_ruimm32(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term sub_logical_mem. -pub fn constructor_sub_logical_mem( - ctx: &mut C, - arg0: Type, - arg1: Reg, - arg2: &MemArg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 2646. - let expr0_0 = constructor_aluop_sub_logical(ctx, pattern0_0)?; - let expr1_0 = constructor_alu_rx(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term sub_logical_mem_zext32. -pub fn constructor_sub_logical_mem_zext32( - ctx: &mut C, - arg0: Type, - arg1: Reg, - arg2: &MemArg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 2649. - let expr0_0 = constructor_aluop_sub_logical(ctx, pattern0_0)?; - let expr1_0 = constructor_alu_rx(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term aluop_mul. -pub fn constructor_aluop_mul(ctx: &mut C, arg0: Type) -> Option { - let pattern0_0 = arg0; - if pattern0_0 == I8 { - // Rule at src/isa/s390x/inst.isle line 2655. - let expr0_0 = ALUOp::Mul32; - return Some(expr0_0); - } - if pattern0_0 == I16 { - // Rule at src/isa/s390x/inst.isle line 2656. - let expr0_0 = ALUOp::Mul32; - return Some(expr0_0); - } - if pattern0_0 == I32 { - // Rule at src/isa/s390x/inst.isle line 2657. - let expr0_0 = ALUOp::Mul32; - return Some(expr0_0); - } - if pattern0_0 == I64 { - // Rule at src/isa/s390x/inst.isle line 2658. - let expr0_0 = ALUOp::Mul64; - return Some(expr0_0); - } - return None; -} - -// Generated as internal constructor for term aluop_mul_sext16. -pub fn constructor_aluop_mul_sext16(ctx: &mut C, arg0: Type) -> Option { - let pattern0_0 = arg0; - if pattern0_0 == I16 { - // Rule at src/isa/s390x/inst.isle line 2661. - let expr0_0 = ALUOp::Mul32Ext16; - return Some(expr0_0); - } - if pattern0_0 == I32 { - // Rule at src/isa/s390x/inst.isle line 2662. - let expr0_0 = ALUOp::Mul32Ext16; - return Some(expr0_0); - } - if pattern0_0 == I64 { - // Rule at src/isa/s390x/inst.isle line 2663. - let expr0_0 = ALUOp::Mul64Ext16; - return Some(expr0_0); - } - return None; -} - -// Generated as internal constructor for term aluop_mul_sext32. -pub fn constructor_aluop_mul_sext32(ctx: &mut C, arg0: Type) -> Option { - let pattern0_0 = arg0; - if pattern0_0 == I64 { - // Rule at src/isa/s390x/inst.isle line 2666. - let expr0_0 = ALUOp::Mul64Ext32; - return Some(expr0_0); - } - return None; -} - -// Generated as internal constructor for term mul_reg. -pub fn constructor_mul_reg( - ctx: &mut C, - arg0: Type, - arg1: Reg, - arg2: Reg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 2669. - let expr0_0 = constructor_aluop_mul(ctx, pattern0_0)?; - let expr1_0 = constructor_alu_rrr(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term mul_reg_sext32. -pub fn constructor_mul_reg_sext32( - ctx: &mut C, - arg0: Type, - arg1: Reg, - arg2: Reg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 2672. - let expr0_0 = constructor_aluop_mul_sext32(ctx, pattern0_0)?; - let expr1_0 = constructor_alu_rr(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term mul_simm16. -pub fn constructor_mul_simm16( - ctx: &mut C, - arg0: Type, - arg1: Reg, - arg2: i16, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 2675. - let expr0_0 = constructor_aluop_mul(ctx, pattern0_0)?; - let expr1_0 = constructor_alu_rsimm16(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term mul_simm32. -pub fn constructor_mul_simm32( - ctx: &mut C, - arg0: Type, - arg1: Reg, - arg2: i32, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 2678. - let expr0_0 = constructor_aluop_mul(ctx, pattern0_0)?; - let expr1_0 = constructor_alu_rsimm32(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term mul_mem. -pub fn constructor_mul_mem( - ctx: &mut C, - arg0: Type, - arg1: Reg, - arg2: &MemArg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 2681. - let expr0_0 = constructor_aluop_mul(ctx, pattern0_0)?; - let expr1_0 = constructor_alu_rx(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term mul_mem_sext16. -pub fn constructor_mul_mem_sext16( - ctx: &mut C, - arg0: Type, - arg1: Reg, - arg2: &MemArg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 2684. - let expr0_0 = constructor_aluop_mul_sext16(ctx, pattern0_0)?; - let expr1_0 = constructor_alu_rx(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term mul_mem_sext32. -pub fn constructor_mul_mem_sext32( - ctx: &mut C, - arg0: Type, - arg1: Reg, - arg2: &MemArg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 2687. - let expr0_0 = constructor_aluop_mul_sext32(ctx, pattern0_0)?; - let expr1_0 = constructor_alu_rx(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term udivmod. -pub fn constructor_udivmod( - ctx: &mut C, - arg0: Type, - arg1: &RegPair, - arg2: Reg, -) -> Option { - let pattern0_0 = arg0; - if pattern0_0 == I32 { - let pattern2_0 = arg1; - let pattern3_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 2693. - let expr0_0 = constructor_udivmod32(ctx, pattern2_0, pattern3_0)?; - return Some(expr0_0); - } - if pattern0_0 == I64 { - let pattern2_0 = arg1; - let pattern3_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 2694. - let expr0_0 = constructor_udivmod64(ctx, pattern2_0, pattern3_0)?; - return Some(expr0_0); - } - return None; -} - -// Generated as internal constructor for term sdivmod. -pub fn constructor_sdivmod( - ctx: &mut C, - arg0: Type, - arg1: &RegPair, - arg2: Reg, -) -> Option { - let pattern0_0 = arg0; - if pattern0_0 == I32 { - let pattern2_0 = arg1; - let pattern3_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 2700. - let expr0_0 = constructor_sdivmod32(ctx, pattern2_0, pattern3_0)?; - return Some(expr0_0); - } - if pattern0_0 == I64 { - let pattern2_0 = arg1; - let pattern3_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 2701. - let expr0_0 = constructor_sdivmod64(ctx, pattern2_0, pattern3_0)?; - return Some(expr0_0); - } - return None; -} - -// Generated as internal constructor for term aluop_and. -pub fn constructor_aluop_and(ctx: &mut C, arg0: Type) -> Option { - let pattern0_0 = arg0; - if let Some(pattern1_0) = C::gpr32_ty(ctx, pattern0_0) { - // Rule at src/isa/s390x/inst.isle line 2707. - let expr0_0 = ALUOp::And32; - return Some(expr0_0); - } - if let Some(pattern1_0) = C::gpr64_ty(ctx, pattern0_0) { - // Rule at src/isa/s390x/inst.isle line 2708. - let expr0_0 = ALUOp::And64; - return Some(expr0_0); - } - return None; -} - -// Generated as internal constructor for term and_reg. -pub fn constructor_and_reg( - ctx: &mut C, - arg0: Type, - arg1: Reg, - arg2: Reg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 2711. - let expr0_0 = constructor_aluop_and(ctx, pattern0_0)?; - let expr1_0 = constructor_alu_rrr(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term and_uimm16shifted. -pub fn constructor_and_uimm16shifted( - ctx: &mut C, - arg0: Type, - arg1: Reg, - arg2: UImm16Shifted, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 2714. - let expr0_0 = constructor_aluop_and(ctx, pattern0_0)?; - let expr1_0 = - constructor_alu_ruimm16shifted(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term and_uimm32shifted. -pub fn constructor_and_uimm32shifted( - ctx: &mut C, - arg0: Type, - arg1: Reg, - arg2: UImm32Shifted, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 2717. - let expr0_0 = constructor_aluop_and(ctx, pattern0_0)?; - let expr1_0 = - constructor_alu_ruimm32shifted(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term and_mem. -pub fn constructor_and_mem( - ctx: &mut C, - arg0: Type, - arg1: Reg, - arg2: &MemArg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 2720. - let expr0_0 = constructor_aluop_and(ctx, pattern0_0)?; - let expr1_0 = constructor_alu_rx(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term aluop_or. -pub fn constructor_aluop_or(ctx: &mut C, arg0: Type) -> Option { - let pattern0_0 = arg0; - if let Some(pattern1_0) = C::gpr32_ty(ctx, pattern0_0) { - // Rule at src/isa/s390x/inst.isle line 2726. - let expr0_0 = ALUOp::Orr32; - return Some(expr0_0); - } - if let Some(pattern1_0) = C::gpr64_ty(ctx, pattern0_0) { - // Rule at src/isa/s390x/inst.isle line 2727. - let expr0_0 = ALUOp::Orr64; - return Some(expr0_0); - } - return None; -} - -// Generated as internal constructor for term or_reg. -pub fn constructor_or_reg( - ctx: &mut C, - arg0: Type, - arg1: Reg, - arg2: Reg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 2730. - let expr0_0 = constructor_aluop_or(ctx, pattern0_0)?; - let expr1_0 = constructor_alu_rrr(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term or_uimm16shifted. -pub fn constructor_or_uimm16shifted( - ctx: &mut C, - arg0: Type, - arg1: Reg, - arg2: UImm16Shifted, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 2733. - let expr0_0 = constructor_aluop_or(ctx, pattern0_0)?; - let expr1_0 = - constructor_alu_ruimm16shifted(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term or_uimm32shifted. -pub fn constructor_or_uimm32shifted( - ctx: &mut C, - arg0: Type, - arg1: Reg, - arg2: UImm32Shifted, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 2736. - let expr0_0 = constructor_aluop_or(ctx, pattern0_0)?; - let expr1_0 = - constructor_alu_ruimm32shifted(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term or_mem. -pub fn constructor_or_mem( - ctx: &mut C, - arg0: Type, - arg1: Reg, - arg2: &MemArg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 2739. - let expr0_0 = constructor_aluop_or(ctx, pattern0_0)?; - let expr1_0 = constructor_alu_rx(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term aluop_xor. -pub fn constructor_aluop_xor(ctx: &mut C, arg0: Type) -> Option { - let pattern0_0 = arg0; - if let Some(pattern1_0) = C::gpr32_ty(ctx, pattern0_0) { - // Rule at src/isa/s390x/inst.isle line 2745. - let expr0_0 = ALUOp::Xor32; - return Some(expr0_0); - } - if let Some(pattern1_0) = C::gpr64_ty(ctx, pattern0_0) { - // Rule at src/isa/s390x/inst.isle line 2746. - let expr0_0 = ALUOp::Xor64; - return Some(expr0_0); - } - return None; -} - -// Generated as internal constructor for term xor_reg. -pub fn constructor_xor_reg( - ctx: &mut C, - arg0: Type, - arg1: Reg, - arg2: Reg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 2749. - let expr0_0 = constructor_aluop_xor(ctx, pattern0_0)?; - let expr1_0 = constructor_alu_rrr(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term xor_uimm32shifted. -pub fn constructor_xor_uimm32shifted( - ctx: &mut C, - arg0: Type, - arg1: Reg, - arg2: UImm32Shifted, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 2752. - let expr0_0 = constructor_aluop_xor(ctx, pattern0_0)?; - let expr1_0 = - constructor_alu_ruimm32shifted(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term xor_mem. -pub fn constructor_xor_mem( - ctx: &mut C, - arg0: Type, - arg1: Reg, - arg2: &MemArg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 2755. - let expr0_0 = constructor_aluop_xor(ctx, pattern0_0)?; - let expr1_0 = constructor_alu_rx(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term push_xor_uimm32shifted. -pub fn constructor_push_xor_uimm32shifted( - ctx: &mut C, - arg0: &VecMInstBuilder, - arg1: Type, - arg2: WritableReg, - arg3: Reg, - arg4: UImm32Shifted, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - let pattern3_0 = arg3; - let pattern4_0 = arg4; - // Rule at src/isa/s390x/inst.isle line 2758. - let expr0_0 = constructor_aluop_xor(ctx, pattern1_0)?; - let expr1_0 = constructor_push_alu_uimm32shifted( - ctx, pattern0_0, &expr0_0, pattern2_0, pattern3_0, pattern4_0, - )?; - return Some(expr1_0); -} - -// Generated as internal constructor for term not_reg. -pub fn constructor_not_reg(ctx: &mut C, arg0: Type, arg1: Reg) -> Option { - let pattern0_0 = arg0; - if let Some(pattern1_0) = C::gpr32_ty(ctx, pattern0_0) { - let pattern2_0 = arg1; - // Rule at src/isa/s390x/inst.isle line 2764. - let expr0_0: u32 = 4294967295; - let expr1_0: u8 = 0; - let expr2_0 = C::uimm32shifted(ctx, expr0_0, expr1_0); - let expr3_0 = constructor_xor_uimm32shifted(ctx, pattern1_0, pattern2_0, expr2_0)?; - return Some(expr3_0); - } - if let Some(pattern1_0) = C::gpr64_ty(ctx, pattern0_0) { - let pattern2_0 = arg1; - // Rule at src/isa/s390x/inst.isle line 2766. - let expr0_0: u32 = 4294967295; - let expr1_0: u8 = 0; - let expr2_0 = C::uimm32shifted(ctx, expr0_0, expr1_0); - let expr3_0 = constructor_xor_uimm32shifted(ctx, pattern1_0, pattern2_0, expr2_0)?; - let expr4_0: u32 = 4294967295; - let expr5_0: u8 = 32; - let expr6_0 = C::uimm32shifted(ctx, expr4_0, expr5_0); - let expr7_0 = constructor_xor_uimm32shifted(ctx, pattern1_0, expr3_0, expr6_0)?; - return Some(expr7_0); - } - return None; -} - -// Generated as internal constructor for term push_not_reg. -pub fn constructor_push_not_reg( - ctx: &mut C, - arg0: &VecMInstBuilder, - arg1: Type, - arg2: WritableReg, - arg3: Reg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - if let Some(pattern2_0) = C::gpr32_ty(ctx, pattern1_0) { - let pattern3_0 = arg2; - let pattern4_0 = arg3; - // Rule at src/isa/s390x/inst.isle line 2772. - let expr0_0: u32 = 4294967295; - let expr1_0: u8 = 0; - let expr2_0 = C::uimm32shifted(ctx, expr0_0, expr1_0); - let expr3_0 = constructor_push_xor_uimm32shifted( - ctx, pattern0_0, pattern2_0, pattern3_0, pattern4_0, expr2_0, - )?; - return Some(expr3_0); - } - if let Some(pattern2_0) = C::gpr64_ty(ctx, pattern1_0) { - let pattern3_0 = arg2; - let pattern4_0 = arg3; - // Rule at src/isa/s390x/inst.isle line 2774. - let expr0_0: u32 = 4294967295; - let expr1_0: u8 = 0; - let expr2_0 = C::uimm32shifted(ctx, expr0_0, expr1_0); - let expr3_0 = constructor_push_xor_uimm32shifted( - ctx, pattern0_0, pattern2_0, pattern3_0, pattern4_0, expr2_0, - )?; - let expr4_0: u32 = 4294967295; - let expr5_0: u8 = 32; - let expr6_0 = C::uimm32shifted(ctx, expr4_0, expr5_0); - let expr7_0 = constructor_push_xor_uimm32shifted( - ctx, pattern0_0, pattern2_0, pattern3_0, expr3_0, expr6_0, - )?; - return Some(expr7_0); - } - return None; -} - -// Generated as internal constructor for term aluop_and_not. -pub fn constructor_aluop_and_not(ctx: &mut C, arg0: Type) -> Option { - let pattern0_0 = arg0; - if let Some(pattern1_0) = C::gpr32_ty(ctx, pattern0_0) { - // Rule at src/isa/s390x/inst.isle line 2782. - let expr0_0 = ALUOp::AndNot32; - return Some(expr0_0); - } - if let Some(pattern1_0) = C::gpr64_ty(ctx, pattern0_0) { - // Rule at src/isa/s390x/inst.isle line 2783. - let expr0_0 = ALUOp::AndNot64; - return Some(expr0_0); - } - return None; -} - -// Generated as internal constructor for term and_not_reg. -pub fn constructor_and_not_reg( - ctx: &mut C, - arg0: Type, - arg1: Reg, - arg2: Reg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 2786. - let expr0_0 = constructor_aluop_and_not(ctx, pattern0_0)?; - let expr1_0 = constructor_alu_rrr(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term aluop_or_not. -pub fn constructor_aluop_or_not(ctx: &mut C, arg0: Type) -> Option { - let pattern0_0 = arg0; - if let Some(pattern1_0) = C::gpr32_ty(ctx, pattern0_0) { - // Rule at src/isa/s390x/inst.isle line 2792. - let expr0_0 = ALUOp::OrrNot32; - return Some(expr0_0); - } - if let Some(pattern1_0) = C::gpr64_ty(ctx, pattern0_0) { - // Rule at src/isa/s390x/inst.isle line 2793. - let expr0_0 = ALUOp::OrrNot64; - return Some(expr0_0); - } - return None; -} - -// Generated as internal constructor for term or_not_reg. -pub fn constructor_or_not_reg( - ctx: &mut C, - arg0: Type, - arg1: Reg, - arg2: Reg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 2796. - let expr0_0 = constructor_aluop_or_not(ctx, pattern0_0)?; - let expr1_0 = constructor_alu_rrr(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term aluop_xor_not. -pub fn constructor_aluop_xor_not(ctx: &mut C, arg0: Type) -> Option { - let pattern0_0 = arg0; - if let Some(pattern1_0) = C::gpr32_ty(ctx, pattern0_0) { - // Rule at src/isa/s390x/inst.isle line 2802. - let expr0_0 = ALUOp::XorNot32; - return Some(expr0_0); - } - if let Some(pattern1_0) = C::gpr64_ty(ctx, pattern0_0) { - // Rule at src/isa/s390x/inst.isle line 2803. - let expr0_0 = ALUOp::XorNot64; - return Some(expr0_0); - } - return None; -} - -// Generated as internal constructor for term xor_not_reg. -pub fn constructor_xor_not_reg( - ctx: &mut C, - arg0: Type, - arg1: Reg, - arg2: Reg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 2806. - let expr0_0 = constructor_aluop_xor_not(ctx, pattern0_0)?; - let expr1_0 = constructor_alu_rrr(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term unaryop_abs. -pub fn constructor_unaryop_abs(ctx: &mut C, arg0: Type) -> Option { - let pattern0_0 = arg0; - if pattern0_0 == I32 { - // Rule at src/isa/s390x/inst.isle line 2812. - let expr0_0 = UnaryOp::Abs32; - return Some(expr0_0); - } - if pattern0_0 == I64 { - // Rule at src/isa/s390x/inst.isle line 2813. - let expr0_0 = UnaryOp::Abs64; - return Some(expr0_0); - } - return None; -} - -// Generated as internal constructor for term unaryop_abs_sext32. -pub fn constructor_unaryop_abs_sext32(ctx: &mut C, arg0: Type) -> Option { - let pattern0_0 = arg0; - if pattern0_0 == I64 { - // Rule at src/isa/s390x/inst.isle line 2816. - let expr0_0 = UnaryOp::Abs64Ext32; - return Some(expr0_0); - } - return None; -} - -// Generated as internal constructor for term abs_reg. -pub fn constructor_abs_reg(ctx: &mut C, arg0: Type, arg1: Reg) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/s390x/inst.isle line 2819. - let expr0_0 = constructor_unaryop_abs(ctx, pattern0_0)?; - let expr1_0 = constructor_unary_rr(ctx, pattern0_0, &expr0_0, pattern1_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term abs_reg_sext32. -pub fn constructor_abs_reg_sext32(ctx: &mut C, arg0: Type, arg1: Reg) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/s390x/inst.isle line 2822. - let expr0_0 = constructor_unaryop_abs_sext32(ctx, pattern0_0)?; - let expr1_0 = constructor_unary_rr(ctx, pattern0_0, &expr0_0, pattern1_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term unaryop_neg. -pub fn constructor_unaryop_neg(ctx: &mut C, arg0: Type) -> Option { - let pattern0_0 = arg0; - if pattern0_0 == I8 { - // Rule at src/isa/s390x/inst.isle line 2828. - let expr0_0 = UnaryOp::Neg32; - return Some(expr0_0); - } - if pattern0_0 == I16 { - // Rule at src/isa/s390x/inst.isle line 2829. - let expr0_0 = UnaryOp::Neg32; - return Some(expr0_0); - } - if pattern0_0 == I32 { - // Rule at src/isa/s390x/inst.isle line 2830. - let expr0_0 = UnaryOp::Neg32; - return Some(expr0_0); - } - if pattern0_0 == I64 { - // Rule at src/isa/s390x/inst.isle line 2831. - let expr0_0 = UnaryOp::Neg64; - return Some(expr0_0); - } - return None; -} - -// Generated as internal constructor for term unaryop_neg_sext32. -pub fn constructor_unaryop_neg_sext32(ctx: &mut C, arg0: Type) -> Option { - let pattern0_0 = arg0; - if pattern0_0 == I64 { - // Rule at src/isa/s390x/inst.isle line 2834. - let expr0_0 = UnaryOp::Neg64Ext32; - return Some(expr0_0); - } - return None; -} - -// Generated as internal constructor for term neg_reg. -pub fn constructor_neg_reg(ctx: &mut C, arg0: Type, arg1: Reg) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/s390x/inst.isle line 2837. - let expr0_0 = constructor_unaryop_neg(ctx, pattern0_0)?; - let expr1_0 = constructor_unary_rr(ctx, pattern0_0, &expr0_0, pattern1_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term neg_reg_sext32. -pub fn constructor_neg_reg_sext32(ctx: &mut C, arg0: Type, arg1: Reg) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/s390x/inst.isle line 2840. - let expr0_0 = constructor_unaryop_neg_sext32(ctx, pattern0_0)?; - let expr1_0 = constructor_unary_rr(ctx, pattern0_0, &expr0_0, pattern1_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term unaryop_bswap. -pub fn constructor_unaryop_bswap(ctx: &mut C, arg0: Type) -> Option { - let pattern0_0 = arg0; - if pattern0_0 == I32 { - // Rule at src/isa/s390x/inst.isle line 2846. - let expr0_0 = UnaryOp::BSwap32; - return Some(expr0_0); - } - if pattern0_0 == I64 { - // Rule at src/isa/s390x/inst.isle line 2847. - let expr0_0 = UnaryOp::BSwap64; - return Some(expr0_0); - } - return None; -} - -// Generated as internal constructor for term bswap_reg. -pub fn constructor_bswap_reg(ctx: &mut C, arg0: Type, arg1: Reg) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/s390x/inst.isle line 2850. - let expr0_0 = constructor_unaryop_bswap(ctx, pattern0_0)?; - let expr1_0 = constructor_unary_rr(ctx, pattern0_0, &expr0_0, pattern1_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term push_bswap_reg. -pub fn constructor_push_bswap_reg( - ctx: &mut C, - arg0: &VecMInstBuilder, - arg1: Type, - arg2: WritableReg, - arg3: Reg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - let pattern3_0 = arg3; - // Rule at src/isa/s390x/inst.isle line 2853. - let expr0_0 = constructor_unaryop_bswap(ctx, pattern1_0)?; - let expr1_0 = constructor_push_unary(ctx, pattern0_0, &expr0_0, pattern2_0, pattern3_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term shiftop_rot. -pub fn constructor_shiftop_rot(ctx: &mut C, arg0: Type) -> Option { - let pattern0_0 = arg0; - if pattern0_0 == I32 { - // Rule at src/isa/s390x/inst.isle line 2859. - let expr0_0 = ShiftOp::RotL32; - return Some(expr0_0); - } - if pattern0_0 == I64 { - // Rule at src/isa/s390x/inst.isle line 2860. - let expr0_0 = ShiftOp::RotL64; - return Some(expr0_0); - } - return None; -} - -// Generated as internal constructor for term rot_reg. -pub fn constructor_rot_reg( - ctx: &mut C, - arg0: Type, - arg1: Reg, - arg2: Reg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 2863. - let expr0_0 = constructor_shiftop_rot(ctx, pattern0_0)?; - let expr1_0: u8 = 0; - let expr2_0 = constructor_shift_rr(ctx, pattern0_0, &expr0_0, pattern1_0, expr1_0, pattern2_0)?; - return Some(expr2_0); -} - -// Generated as internal constructor for term rot_imm. -pub fn constructor_rot_imm( - ctx: &mut C, - arg0: Type, - arg1: Reg, - arg2: u8, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 2867. - let expr0_0 = constructor_shiftop_rot(ctx, pattern0_0)?; - let expr1_0 = C::zero_reg(ctx); - let expr2_0 = constructor_shift_rr(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0, expr1_0)?; - return Some(expr2_0); -} - -// Generated as internal constructor for term rot_imm_reg. -pub fn constructor_rot_imm_reg( - ctx: &mut C, - arg0: Type, - arg1: Reg, - arg2: u8, - arg3: Reg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - let pattern3_0 = arg3; - // Rule at src/isa/s390x/inst.isle line 2871. - let expr0_0 = constructor_shiftop_rot(ctx, pattern0_0)?; - let expr1_0 = constructor_shift_rr( - ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0, pattern3_0, - )?; - return Some(expr1_0); -} - -// Generated as internal constructor for term push_rot_imm_reg. -pub fn constructor_push_rot_imm_reg( - ctx: &mut C, - arg0: &VecMInstBuilder, - arg1: Type, - arg2: WritableReg, - arg3: Reg, - arg4: u8, - arg5: Reg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - let pattern3_0 = arg3; - let pattern4_0 = arg4; - let pattern5_0 = arg5; - // Rule at src/isa/s390x/inst.isle line 2875. - let expr0_0 = constructor_shiftop_rot(ctx, pattern1_0)?; - let expr1_0 = constructor_push_shift( - ctx, pattern0_0, &expr0_0, pattern2_0, pattern3_0, pattern4_0, pattern5_0, - )?; - return Some(expr1_0); -} - -// Generated as internal constructor for term shiftop_lshl. -pub fn constructor_shiftop_lshl(ctx: &mut C, arg0: Type) -> Option { - let pattern0_0 = arg0; - if pattern0_0 == I8 { - // Rule at src/isa/s390x/inst.isle line 2882. - let expr0_0 = ShiftOp::LShL32; - return Some(expr0_0); - } - if pattern0_0 == I16 { - // Rule at src/isa/s390x/inst.isle line 2883. - let expr0_0 = ShiftOp::LShL32; - return Some(expr0_0); - } - if pattern0_0 == I32 { - // Rule at src/isa/s390x/inst.isle line 2884. - let expr0_0 = ShiftOp::LShL32; - return Some(expr0_0); - } - if pattern0_0 == I64 { - // Rule at src/isa/s390x/inst.isle line 2885. - let expr0_0 = ShiftOp::LShL64; - return Some(expr0_0); - } - return None; -} - -// Generated as internal constructor for term lshl_reg. -pub fn constructor_lshl_reg( - ctx: &mut C, - arg0: Type, - arg1: Reg, - arg2: Reg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 2888. - let expr0_0 = constructor_shiftop_lshl(ctx, pattern0_0)?; - let expr1_0: u8 = 0; - let expr2_0 = constructor_shift_rr(ctx, pattern0_0, &expr0_0, pattern1_0, expr1_0, pattern2_0)?; - return Some(expr2_0); -} - -// Generated as internal constructor for term lshl_imm. -pub fn constructor_lshl_imm( - ctx: &mut C, - arg0: Type, - arg1: Reg, - arg2: u8, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 2892. - let expr0_0 = constructor_shiftop_lshl(ctx, pattern0_0)?; - let expr1_0 = C::zero_reg(ctx); - let expr2_0 = constructor_shift_rr(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0, expr1_0)?; - return Some(expr2_0); -} - -// Generated as internal constructor for term shiftop_lshr. -pub fn constructor_shiftop_lshr(ctx: &mut C, arg0: Type) -> Option { - let pattern0_0 = arg0; - if pattern0_0 == I32 { - // Rule at src/isa/s390x/inst.isle line 2899. - let expr0_0 = ShiftOp::LShR32; - return Some(expr0_0); - } - if pattern0_0 == I64 { - // Rule at src/isa/s390x/inst.isle line 2900. - let expr0_0 = ShiftOp::LShR64; - return Some(expr0_0); - } - return None; -} - -// Generated as internal constructor for term lshr_reg. -pub fn constructor_lshr_reg( - ctx: &mut C, - arg0: Type, - arg1: Reg, - arg2: Reg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 2903. - let expr0_0 = constructor_shiftop_lshr(ctx, pattern0_0)?; - let expr1_0: u8 = 0; - let expr2_0 = constructor_shift_rr(ctx, pattern0_0, &expr0_0, pattern1_0, expr1_0, pattern2_0)?; - return Some(expr2_0); -} - -// Generated as internal constructor for term lshr_imm. -pub fn constructor_lshr_imm( - ctx: &mut C, - arg0: Type, - arg1: Reg, - arg2: u8, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 2907. - let expr0_0 = constructor_shiftop_lshr(ctx, pattern0_0)?; - let expr1_0 = C::zero_reg(ctx); - let expr2_0 = constructor_shift_rr(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0, expr1_0)?; - return Some(expr2_0); -} - -// Generated as internal constructor for term shiftop_ashr. -pub fn constructor_shiftop_ashr(ctx: &mut C, arg0: Type) -> Option { - let pattern0_0 = arg0; - if pattern0_0 == I32 { - // Rule at src/isa/s390x/inst.isle line 2914. - let expr0_0 = ShiftOp::AShR32; - return Some(expr0_0); - } - if pattern0_0 == I64 { - // Rule at src/isa/s390x/inst.isle line 2915. - let expr0_0 = ShiftOp::AShR64; - return Some(expr0_0); - } - return None; -} - -// Generated as internal constructor for term ashr_reg. -pub fn constructor_ashr_reg( - ctx: &mut C, - arg0: Type, - arg1: Reg, - arg2: Reg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 2918. - let expr0_0 = constructor_shiftop_ashr(ctx, pattern0_0)?; - let expr1_0: u8 = 0; - let expr2_0 = constructor_shift_rr(ctx, pattern0_0, &expr0_0, pattern1_0, expr1_0, pattern2_0)?; - return Some(expr2_0); -} - -// Generated as internal constructor for term ashr_imm. -pub fn constructor_ashr_imm( - ctx: &mut C, - arg0: Type, - arg1: Reg, - arg2: u8, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 2922. - let expr0_0 = constructor_shiftop_ashr(ctx, pattern0_0)?; - let expr1_0 = C::zero_reg(ctx); - let expr2_0 = constructor_shift_rr(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0, expr1_0)?; - return Some(expr2_0); -} - -// Generated as internal constructor for term popcnt_byte. -pub fn constructor_popcnt_byte(ctx: &mut C, arg0: Reg) -> Option { - let pattern0_0 = arg0; - // Rule at src/isa/s390x/inst.isle line 2929. - let expr0_0: Type = I64; - let expr1_0 = UnaryOp::PopcntByte; - let expr2_0 = constructor_unary_rr(ctx, expr0_0, &expr1_0, pattern0_0)?; - return Some(expr2_0); -} - -// Generated as internal constructor for term popcnt_reg. -pub fn constructor_popcnt_reg(ctx: &mut C, arg0: Reg) -> Option { - let pattern0_0 = arg0; - // Rule at src/isa/s390x/inst.isle line 2932. - let expr0_0: Type = I64; - let expr1_0 = UnaryOp::PopcntReg; - let expr2_0 = constructor_unary_rr(ctx, expr0_0, &expr1_0, pattern0_0)?; - return Some(expr2_0); -} - -// Generated as internal constructor for term atomic_rmw_and. -pub fn constructor_atomic_rmw_and( - ctx: &mut C, - arg0: Type, - arg1: Reg, - arg2: &MemArg, -) -> Option { - let pattern0_0 = arg0; - if pattern0_0 == I32 { - let pattern2_0 = arg1; - let pattern3_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 2938. - let expr0_0: Type = I32; - let expr1_0 = ALUOp::And32; - let expr2_0 = constructor_atomic_rmw_impl(ctx, expr0_0, &expr1_0, pattern2_0, pattern3_0)?; - return Some(expr2_0); - } - if pattern0_0 == I64 { - let pattern2_0 = arg1; - let pattern3_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 2939. - let expr0_0: Type = I64; - let expr1_0 = ALUOp::And64; - let expr2_0 = constructor_atomic_rmw_impl(ctx, expr0_0, &expr1_0, pattern2_0, pattern3_0)?; - return Some(expr2_0); - } - return None; -} - -// Generated as internal constructor for term atomic_rmw_or. -pub fn constructor_atomic_rmw_or( - ctx: &mut C, - arg0: Type, - arg1: Reg, - arg2: &MemArg, -) -> Option { - let pattern0_0 = arg0; - if pattern0_0 == I32 { - let pattern2_0 = arg1; - let pattern3_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 2942. - let expr0_0: Type = I32; - let expr1_0 = ALUOp::Orr32; - let expr2_0 = constructor_atomic_rmw_impl(ctx, expr0_0, &expr1_0, pattern2_0, pattern3_0)?; - return Some(expr2_0); - } - if pattern0_0 == I64 { - let pattern2_0 = arg1; - let pattern3_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 2943. - let expr0_0: Type = I64; - let expr1_0 = ALUOp::Orr64; - let expr2_0 = constructor_atomic_rmw_impl(ctx, expr0_0, &expr1_0, pattern2_0, pattern3_0)?; - return Some(expr2_0); - } - return None; -} - -// Generated as internal constructor for term atomic_rmw_xor. -pub fn constructor_atomic_rmw_xor( - ctx: &mut C, - arg0: Type, - arg1: Reg, - arg2: &MemArg, -) -> Option { - let pattern0_0 = arg0; - if pattern0_0 == I32 { - let pattern2_0 = arg1; - let pattern3_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 2946. - let expr0_0: Type = I32; - let expr1_0 = ALUOp::Xor32; - let expr2_0 = constructor_atomic_rmw_impl(ctx, expr0_0, &expr1_0, pattern2_0, pattern3_0)?; - return Some(expr2_0); - } - if pattern0_0 == I64 { - let pattern2_0 = arg1; - let pattern3_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 2947. - let expr0_0: Type = I64; - let expr1_0 = ALUOp::Xor64; - let expr2_0 = constructor_atomic_rmw_impl(ctx, expr0_0, &expr1_0, pattern2_0, pattern3_0)?; - return Some(expr2_0); - } - return None; -} - -// Generated as internal constructor for term atomic_rmw_add. -pub fn constructor_atomic_rmw_add( - ctx: &mut C, - arg0: Type, - arg1: Reg, - arg2: &MemArg, -) -> Option { - let pattern0_0 = arg0; - if pattern0_0 == I32 { - let pattern2_0 = arg1; - let pattern3_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 2950. - let expr0_0: Type = I32; - let expr1_0 = ALUOp::Add32; - let expr2_0 = constructor_atomic_rmw_impl(ctx, expr0_0, &expr1_0, pattern2_0, pattern3_0)?; - return Some(expr2_0); - } - if pattern0_0 == I64 { - let pattern2_0 = arg1; - let pattern3_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 2951. - let expr0_0: Type = I64; - let expr1_0 = ALUOp::Add64; - let expr2_0 = constructor_atomic_rmw_impl(ctx, expr0_0, &expr1_0, pattern2_0, pattern3_0)?; - return Some(expr2_0); - } - return None; -} - -// Generated as internal constructor for term atomic_cas_impl. -pub fn constructor_atomic_cas_impl( - ctx: &mut C, - arg0: Type, - arg1: Reg, - arg2: Reg, - arg3: &MemArg, -) -> Option { - let pattern0_0 = arg0; - if pattern0_0 == I32 { - let pattern2_0 = arg1; - let pattern3_0 = arg2; - let pattern4_0 = arg3; - // Rule at src/isa/s390x/inst.isle line 2957. - let expr0_0 = constructor_atomic_cas32(ctx, pattern2_0, pattern3_0, pattern4_0)?; - return Some(expr0_0); - } - if pattern0_0 == I64 { - let pattern2_0 = arg1; - let pattern3_0 = arg2; - let pattern4_0 = arg3; - // Rule at src/isa/s390x/inst.isle line 2958. - let expr0_0 = constructor_atomic_cas64(ctx, pattern2_0, pattern3_0, pattern4_0)?; - return Some(expr0_0); - } - return None; -} - -// Generated as internal constructor for term push_atomic_cas. -pub fn constructor_push_atomic_cas( - ctx: &mut C, - arg0: &VecMInstBuilder, - arg1: Type, - arg2: WritableReg, - arg3: Reg, - arg4: &MemArg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - if pattern1_0 == I32 { - let pattern3_0 = arg2; - let pattern4_0 = arg3; - let pattern5_0 = arg4; - // Rule at src/isa/s390x/inst.isle line 2961. - let expr0_0 = - constructor_push_atomic_cas32(ctx, pattern0_0, pattern3_0, pattern4_0, pattern5_0)?; - return Some(expr0_0); - } - if pattern1_0 == I64 { - let pattern3_0 = arg2; - let pattern4_0 = arg3; - let pattern5_0 = arg4; - // Rule at src/isa/s390x/inst.isle line 2962. - let expr0_0 = - constructor_push_atomic_cas64(ctx, pattern0_0, pattern3_0, pattern4_0, pattern5_0)?; - return Some(expr0_0); - } - return None; -} - -// Generated as internal constructor for term fpuop2_add. -pub fn constructor_fpuop2_add(ctx: &mut C, arg0: Type) -> Option { - let pattern0_0 = arg0; - if pattern0_0 == F32 { - // Rule at src/isa/s390x/inst.isle line 2968. - let expr0_0 = FPUOp2::Add32; - return Some(expr0_0); - } - if pattern0_0 == F64 { - // Rule at src/isa/s390x/inst.isle line 2969. - let expr0_0 = FPUOp2::Add64; - return Some(expr0_0); - } - return None; -} - -// Generated as internal constructor for term fadd_reg. -pub fn constructor_fadd_reg( - ctx: &mut C, - arg0: Type, - arg1: Reg, - arg2: Reg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 2972. - let expr0_0 = constructor_fpuop2_add(ctx, pattern0_0)?; - let expr1_0 = constructor_fpu_rrr(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term fpuop2_sub. -pub fn constructor_fpuop2_sub(ctx: &mut C, arg0: Type) -> Option { - let pattern0_0 = arg0; - if pattern0_0 == F32 { - // Rule at src/isa/s390x/inst.isle line 2978. - let expr0_0 = FPUOp2::Sub32; - return Some(expr0_0); - } - if pattern0_0 == F64 { - // Rule at src/isa/s390x/inst.isle line 2979. - let expr0_0 = FPUOp2::Sub64; - return Some(expr0_0); - } - return None; -} - -// Generated as internal constructor for term fsub_reg. -pub fn constructor_fsub_reg( - ctx: &mut C, - arg0: Type, - arg1: Reg, - arg2: Reg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 2982. - let expr0_0 = constructor_fpuop2_sub(ctx, pattern0_0)?; - let expr1_0 = constructor_fpu_rrr(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term fpuop2_mul. -pub fn constructor_fpuop2_mul(ctx: &mut C, arg0: Type) -> Option { - let pattern0_0 = arg0; - if pattern0_0 == F32 { - // Rule at src/isa/s390x/inst.isle line 2988. - let expr0_0 = FPUOp2::Mul32; - return Some(expr0_0); - } - if pattern0_0 == F64 { - // Rule at src/isa/s390x/inst.isle line 2989. - let expr0_0 = FPUOp2::Mul64; - return Some(expr0_0); - } - return None; -} - -// Generated as internal constructor for term fmul_reg. -pub fn constructor_fmul_reg( - ctx: &mut C, - arg0: Type, - arg1: Reg, - arg2: Reg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 2992. - let expr0_0 = constructor_fpuop2_mul(ctx, pattern0_0)?; - let expr1_0 = constructor_fpu_rrr(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term fpuop2_div. -pub fn constructor_fpuop2_div(ctx: &mut C, arg0: Type) -> Option { - let pattern0_0 = arg0; - if pattern0_0 == F32 { - // Rule at src/isa/s390x/inst.isle line 2998. - let expr0_0 = FPUOp2::Div32; - return Some(expr0_0); - } - if pattern0_0 == F64 { - // Rule at src/isa/s390x/inst.isle line 2999. - let expr0_0 = FPUOp2::Div64; - return Some(expr0_0); - } - return None; -} - -// Generated as internal constructor for term fdiv_reg. -pub fn constructor_fdiv_reg( - ctx: &mut C, - arg0: Type, - arg1: Reg, - arg2: Reg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 3002. - let expr0_0 = constructor_fpuop2_div(ctx, pattern0_0)?; - let expr1_0 = constructor_fpu_rrr(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term fpuop2_min. -pub fn constructor_fpuop2_min(ctx: &mut C, arg0: Type) -> Option { - let pattern0_0 = arg0; - if pattern0_0 == F32 { - // Rule at src/isa/s390x/inst.isle line 3008. - let expr0_0 = FPUOp2::Min32; - return Some(expr0_0); - } - if pattern0_0 == F64 { - // Rule at src/isa/s390x/inst.isle line 3009. - let expr0_0 = FPUOp2::Min64; - return Some(expr0_0); - } - return None; -} - -// Generated as internal constructor for term fmin_reg. -pub fn constructor_fmin_reg( - ctx: &mut C, - arg0: Type, - arg1: Reg, - arg2: Reg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 3012. - let expr0_0 = constructor_fpuop2_min(ctx, pattern0_0)?; - let expr1_0 = constructor_fpuvec_rrr(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term fpuop2_max. -pub fn constructor_fpuop2_max(ctx: &mut C, arg0: Type) -> Option { - let pattern0_0 = arg0; - if pattern0_0 == F32 { - // Rule at src/isa/s390x/inst.isle line 3018. - let expr0_0 = FPUOp2::Max32; - return Some(expr0_0); - } - if pattern0_0 == F64 { - // Rule at src/isa/s390x/inst.isle line 3019. - let expr0_0 = FPUOp2::Max64; - return Some(expr0_0); - } - return None; -} - -// Generated as internal constructor for term fmax_reg. -pub fn constructor_fmax_reg( - ctx: &mut C, - arg0: Type, - arg1: Reg, - arg2: Reg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 3022. - let expr0_0 = constructor_fpuop2_max(ctx, pattern0_0)?; - let expr1_0 = constructor_fpuvec_rrr(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term fpuop3_fma. -pub fn constructor_fpuop3_fma(ctx: &mut C, arg0: Type) -> Option { - let pattern0_0 = arg0; - if pattern0_0 == F32 { - // Rule at src/isa/s390x/inst.isle line 3028. - let expr0_0 = FPUOp3::MAdd32; - return Some(expr0_0); - } - if pattern0_0 == F64 { - // Rule at src/isa/s390x/inst.isle line 3029. - let expr0_0 = FPUOp3::MAdd64; - return Some(expr0_0); - } - return None; -} - -// Generated as internal constructor for term fma_reg. -pub fn constructor_fma_reg( - ctx: &mut C, - arg0: Type, - arg1: Reg, - arg2: Reg, - arg3: Reg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - let pattern3_0 = arg3; - // Rule at src/isa/s390x/inst.isle line 3032. - let expr0_0 = constructor_fpuop3_fma(ctx, pattern0_0)?; - let expr1_0 = constructor_fpu_rrrr( - ctx, pattern0_0, &expr0_0, pattern3_0, pattern1_0, pattern2_0, - )?; - return Some(expr1_0); -} - -// Generated as internal constructor for term fpuop1_sqrt. -pub fn constructor_fpuop1_sqrt(ctx: &mut C, arg0: Type) -> Option { - let pattern0_0 = arg0; - if pattern0_0 == F32 { - // Rule at src/isa/s390x/inst.isle line 3038. - let expr0_0 = FPUOp1::Sqrt32; - return Some(expr0_0); - } - if pattern0_0 == F64 { - // Rule at src/isa/s390x/inst.isle line 3039. - let expr0_0 = FPUOp1::Sqrt64; - return Some(expr0_0); - } - return None; -} - -// Generated as internal constructor for term sqrt_reg. -pub fn constructor_sqrt_reg(ctx: &mut C, arg0: Type, arg1: Reg) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/s390x/inst.isle line 3042. - let expr0_0 = constructor_fpuop1_sqrt(ctx, pattern0_0)?; - let expr1_0 = constructor_fpu_rr(ctx, pattern0_0, &expr0_0, pattern1_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term fpuop1_neg. -pub fn constructor_fpuop1_neg(ctx: &mut C, arg0: Type) -> Option { - let pattern0_0 = arg0; - if pattern0_0 == F32 { - // Rule at src/isa/s390x/inst.isle line 3048. - let expr0_0 = FPUOp1::Neg32; - return Some(expr0_0); - } - if pattern0_0 == F64 { - // Rule at src/isa/s390x/inst.isle line 3049. - let expr0_0 = FPUOp1::Neg64; - return Some(expr0_0); - } - return None; -} - -// Generated as internal constructor for term fneg_reg. -pub fn constructor_fneg_reg(ctx: &mut C, arg0: Type, arg1: Reg) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/s390x/inst.isle line 3052. - let expr0_0 = constructor_fpuop1_neg(ctx, pattern0_0)?; - let expr1_0 = constructor_fpu_rr(ctx, pattern0_0, &expr0_0, pattern1_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term fpuop1_abs. -pub fn constructor_fpuop1_abs(ctx: &mut C, arg0: Type) -> Option { - let pattern0_0 = arg0; - if pattern0_0 == F32 { - // Rule at src/isa/s390x/inst.isle line 3058. - let expr0_0 = FPUOp1::Abs32; - return Some(expr0_0); - } - if pattern0_0 == F64 { - // Rule at src/isa/s390x/inst.isle line 3059. - let expr0_0 = FPUOp1::Abs64; - return Some(expr0_0); - } - return None; -} - -// Generated as internal constructor for term fabs_reg. -pub fn constructor_fabs_reg(ctx: &mut C, arg0: Type, arg1: Reg) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/s390x/inst.isle line 3062. - let expr0_0 = constructor_fpuop1_abs(ctx, pattern0_0)?; - let expr1_0 = constructor_fpu_rr(ctx, pattern0_0, &expr0_0, pattern1_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term fpuroundmode_ceil. -pub fn constructor_fpuroundmode_ceil(ctx: &mut C, arg0: Type) -> Option { - let pattern0_0 = arg0; - if pattern0_0 == F32 { - // Rule at src/isa/s390x/inst.isle line 3068. - let expr0_0 = FpuRoundMode::Plus32; - return Some(expr0_0); - } - if pattern0_0 == F64 { - // Rule at src/isa/s390x/inst.isle line 3069. - let expr0_0 = FpuRoundMode::Plus64; - return Some(expr0_0); - } - return None; -} - -// Generated as internal constructor for term ceil_reg. -pub fn constructor_ceil_reg(ctx: &mut C, arg0: Type, arg1: Reg) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/s390x/inst.isle line 3072. - let expr0_0 = constructor_fpuroundmode_ceil(ctx, pattern0_0)?; - let expr1_0 = constructor_fpu_round(ctx, pattern0_0, &expr0_0, pattern1_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term fpuroundmode_floor. -pub fn constructor_fpuroundmode_floor(ctx: &mut C, arg0: Type) -> Option { - let pattern0_0 = arg0; - if pattern0_0 == F32 { - // Rule at src/isa/s390x/inst.isle line 3078. - let expr0_0 = FpuRoundMode::Minus32; - return Some(expr0_0); - } - if pattern0_0 == F64 { - // Rule at src/isa/s390x/inst.isle line 3079. - let expr0_0 = FpuRoundMode::Minus64; - return Some(expr0_0); - } - return None; -} - -// Generated as internal constructor for term floor_reg. -pub fn constructor_floor_reg(ctx: &mut C, arg0: Type, arg1: Reg) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/s390x/inst.isle line 3082. - let expr0_0 = constructor_fpuroundmode_floor(ctx, pattern0_0)?; - let expr1_0 = constructor_fpu_round(ctx, pattern0_0, &expr0_0, pattern1_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term fpuroundmode_trunc. -pub fn constructor_fpuroundmode_trunc(ctx: &mut C, arg0: Type) -> Option { - let pattern0_0 = arg0; - if pattern0_0 == F32 { - // Rule at src/isa/s390x/inst.isle line 3088. - let expr0_0 = FpuRoundMode::Zero32; - return Some(expr0_0); - } - if pattern0_0 == F64 { - // Rule at src/isa/s390x/inst.isle line 3089. - let expr0_0 = FpuRoundMode::Zero64; - return Some(expr0_0); - } - return None; -} - -// Generated as internal constructor for term trunc_reg. -pub fn constructor_trunc_reg(ctx: &mut C, arg0: Type, arg1: Reg) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/s390x/inst.isle line 3092. - let expr0_0 = constructor_fpuroundmode_trunc(ctx, pattern0_0)?; - let expr1_0 = constructor_fpu_round(ctx, pattern0_0, &expr0_0, pattern1_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term fpuroundmode_nearest. -pub fn constructor_fpuroundmode_nearest( - ctx: &mut C, - arg0: Type, -) -> Option { - let pattern0_0 = arg0; - if pattern0_0 == F32 { - // Rule at src/isa/s390x/inst.isle line 3098. - let expr0_0 = FpuRoundMode::Nearest32; - return Some(expr0_0); - } - if pattern0_0 == F64 { - // Rule at src/isa/s390x/inst.isle line 3099. - let expr0_0 = FpuRoundMode::Nearest64; - return Some(expr0_0); - } - return None; -} - -// Generated as internal constructor for term nearest_reg. -pub fn constructor_nearest_reg(ctx: &mut C, arg0: Type, arg1: Reg) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/s390x/inst.isle line 3102. - let expr0_0 = constructor_fpuroundmode_nearest(ctx, pattern0_0)?; - let expr1_0 = constructor_fpu_round(ctx, pattern0_0, &expr0_0, pattern1_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term fpuop1_promote. -pub fn constructor_fpuop1_promote( - ctx: &mut C, - arg0: Type, - arg1: Type, -) -> Option { - let pattern0_0 = arg0; - if pattern0_0 == F64 { - let pattern2_0 = arg1; - if pattern2_0 == F32 { - // Rule at src/isa/s390x/inst.isle line 3108. - let expr0_0 = FPUOp1::Cvt32To64; - return Some(expr0_0); - } - } - return None; -} - -// Generated as internal constructor for term fpromote_reg. -pub fn constructor_fpromote_reg( - ctx: &mut C, - arg0: Type, - arg1: Type, - arg2: Reg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 3111. - let expr0_0 = constructor_fpuop1_promote(ctx, pattern0_0, pattern1_0)?; - let expr1_0 = constructor_fpu_rr(ctx, pattern0_0, &expr0_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term fpuop1_demote. -pub fn constructor_fpuop1_demote( - ctx: &mut C, - arg0: Type, - arg1: Type, -) -> Option { - let pattern0_0 = arg0; - if pattern0_0 == F32 { - let pattern2_0 = arg1; - if pattern2_0 == F64 { - // Rule at src/isa/s390x/inst.isle line 3118. - let expr0_0 = FPUOp1::Cvt64To32; - return Some(expr0_0); - } - } - return None; -} - -// Generated as internal constructor for term fdemote_reg. -pub fn constructor_fdemote_reg( - ctx: &mut C, - arg0: Type, - arg1: Type, - arg2: Reg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 3121. - let expr0_0 = constructor_fpuop1_demote(ctx, pattern0_0, pattern1_0)?; - let expr1_0 = constructor_fpu_rr(ctx, pattern0_0, &expr0_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term uint_to_fpu_op. -pub fn constructor_uint_to_fpu_op( - ctx: &mut C, - arg0: Type, - arg1: Type, -) -> Option { - let pattern0_0 = arg0; - if pattern0_0 == F32 { - let pattern2_0 = arg1; - if pattern2_0 == I32 { - // Rule at src/isa/s390x/inst.isle line 3128. - let expr0_0 = IntToFpuOp::U32ToF32; - return Some(expr0_0); - } - if pattern2_0 == I64 { - // Rule at src/isa/s390x/inst.isle line 3130. - let expr0_0 = IntToFpuOp::U64ToF32; - return Some(expr0_0); - } - } - if pattern0_0 == F64 { - let pattern2_0 = arg1; - if pattern2_0 == I32 { - // Rule at src/isa/s390x/inst.isle line 3129. - let expr0_0 = IntToFpuOp::U32ToF64; - return Some(expr0_0); - } - if pattern2_0 == I64 { - // Rule at src/isa/s390x/inst.isle line 3131. - let expr0_0 = IntToFpuOp::U64ToF64; - return Some(expr0_0); - } - } - return None; -} - -// Generated as internal constructor for term fcvt_from_uint_reg. -pub fn constructor_fcvt_from_uint_reg( - ctx: &mut C, - arg0: Type, - arg1: Type, - arg2: Reg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 3134. - let expr0_0 = constructor_uint_to_fpu_op(ctx, pattern0_0, pattern1_0)?; - let expr1_0 = constructor_int_to_fpu(ctx, pattern0_0, &expr0_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term sint_to_fpu_op. -pub fn constructor_sint_to_fpu_op( - ctx: &mut C, - arg0: Type, - arg1: Type, -) -> Option { - let pattern0_0 = arg0; - if pattern0_0 == F32 { - let pattern2_0 = arg1; - if pattern2_0 == I32 { - // Rule at src/isa/s390x/inst.isle line 3141. - let expr0_0 = IntToFpuOp::I32ToF32; - return Some(expr0_0); - } - if pattern2_0 == I64 { - // Rule at src/isa/s390x/inst.isle line 3143. - let expr0_0 = IntToFpuOp::I64ToF32; - return Some(expr0_0); - } - } - if pattern0_0 == F64 { - let pattern2_0 = arg1; - if pattern2_0 == I32 { - // Rule at src/isa/s390x/inst.isle line 3142. - let expr0_0 = IntToFpuOp::I32ToF64; - return Some(expr0_0); - } - if pattern2_0 == I64 { - // Rule at src/isa/s390x/inst.isle line 3144. - let expr0_0 = IntToFpuOp::I64ToF64; - return Some(expr0_0); - } - } - return None; -} - -// Generated as internal constructor for term fcvt_from_sint_reg. -pub fn constructor_fcvt_from_sint_reg( - ctx: &mut C, - arg0: Type, - arg1: Type, - arg2: Reg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 3147. - let expr0_0 = constructor_sint_to_fpu_op(ctx, pattern0_0, pattern1_0)?; - let expr1_0 = constructor_int_to_fpu(ctx, pattern0_0, &expr0_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term fpu_to_uint_op. -pub fn constructor_fpu_to_uint_op( - ctx: &mut C, - arg0: Type, - arg1: Type, -) -> Option { - let pattern0_0 = arg0; - if pattern0_0 == I32 { - let pattern2_0 = arg1; - if pattern2_0 == F32 { - // Rule at src/isa/s390x/inst.isle line 3154. - let expr0_0 = FpuToIntOp::F32ToU32; - return Some(expr0_0); - } - if pattern2_0 == F64 { - // Rule at src/isa/s390x/inst.isle line 3155. - let expr0_0 = FpuToIntOp::F64ToU32; - return Some(expr0_0); - } - } - if pattern0_0 == I64 { - let pattern2_0 = arg1; - if pattern2_0 == F32 { - // Rule at src/isa/s390x/inst.isle line 3156. - let expr0_0 = FpuToIntOp::F32ToU64; - return Some(expr0_0); - } - if pattern2_0 == F64 { - // Rule at src/isa/s390x/inst.isle line 3157. - let expr0_0 = FpuToIntOp::F64ToU64; - return Some(expr0_0); - } - } - return None; -} - -// Generated as internal constructor for term fcvt_to_uint_reg_with_flags. -pub fn constructor_fcvt_to_uint_reg_with_flags( - ctx: &mut C, - arg0: Type, - arg1: Type, - arg2: Reg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 3160. - let expr0_0 = constructor_fpu_to_uint_op(ctx, pattern0_0, pattern1_0)?; - let expr1_0 = constructor_fpu_to_int(ctx, pattern0_0, &expr0_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term fcvt_to_uint_reg. -pub fn constructor_fcvt_to_uint_reg( - ctx: &mut C, - arg0: Type, - arg1: Type, - arg2: Reg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 3164. - let expr0_0 = constructor_fcvt_to_uint_reg_with_flags(ctx, pattern0_0, pattern1_0, pattern2_0)?; - let expr1_0 = constructor_drop_flags(ctx, &expr0_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term fpu_to_sint_op. -pub fn constructor_fpu_to_sint_op( - ctx: &mut C, - arg0: Type, - arg1: Type, -) -> Option { - let pattern0_0 = arg0; - if pattern0_0 == I32 { - let pattern2_0 = arg1; - if pattern2_0 == F32 { - // Rule at src/isa/s390x/inst.isle line 3171. - let expr0_0 = FpuToIntOp::F32ToI32; - return Some(expr0_0); - } - if pattern2_0 == F64 { - // Rule at src/isa/s390x/inst.isle line 3172. - let expr0_0 = FpuToIntOp::F64ToI32; - return Some(expr0_0); - } - } - if pattern0_0 == I64 { - let pattern2_0 = arg1; - if pattern2_0 == F32 { - // Rule at src/isa/s390x/inst.isle line 3173. - let expr0_0 = FpuToIntOp::F32ToI64; - return Some(expr0_0); - } - if pattern2_0 == F64 { - // Rule at src/isa/s390x/inst.isle line 3174. - let expr0_0 = FpuToIntOp::F64ToI64; - return Some(expr0_0); - } - } - return None; -} - -// Generated as internal constructor for term fcvt_to_sint_reg_with_flags. -pub fn constructor_fcvt_to_sint_reg_with_flags( - ctx: &mut C, - arg0: Type, - arg1: Type, - arg2: Reg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 3177. - let expr0_0 = constructor_fpu_to_sint_op(ctx, pattern0_0, pattern1_0)?; - let expr1_0 = constructor_fpu_to_int(ctx, pattern0_0, &expr0_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term fcvt_to_sint_reg. -pub fn constructor_fcvt_to_sint_reg( - ctx: &mut C, - arg0: Type, - arg1: Type, - arg2: Reg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 3181. - let expr0_0 = constructor_fcvt_to_sint_reg_with_flags(ctx, pattern0_0, pattern1_0, pattern2_0)?; - let expr1_0 = constructor_drop_flags(ctx, &expr0_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term cmpop_cmps. -pub fn constructor_cmpop_cmps(ctx: &mut C, arg0: Type) -> Option { - let pattern0_0 = arg0; - if pattern0_0 == I32 { - // Rule at src/isa/s390x/inst.isle line 3188. - let expr0_0 = CmpOp::CmpS32; - return Some(expr0_0); - } - if pattern0_0 == I64 { - // Rule at src/isa/s390x/inst.isle line 3189. - let expr0_0 = CmpOp::CmpS64; - return Some(expr0_0); - } - return None; -} - -// Generated as internal constructor for term cmpop_cmps_sext16. -pub fn constructor_cmpop_cmps_sext16(ctx: &mut C, arg0: Type) -> Option { - let pattern0_0 = arg0; - if pattern0_0 == I32 { - // Rule at src/isa/s390x/inst.isle line 3192. - let expr0_0 = CmpOp::CmpS32Ext16; - return Some(expr0_0); - } - if pattern0_0 == I64 { - // Rule at src/isa/s390x/inst.isle line 3193. - let expr0_0 = CmpOp::CmpS64Ext16; - return Some(expr0_0); - } - return None; -} - -// Generated as internal constructor for term cmpop_cmps_sext32. -pub fn constructor_cmpop_cmps_sext32(ctx: &mut C, arg0: Type) -> Option { - let pattern0_0 = arg0; - if pattern0_0 == I64 { - // Rule at src/isa/s390x/inst.isle line 3196. - let expr0_0 = CmpOp::CmpS64Ext32; - return Some(expr0_0); - } - return None; -} - -// Generated as internal constructor for term icmps_reg. -pub fn constructor_icmps_reg( - ctx: &mut C, - arg0: Type, - arg1: Reg, - arg2: Reg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 3199. - let expr0_0 = constructor_cmpop_cmps(ctx, pattern0_0)?; - let expr1_0 = constructor_cmp_rr(ctx, &expr0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term icmps_reg_sext32. -pub fn constructor_icmps_reg_sext32( - ctx: &mut C, - arg0: Type, - arg1: Reg, - arg2: Reg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 3202. - let expr0_0 = constructor_cmpop_cmps_sext32(ctx, pattern0_0)?; - let expr1_0 = constructor_cmp_rr(ctx, &expr0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term icmps_simm16. -pub fn constructor_icmps_simm16( - ctx: &mut C, - arg0: Type, - arg1: Reg, - arg2: i16, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 3205. - let expr0_0 = constructor_cmpop_cmps(ctx, pattern0_0)?; - let expr1_0 = constructor_cmp_rsimm16(ctx, &expr0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term icmps_simm32. -pub fn constructor_icmps_simm32( - ctx: &mut C, - arg0: Type, - arg1: Reg, - arg2: i32, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 3208. - let expr0_0 = constructor_cmpop_cmps(ctx, pattern0_0)?; - let expr1_0 = constructor_cmp_rsimm32(ctx, &expr0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term icmps_mem. -pub fn constructor_icmps_mem( - ctx: &mut C, - arg0: Type, - arg1: Reg, - arg2: &MemArg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 3211. - let expr0_0 = constructor_cmpop_cmps(ctx, pattern0_0)?; - let expr1_0 = constructor_cmp_rx(ctx, &expr0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term icmps_mem_sext16. -pub fn constructor_icmps_mem_sext16( - ctx: &mut C, - arg0: Type, - arg1: Reg, - arg2: &MemArg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 3214. - let expr0_0 = constructor_cmpop_cmps_sext16(ctx, pattern0_0)?; - let expr1_0 = constructor_cmp_rx(ctx, &expr0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term icmps_mem_sext32. -pub fn constructor_icmps_mem_sext32( - ctx: &mut C, - arg0: Type, - arg1: Reg, - arg2: &MemArg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 3217. - let expr0_0 = constructor_cmpop_cmps_sext32(ctx, pattern0_0)?; - let expr1_0 = constructor_cmp_rx(ctx, &expr0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term cmpop_cmpu. -pub fn constructor_cmpop_cmpu(ctx: &mut C, arg0: Type) -> Option { - let pattern0_0 = arg0; - if pattern0_0 == I32 { - // Rule at src/isa/s390x/inst.isle line 3223. - let expr0_0 = CmpOp::CmpL32; - return Some(expr0_0); - } - if pattern0_0 == I64 { - // Rule at src/isa/s390x/inst.isle line 3224. - let expr0_0 = CmpOp::CmpL64; - return Some(expr0_0); - } - return None; -} - -// Generated as internal constructor for term cmpop_cmpu_zext16. -pub fn constructor_cmpop_cmpu_zext16(ctx: &mut C, arg0: Type) -> Option { - let pattern0_0 = arg0; - if pattern0_0 == I32 { - // Rule at src/isa/s390x/inst.isle line 3227. - let expr0_0 = CmpOp::CmpL32Ext16; - return Some(expr0_0); - } - if pattern0_0 == I64 { - // Rule at src/isa/s390x/inst.isle line 3228. - let expr0_0 = CmpOp::CmpL64Ext16; - return Some(expr0_0); - } - return None; -} - -// Generated as internal constructor for term cmpop_cmpu_zext32. -pub fn constructor_cmpop_cmpu_zext32(ctx: &mut C, arg0: Type) -> Option { - let pattern0_0 = arg0; - if pattern0_0 == I64 { - // Rule at src/isa/s390x/inst.isle line 3231. - let expr0_0 = CmpOp::CmpL64Ext32; - return Some(expr0_0); - } - return None; -} - -// Generated as internal constructor for term icmpu_reg. -pub fn constructor_icmpu_reg( - ctx: &mut C, - arg0: Type, - arg1: Reg, - arg2: Reg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 3234. - let expr0_0 = constructor_cmpop_cmpu(ctx, pattern0_0)?; - let expr1_0 = constructor_cmp_rr(ctx, &expr0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term icmpu_reg_zext32. -pub fn constructor_icmpu_reg_zext32( - ctx: &mut C, - arg0: Type, - arg1: Reg, - arg2: Reg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 3237. - let expr0_0 = constructor_cmpop_cmpu_zext32(ctx, pattern0_0)?; - let expr1_0 = constructor_cmp_rr(ctx, &expr0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term icmpu_uimm32. -pub fn constructor_icmpu_uimm32( - ctx: &mut C, - arg0: Type, - arg1: Reg, - arg2: u32, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 3240. - let expr0_0 = constructor_cmpop_cmpu(ctx, pattern0_0)?; - let expr1_0 = constructor_cmp_ruimm32(ctx, &expr0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term icmpu_mem. -pub fn constructor_icmpu_mem( - ctx: &mut C, - arg0: Type, - arg1: Reg, - arg2: &MemArg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 3243. - let expr0_0 = constructor_cmpop_cmpu(ctx, pattern0_0)?; - let expr1_0 = constructor_cmp_rx(ctx, &expr0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term icmpu_mem_zext16. -pub fn constructor_icmpu_mem_zext16( - ctx: &mut C, - arg0: Type, - arg1: Reg, - arg2: &MemArg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 3246. - let expr0_0 = constructor_cmpop_cmpu_zext16(ctx, pattern0_0)?; - let expr1_0 = constructor_cmp_rx(ctx, &expr0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term icmpu_mem_zext32. -pub fn constructor_icmpu_mem_zext32( - ctx: &mut C, - arg0: Type, - arg1: Reg, - arg2: &MemArg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 3249. - let expr0_0 = constructor_cmpop_cmpu_zext32(ctx, pattern0_0)?; - let expr1_0 = constructor_cmp_rx(ctx, &expr0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term fcmp_reg. -pub fn constructor_fcmp_reg( - ctx: &mut C, - arg0: Type, - arg1: Reg, - arg2: Reg, -) -> Option { - let pattern0_0 = arg0; - if pattern0_0 == F32 { - let pattern2_0 = arg1; - let pattern3_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 3255. - let expr0_0 = constructor_fpu_cmp32(ctx, pattern2_0, pattern3_0)?; - return Some(expr0_0); - } - if pattern0_0 == F64 { - let pattern2_0 = arg1; - let pattern3_0 = arg2; - // Rule at src/isa/s390x/inst.isle line 3256. - let expr0_0 = constructor_fpu_cmp64(ctx, pattern2_0, pattern3_0)?; - return Some(expr0_0); - } - return None; -} - -// Generated as internal constructor for term lower. -pub fn constructor_lower(ctx: &mut C, arg0: Inst) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = C::inst_data(ctx, pattern0_0); - match &pattern1_0 { - &InstructionData::NullAry { - opcode: ref pattern2_0, - } => { - match pattern2_0 { - &Opcode::Debugtrap => { - // Rule at src/isa/s390x/lower.isle line 2176. - let expr0_0 = constructor_debugtrap_impl(ctx)?; - let expr1_0 = constructor_side_effect(ctx, &expr0_0)?; - return Some(expr1_0); - } - &Opcode::Nop => { - // Rule at src/isa/s390x/lower.isle line 47. - let expr0_0 = C::invalid_reg(ctx); - let expr1_0 = constructor_output_reg(ctx, expr0_0)?; - return Some(expr1_0); - } - &Opcode::Fence => { - // Rule at src/isa/s390x/lower.isle line 1887. - let expr0_0 = constructor_fence_impl(ctx)?; - let expr1_0 = constructor_side_effect(ctx, &expr0_0)?; - return Some(expr1_0); - } - _ => {} - } - } - &InstructionData::FuncAddr { - opcode: ref pattern2_0, - func_ref: pattern2_1, - } => { - if let &Opcode::FuncAddr = pattern2_0 { - let (pattern4_0, pattern4_1, pattern4_2) = C::func_ref_data(ctx, pattern2_1); - if let Some(()) = C::reloc_distance_near(ctx, pattern4_2) { - // Rule at src/isa/s390x/lower.isle line 1163. - let expr0_0: i32 = 0; - let expr1_0 = C::memflags_trusted(ctx); - let expr2_0 = C::memarg_symbol(ctx, pattern4_1, expr0_0, expr1_0); - let expr3_0 = constructor_load_addr(ctx, &expr2_0)?; - let expr4_0 = constructor_output_reg(ctx, expr3_0)?; - return Some(expr4_0); - } - // Rule at src/isa/s390x/lower.isle line 1167. - let expr0_0: i64 = 0; - let expr1_0 = constructor_load_ext_name_far(ctx, pattern4_1, expr0_0)?; - let expr2_0 = constructor_output_reg(ctx, expr1_0)?; - return Some(expr2_0); - } - } - &InstructionData::UnaryGlobalValue { - opcode: ref pattern2_0, - global_value: pattern2_1, - } => { - if let &Opcode::SymbolValue = pattern2_0 { - if let Some((pattern4_0, pattern4_1, pattern4_2)) = - C::symbol_value_data(ctx, pattern2_1) - { - if let Some(()) = C::reloc_distance_near(ctx, pattern4_1) { - let mut closure6 = || { - let expr0_0 = constructor_memarg_symbol_offset(ctx, pattern4_2)?; - return Some(expr0_0); - }; - if let Some(pattern6_0) = closure6() { - // Rule at src/isa/s390x/lower.isle line 1174. - let expr0_0 = C::memflags_trusted(ctx); - let expr1_0 = C::memarg_symbol(ctx, pattern4_0, pattern6_0, expr0_0); - let expr2_0 = constructor_load_addr(ctx, &expr1_0)?; - let expr3_0 = constructor_output_reg(ctx, expr2_0)?; - return Some(expr3_0); - } - } - // Rule at src/isa/s390x/lower.isle line 1180. - let expr0_0 = constructor_load_ext_name_far(ctx, pattern4_0, pattern4_2)?; - let expr1_0 = constructor_output_reg(ctx, expr0_0)?; - return Some(expr1_0); - } - } - } - &InstructionData::UnaryIeee32 { - opcode: ref pattern2_0, - imm: pattern2_1, - } => { - if let &Opcode::F32const = pattern2_0 { - let pattern4_0 = C::u64_from_ieee32(ctx, pattern2_1); - // Rule at src/isa/s390x/lower.isle line 29. - let expr0_0: Type = F32; - let expr1_0 = constructor_imm(ctx, expr0_0, pattern4_0)?; - let expr2_0 = constructor_output_reg(ctx, expr1_0)?; - return Some(expr2_0); - } - } - &InstructionData::UnaryIeee64 { - opcode: ref pattern2_0, - imm: pattern2_1, - } => { - if let &Opcode::F64const = pattern2_0 { - let pattern4_0 = C::u64_from_ieee64(ctx, pattern2_1); - // Rule at src/isa/s390x/lower.isle line 35. - let expr0_0: Type = F64; - let expr1_0 = constructor_imm(ctx, expr0_0, pattern4_0)?; - let expr2_0 = constructor_output_reg(ctx, expr1_0)?; - return Some(expr2_0); - } - } - &InstructionData::Trap { - opcode: ref pattern2_0, - code: ref pattern2_1, - } => { - match pattern2_0 { - &Opcode::Trap => { - // Rule at src/isa/s390x/lower.isle line 2146. - let expr0_0 = constructor_trap_impl(ctx, pattern2_1)?; - let expr1_0 = constructor_side_effect(ctx, &expr0_0)?; - return Some(expr1_0); - } - &Opcode::ResumableTrap => { - // Rule at src/isa/s390x/lower.isle line 2152. - let expr0_0 = constructor_trap_impl(ctx, pattern2_1)?; - let expr1_0 = constructor_side_effect(ctx, &expr0_0)?; - return Some(expr1_0); - } - _ => {} - } - } - &InstructionData::StoreNoOffset { - opcode: ref pattern2_0, - args: ref pattern2_1, - flags: pattern2_2, - } => { - if let &Opcode::AtomicStore = pattern2_0 { - let (pattern4_0, pattern4_1) = C::unpack_value_array_2(ctx, pattern2_1); - let pattern5_0 = C::value_type(ctx, pattern4_0); - if pattern5_0 == I8 { - // Rule at src/isa/s390x/lower.isle line 1868. - let expr0_0 = C::zero_offset(ctx); - let expr1_0 = - constructor_istore8_impl(ctx, pattern2_2, pattern4_0, pattern4_1, expr0_0)?; - let expr2_0 = constructor_atomic_store_impl(ctx, &expr1_0)?; - return Some(expr2_0); - } - if pattern5_0 == I16 { - // Rule at src/isa/s390x/lower.isle line 1872. - let expr0_0 = C::zero_offset(ctx); - let expr1_0 = constructor_istore16_impl( - ctx, pattern2_2, pattern4_0, pattern4_1, expr0_0, - )?; - let expr2_0 = constructor_atomic_store_impl(ctx, &expr1_0)?; - return Some(expr2_0); - } - if pattern5_0 == I32 { - // Rule at src/isa/s390x/lower.isle line 1876. - let expr0_0 = C::zero_offset(ctx); - let expr1_0 = constructor_istore32_impl( - ctx, pattern2_2, pattern4_0, pattern4_1, expr0_0, - )?; - let expr2_0 = constructor_atomic_store_impl(ctx, &expr1_0)?; - return Some(expr2_0); - } - if pattern5_0 == I64 { - // Rule at src/isa/s390x/lower.isle line 1880. - let expr0_0 = C::zero_offset(ctx); - let expr1_0 = constructor_istore64_impl( - ctx, pattern2_2, pattern4_0, pattern4_1, expr0_0, - )?; - let expr2_0 = constructor_atomic_store_impl(ctx, &expr1_0)?; - return Some(expr2_0); - } - } - } - &InstructionData::Store { - opcode: ref pattern2_0, - args: ref pattern2_1, - flags: pattern2_2, - offset: pattern2_3, - } => { - match pattern2_0 { - &Opcode::Store => { - let (pattern4_0, pattern4_1) = C::unpack_value_array_2(ctx, pattern2_1); - let pattern5_0 = C::value_type(ctx, pattern4_0); - if pattern5_0 == I8 { - // Rule at src/isa/s390x/lower.isle line 1359. - let expr0_0 = constructor_istore8_impl( - ctx, pattern2_2, pattern4_0, pattern4_1, pattern2_3, - )?; - let expr1_0 = constructor_side_effect(ctx, &expr0_0)?; - return Some(expr1_0); - } - if pattern5_0 == I16 { - // Rule at src/isa/s390x/lower.isle line 1363. - let expr0_0 = constructor_istore16_impl( - ctx, pattern2_2, pattern4_0, pattern4_1, pattern2_3, - )?; - let expr1_0 = constructor_side_effect(ctx, &expr0_0)?; - return Some(expr1_0); - } - if pattern5_0 == I32 { - // Rule at src/isa/s390x/lower.isle line 1367. - let expr0_0 = constructor_istore32_impl( - ctx, pattern2_2, pattern4_0, pattern4_1, pattern2_3, - )?; - let expr1_0 = constructor_side_effect(ctx, &expr0_0)?; - return Some(expr1_0); - } - if pattern5_0 == I64 { - // Rule at src/isa/s390x/lower.isle line 1371. - let expr0_0 = constructor_istore64_impl( - ctx, pattern2_2, pattern4_0, pattern4_1, pattern2_3, - )?; - let expr1_0 = constructor_side_effect(ctx, &expr0_0)?; - return Some(expr1_0); - } - if pattern5_0 == R64 { - // Rule at src/isa/s390x/lower.isle line 1375. - let expr0_0 = constructor_istore64_impl( - ctx, pattern2_2, pattern4_0, pattern4_1, pattern2_3, - )?; - let expr1_0 = constructor_side_effect(ctx, &expr0_0)?; - return Some(expr1_0); - } - if pattern5_0 == F32 { - if let Some(()) = C::bigendian(ctx, pattern2_2) { - // Rule at src/isa/s390x/lower.isle line 1379. - let expr0_0 = C::put_in_reg(ctx, pattern4_0); - let expr1_0 = - constructor_lower_address(ctx, pattern2_2, pattern4_1, pattern2_3)?; - let expr2_0 = constructor_fpu_store32(ctx, expr0_0, &expr1_0)?; - let expr3_0 = constructor_side_effect(ctx, &expr2_0)?; - return Some(expr3_0); - } - if let Some(()) = C::vxrs_ext2_enabled(ctx, pattern5_0) { - if let Some(()) = C::littleendian(ctx, pattern2_2) { - // Rule at src/isa/s390x/lower.isle line 1385. - let expr0_0 = C::put_in_reg(ctx, pattern4_0); - let expr1_0 = constructor_lower_address( - ctx, pattern2_2, pattern4_1, pattern2_3, - )?; - let expr2_0 = constructor_fpu_storerev32(ctx, expr0_0, &expr1_0)?; - let expr3_0 = constructor_side_effect(ctx, &expr2_0)?; - return Some(expr3_0); - } - } - if let Some(()) = C::vxrs_ext2_disabled(ctx, pattern5_0) { - if let Some(()) = C::littleendian(ctx, pattern2_2) { - // Rule at src/isa/s390x/lower.isle line 1391. - let expr0_0: Type = I64; - let expr1_0 = C::put_in_reg(ctx, pattern4_0); - let expr2_0 = constructor_mov_from_fpr(ctx, expr1_0)?; - let expr3_0: u8 = 32; - let expr4_0 = constructor_lshr_imm(ctx, expr0_0, expr2_0, expr3_0)?; - let expr5_0 = constructor_lower_address( - ctx, pattern2_2, pattern4_1, pattern2_3, - )?; - let expr6_0 = constructor_storerev32(ctx, expr4_0, &expr5_0)?; - let expr7_0 = constructor_side_effect(ctx, &expr6_0)?; - return Some(expr7_0); - } - } - } - if pattern5_0 == F64 { - if let Some(()) = C::bigendian(ctx, pattern2_2) { - // Rule at src/isa/s390x/lower.isle line 1397. - let expr0_0 = C::put_in_reg(ctx, pattern4_0); - let expr1_0 = - constructor_lower_address(ctx, pattern2_2, pattern4_1, pattern2_3)?; - let expr2_0 = constructor_fpu_store64(ctx, expr0_0, &expr1_0)?; - let expr3_0 = constructor_side_effect(ctx, &expr2_0)?; - return Some(expr3_0); - } - if let Some(()) = C::vxrs_ext2_enabled(ctx, pattern5_0) { - if let Some(()) = C::littleendian(ctx, pattern2_2) { - // Rule at src/isa/s390x/lower.isle line 1403. - let expr0_0 = C::put_in_reg(ctx, pattern4_0); - let expr1_0 = constructor_lower_address( - ctx, pattern2_2, pattern4_1, pattern2_3, - )?; - let expr2_0 = constructor_fpu_storerev64(ctx, expr0_0, &expr1_0)?; - let expr3_0 = constructor_side_effect(ctx, &expr2_0)?; - return Some(expr3_0); - } - } - if let Some(()) = C::vxrs_ext2_disabled(ctx, pattern5_0) { - if let Some(()) = C::littleendian(ctx, pattern2_2) { - // Rule at src/isa/s390x/lower.isle line 1409. - let expr0_0 = C::put_in_reg(ctx, pattern4_0); - let expr1_0 = constructor_mov_from_fpr(ctx, expr0_0)?; - let expr2_0 = constructor_lower_address( - ctx, pattern2_2, pattern4_1, pattern2_3, - )?; - let expr3_0 = constructor_storerev64(ctx, expr1_0, &expr2_0)?; - let expr4_0 = constructor_side_effect(ctx, &expr3_0)?; - return Some(expr4_0); - } - } - } - } - &Opcode::Istore8 => { - let (pattern4_0, pattern4_1) = C::unpack_value_array_2(ctx, pattern2_1); - // Rule at src/isa/s390x/lower.isle line 1418. - let expr0_0 = constructor_istore8_impl( - ctx, pattern2_2, pattern4_0, pattern4_1, pattern2_3, - )?; - let expr1_0 = constructor_side_effect(ctx, &expr0_0)?; - return Some(expr1_0); - } - &Opcode::Istore16 => { - let (pattern4_0, pattern4_1) = C::unpack_value_array_2(ctx, pattern2_1); - // Rule at src/isa/s390x/lower.isle line 1436. - let expr0_0 = constructor_istore16_impl( - ctx, pattern2_2, pattern4_0, pattern4_1, pattern2_3, - )?; - let expr1_0 = constructor_side_effect(ctx, &expr0_0)?; - return Some(expr1_0); - } - &Opcode::Istore32 => { - let (pattern4_0, pattern4_1) = C::unpack_value_array_2(ctx, pattern2_1); - // Rule at src/isa/s390x/lower.isle line 1462. - let expr0_0 = constructor_istore32_impl( - ctx, pattern2_2, pattern4_0, pattern4_1, pattern2_3, - )?; - let expr1_0 = constructor_side_effect(ctx, &expr0_0)?; - return Some(expr1_0); - } - _ => {} - } - } - &InstructionData::Unary { - opcode: ref pattern2_0, - arg: pattern2_1, - } => { - match pattern2_0 { - &Opcode::Copy => { - // Rule at src/isa/s390x/lower.isle line 53. - let expr0_0 = constructor_output_value(ctx, pattern2_1)?; - return Some(expr0_0); - } - &Opcode::Breduce => { - // Rule at src/isa/s390x/lower.isle line 756. - let expr0_0 = constructor_output_value(ctx, pattern2_1)?; - return Some(expr0_0); - } - &Opcode::Ireduce => { - // Rule at src/isa/s390x/lower.isle line 600. - let expr0_0 = constructor_output_value(ctx, pattern2_1)?; - return Some(expr0_0); - } - _ => {} - } - } - &InstructionData::IntCondTrap { - opcode: ref pattern2_0, - arg: pattern2_1, - cond: ref pattern2_2, - code: ref pattern2_3, - } => { - if let &Opcode::Trapif = pattern2_0 { - if let Some(pattern4_0) = C::def_inst(ctx, pattern2_1) { - let pattern5_0 = C::inst_data(ctx, pattern4_0); - if let &InstructionData::Binary { - opcode: ref pattern6_0, - args: ref pattern6_1, - } = &pattern5_0 - { - match pattern6_0 { - &Opcode::Ifcmp => { - let (pattern8_0, pattern8_1) = - C::unpack_value_array_2(ctx, pattern6_1); - // Rule at src/isa/s390x/lower.isle line 2188. - let expr0_0: bool = false; - let expr1_0 = constructor_icmp_val( - ctx, expr0_0, pattern2_2, pattern8_0, pattern8_1, - )?; - let expr2_0 = constructor_trap_if_bool(ctx, &expr1_0, pattern2_3)?; - let expr3_0 = constructor_side_effect(ctx, &expr2_0)?; - return Some(expr3_0); - } - &Opcode::IaddIfcout => { - let (pattern8_0, pattern8_1) = - C::unpack_value_array_2(ctx, pattern6_1); - if let &IntCC::UnsignedGreaterThan = pattern2_2 { - // Rule at src/isa/s390x/lower.isle line 2213. - let expr0_0: u8 = 3; - let expr1_0 = C::mask_as_cond(ctx, expr0_0); - let expr2_0 = - constructor_trap_if_impl(ctx, &expr1_0, pattern2_3)?; - let expr3_0 = constructor_side_effect(ctx, &expr2_0)?; - return Some(expr3_0); - } - } - _ => {} - } - } - } - } - } - &InstructionData::CondTrap { - opcode: ref pattern2_0, - arg: pattern2_1, - code: ref pattern2_2, - } => { - match pattern2_0 { - &Opcode::Trapz => { - // Rule at src/isa/s390x/lower.isle line 2158. - let expr0_0 = constructor_value_nonzero(ctx, pattern2_1)?; - let expr1_0 = constructor_invert_bool(ctx, &expr0_0)?; - let expr2_0 = constructor_trap_if_bool(ctx, &expr1_0, pattern2_2)?; - let expr3_0 = constructor_side_effect(ctx, &expr2_0)?; - return Some(expr3_0); - } - &Opcode::Trapnz => { - // Rule at src/isa/s390x/lower.isle line 2164. - let expr0_0 = constructor_value_nonzero(ctx, pattern2_1)?; - let expr1_0 = constructor_trap_if_bool(ctx, &expr0_0, pattern2_2)?; - let expr2_0 = constructor_side_effect(ctx, &expr1_0)?; - return Some(expr2_0); - } - &Opcode::ResumableTrapnz => { - // Rule at src/isa/s390x/lower.isle line 2170. - let expr0_0 = constructor_value_nonzero(ctx, pattern2_1)?; - let expr1_0 = constructor_trap_if_bool(ctx, &expr0_0, pattern2_2)?; - let expr2_0 = constructor_side_effect(ctx, &expr1_0)?; - return Some(expr2_0); - } - _ => {} - } - } - _ => {} - } - if let Some(pattern1_0) = C::first_result(ctx, pattern0_0) { - let pattern2_0 = C::value_type(ctx, pattern1_0); - if pattern2_0 == B1 { - let pattern4_0 = C::inst_data(ctx, pattern0_0); - if let &InstructionData::Unary { - opcode: ref pattern5_0, - arg: pattern5_1, - } = &pattern4_0 - { - match pattern5_0 { - &Opcode::IsNull => { - let pattern7_0 = C::value_type(ctx, pattern5_1); - if pattern7_0 == R64 { - // Rule at src/isa/s390x/lower.isle line 2024. - let expr0_0: Type = B1; - let expr1_0: Type = I64; - let expr2_0 = C::put_in_reg(ctx, pattern5_1); - let expr3_0: i16 = 0; - let expr4_0 = constructor_icmps_simm16(ctx, expr1_0, expr2_0, expr3_0)?; - let expr5_0 = IntCC::Equal; - let expr6_0 = C::intcc_as_cond(ctx, &expr5_0); - let expr7_0 = constructor_bool(ctx, &expr4_0, &expr6_0)?; - let expr8_0 = constructor_lower_bool(ctx, expr0_0, &expr7_0)?; - let expr9_0 = constructor_output_reg(ctx, expr8_0)?; - return Some(expr9_0); - } - } - &Opcode::IsInvalid => { - let pattern7_0 = C::value_type(ctx, pattern5_1); - if pattern7_0 == R64 { - // Rule at src/isa/s390x/lower.isle line 2030. - let expr0_0: Type = B1; - let expr1_0: Type = I64; - let expr2_0 = C::put_in_reg(ctx, pattern5_1); - let expr3_0: i16 = -1; - let expr4_0 = constructor_icmps_simm16(ctx, expr1_0, expr2_0, expr3_0)?; - let expr5_0 = IntCC::Equal; - let expr6_0 = C::intcc_as_cond(ctx, &expr5_0); - let expr7_0 = constructor_bool(ctx, &expr4_0, &expr6_0)?; - let expr8_0 = constructor_lower_bool(ctx, expr0_0, &expr7_0)?; - let expr9_0 = constructor_output_reg(ctx, expr8_0)?; - return Some(expr9_0); - } - } - _ => {} - } - } - } - if pattern2_0 == I8 { - let pattern4_0 = C::inst_data(ctx, pattern0_0); - match &pattern4_0 { - &InstructionData::Unary { - opcode: ref pattern5_0, - arg: pattern5_1, - } => { - if let &Opcode::Popcnt = pattern5_0 { - // Rule at src/isa/s390x/lower.isle line 888. - let expr0_0 = C::put_in_reg(ctx, pattern5_1); - let expr1_0 = constructor_popcnt_byte(ctx, expr0_0)?; - let expr2_0 = constructor_output_reg(ctx, expr1_0)?; - return Some(expr2_0); - } - } - &InstructionData::LoadNoOffset { - opcode: ref pattern5_0, - arg: pattern5_1, - flags: pattern5_2, - } => { - if let &Opcode::AtomicLoad = pattern5_0 { - // Rule at src/isa/s390x/lower.isle line 1831. - let expr0_0: Type = I8; - let expr1_0 = C::zero_offset(ctx); - let expr2_0 = - constructor_lower_address(ctx, pattern5_2, pattern5_1, expr1_0)?; - let expr3_0 = constructor_zext32_mem(ctx, expr0_0, &expr2_0)?; - let expr4_0 = constructor_output_reg(ctx, expr3_0)?; - return Some(expr4_0); - } - } - &InstructionData::Load { - opcode: ref pattern5_0, - arg: pattern5_1, - flags: pattern5_2, - offset: pattern5_3, - } => { - if let &Opcode::Load = pattern5_0 { - // Rule at src/isa/s390x/lower.isle line 1187. - let expr0_0: Type = I8; - let expr1_0 = - constructor_lower_address(ctx, pattern5_2, pattern5_1, pattern5_3)?; - let expr2_0 = constructor_zext32_mem(ctx, expr0_0, &expr1_0)?; - let expr3_0 = constructor_output_reg(ctx, expr2_0)?; - return Some(expr3_0); - } - } - _ => {} - } - } - if pattern2_0 == I16 { - let pattern4_0 = C::inst_data(ctx, pattern0_0); - match &pattern4_0 { - &InstructionData::LoadNoOffset { - opcode: ref pattern5_0, - arg: pattern5_1, - flags: pattern5_2, - } => { - if let &Opcode::AtomicLoad = pattern5_0 { - if let Some(()) = C::littleendian(ctx, pattern5_2) { - // Rule at src/isa/s390x/lower.isle line 1839. - let expr0_0 = C::zero_offset(ctx); - let expr1_0 = - constructor_lower_address(ctx, pattern5_2, pattern5_1, expr0_0)?; - let expr2_0 = constructor_loadrev16(ctx, &expr1_0)?; - let expr3_0 = constructor_output_reg(ctx, expr2_0)?; - return Some(expr3_0); - } - if let Some(()) = C::bigendian(ctx, pattern5_2) { - // Rule at src/isa/s390x/lower.isle line 1835. - let expr0_0: Type = I16; - let expr1_0 = C::zero_offset(ctx); - let expr2_0 = - constructor_lower_address(ctx, pattern5_2, pattern5_1, expr1_0)?; - let expr3_0 = constructor_zext32_mem(ctx, expr0_0, &expr2_0)?; - let expr4_0 = constructor_output_reg(ctx, expr3_0)?; - return Some(expr4_0); - } - } - } - &InstructionData::Load { - opcode: ref pattern5_0, - arg: pattern5_1, - flags: pattern5_2, - offset: pattern5_3, - } => { - if let &Opcode::Load = pattern5_0 { - if let Some(()) = C::littleendian(ctx, pattern5_2) { - // Rule at src/isa/s390x/lower.isle line 1195. - let expr0_0 = - constructor_lower_address(ctx, pattern5_2, pattern5_1, pattern5_3)?; - let expr1_0 = constructor_loadrev16(ctx, &expr0_0)?; - let expr2_0 = constructor_output_reg(ctx, expr1_0)?; - return Some(expr2_0); - } - if let Some(()) = C::bigendian(ctx, pattern5_2) { - // Rule at src/isa/s390x/lower.isle line 1191. - let expr0_0: Type = I16; - let expr1_0 = - constructor_lower_address(ctx, pattern5_2, pattern5_1, pattern5_3)?; - let expr2_0 = constructor_zext32_mem(ctx, expr0_0, &expr1_0)?; - let expr3_0 = constructor_output_reg(ctx, expr2_0)?; - return Some(expr3_0); - } - } - } - _ => {} - } - } - if pattern2_0 == I32 { - let pattern4_0 = C::inst_data(ctx, pattern0_0); - match &pattern4_0 { - &InstructionData::Binary { - opcode: ref pattern5_0, - args: ref pattern5_1, - } => { - match pattern5_0 { - &Opcode::Umulhi => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/s390x/lower.isle line 252. - let expr0_0 = constructor_put_in_reg_zext64(ctx, pattern7_0)?; - let expr1_0 = constructor_put_in_reg_zext64(ctx, pattern7_1)?; - let expr2_0: Type = I64; - let expr3_0 = constructor_mul_reg(ctx, expr2_0, expr0_0, expr1_0)?; - let expr4_0: Type = I64; - let expr5_0: u8 = 32; - let expr6_0 = constructor_lshr_imm(ctx, expr4_0, expr3_0, expr5_0)?; - let expr7_0 = constructor_output_reg(ctx, expr6_0)?; - return Some(expr7_0); - } - &Opcode::Smulhi => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/s390x/lower.isle line 274. - let expr0_0 = constructor_put_in_reg_sext64(ctx, pattern7_0)?; - let expr1_0 = constructor_put_in_reg_sext64(ctx, pattern7_1)?; - let expr2_0: Type = I64; - let expr3_0 = constructor_mul_reg(ctx, expr2_0, expr0_0, expr1_0)?; - let expr4_0: Type = I64; - let expr5_0: u8 = 32; - let expr6_0 = constructor_ashr_imm(ctx, expr4_0, expr3_0, expr5_0)?; - let expr7_0 = constructor_output_reg(ctx, expr6_0)?; - return Some(expr7_0); - } - _ => {} - } - } - &InstructionData::Unary { - opcode: ref pattern5_0, - arg: pattern5_1, - } => { - if let &Opcode::Bitcast = pattern5_0 { - let pattern7_0 = C::value_type(ctx, pattern5_1); - if pattern7_0 == F32 { - // Rule at src/isa/s390x/lower.isle line 1149. - let expr0_0: Type = I64; - let expr1_0 = C::put_in_reg(ctx, pattern5_1); - let expr2_0 = constructor_mov_from_fpr(ctx, expr1_0)?; - let expr3_0: u8 = 32; - let expr4_0 = constructor_lshr_imm(ctx, expr0_0, expr2_0, expr3_0)?; - let expr5_0 = constructor_output_reg(ctx, expr4_0)?; - return Some(expr5_0); - } - } - } - &InstructionData::LoadNoOffset { - opcode: ref pattern5_0, - arg: pattern5_1, - flags: pattern5_2, - } => { - if let &Opcode::AtomicLoad = pattern5_0 { - if let Some(()) = C::littleendian(ctx, pattern5_2) { - // Rule at src/isa/s390x/lower.isle line 1847. - let expr0_0 = C::zero_offset(ctx); - let expr1_0 = - constructor_lower_address(ctx, pattern5_2, pattern5_1, expr0_0)?; - let expr2_0 = constructor_loadrev32(ctx, &expr1_0)?; - let expr3_0 = constructor_output_reg(ctx, expr2_0)?; - return Some(expr3_0); - } - if let Some(()) = C::bigendian(ctx, pattern5_2) { - // Rule at src/isa/s390x/lower.isle line 1843. - let expr0_0 = C::zero_offset(ctx); - let expr1_0 = - constructor_lower_address(ctx, pattern5_2, pattern5_1, expr0_0)?; - let expr2_0 = constructor_load32(ctx, &expr1_0)?; - let expr3_0 = constructor_output_reg(ctx, expr2_0)?; - return Some(expr3_0); - } - } - } - &InstructionData::Load { - opcode: ref pattern5_0, - arg: pattern5_1, - flags: pattern5_2, - offset: pattern5_3, - } => { - if let &Opcode::Load = pattern5_0 { - if let Some(()) = C::littleendian(ctx, pattern5_2) { - // Rule at src/isa/s390x/lower.isle line 1203. - let expr0_0 = - constructor_lower_address(ctx, pattern5_2, pattern5_1, pattern5_3)?; - let expr1_0 = constructor_loadrev32(ctx, &expr0_0)?; - let expr2_0 = constructor_output_reg(ctx, expr1_0)?; - return Some(expr2_0); - } - if let Some(()) = C::bigendian(ctx, pattern5_2) { - // Rule at src/isa/s390x/lower.isle line 1199. - let expr0_0 = - constructor_lower_address(ctx, pattern5_2, pattern5_1, pattern5_3)?; - let expr1_0 = constructor_load32(ctx, &expr0_0)?; - let expr2_0 = constructor_output_reg(ctx, expr1_0)?; - return Some(expr2_0); - } - } - } - _ => {} - } - } - if pattern2_0 == I64 { - let pattern4_0 = C::inst_data(ctx, pattern0_0); - match &pattern4_0 { - &InstructionData::Binary { - opcode: ref pattern5_0, - args: ref pattern5_1, - } => { - match pattern5_0 { - &Opcode::Umulhi => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/s390x/lower.isle line 259. - let expr0_0 = C::put_in_reg(ctx, pattern7_0); - let expr1_0 = C::put_in_reg(ctx, pattern7_1); - let expr2_0 = constructor_umul_wide(ctx, expr0_0, expr1_0)?; - let expr3_0: Type = I64; - let expr4_0 = constructor_regpair_hi(ctx, &expr2_0)?; - let expr5_0 = constructor_copy_reg(ctx, expr3_0, expr4_0)?; - let expr6_0 = constructor_output_reg(ctx, expr5_0)?; - return Some(expr6_0); - } - &Opcode::Smulhi => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/s390x/lower.isle line 281. - let expr0_0 = C::put_in_reg(ctx, pattern7_0); - let expr1_0 = C::put_in_reg(ctx, pattern7_1); - let expr2_0 = constructor_smul_wide(ctx, expr0_0, expr1_0)?; - let expr3_0: Type = I64; - let expr4_0 = constructor_regpair_hi(ctx, &expr2_0)?; - let expr5_0 = constructor_copy_reg(ctx, expr3_0, expr4_0)?; - let expr6_0 = constructor_output_reg(ctx, expr5_0)?; - return Some(expr6_0); - } - _ => {} - } - } - &InstructionData::Unary { - opcode: ref pattern5_0, - arg: pattern5_1, - } => { - if let &Opcode::Bitcast = pattern5_0 { - let pattern7_0 = C::value_type(ctx, pattern5_1); - if pattern7_0 == F64 { - // Rule at src/isa/s390x/lower.isle line 1139. - let expr0_0 = C::put_in_reg(ctx, pattern5_1); - let expr1_0 = constructor_mov_from_fpr(ctx, expr0_0)?; - let expr2_0 = constructor_output_reg(ctx, expr1_0)?; - return Some(expr2_0); - } - } - } - &InstructionData::LoadNoOffset { - opcode: ref pattern5_0, - arg: pattern5_1, - flags: pattern5_2, - } => { - if let &Opcode::AtomicLoad = pattern5_0 { - if let Some(()) = C::littleendian(ctx, pattern5_2) { - // Rule at src/isa/s390x/lower.isle line 1855. - let expr0_0 = C::zero_offset(ctx); - let expr1_0 = - constructor_lower_address(ctx, pattern5_2, pattern5_1, expr0_0)?; - let expr2_0 = constructor_loadrev64(ctx, &expr1_0)?; - let expr3_0 = constructor_output_reg(ctx, expr2_0)?; - return Some(expr3_0); - } - if let Some(()) = C::bigendian(ctx, pattern5_2) { - // Rule at src/isa/s390x/lower.isle line 1851. - let expr0_0 = C::zero_offset(ctx); - let expr1_0 = - constructor_lower_address(ctx, pattern5_2, pattern5_1, expr0_0)?; - let expr2_0 = constructor_load64(ctx, &expr1_0)?; - let expr3_0 = constructor_output_reg(ctx, expr2_0)?; - return Some(expr3_0); - } - } - } - &InstructionData::Load { - opcode: ref pattern5_0, - arg: pattern5_1, - flags: pattern5_2, - offset: pattern5_3, - } => { - if let &Opcode::Load = pattern5_0 { - if let Some(()) = C::littleendian(ctx, pattern5_2) { - // Rule at src/isa/s390x/lower.isle line 1211. - let expr0_0 = - constructor_lower_address(ctx, pattern5_2, pattern5_1, pattern5_3)?; - let expr1_0 = constructor_loadrev64(ctx, &expr0_0)?; - let expr2_0 = constructor_output_reg(ctx, expr1_0)?; - return Some(expr2_0); - } - if let Some(()) = C::bigendian(ctx, pattern5_2) { - // Rule at src/isa/s390x/lower.isle line 1207. - let expr0_0 = - constructor_lower_address(ctx, pattern5_2, pattern5_1, pattern5_3)?; - let expr1_0 = constructor_load64(ctx, &expr0_0)?; - let expr2_0 = constructor_output_reg(ctx, expr1_0)?; - return Some(expr2_0); - } - } - } - _ => {} - } - } - if pattern2_0 == R64 { - let pattern4_0 = C::inst_data(ctx, pattern0_0); - if let &InstructionData::Load { - opcode: ref pattern5_0, - arg: pattern5_1, - flags: pattern5_2, - offset: pattern5_3, - } = &pattern4_0 - { - if let &Opcode::Load = pattern5_0 { - if let Some(()) = C::littleendian(ctx, pattern5_2) { - // Rule at src/isa/s390x/lower.isle line 1219. - let expr0_0 = - constructor_lower_address(ctx, pattern5_2, pattern5_1, pattern5_3)?; - let expr1_0 = constructor_loadrev64(ctx, &expr0_0)?; - let expr2_0 = constructor_output_reg(ctx, expr1_0)?; - return Some(expr2_0); - } - if let Some(()) = C::bigendian(ctx, pattern5_2) { - // Rule at src/isa/s390x/lower.isle line 1215. - let expr0_0 = - constructor_lower_address(ctx, pattern5_2, pattern5_1, pattern5_3)?; - let expr1_0 = constructor_load64(ctx, &expr0_0)?; - let expr2_0 = constructor_output_reg(ctx, expr1_0)?; - return Some(expr2_0); - } - } - } - } - if pattern2_0 == F32 { - let pattern4_0 = C::inst_data(ctx, pattern0_0); - match &pattern4_0 { - &InstructionData::Unary { - opcode: ref pattern5_0, - arg: pattern5_1, - } => { - if let &Opcode::Bitcast = pattern5_0 { - let pattern7_0 = C::value_type(ctx, pattern5_1); - if pattern7_0 == I32 { - // Rule at src/isa/s390x/lower.isle line 1144. - let expr0_0: Type = I64; - let expr1_0 = C::put_in_reg(ctx, pattern5_1); - let expr2_0: u8 = 32; - let expr3_0 = constructor_lshl_imm(ctx, expr0_0, expr1_0, expr2_0)?; - let expr4_0 = constructor_mov_to_fpr(ctx, expr3_0)?; - let expr5_0 = constructor_output_reg(ctx, expr4_0)?; - return Some(expr5_0); - } - } - } - &InstructionData::Load { - opcode: ref pattern5_0, - arg: pattern5_1, - flags: pattern5_2, - offset: pattern5_3, - } => { - if let &Opcode::Load = pattern5_0 { - if let Some(()) = C::bigendian(ctx, pattern5_2) { - // Rule at src/isa/s390x/lower.isle line 1223. - let expr0_0 = - constructor_lower_address(ctx, pattern5_2, pattern5_1, pattern5_3)?; - let expr1_0 = constructor_fpu_load32(ctx, &expr0_0)?; - let expr2_0 = constructor_output_reg(ctx, expr1_0)?; - return Some(expr2_0); - } - } - } - _ => {} - } - } - if pattern2_0 == F64 { - let pattern4_0 = C::inst_data(ctx, pattern0_0); - match &pattern4_0 { - &InstructionData::Unary { - opcode: ref pattern5_0, - arg: pattern5_1, - } => { - if let &Opcode::Bitcast = pattern5_0 { - let pattern7_0 = C::value_type(ctx, pattern5_1); - if pattern7_0 == I64 { - // Rule at src/isa/s390x/lower.isle line 1135. - let expr0_0 = C::put_in_reg(ctx, pattern5_1); - let expr1_0 = constructor_mov_to_fpr(ctx, expr0_0)?; - let expr2_0 = constructor_output_reg(ctx, expr1_0)?; - return Some(expr2_0); - } - } - } - &InstructionData::Load { - opcode: ref pattern5_0, - arg: pattern5_1, - flags: pattern5_2, - offset: pattern5_3, - } => { - if let &Opcode::Load = pattern5_0 { - if let Some(()) = C::bigendian(ctx, pattern5_2) { - // Rule at src/isa/s390x/lower.isle line 1238. - let expr0_0 = - constructor_lower_address(ctx, pattern5_2, pattern5_1, pattern5_3)?; - let expr1_0 = constructor_fpu_load64(ctx, &expr0_0)?; - let expr2_0 = constructor_output_reg(ctx, expr1_0)?; - return Some(expr2_0); - } - } - } - _ => {} - } - } - let pattern3_0 = C::inst_data(ctx, pattern0_0); - match &pattern3_0 { - &InstructionData::NullAry { - opcode: ref pattern4_0, - } => { - if let &Opcode::Null = pattern4_0 { - // Rule at src/isa/s390x/lower.isle line 41. - let expr0_0: u64 = 0; - let expr1_0 = constructor_imm(ctx, pattern2_0, expr0_0)?; - let expr2_0 = constructor_output_reg(ctx, expr1_0)?; - return Some(expr2_0); - } - } - &InstructionData::UnaryImm { - opcode: ref pattern4_0, - imm: pattern4_1, - } => { - if let &Opcode::Iconst = pattern4_0 { - let pattern6_0 = C::u64_from_imm64(ctx, pattern4_1); - // Rule at src/isa/s390x/lower.isle line 15. - let expr0_0 = constructor_imm(ctx, pattern2_0, pattern6_0)?; - let expr1_0 = constructor_output_reg(ctx, expr0_0)?; - return Some(expr1_0); - } - } - &InstructionData::StackLoad { - opcode: ref pattern4_0, - stack_slot: pattern4_1, - offset: pattern4_2, - } => { - if let &Opcode::StackAddr = pattern4_0 { - // Rule at src/isa/s390x/lower.isle line 1156. - let expr0_0 = - constructor_stack_addr_impl(ctx, pattern2_0, pattern4_1, pattern4_2)?; - let expr1_0 = constructor_output_reg(ctx, expr0_0)?; - return Some(expr1_0); - } - } - &InstructionData::UnaryBool { - opcode: ref pattern4_0, - imm: pattern4_1, - } => { - if let &Opcode::Bconst = pattern4_0 { - if pattern4_1 == true { - // Rule at src/isa/s390x/lower.isle line 23. - let expr0_0: u64 = 1; - let expr1_0 = constructor_imm(ctx, pattern2_0, expr0_0)?; - let expr2_0 = constructor_output_reg(ctx, expr1_0)?; - return Some(expr2_0); - } - if pattern4_1 == false { - // Rule at src/isa/s390x/lower.isle line 21. - let expr0_0: u64 = 0; - let expr1_0 = constructor_imm(ctx, pattern2_0, expr0_0)?; - let expr2_0 = constructor_output_reg(ctx, expr1_0)?; - return Some(expr2_0); - } - } - } - &InstructionData::Binary { - opcode: ref pattern4_0, - args: ref pattern4_1, - } => { - match pattern4_0 { - &Opcode::Fadd => { - let (pattern6_0, pattern6_1) = C::unpack_value_array_2(ctx, pattern4_1); - // Rule at src/isa/s390x/lower.isle line 924. - let expr0_0 = C::put_in_reg(ctx, pattern6_0); - let expr1_0 = C::put_in_reg(ctx, pattern6_1); - let expr2_0 = constructor_fadd_reg(ctx, pattern2_0, expr0_0, expr1_0)?; - let expr3_0 = constructor_output_reg(ctx, expr2_0)?; - return Some(expr3_0); - } - &Opcode::Fsub => { - let (pattern6_0, pattern6_1) = C::unpack_value_array_2(ctx, pattern4_1); - // Rule at src/isa/s390x/lower.isle line 931. - let expr0_0 = C::put_in_reg(ctx, pattern6_0); - let expr1_0 = C::put_in_reg(ctx, pattern6_1); - let expr2_0 = constructor_fsub_reg(ctx, pattern2_0, expr0_0, expr1_0)?; - let expr3_0 = constructor_output_reg(ctx, expr2_0)?; - return Some(expr3_0); - } - &Opcode::Fmul => { - let (pattern6_0, pattern6_1) = C::unpack_value_array_2(ctx, pattern4_1); - // Rule at src/isa/s390x/lower.isle line 938. - let expr0_0 = C::put_in_reg(ctx, pattern6_0); - let expr1_0 = C::put_in_reg(ctx, pattern6_1); - let expr2_0 = constructor_fmul_reg(ctx, pattern2_0, expr0_0, expr1_0)?; - let expr3_0 = constructor_output_reg(ctx, expr2_0)?; - return Some(expr3_0); - } - &Opcode::Fdiv => { - let (pattern6_0, pattern6_1) = C::unpack_value_array_2(ctx, pattern4_1); - // Rule at src/isa/s390x/lower.isle line 945. - let expr0_0 = C::put_in_reg(ctx, pattern6_0); - let expr1_0 = C::put_in_reg(ctx, pattern6_1); - let expr2_0 = constructor_fdiv_reg(ctx, pattern2_0, expr0_0, expr1_0)?; - let expr3_0 = constructor_output_reg(ctx, expr2_0)?; - return Some(expr3_0); - } - &Opcode::Fcopysign => { - let (pattern6_0, pattern6_1) = C::unpack_value_array_2(ctx, pattern4_1); - // Rule at src/isa/s390x/lower.isle line 966. - let expr0_0 = C::put_in_reg(ctx, pattern6_0); - let expr1_0 = C::put_in_reg(ctx, pattern6_1); - let expr2_0 = constructor_fpu_copysign(ctx, pattern2_0, expr0_0, expr1_0)?; - let expr3_0 = constructor_output_reg(ctx, expr2_0)?; - return Some(expr3_0); - } - &Opcode::Fmin => { - let (pattern6_0, pattern6_1) = C::unpack_value_array_2(ctx, pattern4_1); - // Rule at src/isa/s390x/lower.isle line 952. - let expr0_0 = C::put_in_reg(ctx, pattern6_0); - let expr1_0 = C::put_in_reg(ctx, pattern6_1); - let expr2_0 = constructor_fmin_reg(ctx, pattern2_0, expr0_0, expr1_0)?; - let expr3_0 = constructor_output_reg(ctx, expr2_0)?; - return Some(expr3_0); - } - &Opcode::Fmax => { - let (pattern6_0, pattern6_1) = C::unpack_value_array_2(ctx, pattern4_1); - // Rule at src/isa/s390x/lower.isle line 959. - let expr0_0 = C::put_in_reg(ctx, pattern6_0); - let expr1_0 = C::put_in_reg(ctx, pattern6_1); - let expr2_0 = constructor_fmax_reg(ctx, pattern2_0, expr0_0, expr1_0)?; - let expr3_0 = constructor_output_reg(ctx, expr2_0)?; - return Some(expr3_0); - } - _ => {} - } - } - &InstructionData::FloatCompare { - opcode: ref pattern4_0, - args: ref pattern4_1, - cond: ref pattern4_2, - } => { - if let &Opcode::Fcmp = pattern4_0 { - let (pattern6_0, pattern6_1) = C::unpack_value_array_2(ctx, pattern4_1); - // Rule at src/isa/s390x/lower.isle line 2011. - let expr0_0 = constructor_fcmp_val(ctx, pattern4_2, pattern6_0, pattern6_1)?; - let expr1_0 = constructor_lower_bool(ctx, pattern2_0, &expr0_0)?; - let expr2_0 = constructor_output_reg(ctx, expr1_0)?; - return Some(expr2_0); - } - } - &InstructionData::IntCompare { - opcode: ref pattern4_0, - args: ref pattern4_1, - cond: ref pattern4_2, - } => { - if let &Opcode::Icmp = pattern4_0 { - let (pattern6_0, pattern6_1) = C::unpack_value_array_2(ctx, pattern4_1); - // Rule at src/isa/s390x/lower.isle line 1920. - let expr0_0: bool = true; - let expr1_0 = - constructor_icmp_val(ctx, expr0_0, pattern4_2, pattern6_0, pattern6_1)?; - let expr2_0 = constructor_lower_bool(ctx, pattern2_0, &expr1_0)?; - let expr3_0 = constructor_output_reg(ctx, expr2_0)?; - return Some(expr3_0); - } - } - &InstructionData::Ternary { - opcode: ref pattern4_0, - args: ref pattern4_1, - } => { - match pattern4_0 { - &Opcode::Select => { - let (pattern6_0, pattern6_1, pattern6_2) = - C::unpack_value_array_3(ctx, pattern4_1); - // Rule at src/isa/s390x/lower.isle line 2053. - let expr0_0 = constructor_value_nonzero(ctx, pattern6_0)?; - let expr1_0 = C::put_in_reg(ctx, pattern6_1); - let expr2_0 = C::put_in_reg(ctx, pattern6_2); - let expr3_0 = constructor_select_bool_reg( - ctx, pattern2_0, &expr0_0, expr1_0, expr2_0, - )?; - let expr4_0 = constructor_output_reg(ctx, expr3_0)?; - return Some(expr4_0); - } - &Opcode::Fma => { - let (pattern6_0, pattern6_1, pattern6_2) = - C::unpack_value_array_3(ctx, pattern4_1); - // Rule at src/isa/s390x/lower.isle line 973. - let expr0_0 = C::put_in_reg(ctx, pattern6_0); - let expr1_0 = C::put_in_reg(ctx, pattern6_1); - let expr2_0 = C::put_in_reg(ctx, pattern6_2); - let expr3_0 = - constructor_fma_reg(ctx, pattern2_0, expr0_0, expr1_0, expr2_0)?; - let expr4_0 = constructor_output_reg(ctx, expr3_0)?; - return Some(expr4_0); - } - _ => {} - } - } - &InstructionData::IntSelect { - opcode: ref pattern4_0, - args: ref pattern4_1, - cond: ref pattern4_2, - } => { - if let &Opcode::SelectifSpectreGuard = pattern4_0 { - let (pattern6_0, pattern6_1, pattern6_2) = - C::unpack_value_array_3(ctx, pattern4_1); - if let Some(pattern7_0) = C::def_inst(ctx, pattern6_0) { - let pattern8_0 = C::inst_data(ctx, pattern7_0); - if let &InstructionData::Binary { - opcode: ref pattern9_0, - args: ref pattern9_1, - } = &pattern8_0 - { - if let &Opcode::Ifcmp = pattern9_0 { - let (pattern11_0, pattern11_1) = - C::unpack_value_array_2(ctx, pattern9_1); - // Rule at src/isa/s390x/lower.isle line 2065. - let expr0_0: bool = false; - let expr1_0 = constructor_icmp_val( - ctx, - expr0_0, - pattern4_2, - pattern11_0, - pattern11_1, - )?; - let expr2_0 = C::put_in_reg(ctx, pattern6_1); - let expr3_0 = C::put_in_reg(ctx, pattern6_2); - let expr4_0 = constructor_select_bool_reg( - ctx, pattern2_0, &expr1_0, expr2_0, expr3_0, - )?; - let expr5_0 = constructor_output_reg(ctx, expr4_0)?; - return Some(expr5_0); - } - } - } - } - } - &InstructionData::Unary { - opcode: ref pattern4_0, - arg: pattern4_1, - } => { - match pattern4_0 { - &Opcode::Sqrt => { - // Rule at src/isa/s390x/lower.isle line 980. - let expr0_0 = C::put_in_reg(ctx, pattern4_1); - let expr1_0 = constructor_sqrt_reg(ctx, pattern2_0, expr0_0)?; - let expr2_0 = constructor_output_reg(ctx, expr1_0)?; - return Some(expr2_0); - } - &Opcode::Fneg => { - // Rule at src/isa/s390x/lower.isle line 987. - let expr0_0 = C::put_in_reg(ctx, pattern4_1); - let expr1_0 = constructor_fneg_reg(ctx, pattern2_0, expr0_0)?; - let expr2_0 = constructor_output_reg(ctx, expr1_0)?; - return Some(expr2_0); - } - &Opcode::Fabs => { - // Rule at src/isa/s390x/lower.isle line 994. - let expr0_0 = C::put_in_reg(ctx, pattern4_1); - let expr1_0 = constructor_fabs_reg(ctx, pattern2_0, expr0_0)?; - let expr2_0 = constructor_output_reg(ctx, expr1_0)?; - return Some(expr2_0); - } - &Opcode::Ceil => { - // Rule at src/isa/s390x/lower.isle line 1001. - let expr0_0 = C::put_in_reg(ctx, pattern4_1); - let expr1_0 = constructor_ceil_reg(ctx, pattern2_0, expr0_0)?; - let expr2_0 = constructor_output_reg(ctx, expr1_0)?; - return Some(expr2_0); - } - &Opcode::Floor => { - // Rule at src/isa/s390x/lower.isle line 1008. - let expr0_0 = C::put_in_reg(ctx, pattern4_1); - let expr1_0 = constructor_floor_reg(ctx, pattern2_0, expr0_0)?; - let expr2_0 = constructor_output_reg(ctx, expr1_0)?; - return Some(expr2_0); - } - &Opcode::Trunc => { - // Rule at src/isa/s390x/lower.isle line 1015. - let expr0_0 = C::put_in_reg(ctx, pattern4_1); - let expr1_0 = constructor_trunc_reg(ctx, pattern2_0, expr0_0)?; - let expr2_0 = constructor_output_reg(ctx, expr1_0)?; - return Some(expr2_0); - } - &Opcode::Nearest => { - // Rule at src/isa/s390x/lower.isle line 1022. - let expr0_0 = C::put_in_reg(ctx, pattern4_1); - let expr1_0 = constructor_nearest_reg(ctx, pattern2_0, expr0_0)?; - let expr2_0 = constructor_output_reg(ctx, expr1_0)?; - return Some(expr2_0); - } - &Opcode::Bextend => { - // Rule at src/isa/s390x/lower.isle line 764. - let expr0_0 = constructor_cast_bool(ctx, pattern2_0, pattern4_1)?; - let expr1_0 = constructor_output_reg(ctx, expr0_0)?; - return Some(expr1_0); - } - &Opcode::Bmask => { - // Rule at src/isa/s390x/lower.isle line 766. - let expr0_0 = constructor_cast_bool(ctx, pattern2_0, pattern4_1)?; - let expr1_0 = constructor_output_reg(ctx, expr0_0)?; - return Some(expr1_0); - } - &Opcode::Fpromote => { - let pattern6_0 = C::value_type(ctx, pattern4_1); - // Rule at src/isa/s390x/lower.isle line 1029. - let expr0_0 = C::put_in_reg(ctx, pattern4_1); - let expr1_0 = - constructor_fpromote_reg(ctx, pattern2_0, pattern6_0, expr0_0)?; - let expr2_0 = constructor_output_reg(ctx, expr1_0)?; - return Some(expr2_0); - } - &Opcode::Fdemote => { - let pattern6_0 = C::value_type(ctx, pattern4_1); - // Rule at src/isa/s390x/lower.isle line 1036. - let expr0_0 = C::put_in_reg(ctx, pattern4_1); - let expr1_0 = - constructor_fdemote_reg(ctx, pattern2_0, pattern6_0, expr0_0)?; - let expr2_0 = constructor_output_reg(ctx, expr1_0)?; - return Some(expr2_0); - } - &Opcode::FcvtFromUint => { - let pattern6_0 = C::value_type(ctx, pattern4_1); - // Rule at src/isa/s390x/lower.isle line 1043. - let expr0_0 = constructor_ty_ext32(ctx, pattern6_0)?; - let expr1_0 = constructor_put_in_reg_zext32(ctx, pattern4_1)?; - let expr2_0 = - constructor_fcvt_from_uint_reg(ctx, pattern2_0, expr0_0, expr1_0)?; - let expr3_0 = constructor_output_reg(ctx, expr2_0)?; - return Some(expr3_0); - } - &Opcode::FcvtFromSint => { - let pattern6_0 = C::value_type(ctx, pattern4_1); - // Rule at src/isa/s390x/lower.isle line 1051. - let expr0_0 = constructor_ty_ext32(ctx, pattern6_0)?; - let expr1_0 = constructor_put_in_reg_sext32(ctx, pattern4_1)?; - let expr2_0 = - constructor_fcvt_from_sint_reg(ctx, pattern2_0, expr0_0, expr1_0)?; - let expr3_0 = constructor_output_reg(ctx, expr2_0)?; - return Some(expr3_0); - } - _ => {} - } - } - _ => {} - } - if let Some(()) = C::mie2_enabled(ctx, pattern2_0) { - if let Some(pattern4_0) = C::fits_in_64(ctx, pattern2_0) { - let pattern5_0 = C::inst_data(ctx, pattern0_0); - match &pattern5_0 { - &InstructionData::Binary { - opcode: ref pattern6_0, - args: ref pattern6_1, - } => { - match pattern6_0 { - &Opcode::BandNot => { - let (pattern8_0, pattern8_1) = - C::unpack_value_array_2(ctx, pattern6_1); - // Rule at src/isa/s390x/lower.isle line 706. - let expr0_0 = C::put_in_reg(ctx, pattern8_0); - let expr1_0 = C::put_in_reg(ctx, pattern8_1); - let expr2_0 = - constructor_and_not_reg(ctx, pattern4_0, expr0_0, expr1_0)?; - let expr3_0 = constructor_output_reg(ctx, expr2_0)?; - return Some(expr3_0); - } - &Opcode::BorNot => { - let (pattern8_0, pattern8_1) = - C::unpack_value_array_2(ctx, pattern6_1); - // Rule at src/isa/s390x/lower.isle line 717. - let expr0_0 = C::put_in_reg(ctx, pattern8_0); - let expr1_0 = C::put_in_reg(ctx, pattern8_1); - let expr2_0 = - constructor_or_not_reg(ctx, pattern4_0, expr0_0, expr1_0)?; - let expr3_0 = constructor_output_reg(ctx, expr2_0)?; - return Some(expr3_0); - } - &Opcode::BxorNot => { - let (pattern8_0, pattern8_1) = - C::unpack_value_array_2(ctx, pattern6_1); - // Rule at src/isa/s390x/lower.isle line 728. - let expr0_0 = C::put_in_reg(ctx, pattern8_0); - let expr1_0 = C::put_in_reg(ctx, pattern8_1); - let expr2_0 = - constructor_xor_not_reg(ctx, pattern4_0, expr0_0, expr1_0)?; - let expr3_0 = constructor_output_reg(ctx, expr2_0)?; - return Some(expr3_0); - } - _ => {} - } - } - &InstructionData::Ternary { - opcode: ref pattern6_0, - args: ref pattern6_1, - } => { - if let &Opcode::Bitselect = pattern6_0 { - let (pattern8_0, pattern8_1, pattern8_2) = - C::unpack_value_array_3(ctx, pattern6_1); - // Rule at src/isa/s390x/lower.isle line 739. - let expr0_0 = C::put_in_reg(ctx, pattern8_0); - let expr1_0 = C::put_in_reg(ctx, pattern8_1); - let expr2_0 = constructor_and_reg(ctx, pattern4_0, expr1_0, expr0_0)?; - let expr3_0 = C::put_in_reg(ctx, pattern8_2); - let expr4_0 = - constructor_and_not_reg(ctx, pattern4_0, expr3_0, expr0_0)?; - let expr5_0 = constructor_or_reg(ctx, pattern4_0, expr4_0, expr2_0)?; - let expr6_0 = constructor_output_reg(ctx, expr5_0)?; - return Some(expr6_0); - } - } - &InstructionData::Unary { - opcode: ref pattern6_0, - arg: pattern6_1, - } => { - match pattern6_0 { - &Opcode::Bnot => { - // Rule at src/isa/s390x/lower.isle line 629. - let expr0_0 = C::put_in_reg(ctx, pattern6_1); - let expr1_0 = - constructor_or_not_reg(ctx, pattern4_0, expr0_0, expr0_0)?; - let expr2_0 = constructor_output_reg(ctx, expr1_0)?; - return Some(expr2_0); - } - &Opcode::Popcnt => { - // Rule at src/isa/s390x/lower.isle line 893. - let expr0_0 = constructor_put_in_reg_zext64(ctx, pattern6_1)?; - let expr1_0 = constructor_popcnt_reg(ctx, expr0_0)?; - let expr2_0 = constructor_output_reg(ctx, expr1_0)?; - return Some(expr2_0); - } - _ => {} - } - } - _ => {} - } - } - } - if let Some(()) = C::mie2_disabled(ctx, pattern2_0) { - if pattern2_0 == I16 { - let pattern5_0 = C::inst_data(ctx, pattern0_0); - if let &InstructionData::Unary { - opcode: ref pattern6_0, - arg: pattern6_1, - } = &pattern5_0 - { - if let &Opcode::Popcnt = pattern6_0 { - // Rule at src/isa/s390x/lower.isle line 902. - let expr0_0 = C::put_in_reg(ctx, pattern6_1); - let expr1_0 = constructor_popcnt_byte(ctx, expr0_0)?; - let expr2_0: Type = I32; - let expr3_0: Type = I32; - let expr4_0: u8 = 8; - let expr5_0 = constructor_lshl_imm(ctx, expr3_0, expr1_0, expr4_0)?; - let expr6_0 = constructor_add_reg(ctx, expr2_0, expr1_0, expr5_0)?; - let expr7_0: Type = I32; - let expr8_0: u8 = 8; - let expr9_0 = constructor_lshr_imm(ctx, expr7_0, expr6_0, expr8_0)?; - let expr10_0 = constructor_output_reg(ctx, expr9_0)?; - return Some(expr10_0); - } - } - } - if pattern2_0 == I32 { - let pattern5_0 = C::inst_data(ctx, pattern0_0); - if let &InstructionData::Unary { - opcode: ref pattern6_0, - arg: pattern6_1, - } = &pattern5_0 - { - if let &Opcode::Popcnt = pattern6_0 { - // Rule at src/isa/s390x/lower.isle line 907. - let expr0_0 = C::put_in_reg(ctx, pattern6_1); - let expr1_0 = constructor_popcnt_byte(ctx, expr0_0)?; - let expr2_0: Type = I32; - let expr3_0: Type = I32; - let expr4_0: u8 = 16; - let expr5_0 = constructor_lshl_imm(ctx, expr3_0, expr1_0, expr4_0)?; - let expr6_0 = constructor_add_reg(ctx, expr2_0, expr1_0, expr5_0)?; - let expr7_0: Type = I32; - let expr8_0: Type = I32; - let expr9_0: u8 = 8; - let expr10_0 = constructor_lshl_imm(ctx, expr8_0, expr6_0, expr9_0)?; - let expr11_0 = constructor_add_reg(ctx, expr7_0, expr6_0, expr10_0)?; - let expr12_0: Type = I32; - let expr13_0: u8 = 24; - let expr14_0 = constructor_lshr_imm(ctx, expr12_0, expr11_0, expr13_0)?; - let expr15_0 = constructor_output_reg(ctx, expr14_0)?; - return Some(expr15_0); - } - } - } - if pattern2_0 == I64 { - let pattern5_0 = C::inst_data(ctx, pattern0_0); - if let &InstructionData::Unary { - opcode: ref pattern6_0, - arg: pattern6_1, - } = &pattern5_0 - { - if let &Opcode::Popcnt = pattern6_0 { - // Rule at src/isa/s390x/lower.isle line 913. - let expr0_0 = C::put_in_reg(ctx, pattern6_1); - let expr1_0 = constructor_popcnt_byte(ctx, expr0_0)?; - let expr2_0: Type = I64; - let expr3_0: Type = I64; - let expr4_0: u8 = 32; - let expr5_0 = constructor_lshl_imm(ctx, expr3_0, expr1_0, expr4_0)?; - let expr6_0 = constructor_add_reg(ctx, expr2_0, expr1_0, expr5_0)?; - let expr7_0: Type = I64; - let expr8_0: Type = I64; - let expr9_0: u8 = 16; - let expr10_0 = constructor_lshl_imm(ctx, expr8_0, expr6_0, expr9_0)?; - let expr11_0 = constructor_add_reg(ctx, expr7_0, expr6_0, expr10_0)?; - let expr12_0: Type = I64; - let expr13_0: Type = I64; - let expr14_0: u8 = 8; - let expr15_0 = constructor_lshl_imm(ctx, expr13_0, expr11_0, expr14_0)?; - let expr16_0 = constructor_add_reg(ctx, expr12_0, expr11_0, expr15_0)?; - let expr17_0: Type = I64; - let expr18_0: u8 = 56; - let expr19_0 = constructor_lshr_imm(ctx, expr17_0, expr16_0, expr18_0)?; - let expr20_0 = constructor_output_reg(ctx, expr19_0)?; - return Some(expr20_0); - } - } - } - if let Some(pattern4_0) = C::fits_in_64(ctx, pattern2_0) { - let pattern5_0 = C::inst_data(ctx, pattern0_0); - match &pattern5_0 { - &InstructionData::Binary { - opcode: ref pattern6_0, - args: ref pattern6_1, - } => { - match pattern6_0 { - &Opcode::BandNot => { - let (pattern8_0, pattern8_1) = - C::unpack_value_array_2(ctx, pattern6_1); - // Rule at src/isa/s390x/lower.isle line 710. - let expr0_0 = C::put_in_reg(ctx, pattern8_0); - let expr1_0 = C::put_in_reg(ctx, pattern8_1); - let expr2_0 = - constructor_and_reg(ctx, pattern4_0, expr0_0, expr1_0)?; - let expr3_0 = constructor_not_reg(ctx, pattern4_0, expr2_0)?; - let expr4_0 = constructor_output_reg(ctx, expr3_0)?; - return Some(expr4_0); - } - &Opcode::BorNot => { - let (pattern8_0, pattern8_1) = - C::unpack_value_array_2(ctx, pattern6_1); - // Rule at src/isa/s390x/lower.isle line 721. - let expr0_0 = C::put_in_reg(ctx, pattern8_0); - let expr1_0 = C::put_in_reg(ctx, pattern8_1); - let expr2_0 = - constructor_or_reg(ctx, pattern4_0, expr0_0, expr1_0)?; - let expr3_0 = constructor_not_reg(ctx, pattern4_0, expr2_0)?; - let expr4_0 = constructor_output_reg(ctx, expr3_0)?; - return Some(expr4_0); - } - &Opcode::BxorNot => { - let (pattern8_0, pattern8_1) = - C::unpack_value_array_2(ctx, pattern6_1); - // Rule at src/isa/s390x/lower.isle line 732. - let expr0_0 = C::put_in_reg(ctx, pattern8_0); - let expr1_0 = C::put_in_reg(ctx, pattern8_1); - let expr2_0 = - constructor_xor_reg(ctx, pattern4_0, expr0_0, expr1_0)?; - let expr3_0 = constructor_not_reg(ctx, pattern4_0, expr2_0)?; - let expr4_0 = constructor_output_reg(ctx, expr3_0)?; - return Some(expr4_0); - } - _ => {} - } - } - &InstructionData::Ternary { - opcode: ref pattern6_0, - args: ref pattern6_1, - } => { - if let &Opcode::Bitselect = pattern6_0 { - let (pattern8_0, pattern8_1, pattern8_2) = - C::unpack_value_array_3(ctx, pattern6_1); - // Rule at src/isa/s390x/lower.isle line 746. - let expr0_0 = C::put_in_reg(ctx, pattern8_0); - let expr1_0 = C::put_in_reg(ctx, pattern8_1); - let expr2_0 = constructor_and_reg(ctx, pattern4_0, expr1_0, expr0_0)?; - let expr3_0 = C::put_in_reg(ctx, pattern8_2); - let expr4_0 = constructor_and_reg(ctx, pattern4_0, expr3_0, expr0_0)?; - let expr5_0 = constructor_not_reg(ctx, pattern4_0, expr4_0)?; - let expr6_0 = constructor_or_reg(ctx, pattern4_0, expr5_0, expr2_0)?; - let expr7_0 = constructor_output_reg(ctx, expr6_0)?; - return Some(expr7_0); - } - } - &InstructionData::Unary { - opcode: ref pattern6_0, - arg: pattern6_1, - } => { - if let &Opcode::Bnot = pattern6_0 { - // Rule at src/isa/s390x/lower.isle line 634. - let expr0_0 = C::put_in_reg(ctx, pattern6_1); - let expr1_0 = constructor_not_reg(ctx, pattern4_0, expr0_0)?; - let expr2_0 = constructor_output_reg(ctx, expr1_0)?; - return Some(expr2_0); - } - } - _ => {} - } - } - } - if let Some(()) = C::vxrs_ext2_enabled(ctx, pattern2_0) { - if pattern2_0 == F32 { - let pattern5_0 = C::inst_data(ctx, pattern0_0); - if let &InstructionData::Load { - opcode: ref pattern6_0, - arg: pattern6_1, - flags: pattern6_2, - offset: pattern6_3, - } = &pattern5_0 - { - if let &Opcode::Load = pattern6_0 { - if let Some(()) = C::littleendian(ctx, pattern6_2) { - // Rule at src/isa/s390x/lower.isle line 1227. - let expr0_0 = - constructor_lower_address(ctx, pattern6_2, pattern6_1, pattern6_3)?; - let expr1_0 = constructor_fpu_loadrev32(ctx, &expr0_0)?; - let expr2_0 = constructor_output_reg(ctx, expr1_0)?; - return Some(expr2_0); - } - } - } - } - if pattern2_0 == F64 { - let pattern5_0 = C::inst_data(ctx, pattern0_0); - if let &InstructionData::Load { - opcode: ref pattern6_0, - arg: pattern6_1, - flags: pattern6_2, - offset: pattern6_3, - } = &pattern5_0 - { - if let &Opcode::Load = pattern6_0 { - if let Some(()) = C::littleendian(ctx, pattern6_2) { - // Rule at src/isa/s390x/lower.isle line 1242. - let expr0_0 = - constructor_lower_address(ctx, pattern6_2, pattern6_1, pattern6_3)?; - let expr1_0 = constructor_fpu_loadrev64(ctx, &expr0_0)?; - let expr2_0 = constructor_output_reg(ctx, expr1_0)?; - return Some(expr2_0); - } - } - } - } - } - if let Some(()) = C::vxrs_ext2_disabled(ctx, pattern2_0) { - if pattern2_0 == F32 { - let pattern5_0 = C::inst_data(ctx, pattern0_0); - if let &InstructionData::Load { - opcode: ref pattern6_0, - arg: pattern6_1, - flags: pattern6_2, - offset: pattern6_3, - } = &pattern5_0 - { - if let &Opcode::Load = pattern6_0 { - if let Some(()) = C::littleendian(ctx, pattern6_2) { - // Rule at src/isa/s390x/lower.isle line 1232. - let expr0_0 = - constructor_lower_address(ctx, pattern6_2, pattern6_1, pattern6_3)?; - let expr1_0 = constructor_loadrev32(ctx, &expr0_0)?; - let expr2_0: Type = I64; - let expr3_0: u8 = 32; - let expr4_0 = constructor_lshl_imm(ctx, expr2_0, expr1_0, expr3_0)?; - let expr5_0 = constructor_mov_to_fpr(ctx, expr4_0)?; - let expr6_0 = constructor_output_reg(ctx, expr5_0)?; - return Some(expr6_0); - } - } - } - } - if pattern2_0 == F64 { - let pattern5_0 = C::inst_data(ctx, pattern0_0); - if let &InstructionData::Load { - opcode: ref pattern6_0, - arg: pattern6_1, - flags: pattern6_2, - offset: pattern6_3, - } = &pattern5_0 - { - if let &Opcode::Load = pattern6_0 { - if let Some(()) = C::littleendian(ctx, pattern6_2) { - // Rule at src/isa/s390x/lower.isle line 1247. - let expr0_0 = - constructor_lower_address(ctx, pattern6_2, pattern6_1, pattern6_3)?; - let expr1_0 = constructor_loadrev64(ctx, &expr0_0)?; - let expr2_0 = constructor_mov_to_fpr(ctx, expr1_0)?; - let expr3_0 = constructor_output_reg(ctx, expr2_0)?; - return Some(expr3_0); - } - } - } - } - } - if let Some(pattern3_0) = C::fits_in_16(ctx, pattern2_0) { - let pattern4_0 = C::inst_data(ctx, pattern0_0); - if let &InstructionData::Unary { - opcode: ref pattern5_0, - arg: pattern5_1, - } = &pattern4_0 - { - if let &Opcode::Bint = pattern5_0 { - // Rule at src/isa/s390x/lower.isle line 800. - let expr0_0 = C::put_in_reg(ctx, pattern5_1); - let expr1_0: u16 = 1; - let expr2_0: u8 = 0; - let expr3_0 = C::uimm16shifted(ctx, expr1_0, expr2_0); - let expr4_0 = constructor_and_uimm16shifted(ctx, pattern3_0, expr0_0, expr3_0)?; - let expr5_0 = constructor_output_reg(ctx, expr4_0)?; - return Some(expr5_0); - } - } - } - if let Some(pattern3_0) = C::fits_in_32(ctx, pattern2_0) { - let pattern4_0 = C::inst_data(ctx, pattern0_0); - if let &InstructionData::Unary { - opcode: ref pattern5_0, - arg: pattern5_1, - } = &pattern4_0 - { - if let &Opcode::Bint = pattern5_0 { - // Rule at src/isa/s390x/lower.isle line 804. - let expr0_0 = C::put_in_reg(ctx, pattern5_1); - let expr1_0: u32 = 1; - let expr2_0: u8 = 0; - let expr3_0 = C::uimm32shifted(ctx, expr1_0, expr2_0); - let expr4_0 = constructor_and_uimm32shifted(ctx, pattern3_0, expr0_0, expr3_0)?; - let expr5_0 = constructor_output_reg(ctx, expr4_0)?; - return Some(expr5_0); - } - } - } - if let Some(pattern3_0) = C::fits_in_64(ctx, pattern2_0) { - let pattern4_0 = C::inst_data(ctx, pattern0_0); - match &pattern4_0 { - &InstructionData::Binary { - opcode: ref pattern5_0, - args: ref pattern5_1, - } => { - match pattern5_0 { - &Opcode::Iadd => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - if let Some(pattern8_0) = C::i16_from_value(ctx, pattern7_0) { - // Rule at src/isa/s390x/lower.isle line 72. - let expr0_0 = C::put_in_reg(ctx, pattern7_1); - let expr1_0 = - constructor_add_simm16(ctx, pattern3_0, expr0_0, pattern8_0)?; - let expr2_0 = constructor_output_reg(ctx, expr1_0)?; - return Some(expr2_0); - } - if let Some(pattern8_0) = C::i32_from_value(ctx, pattern7_0) { - // Rule at src/isa/s390x/lower.isle line 76. - let expr0_0 = C::put_in_reg(ctx, pattern7_1); - let expr1_0 = - constructor_add_simm32(ctx, pattern3_0, expr0_0, pattern8_0)?; - let expr2_0 = constructor_output_reg(ctx, expr1_0)?; - return Some(expr2_0); - } - if let Some(pattern8_0) = C::def_inst(ctx, pattern7_0) { - let pattern9_0 = C::inst_data(ctx, pattern8_0); - if let &InstructionData::Unary { - opcode: ref pattern10_0, - arg: pattern10_1, - } = &pattern9_0 - { - if let &Opcode::Sextend = pattern10_0 { - let pattern12_0 = C::value_type(ctx, pattern10_1); - if pattern12_0 == I32 { - // Rule at src/isa/s390x/lower.isle line 66. - let expr0_0 = C::put_in_reg(ctx, pattern7_1); - let expr1_0 = C::put_in_reg(ctx, pattern10_1); - let expr2_0 = constructor_add_reg_sext32( - ctx, pattern3_0, expr0_0, expr1_0, - )?; - let expr3_0 = constructor_output_reg(ctx, expr2_0)?; - return Some(expr3_0); - } - } - } - } - if let Some(pattern8_0) = C::sinkable_inst(ctx, pattern7_0) { - let pattern9_0 = C::inst_data(ctx, pattern8_0); - if let &InstructionData::Load { - opcode: ref pattern10_0, - arg: pattern10_1, - flags: pattern10_2, - offset: pattern10_3, - } = &pattern9_0 - { - match pattern10_0 { - &Opcode::Sload16 => { - if let Some(()) = C::bigendian(ctx, pattern10_2) { - // Rule at src/isa/s390x/lower.isle line 94. - let expr0_0 = C::put_in_reg(ctx, pattern7_1); - let expr1_0 = - constructor_sink_sload16(ctx, pattern8_0)?; - let expr2_0 = constructor_add_mem_sext16( - ctx, pattern3_0, expr0_0, &expr1_0, - )?; - let expr3_0 = constructor_output_reg(ctx, expr2_0)?; - return Some(expr3_0); - } - } - &Opcode::Sload32 => { - if let Some(()) = C::bigendian(ctx, pattern10_2) { - // Rule at src/isa/s390x/lower.isle line 98. - let expr0_0 = C::put_in_reg(ctx, pattern7_1); - let expr1_0 = - constructor_sink_sload32(ctx, pattern8_0)?; - let expr2_0 = constructor_add_mem_sext32( - ctx, pattern3_0, expr0_0, &expr1_0, - )?; - let expr3_0 = constructor_output_reg(ctx, expr2_0)?; - return Some(expr3_0); - } - } - _ => {} - } - } - } - let pattern8_0 = C::value_type(ctx, pattern7_0); - if pattern8_0 == I16 { - if let Some(pattern10_0) = C::sinkable_inst(ctx, pattern7_0) { - let pattern11_0 = C::inst_data(ctx, pattern10_0); - if let &InstructionData::Load { - opcode: ref pattern12_0, - arg: pattern12_1, - flags: pattern12_2, - offset: pattern12_3, - } = &pattern11_0 - { - if let &Opcode::Load = pattern12_0 { - if let Some(()) = C::bigendian(ctx, pattern12_2) { - // Rule at src/isa/s390x/lower.isle line 88. - let expr0_0 = C::put_in_reg(ctx, pattern7_1); - let expr1_0 = - constructor_sink_load(ctx, pattern10_0)?; - let expr2_0 = constructor_add_mem_sext16( - ctx, pattern3_0, expr0_0, &expr1_0, - )?; - let expr3_0 = constructor_output_reg(ctx, expr2_0)?; - return Some(expr3_0); - } - } - } - } - } - if let Some(pattern9_0) = C::ty_32_or_64(ctx, pattern8_0) { - if let Some(pattern10_0) = C::sinkable_inst(ctx, pattern7_0) { - let pattern11_0 = C::inst_data(ctx, pattern10_0); - if let &InstructionData::Load { - opcode: ref pattern12_0, - arg: pattern12_1, - flags: pattern12_2, - offset: pattern12_3, - } = &pattern11_0 - { - if let &Opcode::Load = pattern12_0 { - if let Some(()) = C::bigendian(ctx, pattern12_2) { - // Rule at src/isa/s390x/lower.isle line 82. - let expr0_0 = C::put_in_reg(ctx, pattern7_1); - let expr1_0 = - constructor_sink_load(ctx, pattern10_0)?; - let expr2_0 = constructor_add_mem( - ctx, pattern3_0, expr0_0, &expr1_0, - )?; - let expr3_0 = constructor_output_reg(ctx, expr2_0)?; - return Some(expr3_0); - } - } - } - } - } - if let Some(pattern8_0) = C::i16_from_value(ctx, pattern7_1) { - // Rule at src/isa/s390x/lower.isle line 70. - let expr0_0 = C::put_in_reg(ctx, pattern7_0); - let expr1_0 = - constructor_add_simm16(ctx, pattern3_0, expr0_0, pattern8_0)?; - let expr2_0 = constructor_output_reg(ctx, expr1_0)?; - return Some(expr2_0); - } - if let Some(pattern8_0) = C::i32_from_value(ctx, pattern7_1) { - // Rule at src/isa/s390x/lower.isle line 74. - let expr0_0 = C::put_in_reg(ctx, pattern7_0); - let expr1_0 = - constructor_add_simm32(ctx, pattern3_0, expr0_0, pattern8_0)?; - let expr2_0 = constructor_output_reg(ctx, expr1_0)?; - return Some(expr2_0); - } - if let Some(pattern8_0) = C::def_inst(ctx, pattern7_1) { - let pattern9_0 = C::inst_data(ctx, pattern8_0); - if let &InstructionData::Unary { - opcode: ref pattern10_0, - arg: pattern10_1, - } = &pattern9_0 - { - if let &Opcode::Sextend = pattern10_0 { - let pattern12_0 = C::value_type(ctx, pattern10_1); - if pattern12_0 == I32 { - // Rule at src/isa/s390x/lower.isle line 64. - let expr0_0 = C::put_in_reg(ctx, pattern7_0); - let expr1_0 = C::put_in_reg(ctx, pattern10_1); - let expr2_0 = constructor_add_reg_sext32( - ctx, pattern3_0, expr0_0, expr1_0, - )?; - let expr3_0 = constructor_output_reg(ctx, expr2_0)?; - return Some(expr3_0); - } - } - } - } - if let Some(pattern8_0) = C::sinkable_inst(ctx, pattern7_1) { - let pattern9_0 = C::inst_data(ctx, pattern8_0); - if let &InstructionData::Load { - opcode: ref pattern10_0, - arg: pattern10_1, - flags: pattern10_2, - offset: pattern10_3, - } = &pattern9_0 - { - match pattern10_0 { - &Opcode::Sload16 => { - if let Some(()) = C::bigendian(ctx, pattern10_2) { - // Rule at src/isa/s390x/lower.isle line 92. - let expr0_0 = C::put_in_reg(ctx, pattern7_0); - let expr1_0 = - constructor_sink_sload16(ctx, pattern8_0)?; - let expr2_0 = constructor_add_mem_sext16( - ctx, pattern3_0, expr0_0, &expr1_0, - )?; - let expr3_0 = constructor_output_reg(ctx, expr2_0)?; - return Some(expr3_0); - } - } - &Opcode::Sload32 => { - if let Some(()) = C::bigendian(ctx, pattern10_2) { - // Rule at src/isa/s390x/lower.isle line 96. - let expr0_0 = C::put_in_reg(ctx, pattern7_0); - let expr1_0 = - constructor_sink_sload32(ctx, pattern8_0)?; - let expr2_0 = constructor_add_mem_sext32( - ctx, pattern3_0, expr0_0, &expr1_0, - )?; - let expr3_0 = constructor_output_reg(ctx, expr2_0)?; - return Some(expr3_0); - } - } - _ => {} - } - } - } - let pattern8_0 = C::value_type(ctx, pattern7_1); - if pattern8_0 == I16 { - if let Some(pattern10_0) = C::sinkable_inst(ctx, pattern7_1) { - let pattern11_0 = C::inst_data(ctx, pattern10_0); - if let &InstructionData::Load { - opcode: ref pattern12_0, - arg: pattern12_1, - flags: pattern12_2, - offset: pattern12_3, - } = &pattern11_0 - { - if let &Opcode::Load = pattern12_0 { - if let Some(()) = C::bigendian(ctx, pattern12_2) { - // Rule at src/isa/s390x/lower.isle line 86. - let expr0_0 = C::put_in_reg(ctx, pattern7_0); - let expr1_0 = - constructor_sink_load(ctx, pattern10_0)?; - let expr2_0 = constructor_add_mem_sext16( - ctx, pattern3_0, expr0_0, &expr1_0, - )?; - let expr3_0 = constructor_output_reg(ctx, expr2_0)?; - return Some(expr3_0); - } - } - } - } - } - if let Some(pattern9_0) = C::ty_32_or_64(ctx, pattern8_0) { - if let Some(pattern10_0) = C::sinkable_inst(ctx, pattern7_1) { - let pattern11_0 = C::inst_data(ctx, pattern10_0); - if let &InstructionData::Load { - opcode: ref pattern12_0, - arg: pattern12_1, - flags: pattern12_2, - offset: pattern12_3, - } = &pattern11_0 - { - if let &Opcode::Load = pattern12_0 { - if let Some(()) = C::bigendian(ctx, pattern12_2) { - // Rule at src/isa/s390x/lower.isle line 80. - let expr0_0 = C::put_in_reg(ctx, pattern7_0); - let expr1_0 = - constructor_sink_load(ctx, pattern10_0)?; - let expr2_0 = constructor_add_mem( - ctx, pattern3_0, expr0_0, &expr1_0, - )?; - let expr3_0 = constructor_output_reg(ctx, expr2_0)?; - return Some(expr3_0); - } - } - } - } - } - // Rule at src/isa/s390x/lower.isle line 60. - let expr0_0 = C::put_in_reg(ctx, pattern7_0); - let expr1_0 = C::put_in_reg(ctx, pattern7_1); - let expr2_0 = constructor_add_reg(ctx, pattern3_0, expr0_0, expr1_0)?; - let expr3_0 = constructor_output_reg(ctx, expr2_0)?; - return Some(expr3_0); - } - &Opcode::Isub => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - if let Some(pattern8_0) = C::i16_from_negated_value(ctx, pattern7_1) { - // Rule at src/isa/s390x/lower.isle line 113. - let expr0_0 = C::put_in_reg(ctx, pattern7_0); - let expr1_0 = - constructor_add_simm16(ctx, pattern3_0, expr0_0, pattern8_0)?; - let expr2_0 = constructor_output_reg(ctx, expr1_0)?; - return Some(expr2_0); - } - if let Some(pattern8_0) = C::i32_from_negated_value(ctx, pattern7_1) { - // Rule at src/isa/s390x/lower.isle line 115. - let expr0_0 = C::put_in_reg(ctx, pattern7_0); - let expr1_0 = - constructor_add_simm32(ctx, pattern3_0, expr0_0, pattern8_0)?; - let expr2_0 = constructor_output_reg(ctx, expr1_0)?; - return Some(expr2_0); - } - if let Some(pattern8_0) = C::def_inst(ctx, pattern7_1) { - let pattern9_0 = C::inst_data(ctx, pattern8_0); - if let &InstructionData::Unary { - opcode: ref pattern10_0, - arg: pattern10_1, - } = &pattern9_0 - { - if let &Opcode::Sextend = pattern10_0 { - let pattern12_0 = C::value_type(ctx, pattern10_1); - if pattern12_0 == I32 { - // Rule at src/isa/s390x/lower.isle line 109. - let expr0_0 = C::put_in_reg(ctx, pattern7_0); - let expr1_0 = C::put_in_reg(ctx, pattern10_1); - let expr2_0 = constructor_sub_reg_sext32( - ctx, pattern3_0, expr0_0, expr1_0, - )?; - let expr3_0 = constructor_output_reg(ctx, expr2_0)?; - return Some(expr3_0); - } - } - } - } - if let Some(pattern8_0) = C::sinkable_inst(ctx, pattern7_1) { - let pattern9_0 = C::inst_data(ctx, pattern8_0); - if let &InstructionData::Load { - opcode: ref pattern10_0, - arg: pattern10_1, - flags: pattern10_2, - offset: pattern10_3, - } = &pattern9_0 - { - match pattern10_0 { - &Opcode::Sload16 => { - if let Some(()) = C::bigendian(ctx, pattern10_2) { - // Rule at src/isa/s390x/lower.isle line 127. - let expr0_0 = C::put_in_reg(ctx, pattern7_0); - let expr1_0 = - constructor_sink_sload16(ctx, pattern8_0)?; - let expr2_0 = constructor_sub_mem_sext16( - ctx, pattern3_0, expr0_0, &expr1_0, - )?; - let expr3_0 = constructor_output_reg(ctx, expr2_0)?; - return Some(expr3_0); - } - } - &Opcode::Sload32 => { - if let Some(()) = C::bigendian(ctx, pattern10_2) { - // Rule at src/isa/s390x/lower.isle line 129. - let expr0_0 = C::put_in_reg(ctx, pattern7_0); - let expr1_0 = - constructor_sink_sload32(ctx, pattern8_0)?; - let expr2_0 = constructor_sub_mem_sext32( - ctx, pattern3_0, expr0_0, &expr1_0, - )?; - let expr3_0 = constructor_output_reg(ctx, expr2_0)?; - return Some(expr3_0); - } - } - _ => {} - } - } - } - let pattern8_0 = C::value_type(ctx, pattern7_1); - if pattern8_0 == I16 { - if let Some(pattern10_0) = C::sinkable_inst(ctx, pattern7_1) { - let pattern11_0 = C::inst_data(ctx, pattern10_0); - if let &InstructionData::Load { - opcode: ref pattern12_0, - arg: pattern12_1, - flags: pattern12_2, - offset: pattern12_3, - } = &pattern11_0 - { - if let &Opcode::Load = pattern12_0 { - if let Some(()) = C::bigendian(ctx, pattern12_2) { - // Rule at src/isa/s390x/lower.isle line 123. - let expr0_0 = C::put_in_reg(ctx, pattern7_0); - let expr1_0 = - constructor_sink_load(ctx, pattern10_0)?; - let expr2_0 = constructor_sub_mem_sext16( - ctx, pattern3_0, expr0_0, &expr1_0, - )?; - let expr3_0 = constructor_output_reg(ctx, expr2_0)?; - return Some(expr3_0); - } - } - } - } - } - if let Some(pattern9_0) = C::ty_32_or_64(ctx, pattern8_0) { - if let Some(pattern10_0) = C::sinkable_inst(ctx, pattern7_1) { - let pattern11_0 = C::inst_data(ctx, pattern10_0); - if let &InstructionData::Load { - opcode: ref pattern12_0, - arg: pattern12_1, - flags: pattern12_2, - offset: pattern12_3, - } = &pattern11_0 - { - if let &Opcode::Load = pattern12_0 { - if let Some(()) = C::bigendian(ctx, pattern12_2) { - // Rule at src/isa/s390x/lower.isle line 119. - let expr0_0 = C::put_in_reg(ctx, pattern7_0); - let expr1_0 = - constructor_sink_load(ctx, pattern10_0)?; - let expr2_0 = constructor_sub_mem( - ctx, pattern3_0, expr0_0, &expr1_0, - )?; - let expr3_0 = constructor_output_reg(ctx, expr2_0)?; - return Some(expr3_0); - } - } - } - } - } - // Rule at src/isa/s390x/lower.isle line 105. - let expr0_0 = C::put_in_reg(ctx, pattern7_0); - let expr1_0 = C::put_in_reg(ctx, pattern7_1); - let expr2_0 = constructor_sub_reg(ctx, pattern3_0, expr0_0, expr1_0)?; - let expr3_0 = constructor_output_reg(ctx, expr2_0)?; - return Some(expr3_0); - } - &Opcode::Imul => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - if let Some(pattern8_0) = C::i16_from_value(ctx, pattern7_0) { - // Rule at src/isa/s390x/lower.isle line 212. - let expr0_0 = C::put_in_reg(ctx, pattern7_1); - let expr1_0 = - constructor_mul_simm16(ctx, pattern3_0, expr0_0, pattern8_0)?; - let expr2_0 = constructor_output_reg(ctx, expr1_0)?; - return Some(expr2_0); - } - if let Some(pattern8_0) = C::i32_from_value(ctx, pattern7_0) { - // Rule at src/isa/s390x/lower.isle line 216. - let expr0_0 = C::put_in_reg(ctx, pattern7_1); - let expr1_0 = - constructor_mul_simm32(ctx, pattern3_0, expr0_0, pattern8_0)?; - let expr2_0 = constructor_output_reg(ctx, expr1_0)?; - return Some(expr2_0); - } - if let Some(pattern8_0) = C::def_inst(ctx, pattern7_0) { - let pattern9_0 = C::inst_data(ctx, pattern8_0); - if let &InstructionData::Unary { - opcode: ref pattern10_0, - arg: pattern10_1, - } = &pattern9_0 - { - if let &Opcode::Sextend = pattern10_0 { - let pattern12_0 = C::value_type(ctx, pattern10_1); - if pattern12_0 == I32 { - // Rule at src/isa/s390x/lower.isle line 206. - let expr0_0 = C::put_in_reg(ctx, pattern7_1); - let expr1_0 = C::put_in_reg(ctx, pattern10_1); - let expr2_0 = constructor_mul_reg_sext32( - ctx, pattern3_0, expr0_0, expr1_0, - )?; - let expr3_0 = constructor_output_reg(ctx, expr2_0)?; - return Some(expr3_0); - } - } - } - } - if let Some(pattern8_0) = C::sinkable_inst(ctx, pattern7_0) { - let pattern9_0 = C::inst_data(ctx, pattern8_0); - if let &InstructionData::Load { - opcode: ref pattern10_0, - arg: pattern10_1, - flags: pattern10_2, - offset: pattern10_3, - } = &pattern9_0 - { - match pattern10_0 { - &Opcode::Sload16 => { - if let Some(()) = C::bigendian(ctx, pattern10_2) { - // Rule at src/isa/s390x/lower.isle line 234. - let expr0_0 = C::put_in_reg(ctx, pattern7_1); - let expr1_0 = - constructor_sink_sload16(ctx, pattern8_0)?; - let expr2_0 = constructor_mul_mem_sext16( - ctx, pattern3_0, expr0_0, &expr1_0, - )?; - let expr3_0 = constructor_output_reg(ctx, expr2_0)?; - return Some(expr3_0); - } - } - &Opcode::Sload32 => { - if let Some(()) = C::bigendian(ctx, pattern10_2) { - // Rule at src/isa/s390x/lower.isle line 238. - let expr0_0 = C::put_in_reg(ctx, pattern7_1); - let expr1_0 = - constructor_sink_sload32(ctx, pattern8_0)?; - let expr2_0 = constructor_mul_mem_sext32( - ctx, pattern3_0, expr0_0, &expr1_0, - )?; - let expr3_0 = constructor_output_reg(ctx, expr2_0)?; - return Some(expr3_0); - } - } - _ => {} - } - } - } - let pattern8_0 = C::value_type(ctx, pattern7_0); - if pattern8_0 == I16 { - if let Some(pattern10_0) = C::sinkable_inst(ctx, pattern7_0) { - let pattern11_0 = C::inst_data(ctx, pattern10_0); - if let &InstructionData::Load { - opcode: ref pattern12_0, - arg: pattern12_1, - flags: pattern12_2, - offset: pattern12_3, - } = &pattern11_0 - { - if let &Opcode::Load = pattern12_0 { - if let Some(()) = C::bigendian(ctx, pattern12_2) { - // Rule at src/isa/s390x/lower.isle line 228. - let expr0_0 = C::put_in_reg(ctx, pattern7_1); - let expr1_0 = - constructor_sink_load(ctx, pattern10_0)?; - let expr2_0 = constructor_mul_mem_sext16( - ctx, pattern3_0, expr0_0, &expr1_0, - )?; - let expr3_0 = constructor_output_reg(ctx, expr2_0)?; - return Some(expr3_0); - } - } - } - } - } - if let Some(pattern9_0) = C::ty_32_or_64(ctx, pattern8_0) { - if let Some(pattern10_0) = C::sinkable_inst(ctx, pattern7_0) { - let pattern11_0 = C::inst_data(ctx, pattern10_0); - if let &InstructionData::Load { - opcode: ref pattern12_0, - arg: pattern12_1, - flags: pattern12_2, - offset: pattern12_3, - } = &pattern11_0 - { - if let &Opcode::Load = pattern12_0 { - if let Some(()) = C::bigendian(ctx, pattern12_2) { - // Rule at src/isa/s390x/lower.isle line 222. - let expr0_0 = C::put_in_reg(ctx, pattern7_1); - let expr1_0 = - constructor_sink_load(ctx, pattern10_0)?; - let expr2_0 = constructor_mul_mem( - ctx, pattern3_0, expr0_0, &expr1_0, - )?; - let expr3_0 = constructor_output_reg(ctx, expr2_0)?; - return Some(expr3_0); - } - } - } - } - } - if let Some(pattern8_0) = C::i16_from_value(ctx, pattern7_1) { - // Rule at src/isa/s390x/lower.isle line 210. - let expr0_0 = C::put_in_reg(ctx, pattern7_0); - let expr1_0 = - constructor_mul_simm16(ctx, pattern3_0, expr0_0, pattern8_0)?; - let expr2_0 = constructor_output_reg(ctx, expr1_0)?; - return Some(expr2_0); - } - if let Some(pattern8_0) = C::i32_from_value(ctx, pattern7_1) { - // Rule at src/isa/s390x/lower.isle line 214. - let expr0_0 = C::put_in_reg(ctx, pattern7_0); - let expr1_0 = - constructor_mul_simm32(ctx, pattern3_0, expr0_0, pattern8_0)?; - let expr2_0 = constructor_output_reg(ctx, expr1_0)?; - return Some(expr2_0); - } - if let Some(pattern8_0) = C::def_inst(ctx, pattern7_1) { - let pattern9_0 = C::inst_data(ctx, pattern8_0); - if let &InstructionData::Unary { - opcode: ref pattern10_0, - arg: pattern10_1, - } = &pattern9_0 - { - if let &Opcode::Sextend = pattern10_0 { - let pattern12_0 = C::value_type(ctx, pattern10_1); - if pattern12_0 == I32 { - // Rule at src/isa/s390x/lower.isle line 204. - let expr0_0 = C::put_in_reg(ctx, pattern7_0); - let expr1_0 = C::put_in_reg(ctx, pattern10_1); - let expr2_0 = constructor_mul_reg_sext32( - ctx, pattern3_0, expr0_0, expr1_0, - )?; - let expr3_0 = constructor_output_reg(ctx, expr2_0)?; - return Some(expr3_0); - } - } - } - } - if let Some(pattern8_0) = C::sinkable_inst(ctx, pattern7_1) { - let pattern9_0 = C::inst_data(ctx, pattern8_0); - if let &InstructionData::Load { - opcode: ref pattern10_0, - arg: pattern10_1, - flags: pattern10_2, - offset: pattern10_3, - } = &pattern9_0 - { - match pattern10_0 { - &Opcode::Sload16 => { - if let Some(()) = C::bigendian(ctx, pattern10_2) { - // Rule at src/isa/s390x/lower.isle line 232. - let expr0_0 = C::put_in_reg(ctx, pattern7_0); - let expr1_0 = - constructor_sink_sload16(ctx, pattern8_0)?; - let expr2_0 = constructor_mul_mem_sext16( - ctx, pattern3_0, expr0_0, &expr1_0, - )?; - let expr3_0 = constructor_output_reg(ctx, expr2_0)?; - return Some(expr3_0); - } - } - &Opcode::Sload32 => { - if let Some(()) = C::bigendian(ctx, pattern10_2) { - // Rule at src/isa/s390x/lower.isle line 236. - let expr0_0 = C::put_in_reg(ctx, pattern7_0); - let expr1_0 = - constructor_sink_sload32(ctx, pattern8_0)?; - let expr2_0 = constructor_mul_mem_sext32( - ctx, pattern3_0, expr0_0, &expr1_0, - )?; - let expr3_0 = constructor_output_reg(ctx, expr2_0)?; - return Some(expr3_0); - } - } - _ => {} - } - } - } - let pattern8_0 = C::value_type(ctx, pattern7_1); - if pattern8_0 == I16 { - if let Some(pattern10_0) = C::sinkable_inst(ctx, pattern7_1) { - let pattern11_0 = C::inst_data(ctx, pattern10_0); - if let &InstructionData::Load { - opcode: ref pattern12_0, - arg: pattern12_1, - flags: pattern12_2, - offset: pattern12_3, - } = &pattern11_0 - { - if let &Opcode::Load = pattern12_0 { - if let Some(()) = C::bigendian(ctx, pattern12_2) { - // Rule at src/isa/s390x/lower.isle line 226. - let expr0_0 = C::put_in_reg(ctx, pattern7_0); - let expr1_0 = - constructor_sink_load(ctx, pattern10_0)?; - let expr2_0 = constructor_mul_mem_sext16( - ctx, pattern3_0, expr0_0, &expr1_0, - )?; - let expr3_0 = constructor_output_reg(ctx, expr2_0)?; - return Some(expr3_0); - } - } - } - } - } - if let Some(pattern9_0) = C::ty_32_or_64(ctx, pattern8_0) { - if let Some(pattern10_0) = C::sinkable_inst(ctx, pattern7_1) { - let pattern11_0 = C::inst_data(ctx, pattern10_0); - if let &InstructionData::Load { - opcode: ref pattern12_0, - arg: pattern12_1, - flags: pattern12_2, - offset: pattern12_3, - } = &pattern11_0 - { - if let &Opcode::Load = pattern12_0 { - if let Some(()) = C::bigendian(ctx, pattern12_2) { - // Rule at src/isa/s390x/lower.isle line 220. - let expr0_0 = C::put_in_reg(ctx, pattern7_0); - let expr1_0 = - constructor_sink_load(ctx, pattern10_0)?; - let expr2_0 = constructor_mul_mem( - ctx, pattern3_0, expr0_0, &expr1_0, - )?; - let expr3_0 = constructor_output_reg(ctx, expr2_0)?; - return Some(expr3_0); - } - } - } - } - } - // Rule at src/isa/s390x/lower.isle line 200. - let expr0_0 = C::put_in_reg(ctx, pattern7_0); - let expr1_0 = C::put_in_reg(ctx, pattern7_1); - let expr2_0 = constructor_mul_reg(ctx, pattern3_0, expr0_0, expr1_0)?; - let expr3_0 = constructor_output_reg(ctx, expr2_0)?; - return Some(expr3_0); - } - &Opcode::Udiv => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/s390x/lower.isle line 303. - let expr0_0 = constructor_zero_divisor_check_needed(ctx, pattern7_1)?; - let expr1_0 = constructor_ty_ext32(ctx, pattern3_0)?; - let expr2_0: u64 = 0; - let expr3_0 = constructor_uninitialized_regpair(ctx)?; - let expr4_0 = - constructor_imm_regpair_hi(ctx, expr1_0, expr2_0, &expr3_0)?; - let expr5_0 = - constructor_put_in_regpair_lo_zext32(ctx, pattern7_0, &expr4_0)?; - let expr6_0 = constructor_put_in_reg_zext32(ctx, pattern7_1)?; - let expr7_0 = constructor_ty_ext32(ctx, pattern3_0)?; - let expr8_0 = constructor_maybe_trap_if_zero_divisor( - ctx, expr0_0, expr7_0, expr6_0, - )?; - let expr9_0 = constructor_udivmod(ctx, expr7_0, &expr5_0, expr6_0)?; - let expr10_0 = constructor_regpair_lo(ctx, &expr9_0)?; - let expr11_0 = constructor_copy_reg(ctx, pattern3_0, expr10_0)?; - let expr12_0 = constructor_output_reg(ctx, expr11_0)?; - return Some(expr12_0); - } - &Opcode::Sdiv => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/s390x/lower.isle line 377. - let expr0_0 = constructor_zero_divisor_check_needed(ctx, pattern7_1)?; - let expr1_0 = constructor_div_overflow_check_needed(ctx, pattern7_1)?; - let expr2_0 = constructor_uninitialized_regpair(ctx)?; - let expr3_0 = - constructor_put_in_regpair_lo_sext64(ctx, pattern7_0, &expr2_0)?; - let expr4_0 = constructor_put_in_reg_sext32(ctx, pattern7_1)?; - let expr5_0 = constructor_ty_ext32(ctx, pattern3_0)?; - let expr6_0 = constructor_maybe_trap_if_zero_divisor( - ctx, expr0_0, expr5_0, expr4_0, - )?; - let expr7_0 = constructor_maybe_trap_if_sdiv_overflow( - ctx, expr1_0, expr5_0, pattern3_0, &expr3_0, expr4_0, - )?; - let expr8_0 = constructor_sdivmod(ctx, expr5_0, &expr3_0, expr4_0)?; - let expr9_0 = constructor_regpair_lo(ctx, &expr8_0)?; - let expr10_0 = constructor_copy_reg(ctx, pattern3_0, expr9_0)?; - let expr11_0 = constructor_output_reg(ctx, expr10_0)?; - return Some(expr11_0); - } - &Opcode::Urem => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/s390x/lower.isle line 326. - let expr0_0 = constructor_zero_divisor_check_needed(ctx, pattern7_1)?; - let expr1_0: u64 = 0; - let expr2_0 = constructor_uninitialized_regpair(ctx)?; - let expr3_0 = - constructor_imm_regpair_hi(ctx, pattern3_0, expr1_0, &expr2_0)?; - let expr4_0 = - constructor_put_in_regpair_lo_zext32(ctx, pattern7_0, &expr3_0)?; - let expr5_0 = constructor_put_in_reg_zext32(ctx, pattern7_1)?; - let expr6_0 = constructor_ty_ext32(ctx, pattern3_0)?; - let expr7_0 = constructor_maybe_trap_if_zero_divisor( - ctx, expr0_0, expr6_0, expr5_0, - )?; - let expr8_0 = constructor_udivmod(ctx, expr6_0, &expr4_0, expr5_0)?; - let expr9_0 = constructor_regpair_hi(ctx, &expr8_0)?; - let expr10_0 = constructor_copy_reg(ctx, pattern3_0, expr9_0)?; - let expr11_0 = constructor_output_reg(ctx, expr10_0)?; - return Some(expr11_0); - } - &Opcode::Srem => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/s390x/lower.isle line 400. - let expr0_0 = constructor_zero_divisor_check_needed(ctx, pattern7_1)?; - let expr1_0 = constructor_div_overflow_check_needed(ctx, pattern7_1)?; - let expr2_0 = constructor_uninitialized_regpair(ctx)?; - let expr3_0 = - constructor_put_in_regpair_lo_sext64(ctx, pattern7_0, &expr2_0)?; - let expr4_0 = constructor_put_in_reg_sext32(ctx, pattern7_1)?; - let expr5_0 = constructor_ty_ext32(ctx, pattern3_0)?; - let expr6_0 = constructor_maybe_trap_if_zero_divisor( - ctx, expr0_0, expr5_0, expr4_0, - )?; - let expr7_0 = constructor_maybe_avoid_srem_overflow( - ctx, expr1_0, expr5_0, &expr3_0, expr4_0, - )?; - let expr8_0 = constructor_sdivmod(ctx, expr5_0, &expr7_0, expr4_0)?; - let expr9_0 = constructor_regpair_hi(ctx, &expr8_0)?; - let expr10_0 = constructor_copy_reg(ctx, pattern3_0, expr9_0)?; - let expr11_0 = constructor_output_reg(ctx, expr10_0)?; - return Some(expr11_0); - } - &Opcode::IaddIfcout => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - if let Some(pattern8_0) = C::u32_from_value(ctx, pattern7_0) { - // Rule at src/isa/s390x/lower.isle line 170. - let expr0_0 = C::put_in_reg(ctx, pattern7_1); - let expr1_0 = constructor_add_logical_zimm32( - ctx, pattern3_0, expr0_0, pattern8_0, - )?; - let expr2_0 = constructor_output_ifcout(ctx, expr1_0)?; - return Some(expr2_0); - } - if let Some(pattern8_0) = C::def_inst(ctx, pattern7_0) { - let pattern9_0 = C::inst_data(ctx, pattern8_0); - if let &InstructionData::Unary { - opcode: ref pattern10_0, - arg: pattern10_1, - } = &pattern9_0 - { - if let &Opcode::Uextend = pattern10_0 { - let pattern12_0 = C::value_type(ctx, pattern10_1); - if pattern12_0 == I32 { - // Rule at src/isa/s390x/lower.isle line 164. - let expr0_0 = C::put_in_reg(ctx, pattern7_1); - let expr1_0 = C::put_in_reg(ctx, pattern10_1); - let expr2_0 = constructor_add_logical_reg_zext32( - ctx, pattern3_0, expr0_0, expr1_0, - )?; - let expr3_0 = constructor_output_ifcout(ctx, expr2_0)?; - return Some(expr3_0); - } - } - } - } - if let Some(pattern8_0) = C::sinkable_inst(ctx, pattern7_0) { - let pattern9_0 = C::inst_data(ctx, pattern8_0); - if let &InstructionData::Load { - opcode: ref pattern10_0, - arg: pattern10_1, - flags: pattern10_2, - offset: pattern10_3, - } = &pattern9_0 - { - if let &Opcode::Uload32 = pattern10_0 { - if let Some(()) = C::bigendian(ctx, pattern10_2) { - // Rule at src/isa/s390x/lower.isle line 182. - let expr0_0 = C::put_in_reg(ctx, pattern7_1); - let expr1_0 = - constructor_sink_uload32(ctx, pattern8_0)?; - let expr2_0 = constructor_add_logical_mem_zext32( - ctx, pattern3_0, expr0_0, &expr1_0, - )?; - let expr3_0 = constructor_output_ifcout(ctx, expr2_0)?; - return Some(expr3_0); - } - } - } - } - let pattern8_0 = C::value_type(ctx, pattern7_0); - if let Some(pattern9_0) = C::ty_32_or_64(ctx, pattern8_0) { - if let Some(pattern10_0) = C::sinkable_inst(ctx, pattern7_0) { - let pattern11_0 = C::inst_data(ctx, pattern10_0); - if let &InstructionData::Load { - opcode: ref pattern12_0, - arg: pattern12_1, - flags: pattern12_2, - offset: pattern12_3, - } = &pattern11_0 - { - if let &Opcode::Load = pattern12_0 { - if let Some(()) = C::bigendian(ctx, pattern12_2) { - // Rule at src/isa/s390x/lower.isle line 176. - let expr0_0 = C::put_in_reg(ctx, pattern7_1); - let expr1_0 = - constructor_sink_load(ctx, pattern10_0)?; - let expr2_0 = constructor_add_logical_mem( - ctx, pattern3_0, expr0_0, &expr1_0, - )?; - let expr3_0 = - constructor_output_ifcout(ctx, expr2_0)?; - return Some(expr3_0); - } - } - } - } - } - if let Some(pattern8_0) = C::u32_from_value(ctx, pattern7_1) { - // Rule at src/isa/s390x/lower.isle line 168. - let expr0_0 = C::put_in_reg(ctx, pattern7_0); - let expr1_0 = constructor_add_logical_zimm32( - ctx, pattern3_0, expr0_0, pattern8_0, - )?; - let expr2_0 = constructor_output_ifcout(ctx, expr1_0)?; - return Some(expr2_0); - } - if let Some(pattern8_0) = C::def_inst(ctx, pattern7_1) { - let pattern9_0 = C::inst_data(ctx, pattern8_0); - if let &InstructionData::Unary { - opcode: ref pattern10_0, - arg: pattern10_1, - } = &pattern9_0 - { - if let &Opcode::Uextend = pattern10_0 { - let pattern12_0 = C::value_type(ctx, pattern10_1); - if pattern12_0 == I32 { - // Rule at src/isa/s390x/lower.isle line 162. - let expr0_0 = C::put_in_reg(ctx, pattern7_0); - let expr1_0 = C::put_in_reg(ctx, pattern10_1); - let expr2_0 = constructor_add_logical_reg_zext32( - ctx, pattern3_0, expr0_0, expr1_0, - )?; - let expr3_0 = constructor_output_ifcout(ctx, expr2_0)?; - return Some(expr3_0); - } - } - } - } - if let Some(pattern8_0) = C::sinkable_inst(ctx, pattern7_1) { - let pattern9_0 = C::inst_data(ctx, pattern8_0); - if let &InstructionData::Load { - opcode: ref pattern10_0, - arg: pattern10_1, - flags: pattern10_2, - offset: pattern10_3, - } = &pattern9_0 - { - if let &Opcode::Uload32 = pattern10_0 { - if let Some(()) = C::bigendian(ctx, pattern10_2) { - // Rule at src/isa/s390x/lower.isle line 180. - let expr0_0 = C::put_in_reg(ctx, pattern7_0); - let expr1_0 = - constructor_sink_uload32(ctx, pattern8_0)?; - let expr2_0 = constructor_add_logical_mem_zext32( - ctx, pattern3_0, expr0_0, &expr1_0, - )?; - let expr3_0 = constructor_output_ifcout(ctx, expr2_0)?; - return Some(expr3_0); - } - } - } - } - let pattern8_0 = C::value_type(ctx, pattern7_1); - if let Some(pattern9_0) = C::ty_32_or_64(ctx, pattern8_0) { - if let Some(pattern10_0) = C::sinkable_inst(ctx, pattern7_1) { - let pattern11_0 = C::inst_data(ctx, pattern10_0); - if let &InstructionData::Load { - opcode: ref pattern12_0, - arg: pattern12_1, - flags: pattern12_2, - offset: pattern12_3, - } = &pattern11_0 - { - if let &Opcode::Load = pattern12_0 { - if let Some(()) = C::bigendian(ctx, pattern12_2) { - // Rule at src/isa/s390x/lower.isle line 174. - let expr0_0 = C::put_in_reg(ctx, pattern7_0); - let expr1_0 = - constructor_sink_load(ctx, pattern10_0)?; - let expr2_0 = constructor_add_logical_mem( - ctx, pattern3_0, expr0_0, &expr1_0, - )?; - let expr3_0 = - constructor_output_ifcout(ctx, expr2_0)?; - return Some(expr3_0); - } - } - } - } - } - // Rule at src/isa/s390x/lower.isle line 158. - let expr0_0 = C::put_in_reg(ctx, pattern7_0); - let expr1_0 = C::put_in_reg(ctx, pattern7_1); - let expr2_0 = - constructor_add_logical_reg(ctx, pattern3_0, expr0_0, expr1_0)?; - let expr3_0 = constructor_output_ifcout(ctx, expr2_0)?; - return Some(expr3_0); - } - &Opcode::Band => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - let pattern8_0 = C::value_type(ctx, pattern7_0); - if let Some(pattern9_0) = C::ty_32_or_64(ctx, pattern8_0) { - if let Some(pattern10_0) = C::sinkable_inst(ctx, pattern7_0) { - let pattern11_0 = C::inst_data(ctx, pattern10_0); - if let &InstructionData::Load { - opcode: ref pattern12_0, - arg: pattern12_1, - flags: pattern12_2, - offset: pattern12_3, - } = &pattern11_0 - { - if let &Opcode::Load = pattern12_0 { - if let Some(()) = C::bigendian(ctx, pattern12_2) { - // Rule at src/isa/s390x/lower.isle line 657. - let expr0_0 = C::put_in_reg(ctx, pattern7_1); - let expr1_0 = - constructor_sink_load(ctx, pattern10_0)?; - let expr2_0 = constructor_and_mem( - ctx, pattern3_0, expr0_0, &expr1_0, - )?; - let expr3_0 = constructor_output_reg(ctx, expr2_0)?; - return Some(expr3_0); - } - } - } - } - } - if let Some(pattern8_0) = - C::uimm32shifted_from_inverted_value(ctx, pattern7_0) - { - // Rule at src/isa/s390x/lower.isle line 651. - let expr0_0 = C::put_in_reg(ctx, pattern7_1); - let expr1_0 = constructor_and_uimm32shifted( - ctx, pattern3_0, expr0_0, pattern8_0, - )?; - let expr2_0 = constructor_output_reg(ctx, expr1_0)?; - return Some(expr2_0); - } - if let Some(pattern8_0) = - C::uimm16shifted_from_inverted_value(ctx, pattern7_0) - { - // Rule at src/isa/s390x/lower.isle line 647. - let expr0_0 = C::put_in_reg(ctx, pattern7_1); - let expr1_0 = constructor_and_uimm16shifted( - ctx, pattern3_0, expr0_0, pattern8_0, - )?; - let expr2_0 = constructor_output_reg(ctx, expr1_0)?; - return Some(expr2_0); - } - let pattern8_0 = C::value_type(ctx, pattern7_1); - if let Some(pattern9_0) = C::ty_32_or_64(ctx, pattern8_0) { - if let Some(pattern10_0) = C::sinkable_inst(ctx, pattern7_1) { - let pattern11_0 = C::inst_data(ctx, pattern10_0); - if let &InstructionData::Load { - opcode: ref pattern12_0, - arg: pattern12_1, - flags: pattern12_2, - offset: pattern12_3, - } = &pattern11_0 - { - if let &Opcode::Load = pattern12_0 { - if let Some(()) = C::bigendian(ctx, pattern12_2) { - // Rule at src/isa/s390x/lower.isle line 655. - let expr0_0 = C::put_in_reg(ctx, pattern7_0); - let expr1_0 = - constructor_sink_load(ctx, pattern10_0)?; - let expr2_0 = constructor_and_mem( - ctx, pattern3_0, expr0_0, &expr1_0, - )?; - let expr3_0 = constructor_output_reg(ctx, expr2_0)?; - return Some(expr3_0); - } - } - } - } - } - if let Some(pattern8_0) = - C::uimm32shifted_from_inverted_value(ctx, pattern7_1) - { - // Rule at src/isa/s390x/lower.isle line 649. - let expr0_0 = C::put_in_reg(ctx, pattern7_0); - let expr1_0 = constructor_and_uimm32shifted( - ctx, pattern3_0, expr0_0, pattern8_0, - )?; - let expr2_0 = constructor_output_reg(ctx, expr1_0)?; - return Some(expr2_0); - } - if let Some(pattern8_0) = - C::uimm16shifted_from_inverted_value(ctx, pattern7_1) - { - // Rule at src/isa/s390x/lower.isle line 645. - let expr0_0 = C::put_in_reg(ctx, pattern7_0); - let expr1_0 = constructor_and_uimm16shifted( - ctx, pattern3_0, expr0_0, pattern8_0, - )?; - let expr2_0 = constructor_output_reg(ctx, expr1_0)?; - return Some(expr2_0); - } - // Rule at src/isa/s390x/lower.isle line 641. - let expr0_0 = C::put_in_reg(ctx, pattern7_0); - let expr1_0 = C::put_in_reg(ctx, pattern7_1); - let expr2_0 = constructor_and_reg(ctx, pattern3_0, expr0_0, expr1_0)?; - let expr3_0 = constructor_output_reg(ctx, expr2_0)?; - return Some(expr3_0); - } - &Opcode::Bor => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - let pattern8_0 = C::value_type(ctx, pattern7_0); - if let Some(pattern9_0) = C::ty_32_or_64(ctx, pattern8_0) { - if let Some(pattern10_0) = C::sinkable_inst(ctx, pattern7_0) { - let pattern11_0 = C::inst_data(ctx, pattern10_0); - if let &InstructionData::Load { - opcode: ref pattern12_0, - arg: pattern12_1, - flags: pattern12_2, - offset: pattern12_3, - } = &pattern11_0 - { - if let &Opcode::Load = pattern12_0 { - if let Some(()) = C::bigendian(ctx, pattern12_2) { - // Rule at src/isa/s390x/lower.isle line 680. - let expr0_0 = C::put_in_reg(ctx, pattern7_1); - let expr1_0 = - constructor_sink_load(ctx, pattern10_0)?; - let expr2_0 = constructor_or_mem( - ctx, pattern3_0, expr0_0, &expr1_0, - )?; - let expr3_0 = constructor_output_reg(ctx, expr2_0)?; - return Some(expr3_0); - } - } - } - } - } - if let Some(pattern8_0) = C::uimm32shifted_from_value(ctx, pattern7_0) { - // Rule at src/isa/s390x/lower.isle line 674. - let expr0_0 = C::put_in_reg(ctx, pattern7_1); - let expr1_0 = constructor_or_uimm32shifted( - ctx, pattern3_0, expr0_0, pattern8_0, - )?; - let expr2_0 = constructor_output_reg(ctx, expr1_0)?; - return Some(expr2_0); - } - if let Some(pattern8_0) = C::uimm16shifted_from_value(ctx, pattern7_0) { - // Rule at src/isa/s390x/lower.isle line 670. - let expr0_0 = C::put_in_reg(ctx, pattern7_1); - let expr1_0 = constructor_or_uimm16shifted( - ctx, pattern3_0, expr0_0, pattern8_0, - )?; - let expr2_0 = constructor_output_reg(ctx, expr1_0)?; - return Some(expr2_0); - } - let pattern8_0 = C::value_type(ctx, pattern7_1); - if let Some(pattern9_0) = C::ty_32_or_64(ctx, pattern8_0) { - if let Some(pattern10_0) = C::sinkable_inst(ctx, pattern7_1) { - let pattern11_0 = C::inst_data(ctx, pattern10_0); - if let &InstructionData::Load { - opcode: ref pattern12_0, - arg: pattern12_1, - flags: pattern12_2, - offset: pattern12_3, - } = &pattern11_0 - { - if let &Opcode::Load = pattern12_0 { - if let Some(()) = C::bigendian(ctx, pattern12_2) { - // Rule at src/isa/s390x/lower.isle line 678. - let expr0_0 = C::put_in_reg(ctx, pattern7_0); - let expr1_0 = - constructor_sink_load(ctx, pattern10_0)?; - let expr2_0 = constructor_or_mem( - ctx, pattern3_0, expr0_0, &expr1_0, - )?; - let expr3_0 = constructor_output_reg(ctx, expr2_0)?; - return Some(expr3_0); - } - } - } - } - } - if let Some(pattern8_0) = C::uimm32shifted_from_value(ctx, pattern7_1) { - // Rule at src/isa/s390x/lower.isle line 672. - let expr0_0 = C::put_in_reg(ctx, pattern7_0); - let expr1_0 = constructor_or_uimm32shifted( - ctx, pattern3_0, expr0_0, pattern8_0, - )?; - let expr2_0 = constructor_output_reg(ctx, expr1_0)?; - return Some(expr2_0); - } - if let Some(pattern8_0) = C::uimm16shifted_from_value(ctx, pattern7_1) { - // Rule at src/isa/s390x/lower.isle line 668. - let expr0_0 = C::put_in_reg(ctx, pattern7_0); - let expr1_0 = constructor_or_uimm16shifted( - ctx, pattern3_0, expr0_0, pattern8_0, - )?; - let expr2_0 = constructor_output_reg(ctx, expr1_0)?; - return Some(expr2_0); - } - // Rule at src/isa/s390x/lower.isle line 664. - let expr0_0 = C::put_in_reg(ctx, pattern7_0); - let expr1_0 = C::put_in_reg(ctx, pattern7_1); - let expr2_0 = constructor_or_reg(ctx, pattern3_0, expr0_0, expr1_0)?; - let expr3_0 = constructor_output_reg(ctx, expr2_0)?; - return Some(expr3_0); - } - &Opcode::Bxor => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - let pattern8_0 = C::value_type(ctx, pattern7_0); - if let Some(pattern9_0) = C::ty_32_or_64(ctx, pattern8_0) { - if let Some(pattern10_0) = C::sinkable_inst(ctx, pattern7_0) { - let pattern11_0 = C::inst_data(ctx, pattern10_0); - if let &InstructionData::Load { - opcode: ref pattern12_0, - arg: pattern12_1, - flags: pattern12_2, - offset: pattern12_3, - } = &pattern11_0 - { - if let &Opcode::Load = pattern12_0 { - if let Some(()) = C::bigendian(ctx, pattern12_2) { - // Rule at src/isa/s390x/lower.isle line 699. - let expr0_0 = C::put_in_reg(ctx, pattern7_1); - let expr1_0 = - constructor_sink_load(ctx, pattern10_0)?; - let expr2_0 = constructor_xor_mem( - ctx, pattern3_0, expr0_0, &expr1_0, - )?; - let expr3_0 = constructor_output_reg(ctx, expr2_0)?; - return Some(expr3_0); - } - } - } - } - } - if let Some(pattern8_0) = C::uimm32shifted_from_value(ctx, pattern7_0) { - // Rule at src/isa/s390x/lower.isle line 693. - let expr0_0 = C::put_in_reg(ctx, pattern7_1); - let expr1_0 = constructor_xor_uimm32shifted( - ctx, pattern3_0, expr0_0, pattern8_0, - )?; - let expr2_0 = constructor_output_reg(ctx, expr1_0)?; - return Some(expr2_0); - } - let pattern8_0 = C::value_type(ctx, pattern7_1); - if let Some(pattern9_0) = C::ty_32_or_64(ctx, pattern8_0) { - if let Some(pattern10_0) = C::sinkable_inst(ctx, pattern7_1) { - let pattern11_0 = C::inst_data(ctx, pattern10_0); - if let &InstructionData::Load { - opcode: ref pattern12_0, - arg: pattern12_1, - flags: pattern12_2, - offset: pattern12_3, - } = &pattern11_0 - { - if let &Opcode::Load = pattern12_0 { - if let Some(()) = C::bigendian(ctx, pattern12_2) { - // Rule at src/isa/s390x/lower.isle line 697. - let expr0_0 = C::put_in_reg(ctx, pattern7_0); - let expr1_0 = - constructor_sink_load(ctx, pattern10_0)?; - let expr2_0 = constructor_xor_mem( - ctx, pattern3_0, expr0_0, &expr1_0, - )?; - let expr3_0 = constructor_output_reg(ctx, expr2_0)?; - return Some(expr3_0); - } - } - } - } - } - if let Some(pattern8_0) = C::uimm32shifted_from_value(ctx, pattern7_1) { - // Rule at src/isa/s390x/lower.isle line 691. - let expr0_0 = C::put_in_reg(ctx, pattern7_0); - let expr1_0 = constructor_xor_uimm32shifted( - ctx, pattern3_0, expr0_0, pattern8_0, - )?; - let expr2_0 = constructor_output_reg(ctx, expr1_0)?; - return Some(expr2_0); - } - // Rule at src/isa/s390x/lower.isle line 687. - let expr0_0 = C::put_in_reg(ctx, pattern7_0); - let expr1_0 = C::put_in_reg(ctx, pattern7_1); - let expr2_0 = constructor_xor_reg(ctx, pattern3_0, expr0_0, expr1_0)?; - let expr3_0 = constructor_output_reg(ctx, expr2_0)?; - return Some(expr3_0); - } - &Opcode::Ishl => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - if let Some(pattern8_0) = C::i64_from_value(ctx, pattern7_1) { - // Rule at src/isa/s390x/lower.isle line 486. - let expr0_0 = C::mask_amt_imm(ctx, pattern3_0, pattern8_0); - let expr1_0 = C::put_in_reg(ctx, pattern7_0); - let expr2_0 = - constructor_lshl_imm(ctx, pattern3_0, expr1_0, expr0_0)?; - let expr3_0 = constructor_output_reg(ctx, expr2_0)?; - return Some(expr3_0); - } - // Rule at src/isa/s390x/lower.isle line 481. - let expr0_0 = C::put_in_reg(ctx, pattern7_1); - let expr1_0 = constructor_mask_amt_reg(ctx, pattern3_0, expr0_0)?; - let expr2_0 = C::put_in_reg(ctx, pattern7_0); - let expr3_0 = constructor_lshl_reg(ctx, pattern3_0, expr2_0, expr1_0)?; - let expr4_0 = constructor_output_reg(ctx, expr3_0)?; - return Some(expr4_0); - } - &Opcode::Ushr => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - if let Some(pattern8_0) = C::i64_from_value(ctx, pattern7_1) { - // Rule at src/isa/s390x/lower.isle line 502. - let expr0_0 = constructor_put_in_reg_zext32(ctx, pattern7_0)?; - let expr1_0 = C::mask_amt_imm(ctx, pattern3_0, pattern8_0); - let expr2_0 = constructor_ty_ext32(ctx, pattern3_0)?; - let expr3_0 = constructor_lshr_imm(ctx, expr2_0, expr0_0, expr1_0)?; - let expr4_0 = constructor_output_reg(ctx, expr3_0)?; - return Some(expr4_0); - } - // Rule at src/isa/s390x/lower.isle line 495. - let expr0_0 = constructor_put_in_reg_zext32(ctx, pattern7_0)?; - let expr1_0 = C::put_in_reg(ctx, pattern7_1); - let expr2_0 = constructor_mask_amt_reg(ctx, pattern3_0, expr1_0)?; - let expr3_0 = constructor_ty_ext32(ctx, pattern3_0)?; - let expr4_0 = constructor_lshr_reg(ctx, expr3_0, expr0_0, expr2_0)?; - let expr5_0 = constructor_output_reg(ctx, expr4_0)?; - return Some(expr5_0); - } - &Opcode::Sshr => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - if let Some(pattern8_0) = C::i64_from_value(ctx, pattern7_1) { - // Rule at src/isa/s390x/lower.isle line 519. - let expr0_0 = constructor_put_in_reg_sext32(ctx, pattern7_0)?; - let expr1_0 = C::mask_amt_imm(ctx, pattern3_0, pattern8_0); - let expr2_0 = constructor_ty_ext32(ctx, pattern3_0)?; - let expr3_0 = constructor_ashr_imm(ctx, expr2_0, expr0_0, expr1_0)?; - let expr4_0 = constructor_output_reg(ctx, expr3_0)?; - return Some(expr4_0); - } - // Rule at src/isa/s390x/lower.isle line 512. - let expr0_0 = constructor_put_in_reg_sext32(ctx, pattern7_0)?; - let expr1_0 = C::put_in_reg(ctx, pattern7_1); - let expr2_0 = constructor_mask_amt_reg(ctx, pattern3_0, expr1_0)?; - let expr3_0 = constructor_ty_ext32(ctx, pattern3_0)?; - let expr4_0 = constructor_ashr_reg(ctx, expr3_0, expr0_0, expr2_0)?; - let expr5_0 = constructor_output_reg(ctx, expr4_0)?; - return Some(expr5_0); - } - _ => {} - } - } - &InstructionData::Unary { - opcode: ref pattern5_0, - arg: pattern5_1, - } => { - match pattern5_0 { - &Opcode::Ineg => { - if let Some(pattern7_0) = C::def_inst(ctx, pattern5_1) { - let pattern8_0 = C::inst_data(ctx, pattern7_0); - if let &InstructionData::Unary { - opcode: ref pattern9_0, - arg: pattern9_1, - } = &pattern8_0 - { - if let &Opcode::Sextend = pattern9_0 { - let pattern11_0 = C::value_type(ctx, pattern9_1); - if pattern11_0 == I32 { - // Rule at src/isa/s390x/lower.isle line 193. - let expr0_0 = C::put_in_reg(ctx, pattern9_1); - let expr1_0 = constructor_neg_reg_sext32( - ctx, pattern3_0, expr0_0, - )?; - let expr2_0 = constructor_output_reg(ctx, expr1_0)?; - return Some(expr2_0); - } - } - } - } - // Rule at src/isa/s390x/lower.isle line 189. - let expr0_0 = C::put_in_reg(ctx, pattern5_1); - let expr1_0 = constructor_neg_reg(ctx, pattern3_0, expr0_0)?; - let expr2_0 = constructor_output_reg(ctx, expr1_0)?; - return Some(expr2_0); - } - &Opcode::Iabs => { - if let Some(pattern7_0) = C::def_inst(ctx, pattern5_1) { - let pattern8_0 = C::inst_data(ctx, pattern7_0); - if let &InstructionData::Unary { - opcode: ref pattern9_0, - arg: pattern9_1, - } = &pattern8_0 - { - if let &Opcode::Sextend = pattern9_0 { - let pattern11_0 = C::value_type(ctx, pattern9_1); - if pattern11_0 == I32 { - // Rule at src/isa/s390x/lower.isle line 141. - let expr0_0 = C::put_in_reg(ctx, pattern9_1); - let expr1_0 = constructor_abs_reg_sext32( - ctx, pattern3_0, expr0_0, - )?; - let expr2_0 = constructor_output_reg(ctx, expr1_0)?; - return Some(expr2_0); - } - } - } - } - // Rule at src/isa/s390x/lower.isle line 137. - let expr0_0 = constructor_ty_ext32(ctx, pattern3_0)?; - let expr1_0 = constructor_put_in_reg_sext32(ctx, pattern5_1)?; - let expr2_0 = constructor_abs_reg(ctx, expr0_0, expr1_0)?; - let expr3_0 = constructor_output_reg(ctx, expr2_0)?; - return Some(expr3_0); - } - &Opcode::Clz => { - // Rule at src/isa/s390x/lower.isle line 825. - let expr0_0 = constructor_put_in_reg_zext64(ctx, pattern5_1)?; - let expr1_0: i16 = 64; - let expr2_0 = constructor_clz_reg(ctx, expr1_0, expr0_0)?; - let expr3_0 = constructor_regpair_hi(ctx, &expr2_0)?; - let expr4_0 = constructor_clz_offset(ctx, pattern3_0, expr3_0)?; - let expr5_0 = constructor_output_reg(ctx, expr4_0)?; - return Some(expr5_0); - } - &Opcode::Cls => { - // Rule at src/isa/s390x/lower.isle line 840. - let expr0_0 = constructor_put_in_reg_sext64(ctx, pattern5_1)?; - let expr1_0: Type = I64; - let expr2_0: u8 = 63; - let expr3_0 = constructor_ashr_imm(ctx, expr1_0, expr0_0, expr2_0)?; - let expr4_0: Type = I64; - let expr5_0 = constructor_xor_reg(ctx, expr4_0, expr0_0, expr3_0)?; - let expr6_0: i16 = 64; - let expr7_0 = constructor_clz_reg(ctx, expr6_0, expr5_0)?; - let expr8_0 = constructor_regpair_hi(ctx, &expr7_0)?; - let expr9_0 = constructor_clz_offset(ctx, pattern3_0, expr8_0)?; - let expr10_0 = constructor_output_reg(ctx, expr9_0)?; - return Some(expr10_0); - } - &Opcode::Bint => { - // Rule at src/isa/s390x/lower.isle line 808. - let expr0_0 = C::put_in_reg(ctx, pattern5_1); - let expr1_0: u64 = 1; - let expr2_0 = constructor_imm(ctx, pattern3_0, expr1_0)?; - let expr3_0 = constructor_and_reg(ctx, pattern3_0, expr0_0, expr2_0)?; - let expr4_0 = constructor_output_reg(ctx, expr3_0)?; - return Some(expr4_0); - } - _ => {} - } - } - _ => {} - } - } - if let Some(pattern3_0) = C::ty_32_or_64(ctx, pattern2_0) { - let pattern4_0 = C::inst_data(ctx, pattern0_0); - match &pattern4_0 { - &InstructionData::Binary { - opcode: ref pattern5_0, - args: ref pattern5_1, - } => { - match pattern5_0 { - &Opcode::Rotl => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - if let Some(pattern8_0) = C::i64_from_value(ctx, pattern7_1) { - // Rule at src/isa/s390x/lower.isle line 532. - let expr0_0 = C::mask_amt_imm(ctx, pattern3_0, pattern8_0); - let expr1_0 = C::put_in_reg(ctx, pattern7_0); - let expr2_0 = - constructor_rot_imm(ctx, pattern3_0, expr1_0, expr0_0)?; - let expr3_0 = constructor_output_reg(ctx, expr2_0)?; - return Some(expr3_0); - } - // Rule at src/isa/s390x/lower.isle line 528. - let expr0_0 = C::put_in_reg(ctx, pattern7_0); - let expr1_0 = C::put_in_reg(ctx, pattern7_1); - let expr2_0 = constructor_rot_reg(ctx, pattern3_0, expr0_0, expr1_0)?; - let expr3_0 = constructor_output_reg(ctx, expr2_0)?; - return Some(expr3_0); - } - &Opcode::Rotr => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - if let Some(pattern8_0) = C::i64_from_negated_value(ctx, pattern7_1) { - // Rule at src/isa/s390x/lower.isle line 570. - let expr0_0 = C::mask_amt_imm(ctx, pattern3_0, pattern8_0); - let expr1_0 = C::put_in_reg(ctx, pattern7_0); - let expr2_0 = - constructor_rot_imm(ctx, pattern3_0, expr1_0, expr0_0)?; - let expr3_0 = constructor_output_reg(ctx, expr2_0)?; - return Some(expr3_0); - } - // Rule at src/isa/s390x/lower.isle line 564. - let expr0_0 = C::put_in_reg(ctx, pattern7_1); - let expr1_0 = constructor_neg_reg(ctx, pattern3_0, expr0_0)?; - let expr2_0 = C::put_in_reg(ctx, pattern7_0); - let expr3_0 = constructor_rot_reg(ctx, pattern3_0, expr2_0, expr1_0)?; - let expr4_0 = constructor_output_reg(ctx, expr3_0)?; - return Some(expr4_0); - } - _ => {} - } - } - &InstructionData::AtomicRmw { - opcode: ref pattern5_0, - args: ref pattern5_1, - flags: pattern5_2, - op: ref pattern5_3, - } => { - if let &Opcode::AtomicRmw = pattern5_0 { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - if let Some(()) = C::littleendian(ctx, pattern5_2) { - match pattern5_3 { - &AtomicRmwOp::And => { - // Rule at src/isa/s390x/lower.isle line 1510. - let expr0_0 = C::put_in_reg(ctx, pattern7_1); - let expr1_0 = constructor_bswap_reg(ctx, pattern3_0, expr0_0)?; - let expr2_0 = C::zero_offset(ctx); - let expr3_0 = constructor_lower_address( - ctx, pattern5_2, pattern7_0, expr2_0, - )?; - let expr4_0 = constructor_atomic_rmw_and( - ctx, pattern3_0, expr1_0, &expr3_0, - )?; - let expr5_0 = constructor_bswap_reg(ctx, pattern3_0, expr4_0)?; - let expr6_0 = constructor_output_reg(ctx, expr5_0)?; - return Some(expr6_0); - } - &AtomicRmwOp::Or => { - // Rule at src/isa/s390x/lower.isle line 1522. - let expr0_0 = C::put_in_reg(ctx, pattern7_1); - let expr1_0 = constructor_bswap_reg(ctx, pattern3_0, expr0_0)?; - let expr2_0 = C::zero_offset(ctx); - let expr3_0 = constructor_lower_address( - ctx, pattern5_2, pattern7_0, expr2_0, - )?; - let expr4_0 = constructor_atomic_rmw_or( - ctx, pattern3_0, expr1_0, &expr3_0, - )?; - let expr5_0 = constructor_bswap_reg(ctx, pattern3_0, expr4_0)?; - let expr6_0 = constructor_output_reg(ctx, expr5_0)?; - return Some(expr6_0); - } - &AtomicRmwOp::Xor => { - // Rule at src/isa/s390x/lower.isle line 1534. - let expr0_0 = C::put_in_reg(ctx, pattern7_1); - let expr1_0 = constructor_bswap_reg(ctx, pattern3_0, expr0_0)?; - let expr2_0 = C::zero_offset(ctx); - let expr3_0 = constructor_lower_address( - ctx, pattern5_2, pattern7_0, expr2_0, - )?; - let expr4_0 = constructor_atomic_rmw_xor( - ctx, pattern3_0, expr1_0, &expr3_0, - )?; - let expr5_0 = constructor_bswap_reg(ctx, pattern3_0, expr4_0)?; - let expr6_0 = constructor_output_reg(ctx, expr5_0)?; - return Some(expr6_0); - } - _ => {} - } - } - if let Some(()) = C::bigendian(ctx, pattern5_2) { - match pattern5_3 { - &AtomicRmwOp::Add => { - // Rule at src/isa/s390x/lower.isle line 1540. - let expr0_0 = C::put_in_reg(ctx, pattern7_1); - let expr1_0 = C::zero_offset(ctx); - let expr2_0 = constructor_lower_address( - ctx, pattern5_2, pattern7_0, expr1_0, - )?; - let expr3_0 = constructor_atomic_rmw_add( - ctx, pattern3_0, expr0_0, &expr2_0, - )?; - let expr4_0 = constructor_output_reg(ctx, expr3_0)?; - return Some(expr4_0); - } - &AtomicRmwOp::And => { - // Rule at src/isa/s390x/lower.isle line 1504. - let expr0_0 = C::put_in_reg(ctx, pattern7_1); - let expr1_0 = C::zero_offset(ctx); - let expr2_0 = constructor_lower_address( - ctx, pattern5_2, pattern7_0, expr1_0, - )?; - let expr3_0 = constructor_atomic_rmw_and( - ctx, pattern3_0, expr0_0, &expr2_0, - )?; - let expr4_0 = constructor_output_reg(ctx, expr3_0)?; - return Some(expr4_0); - } - &AtomicRmwOp::Or => { - // Rule at src/isa/s390x/lower.isle line 1516. - let expr0_0 = C::put_in_reg(ctx, pattern7_1); - let expr1_0 = C::zero_offset(ctx); - let expr2_0 = constructor_lower_address( - ctx, pattern5_2, pattern7_0, expr1_0, - )?; - let expr3_0 = constructor_atomic_rmw_or( - ctx, pattern3_0, expr0_0, &expr2_0, - )?; - let expr4_0 = constructor_output_reg(ctx, expr3_0)?; - return Some(expr4_0); - } - &AtomicRmwOp::Sub => { - // Rule at src/isa/s390x/lower.isle line 1546. - let expr0_0 = C::put_in_reg(ctx, pattern7_1); - let expr1_0 = constructor_neg_reg(ctx, pattern3_0, expr0_0)?; - let expr2_0 = C::zero_offset(ctx); - let expr3_0 = constructor_lower_address( - ctx, pattern5_2, pattern7_0, expr2_0, - )?; - let expr4_0 = constructor_atomic_rmw_add( - ctx, pattern3_0, expr1_0, &expr3_0, - )?; - let expr5_0 = constructor_output_reg(ctx, expr4_0)?; - return Some(expr5_0); - } - &AtomicRmwOp::Xor => { - // Rule at src/isa/s390x/lower.isle line 1528. - let expr0_0 = C::put_in_reg(ctx, pattern7_1); - let expr1_0 = C::zero_offset(ctx); - let expr2_0 = constructor_lower_address( - ctx, pattern5_2, pattern7_0, expr1_0, - )?; - let expr3_0 = constructor_atomic_rmw_xor( - ctx, pattern3_0, expr0_0, &expr2_0, - )?; - let expr4_0 = constructor_output_reg(ctx, expr3_0)?; - return Some(expr4_0); - } - _ => {} - } - } - // Rule at src/isa/s390x/lower.isle line 1555. - let expr0_0 = C::put_in_reg(ctx, pattern7_1); - let expr1_0 = C::put_in_reg(ctx, pattern7_0); - let expr2_0 = C::inst_builder_new(ctx); - let expr3_0 = constructor_casloop_val_reg(ctx)?; - let expr4_0 = C::writable_reg_to_reg(ctx, expr3_0); - let expr5_0 = constructor_casloop_tmp_reg(ctx)?; - let expr6_0 = constructor_atomic_rmw_body( - ctx, &expr2_0, pattern3_0, pattern5_2, pattern5_3, expr5_0, expr4_0, - expr0_0, - )?; - let expr7_0 = constructor_casloop( - ctx, &expr2_0, pattern3_0, pattern5_2, expr1_0, expr6_0, - )?; - let expr8_0 = constructor_output_reg(ctx, expr7_0)?; - return Some(expr8_0); - } - } - &InstructionData::AtomicCas { - opcode: ref pattern5_0, - args: ref pattern5_1, - flags: pattern5_2, - } => { - if let &Opcode::AtomicCas = pattern5_0 { - let (pattern7_0, pattern7_1, pattern7_2) = - C::unpack_value_array_3(ctx, pattern5_1); - if let Some(()) = C::littleendian(ctx, pattern5_2) { - // Rule at src/isa/s390x/lower.isle line 1767. - let expr0_0 = C::put_in_reg(ctx, pattern7_1); - let expr1_0 = constructor_bswap_reg(ctx, pattern3_0, expr0_0)?; - let expr2_0 = C::put_in_reg(ctx, pattern7_2); - let expr3_0 = constructor_bswap_reg(ctx, pattern3_0, expr2_0)?; - let expr4_0 = C::zero_offset(ctx); - let expr5_0 = - constructor_lower_address(ctx, pattern5_2, pattern7_0, expr4_0)?; - let expr6_0 = constructor_atomic_cas_impl( - ctx, pattern3_0, expr1_0, expr3_0, &expr5_0, - )?; - let expr7_0 = constructor_bswap_reg(ctx, pattern3_0, expr6_0)?; - let expr8_0 = constructor_output_reg(ctx, expr7_0)?; - return Some(expr8_0); - } - if let Some(()) = C::bigendian(ctx, pattern5_2) { - // Rule at src/isa/s390x/lower.isle line 1760. - let expr0_0 = C::put_in_reg(ctx, pattern7_1); - let expr1_0 = C::put_in_reg(ctx, pattern7_2); - let expr2_0 = C::zero_offset(ctx); - let expr3_0 = - constructor_lower_address(ctx, pattern5_2, pattern7_0, expr2_0)?; - let expr4_0 = constructor_atomic_cas_impl( - ctx, pattern3_0, expr0_0, expr1_0, &expr3_0, - )?; - let expr5_0 = constructor_output_reg(ctx, expr4_0)?; - return Some(expr5_0); - } - } - } - &InstructionData::Unary { - opcode: ref pattern5_0, - arg: pattern5_1, - } => { - match pattern5_0 { - &Opcode::FcvtToUint => { - let pattern7_0 = C::value_type(ctx, pattern5_1); - // Rule at src/isa/s390x/lower.isle line 1061. - let expr0_0 = C::put_in_reg(ctx, pattern5_1); - let expr1_0 = constructor_fcmp_reg(ctx, pattern7_0, expr0_0, expr0_0)?; - let expr2_0 = FloatCC::Unordered; - let expr3_0 = C::floatcc_as_cond(ctx, &expr2_0); - let expr4_0 = C::trap_code_bad_conversion_to_integer(ctx); - let expr5_0 = constructor_trap_if(ctx, &expr1_0, &expr3_0, &expr4_0)?; - let expr6_0 = constructor_fcvt_to_uint_reg_with_flags( - ctx, pattern3_0, pattern7_0, expr0_0, - )?; - let expr7_0 = FloatCC::Unordered; - let expr8_0 = C::floatcc_as_cond(ctx, &expr7_0); - let expr9_0 = C::trap_code_integer_overflow(ctx); - let expr10_0 = constructor_trap_if(ctx, &expr6_0, &expr8_0, &expr9_0)?; - let expr11_0 = constructor_output_reg(ctx, expr10_0)?; - return Some(expr11_0); - } - &Opcode::FcvtToUintSat => { - let pattern7_0 = C::value_type(ctx, pattern5_1); - // Rule at src/isa/s390x/lower.isle line 1102. - let expr0_0 = C::put_in_reg(ctx, pattern5_1); - let expr1_0 = - constructor_fcvt_to_uint_reg(ctx, pattern3_0, pattern7_0, expr0_0)?; - let expr2_0 = constructor_fcmp_reg(ctx, pattern7_0, expr0_0, expr0_0)?; - let expr3_0 = FloatCC::Unordered; - let expr4_0 = C::floatcc_as_cond(ctx, &expr3_0); - let expr5_0: i16 = 0; - let expr6_0 = - constructor_cmov_imm(ctx, pattern3_0, &expr4_0, expr5_0, expr1_0)?; - let expr7_0 = constructor_with_flags_reg(ctx, &expr2_0, &expr6_0)?; - let expr8_0 = constructor_output_reg(ctx, expr7_0)?; - return Some(expr8_0); - } - &Opcode::FcvtToSint => { - let pattern7_0 = C::value_type(ctx, pattern5_1); - // Rule at src/isa/s390x/lower.isle line 1082. - let expr0_0 = C::put_in_reg(ctx, pattern5_1); - let expr1_0 = constructor_fcmp_reg(ctx, pattern7_0, expr0_0, expr0_0)?; - let expr2_0 = FloatCC::Unordered; - let expr3_0 = C::floatcc_as_cond(ctx, &expr2_0); - let expr4_0 = C::trap_code_bad_conversion_to_integer(ctx); - let expr5_0 = constructor_trap_if(ctx, &expr1_0, &expr3_0, &expr4_0)?; - let expr6_0 = constructor_fcvt_to_sint_reg_with_flags( - ctx, pattern3_0, pattern7_0, expr0_0, - )?; - let expr7_0 = FloatCC::Unordered; - let expr8_0 = C::floatcc_as_cond(ctx, &expr7_0); - let expr9_0 = C::trap_code_integer_overflow(ctx); - let expr10_0 = constructor_trap_if(ctx, &expr6_0, &expr8_0, &expr9_0)?; - let expr11_0 = constructor_output_reg(ctx, expr10_0)?; - return Some(expr11_0); - } - &Opcode::FcvtToSintSat => { - let pattern7_0 = C::value_type(ctx, pattern5_1); - // Rule at src/isa/s390x/lower.isle line 1119. - let expr0_0 = C::put_in_reg(ctx, pattern5_1); - let expr1_0 = - constructor_fcvt_to_sint_reg(ctx, pattern3_0, pattern7_0, expr0_0)?; - let expr2_0 = constructor_fcmp_reg(ctx, pattern7_0, expr0_0, expr0_0)?; - let expr3_0 = FloatCC::Unordered; - let expr4_0 = C::floatcc_as_cond(ctx, &expr3_0); - let expr5_0: i16 = 0; - let expr6_0 = - constructor_cmov_imm(ctx, pattern3_0, &expr4_0, expr5_0, expr1_0)?; - let expr7_0 = constructor_with_flags_reg(ctx, &expr2_0, &expr6_0)?; - let expr8_0 = constructor_output_reg(ctx, expr7_0)?; - return Some(expr8_0); - } - _ => {} - } - } - _ => {} - } - } - if let Some(pattern3_0) = C::ty_8_or_16(ctx, pattern2_0) { - let pattern4_0 = C::inst_data(ctx, pattern0_0); - match &pattern4_0 { - &InstructionData::Binary { - opcode: ref pattern5_0, - args: ref pattern5_1, - } => { - match pattern5_0 { - &Opcode::Umulhi => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/s390x/lower.isle line 245. - let expr0_0 = constructor_put_in_reg_zext32(ctx, pattern7_0)?; - let expr1_0 = constructor_put_in_reg_zext32(ctx, pattern7_1)?; - let expr2_0: Type = I32; - let expr3_0 = constructor_mul_reg(ctx, expr2_0, expr0_0, expr1_0)?; - let expr4_0: Type = I32; - let expr5_0 = C::ty_bits(ctx, pattern3_0)?; - let expr6_0 = constructor_lshr_imm(ctx, expr4_0, expr3_0, expr5_0)?; - let expr7_0 = constructor_output_reg(ctx, expr6_0)?; - return Some(expr7_0); - } - &Opcode::Smulhi => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/s390x/lower.isle line 267. - let expr0_0 = constructor_put_in_reg_sext32(ctx, pattern7_0)?; - let expr1_0 = constructor_put_in_reg_sext32(ctx, pattern7_1)?; - let expr2_0: Type = I32; - let expr3_0 = constructor_mul_reg(ctx, expr2_0, expr0_0, expr1_0)?; - let expr4_0: Type = I32; - let expr5_0 = C::ty_bits(ctx, pattern3_0)?; - let expr6_0 = constructor_ashr_imm(ctx, expr4_0, expr3_0, expr5_0)?; - let expr7_0 = constructor_output_reg(ctx, expr6_0)?; - return Some(expr7_0); - } - &Opcode::Rotl => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - if let Some(pattern8_0) = C::i64_from_value(ctx, pattern7_1) { - if let Some(pattern9_0) = C::i64_from_negated_value(ctx, pattern7_1) - { - // Rule at src/isa/s390x/lower.isle line 550. - let expr0_0 = constructor_put_in_reg_zext32(ctx, pattern7_0)?; - let expr1_0 = constructor_ty_ext32(ctx, pattern3_0)?; - let expr2_0 = C::mask_amt_imm(ctx, pattern3_0, pattern8_0); - let expr3_0 = C::mask_amt_imm(ctx, pattern3_0, pattern9_0); - let expr4_0 = - constructor_lshl_imm(ctx, expr1_0, expr0_0, expr2_0)?; - let expr5_0 = - constructor_lshr_imm(ctx, expr1_0, expr0_0, expr3_0)?; - let expr6_0 = - constructor_or_reg(ctx, pattern3_0, expr4_0, expr5_0)?; - let expr7_0 = constructor_output_reg(ctx, expr6_0)?; - return Some(expr7_0); - } - } - // Rule at src/isa/s390x/lower.isle line 538. - let expr0_0 = constructor_put_in_reg_zext32(ctx, pattern7_0)?; - let expr1_0 = constructor_ty_ext32(ctx, pattern3_0)?; - let expr2_0 = C::put_in_reg(ctx, pattern7_1); - let expr3_0 = constructor_neg_reg(ctx, pattern3_0, expr2_0)?; - let expr4_0 = constructor_mask_amt_reg(ctx, pattern3_0, expr2_0)?; - let expr5_0 = constructor_mask_amt_reg(ctx, pattern3_0, expr3_0)?; - let expr6_0 = constructor_lshl_reg(ctx, expr1_0, expr0_0, expr4_0)?; - let expr7_0 = constructor_lshr_reg(ctx, expr1_0, expr0_0, expr5_0)?; - let expr8_0 = constructor_or_reg(ctx, pattern3_0, expr6_0, expr7_0)?; - let expr9_0 = constructor_output_reg(ctx, expr8_0)?; - return Some(expr9_0); - } - &Opcode::Rotr => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - if let Some(pattern8_0) = C::i64_from_value(ctx, pattern7_1) { - if let Some(pattern9_0) = C::i64_from_negated_value(ctx, pattern7_1) - { - // Rule at src/isa/s390x/lower.isle line 588. - let expr0_0 = constructor_put_in_reg_zext32(ctx, pattern7_0)?; - let expr1_0 = constructor_ty_ext32(ctx, pattern3_0)?; - let expr2_0 = C::mask_amt_imm(ctx, pattern3_0, pattern8_0); - let expr3_0 = C::mask_amt_imm(ctx, pattern3_0, pattern9_0); - let expr4_0 = - constructor_lshl_imm(ctx, expr1_0, expr0_0, expr3_0)?; - let expr5_0 = - constructor_lshr_imm(ctx, expr1_0, expr0_0, expr2_0)?; - let expr6_0 = - constructor_or_reg(ctx, pattern3_0, expr4_0, expr5_0)?; - let expr7_0 = constructor_output_reg(ctx, expr6_0)?; - return Some(expr7_0); - } - } - // Rule at src/isa/s390x/lower.isle line 576. - let expr0_0 = constructor_put_in_reg_zext32(ctx, pattern7_0)?; - let expr1_0 = constructor_ty_ext32(ctx, pattern3_0)?; - let expr2_0 = C::put_in_reg(ctx, pattern7_1); - let expr3_0 = constructor_neg_reg(ctx, pattern3_0, expr2_0)?; - let expr4_0 = constructor_mask_amt_reg(ctx, pattern3_0, expr2_0)?; - let expr5_0 = constructor_mask_amt_reg(ctx, pattern3_0, expr3_0)?; - let expr6_0 = constructor_lshl_reg(ctx, expr1_0, expr0_0, expr5_0)?; - let expr7_0 = constructor_lshr_reg(ctx, expr1_0, expr0_0, expr4_0)?; - let expr8_0 = constructor_or_reg(ctx, pattern3_0, expr6_0, expr7_0)?; - let expr9_0 = constructor_output_reg(ctx, expr8_0)?; - return Some(expr9_0); - } - _ => {} - } - } - &InstructionData::AtomicRmw { - opcode: ref pattern5_0, - args: ref pattern5_1, - flags: pattern5_2, - op: ref pattern5_3, - } => { - if let &Opcode::AtomicRmw = pattern5_0 { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/s390x/lower.isle line 1567. - let expr0_0 = C::put_in_reg(ctx, pattern7_1); - let expr1_0 = C::put_in_reg(ctx, pattern7_0); - let expr2_0 = constructor_casloop_bitshift(ctx, expr1_0)?; - let expr3_0 = constructor_casloop_aligned_addr(ctx, expr1_0)?; - let expr4_0 = C::inst_builder_new(ctx); - let expr5_0 = constructor_casloop_val_reg(ctx)?; - let expr6_0 = C::writable_reg_to_reg(ctx, expr5_0); - let expr7_0 = constructor_casloop_rotate_in( - ctx, &expr4_0, pattern3_0, pattern5_2, expr2_0, expr6_0, - )?; - let expr8_0 = constructor_casloop_tmp_reg(ctx)?; - let expr9_0 = constructor_atomic_rmw_body( - ctx, &expr4_0, pattern3_0, pattern5_2, pattern5_3, expr8_0, expr7_0, - expr0_0, - )?; - let expr10_0 = constructor_casloop_rotate_out( - ctx, &expr4_0, pattern3_0, pattern5_2, expr2_0, expr9_0, - )?; - let expr11_0 = constructor_casloop_subword( - ctx, &expr4_0, pattern3_0, pattern5_2, expr3_0, expr2_0, expr10_0, - )?; - let expr12_0 = constructor_output_reg(ctx, expr11_0)?; - return Some(expr12_0); - } - } - &InstructionData::AtomicCas { - opcode: ref pattern5_0, - args: ref pattern5_1, - flags: pattern5_2, - } => { - if let &Opcode::AtomicCas = pattern5_0 { - let (pattern7_0, pattern7_1, pattern7_2) = - C::unpack_value_array_3(ctx, pattern5_1); - // Rule at src/isa/s390x/lower.isle line 1774. - let expr0_0 = C::put_in_reg(ctx, pattern7_1); - let expr1_0 = C::put_in_reg(ctx, pattern7_2); - let expr2_0 = C::put_in_reg(ctx, pattern7_0); - let expr3_0 = constructor_casloop_bitshift(ctx, expr2_0)?; - let expr4_0 = constructor_casloop_aligned_addr(ctx, expr2_0)?; - let expr5_0 = C::inst_builder_new(ctx); - let expr6_0 = constructor_casloop_val_reg(ctx)?; - let expr7_0 = C::writable_reg_to_reg(ctx, expr6_0); - let expr8_0 = constructor_casloop_rotate_in( - ctx, &expr5_0, pattern3_0, pattern5_2, expr3_0, expr7_0, - )?; - let expr9_0 = constructor_casloop_tmp_reg(ctx)?; - let expr10_0 = constructor_atomic_cas_body( - ctx, &expr5_0, pattern3_0, pattern5_2, expr9_0, expr8_0, expr0_0, - expr1_0, - )?; - let expr11_0 = constructor_casloop_rotate_out( - ctx, &expr5_0, pattern3_0, pattern5_2, expr3_0, expr10_0, - )?; - let expr12_0 = constructor_casloop_subword( - ctx, &expr5_0, pattern3_0, pattern5_2, expr4_0, expr3_0, expr11_0, - )?; - let expr13_0 = constructor_output_reg(ctx, expr12_0)?; - return Some(expr13_0); - } - } - _ => {} - } - } - if let Some(pattern3_0) = C::gpr32_ty(ctx, pattern2_0) { - let pattern4_0 = C::inst_data(ctx, pattern0_0); - match &pattern4_0 { - &InstructionData::Unary { - opcode: ref pattern5_0, - arg: pattern5_1, - } => { - match pattern5_0 { - &Opcode::Ctz => { - // Rule at src/isa/s390x/lower.isle line 863. - let expr0_0: Type = I64; - let expr1_0 = C::put_in_reg(ctx, pattern5_1); - let expr2_0 = constructor_ctz_guardbit(ctx, pattern3_0)?; - let expr3_0 = - constructor_or_uimm16shifted(ctx, expr0_0, expr1_0, expr2_0)?; - let expr4_0: Type = I64; - let expr5_0: Type = I64; - let expr6_0 = constructor_neg_reg(ctx, expr5_0, expr3_0)?; - let expr7_0 = constructor_and_reg(ctx, expr4_0, expr3_0, expr6_0)?; - let expr8_0: i16 = 64; - let expr9_0 = constructor_clz_reg(ctx, expr8_0, expr7_0)?; - let expr10_0: u64 = 63; - let expr11_0 = constructor_imm(ctx, pattern3_0, expr10_0)?; - let expr12_0 = constructor_regpair_hi(ctx, &expr9_0)?; - let expr13_0 = - constructor_sub_reg(ctx, pattern3_0, expr11_0, expr12_0)?; - let expr14_0 = constructor_output_reg(ctx, expr13_0)?; - return Some(expr14_0); - } - &Opcode::Uextend => { - // Rule at src/isa/s390x/lower.isle line 607. - let expr0_0 = constructor_put_in_reg_zext32(ctx, pattern5_1)?; - let expr1_0 = constructor_output_reg(ctx, expr0_0)?; - return Some(expr1_0); - } - &Opcode::Sextend => { - // Rule at src/isa/s390x/lower.isle line 618. - let expr0_0 = constructor_put_in_reg_sext32(ctx, pattern5_1)?; - let expr1_0 = constructor_output_reg(ctx, expr0_0)?; - return Some(expr1_0); - } - _ => {} - } - } - &InstructionData::Load { - opcode: ref pattern5_0, - arg: pattern5_1, - flags: pattern5_2, - offset: pattern5_3, - } => { - match pattern5_0 { - &Opcode::Uload8 => { - // Rule at src/isa/s390x/lower.isle line 1256. - let expr0_0: Type = I8; - let expr1_0 = - constructor_lower_address(ctx, pattern5_2, pattern5_1, pattern5_3)?; - let expr2_0 = constructor_zext32_mem(ctx, expr0_0, &expr1_0)?; - let expr3_0 = constructor_output_reg(ctx, expr2_0)?; - return Some(expr3_0); - } - &Opcode::Sload8 => { - // Rule at src/isa/s390x/lower.isle line 1267. - let expr0_0: Type = I8; - let expr1_0 = - constructor_lower_address(ctx, pattern5_2, pattern5_1, pattern5_3)?; - let expr2_0 = constructor_sext32_mem(ctx, expr0_0, &expr1_0)?; - let expr3_0 = constructor_output_reg(ctx, expr2_0)?; - return Some(expr3_0); - } - &Opcode::Uload16 => { - if let Some(()) = C::littleendian(ctx, pattern5_2) { - // Rule at src/isa/s390x/lower.isle line 1283. - let expr0_0 = constructor_lower_address( - ctx, pattern5_2, pattern5_1, pattern5_3, - )?; - let expr1_0 = constructor_loadrev16(ctx, &expr0_0)?; - let expr2_0: Type = I16; - let expr3_0 = constructor_zext32_reg(ctx, expr2_0, expr1_0)?; - let expr4_0 = constructor_output_reg(ctx, expr3_0)?; - return Some(expr4_0); - } - if let Some(()) = C::bigendian(ctx, pattern5_2) { - // Rule at src/isa/s390x/lower.isle line 1278. - let expr0_0: Type = I16; - let expr1_0 = constructor_lower_address( - ctx, pattern5_2, pattern5_1, pattern5_3, - )?; - let expr2_0 = constructor_zext32_mem(ctx, expr0_0, &expr1_0)?; - let expr3_0 = constructor_output_reg(ctx, expr2_0)?; - return Some(expr3_0); - } - } - &Opcode::Sload16 => { - if let Some(()) = C::littleendian(ctx, pattern5_2) { - // Rule at src/isa/s390x/lower.isle line 1308. - let expr0_0 = constructor_lower_address( - ctx, pattern5_2, pattern5_1, pattern5_3, - )?; - let expr1_0 = constructor_loadrev16(ctx, &expr0_0)?; - let expr2_0: Type = I16; - let expr3_0 = constructor_sext32_reg(ctx, expr2_0, expr1_0)?; - let expr4_0 = constructor_output_reg(ctx, expr3_0)?; - return Some(expr4_0); - } - if let Some(()) = C::bigendian(ctx, pattern5_2) { - // Rule at src/isa/s390x/lower.isle line 1303. - let expr0_0: Type = I16; - let expr1_0 = constructor_lower_address( - ctx, pattern5_2, pattern5_1, pattern5_3, - )?; - let expr2_0 = constructor_sext32_mem(ctx, expr0_0, &expr1_0)?; - let expr3_0 = constructor_output_reg(ctx, expr2_0)?; - return Some(expr3_0); - } - } - _ => {} - } - } - _ => {} - } - } - if let Some(pattern3_0) = C::gpr64_ty(ctx, pattern2_0) { - let pattern4_0 = C::inst_data(ctx, pattern0_0); - match &pattern4_0 { - &InstructionData::Unary { - opcode: ref pattern5_0, - arg: pattern5_1, - } => { - match pattern5_0 { - &Opcode::Ctz => { - // Rule at src/isa/s390x/lower.isle line 878. - let expr0_0 = C::put_in_reg(ctx, pattern5_1); - let expr1_0: Type = I64; - let expr2_0: Type = I64; - let expr3_0 = constructor_neg_reg(ctx, expr2_0, expr0_0)?; - let expr4_0 = constructor_and_reg(ctx, expr1_0, expr0_0, expr3_0)?; - let expr5_0: i16 = -1; - let expr6_0 = constructor_clz_reg(ctx, expr5_0, expr4_0)?; - let expr7_0: Type = I64; - let expr8_0: Type = I64; - let expr9_0: u64 = 63; - let expr10_0 = constructor_imm(ctx, expr8_0, expr9_0)?; - let expr11_0 = constructor_regpair_hi(ctx, &expr6_0)?; - let expr12_0 = constructor_sub_reg(ctx, expr7_0, expr10_0, expr11_0)?; - let expr13_0 = constructor_output_reg(ctx, expr12_0)?; - return Some(expr13_0); - } - &Opcode::Uextend => { - // Rule at src/isa/s390x/lower.isle line 611. - let expr0_0 = constructor_put_in_reg_zext64(ctx, pattern5_1)?; - let expr1_0 = constructor_output_reg(ctx, expr0_0)?; - return Some(expr1_0); - } - &Opcode::Sextend => { - // Rule at src/isa/s390x/lower.isle line 622. - let expr0_0 = constructor_put_in_reg_sext64(ctx, pattern5_1)?; - let expr1_0 = constructor_output_reg(ctx, expr0_0)?; - return Some(expr1_0); - } - _ => {} - } - } - &InstructionData::Load { - opcode: ref pattern5_0, - arg: pattern5_1, - flags: pattern5_2, - offset: pattern5_3, - } => { - match pattern5_0 { - &Opcode::Uload8 => { - // Rule at src/isa/s390x/lower.isle line 1260. - let expr0_0: Type = I8; - let expr1_0 = - constructor_lower_address(ctx, pattern5_2, pattern5_1, pattern5_3)?; - let expr2_0 = constructor_zext64_mem(ctx, expr0_0, &expr1_0)?; - let expr3_0 = constructor_output_reg(ctx, expr2_0)?; - return Some(expr3_0); - } - &Opcode::Sload8 => { - // Rule at src/isa/s390x/lower.isle line 1271. - let expr0_0: Type = I8; - let expr1_0 = - constructor_lower_address(ctx, pattern5_2, pattern5_1, pattern5_3)?; - let expr2_0 = constructor_sext64_mem(ctx, expr0_0, &expr1_0)?; - let expr3_0 = constructor_output_reg(ctx, expr2_0)?; - return Some(expr3_0); - } - &Opcode::Uload16 => { - if let Some(()) = C::littleendian(ctx, pattern5_2) { - // Rule at src/isa/s390x/lower.isle line 1294. - let expr0_0 = constructor_lower_address( - ctx, pattern5_2, pattern5_1, pattern5_3, - )?; - let expr1_0 = constructor_loadrev16(ctx, &expr0_0)?; - let expr2_0: Type = I16; - let expr3_0 = constructor_zext64_reg(ctx, expr2_0, expr1_0)?; - let expr4_0 = constructor_output_reg(ctx, expr3_0)?; - return Some(expr4_0); - } - if let Some(()) = C::bigendian(ctx, pattern5_2) { - // Rule at src/isa/s390x/lower.isle line 1289. - let expr0_0: Type = I16; - let expr1_0 = constructor_lower_address( - ctx, pattern5_2, pattern5_1, pattern5_3, - )?; - let expr2_0 = constructor_zext64_mem(ctx, expr0_0, &expr1_0)?; - let expr3_0 = constructor_output_reg(ctx, expr2_0)?; - return Some(expr3_0); - } - } - &Opcode::Sload16 => { - if let Some(()) = C::littleendian(ctx, pattern5_2) { - // Rule at src/isa/s390x/lower.isle line 1319. - let expr0_0 = constructor_lower_address( - ctx, pattern5_2, pattern5_1, pattern5_3, - )?; - let expr1_0 = constructor_loadrev16(ctx, &expr0_0)?; - let expr2_0: Type = I16; - let expr3_0 = constructor_sext64_reg(ctx, expr2_0, expr1_0)?; - let expr4_0 = constructor_output_reg(ctx, expr3_0)?; - return Some(expr4_0); - } - if let Some(()) = C::bigendian(ctx, pattern5_2) { - // Rule at src/isa/s390x/lower.isle line 1314. - let expr0_0: Type = I16; - let expr1_0 = constructor_lower_address( - ctx, pattern5_2, pattern5_1, pattern5_3, - )?; - let expr2_0 = constructor_sext64_mem(ctx, expr0_0, &expr1_0)?; - let expr3_0 = constructor_output_reg(ctx, expr2_0)?; - return Some(expr3_0); - } - } - &Opcode::Uload32 => { - if let Some(()) = C::littleendian(ctx, pattern5_2) { - // Rule at src/isa/s390x/lower.isle line 1333. - let expr0_0 = constructor_lower_address( - ctx, pattern5_2, pattern5_1, pattern5_3, - )?; - let expr1_0 = constructor_loadrev32(ctx, &expr0_0)?; - let expr2_0: Type = I32; - let expr3_0 = constructor_zext64_reg(ctx, expr2_0, expr1_0)?; - let expr4_0 = constructor_output_reg(ctx, expr3_0)?; - return Some(expr4_0); - } - if let Some(()) = C::bigendian(ctx, pattern5_2) { - // Rule at src/isa/s390x/lower.isle line 1328. - let expr0_0: Type = I32; - let expr1_0 = constructor_lower_address( - ctx, pattern5_2, pattern5_1, pattern5_3, - )?; - let expr2_0 = constructor_zext64_mem(ctx, expr0_0, &expr1_0)?; - let expr3_0 = constructor_output_reg(ctx, expr2_0)?; - return Some(expr3_0); - } - } - &Opcode::Sload32 => { - if let Some(()) = C::littleendian(ctx, pattern5_2) { - // Rule at src/isa/s390x/lower.isle line 1347. - let expr0_0 = constructor_lower_address( - ctx, pattern5_2, pattern5_1, pattern5_3, - )?; - let expr1_0 = constructor_loadrev32(ctx, &expr0_0)?; - let expr2_0: Type = I32; - let expr3_0 = constructor_sext64_reg(ctx, expr2_0, expr1_0)?; - let expr4_0 = constructor_output_reg(ctx, expr3_0)?; - return Some(expr4_0); - } - if let Some(()) = C::bigendian(ctx, pattern5_2) { - // Rule at src/isa/s390x/lower.isle line 1342. - let expr0_0: Type = I32; - let expr1_0 = constructor_lower_address( - ctx, pattern5_2, pattern5_1, pattern5_3, - )?; - let expr2_0 = constructor_sext64_mem(ctx, expr0_0, &expr1_0)?; - let expr3_0 = constructor_output_reg(ctx, expr2_0)?; - return Some(expr3_0); - } - } - _ => {} - } - } - _ => {} - } - } - } - return None; -} - -// Generated as internal constructor for term lower_branch. -pub fn constructor_lower_branch( - ctx: &mut C, - arg0: Inst, - arg1: &VecMachLabel, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = C::inst_data(ctx, pattern0_0); - match &pattern1_0 { - &InstructionData::BranchTable { - opcode: ref pattern2_0, - arg: pattern2_1, - destination: pattern2_2, - table: pattern2_3, - } => { - if let &Opcode::BrTable = pattern2_0 { - let pattern4_0 = arg1; - // Rule at src/isa/s390x/lower.isle line 2083. - let expr0_0 = constructor_put_in_reg_zext64(ctx, pattern2_1)?; - let expr1_0: Type = I64; - let expr2_0 = C::vec_length_minus1(ctx, pattern4_0); - let expr3_0 = constructor_icmpu_uimm32(ctx, expr1_0, expr0_0, expr2_0)?; - let expr4_0 = IntCC::UnsignedGreaterThanOrEqual; - let expr5_0 = C::intcc_as_cond(ctx, &expr4_0); - let expr6_0 = constructor_bool(ctx, &expr3_0, &expr5_0)?; - let expr7_0: u8 = 0; - let expr8_0 = C::vec_element(ctx, pattern4_0, expr7_0); - let expr9_0 = constructor_oneway_cond_br_bool(ctx, &expr6_0, expr8_0)?; - let expr10_0 = constructor_side_effect(ctx, &expr9_0)?; - let expr11_0: Type = I64; - let expr12_0: u8 = 2; - let expr13_0 = constructor_lshl_imm(ctx, expr11_0, expr0_0, expr12_0)?; - let expr14_0 = constructor_jt_sequence(ctx, expr13_0, pattern4_0)?; - let expr15_0 = constructor_side_effect(ctx, &expr14_0)?; - return Some(expr15_0); - } - } - &InstructionData::Branch { - opcode: ref pattern2_0, - args: pattern2_1, - destination: pattern2_2, - } => { - match pattern2_0 { - &Opcode::Brz => { - let pattern4_0 = C::value_list_slice(ctx, pattern2_1); - if let Some((pattern5_0, pattern5_1)) = C::value_slice_unwrap(ctx, pattern4_0) { - let pattern6_0 = arg1; - // Rule at src/isa/s390x/lower.isle line 2116. - let expr0_0 = constructor_value_nonzero(ctx, pattern5_0)?; - let expr1_0 = constructor_invert_bool(ctx, &expr0_0)?; - let expr2_0: u8 = 0; - let expr3_0 = C::vec_element(ctx, pattern6_0, expr2_0); - let expr4_0: u8 = 1; - let expr5_0 = C::vec_element(ctx, pattern6_0, expr4_0); - let expr6_0 = constructor_cond_br_bool(ctx, &expr1_0, expr3_0, expr5_0)?; - let expr7_0 = constructor_side_effect(ctx, &expr6_0)?; - return Some(expr7_0); - } - } - &Opcode::Brnz => { - let pattern4_0 = C::value_list_slice(ctx, pattern2_1); - if let Some((pattern5_0, pattern5_1)) = C::value_slice_unwrap(ctx, pattern4_0) { - let pattern6_0 = arg1; - // Rule at src/isa/s390x/lower.isle line 2127. - let expr0_0 = constructor_value_nonzero(ctx, pattern5_0)?; - let expr1_0: u8 = 0; - let expr2_0 = C::vec_element(ctx, pattern6_0, expr1_0); - let expr3_0: u8 = 1; - let expr4_0 = C::vec_element(ctx, pattern6_0, expr3_0); - let expr5_0 = constructor_cond_br_bool(ctx, &expr0_0, expr2_0, expr4_0)?; - let expr6_0 = constructor_side_effect(ctx, &expr5_0)?; - return Some(expr6_0); - } - } - _ => {} - } - } - &InstructionData::Jump { - opcode: ref pattern2_0, - args: pattern2_1, - destination: pattern2_2, - } => { - if let &Opcode::Jump = pattern2_0 { - let pattern4_0 = C::value_list_slice(ctx, pattern2_1); - let pattern5_0 = arg1; - // Rule at src/isa/s390x/lower.isle line 2075. - let expr0_0: u8 = 0; - let expr1_0 = C::vec_element(ctx, pattern5_0, expr0_0); - let expr2_0 = constructor_jump_impl(ctx, expr1_0)?; - let expr3_0 = constructor_side_effect(ctx, &expr2_0)?; - return Some(expr3_0); - } - } - &InstructionData::BranchInt { - opcode: ref pattern2_0, - args: pattern2_1, - cond: ref pattern2_2, - destination: pattern2_3, - } => { - if let &Opcode::Brif = pattern2_0 { - let pattern4_0 = C::value_list_slice(ctx, pattern2_1); - if let Some((pattern5_0, pattern5_1)) = C::value_slice_unwrap(ctx, pattern4_0) { - if let Some(pattern6_0) = C::def_inst(ctx, pattern5_0) { - let pattern7_0 = C::inst_data(ctx, pattern6_0); - if let &InstructionData::Binary { - opcode: ref pattern8_0, - args: ref pattern8_1, - } = &pattern7_0 - { - if let &Opcode::Ifcmp = pattern8_0 { - let (pattern10_0, pattern10_1) = - C::unpack_value_array_2(ctx, pattern8_1); - let pattern11_0 = arg1; - // Rule at src/isa/s390x/lower.isle line 2138. - let expr0_0: bool = false; - let expr1_0 = constructor_icmp_val( - ctx, - expr0_0, - pattern2_2, - pattern10_0, - pattern10_1, - )?; - let expr2_0: u8 = 0; - let expr3_0 = C::vec_element(ctx, pattern11_0, expr2_0); - let expr4_0: u8 = 1; - let expr5_0 = C::vec_element(ctx, pattern11_0, expr4_0); - let expr6_0 = - constructor_cond_br_bool(ctx, &expr1_0, expr3_0, expr5_0)?; - let expr7_0 = constructor_side_effect(ctx, &expr6_0)?; - return Some(expr7_0); - } - } - } - } - } - } - _ => {} - } - return None; -} - -// Generated as internal constructor for term output_ifcout. -pub fn constructor_output_ifcout(ctx: &mut C, arg0: Reg) -> Option { - let pattern0_0 = arg0; - // Rule at src/isa/s390x/lower.isle line 154. - let expr0_0 = C::value_reg(ctx, pattern0_0); - let expr1_0 = C::value_regs_invalid(ctx); - let expr2_0 = C::output_pair(ctx, expr0_0, expr1_0); - return Some(expr2_0); -} - -// Generated as internal constructor for term zero_divisor_check_needed. -pub fn constructor_zero_divisor_check_needed(ctx: &mut C, arg0: Value) -> Option { - let pattern0_0 = arg0; - if let Some(pattern1_0) = C::i64_from_value(ctx, pattern0_0) { - let mut closure2 = || { - let expr0_0 = constructor_i64_nonzero(ctx, pattern1_0)?; - return Some(expr0_0); - }; - if let Some(pattern2_0) = closure2() { - // Rule at src/isa/s390x/lower.isle line 344. - let expr0_0: bool = false; - return Some(expr0_0); - } - } - let pattern1_0 = C::value_type(ctx, pattern0_0); - if let Some(()) = C::allow_div_traps(ctx, pattern1_0) { - // Rule at src/isa/s390x/lower.isle line 347. - let expr0_0: bool = false; - return Some(expr0_0); - } - // Rule at src/isa/s390x/lower.isle line 348. - let expr0_0: bool = true; - return Some(expr0_0); -} - -// Generated as internal constructor for term maybe_trap_if_zero_divisor. -pub fn constructor_maybe_trap_if_zero_divisor( - ctx: &mut C, - arg0: bool, - arg1: Type, - arg2: Reg, -) -> Option { - let pattern0_0 = arg0; - if pattern0_0 == true { - let pattern2_0 = arg1; - let pattern3_0 = arg2; - // Rule at src/isa/s390x/lower.isle line 354. - let expr0_0: i16 = 0; - let expr1_0 = IntCC::Equal; - let expr2_0 = C::intcc_as_cond(ctx, &expr1_0); - let expr3_0 = C::trap_code_division_by_zero(ctx); - let expr4_0 = constructor_icmps_simm16_and_trap( - ctx, pattern2_0, pattern3_0, expr0_0, &expr2_0, &expr3_0, - )?; - return Some(expr4_0); - } - if pattern0_0 == false { - let pattern2_0 = arg1; - let pattern3_0 = arg2; - // Rule at src/isa/s390x/lower.isle line 353. - let expr0_0 = C::invalid_reg(ctx); - return Some(expr0_0); - } - return None; -} - -// Generated as internal constructor for term div_overflow_check_needed. -pub fn constructor_div_overflow_check_needed(ctx: &mut C, arg0: Value) -> Option { - let pattern0_0 = arg0; - if let Some(pattern1_0) = C::i64_from_value(ctx, pattern0_0) { - let mut closure2 = || { - let expr0_0 = constructor_i64_not_neg1(ctx, pattern1_0)?; - return Some(expr0_0); - }; - if let Some(pattern2_0) = closure2() { - // Rule at src/isa/s390x/lower.isle line 427. - let expr0_0: bool = false; - return Some(expr0_0); - } - } - // Rule at src/isa/s390x/lower.isle line 430. - let expr0_0: bool = true; - return Some(expr0_0); -} - -// Generated as internal constructor for term maybe_trap_if_sdiv_overflow. -pub fn constructor_maybe_trap_if_sdiv_overflow( - ctx: &mut C, - arg0: bool, - arg1: Type, - arg2: Type, - arg3: &RegPair, - arg4: Reg, -) -> Option { - let pattern0_0 = arg0; - if pattern0_0 == true { - let pattern2_0 = arg1; - let pattern3_0 = arg2; - let pattern4_0 = arg3; - let pattern5_0 = arg4; - // Rule at src/isa/s390x/lower.isle line 443. - let expr0_0 = constructor_int_max(ctx, pattern3_0)?; - let expr1_0 = constructor_imm(ctx, pattern2_0, expr0_0)?; - let expr2_0 = constructor_regpair_lo(ctx, pattern4_0)?; - let expr3_0 = constructor_xor_reg(ctx, pattern2_0, expr1_0, expr2_0)?; - let expr4_0 = constructor_and_reg(ctx, pattern2_0, expr3_0, pattern5_0)?; - let expr5_0: i16 = -1; - let expr6_0 = IntCC::Equal; - let expr7_0 = C::intcc_as_cond(ctx, &expr6_0); - let expr8_0 = C::trap_code_integer_overflow(ctx); - let expr9_0 = constructor_icmps_simm16_and_trap( - ctx, pattern2_0, expr4_0, expr5_0, &expr7_0, &expr8_0, - )?; - return Some(expr9_0); - } - if pattern0_0 == false { - let pattern2_0 = arg1; - let pattern3_0 = arg2; - let pattern4_0 = arg3; - let pattern5_0 = arg4; - // Rule at src/isa/s390x/lower.isle line 442. - let expr0_0 = C::invalid_reg(ctx); - return Some(expr0_0); - } - return None; -} - -// Generated as internal constructor for term int_max. -pub fn constructor_int_max(ctx: &mut C, arg0: Type) -> Option { - let pattern0_0 = arg0; - if pattern0_0 == I8 { - // Rule at src/isa/s390x/lower.isle line 451. - let expr0_0: u64 = 127; - return Some(expr0_0); - } - if pattern0_0 == I16 { - // Rule at src/isa/s390x/lower.isle line 452. - let expr0_0: u64 = 32767; - return Some(expr0_0); - } - if pattern0_0 == I32 { - // Rule at src/isa/s390x/lower.isle line 453. - let expr0_0: u64 = 2147483647; - return Some(expr0_0); - } - if pattern0_0 == I64 { - // Rule at src/isa/s390x/lower.isle line 454. - let expr0_0: u64 = 9223372036854775807; - return Some(expr0_0); - } - return None; -} - -// Generated as internal constructor for term maybe_avoid_srem_overflow. -pub fn constructor_maybe_avoid_srem_overflow( - ctx: &mut C, - arg0: bool, - arg1: Type, - arg2: &RegPair, - arg3: Reg, -) -> Option { - let pattern0_0 = arg0; - if pattern0_0 == true { - let pattern2_0 = arg1; - if pattern2_0 == I32 { - let pattern4_0 = arg2; - let pattern5_0 = arg3; - // Rule at src/isa/s390x/lower.isle line 472. - return Some(pattern4_0.clone()); - } - if pattern2_0 == I64 { - let pattern4_0 = arg2; - let pattern5_0 = arg3; - // Rule at src/isa/s390x/lower.isle line 473. - let expr0_0: Type = I64; - let expr1_0: Type = I64; - let expr2_0: i16 = -1; - let expr3_0 = constructor_icmps_simm16(ctx, expr1_0, pattern5_0, expr2_0)?; - let expr4_0 = IntCC::Equal; - let expr5_0 = C::intcc_as_cond(ctx, &expr4_0); - let expr6_0: i16 = 0; - let expr7_0 = constructor_cmov_imm_regpair_lo( - ctx, expr0_0, &expr3_0, &expr5_0, expr6_0, pattern4_0, - )?; - return Some(expr7_0); - } - } - if pattern0_0 == false { - let pattern2_0 = arg1; - let pattern3_0 = arg2; - let pattern4_0 = arg3; - // Rule at src/isa/s390x/lower.isle line 471. - return Some(pattern3_0.clone()); - } - return None; -} - -// Generated as internal constructor for term cast_bool. -pub fn constructor_cast_bool(ctx: &mut C, arg0: Type, arg1: Value) -> Option { - let pattern0_0 = arg0; - if pattern0_0 == B1 { - let pattern2_0 = arg1; - let pattern3_0 = C::value_type(ctx, pattern2_0); - if pattern3_0 == B1 { - // Rule at src/isa/s390x/lower.isle line 770. - let expr0_0 = C::put_in_reg(ctx, pattern2_0); - return Some(expr0_0); - } - if pattern3_0 == B8 { - // Rule at src/isa/s390x/lower.isle line 771. - let expr0_0 = C::put_in_reg(ctx, pattern2_0); - return Some(expr0_0); - } - } - if pattern0_0 == B8 { - let pattern2_0 = arg1; - let pattern3_0 = C::value_type(ctx, pattern2_0); - if pattern3_0 == B8 { - // Rule at src/isa/s390x/lower.isle line 772. - let expr0_0 = C::put_in_reg(ctx, pattern2_0); - return Some(expr0_0); - } - } - if pattern0_0 == I8 { - let pattern2_0 = arg1; - let pattern3_0 = C::value_type(ctx, pattern2_0); - if pattern3_0 == B8 { - // Rule at src/isa/s390x/lower.isle line 773. - let expr0_0 = C::put_in_reg(ctx, pattern2_0); - return Some(expr0_0); - } - } - if let Some(pattern1_0) = C::fits_in_16(ctx, pattern0_0) { - let pattern2_0 = arg1; - let pattern3_0 = C::value_type(ctx, pattern2_0); - if pattern3_0 == B16 { - // Rule at src/isa/s390x/lower.isle line 774. - let expr0_0 = C::put_in_reg(ctx, pattern2_0); - return Some(expr0_0); - } - } - if let Some(pattern1_0) = C::fits_in_32(ctx, pattern0_0) { - let pattern2_0 = arg1; - let pattern3_0 = C::value_type(ctx, pattern2_0); - if pattern3_0 == B32 { - // Rule at src/isa/s390x/lower.isle line 775. - let expr0_0 = C::put_in_reg(ctx, pattern2_0); - return Some(expr0_0); - } - } - if let Some(pattern1_0) = C::fits_in_64(ctx, pattern0_0) { - let pattern2_0 = arg1; - let pattern3_0 = C::value_type(ctx, pattern2_0); - if pattern3_0 == B64 { - // Rule at src/isa/s390x/lower.isle line 776. - let expr0_0 = C::put_in_reg(ctx, pattern2_0); - return Some(expr0_0); - } - } - if let Some(pattern1_0) = C::gpr32_ty(ctx, pattern0_0) { - let pattern2_0 = arg1; - let pattern3_0 = C::value_type(ctx, pattern2_0); - if pattern3_0 == B1 { - // Rule at src/isa/s390x/lower.isle line 779. - let expr0_0: Type = I32; - let expr1_0: Type = I32; - let expr2_0 = C::put_in_reg(ctx, pattern2_0); - let expr3_0: u8 = 31; - let expr4_0 = constructor_lshl_imm(ctx, expr1_0, expr2_0, expr3_0)?; - let expr5_0: u8 = 31; - let expr6_0 = constructor_ashr_imm(ctx, expr0_0, expr4_0, expr5_0)?; - return Some(expr6_0); - } - if pattern3_0 == B8 { - // Rule at src/isa/s390x/lower.isle line 785. - let expr0_0: Type = I8; - let expr1_0 = C::put_in_reg(ctx, pattern2_0); - let expr2_0 = constructor_sext32_reg(ctx, expr0_0, expr1_0)?; - return Some(expr2_0); - } - if pattern3_0 == B16 { - // Rule at src/isa/s390x/lower.isle line 787. - let expr0_0: Type = I16; - let expr1_0 = C::put_in_reg(ctx, pattern2_0); - let expr2_0 = constructor_sext32_reg(ctx, expr0_0, expr1_0)?; - return Some(expr2_0); - } - } - if let Some(pattern1_0) = C::gpr64_ty(ctx, pattern0_0) { - let pattern2_0 = arg1; - let pattern3_0 = C::value_type(ctx, pattern2_0); - if pattern3_0 == B1 { - // Rule at src/isa/s390x/lower.isle line 781. - let expr0_0: Type = I64; - let expr1_0: Type = I64; - let expr2_0 = C::put_in_reg(ctx, pattern2_0); - let expr3_0: u8 = 63; - let expr4_0 = constructor_lshl_imm(ctx, expr1_0, expr2_0, expr3_0)?; - let expr5_0: u8 = 63; - let expr6_0 = constructor_ashr_imm(ctx, expr0_0, expr4_0, expr5_0)?; - return Some(expr6_0); - } - if pattern3_0 == B8 { - // Rule at src/isa/s390x/lower.isle line 789. - let expr0_0: Type = I8; - let expr1_0 = C::put_in_reg(ctx, pattern2_0); - let expr2_0 = constructor_sext64_reg(ctx, expr0_0, expr1_0)?; - return Some(expr2_0); - } - if pattern3_0 == B16 { - // Rule at src/isa/s390x/lower.isle line 791. - let expr0_0: Type = I16; - let expr1_0 = C::put_in_reg(ctx, pattern2_0); - let expr2_0 = constructor_sext64_reg(ctx, expr0_0, expr1_0)?; - return Some(expr2_0); - } - if pattern3_0 == B32 { - // Rule at src/isa/s390x/lower.isle line 793. - let expr0_0: Type = I32; - let expr1_0 = C::put_in_reg(ctx, pattern2_0); - let expr2_0 = constructor_sext64_reg(ctx, expr0_0, expr1_0)?; - return Some(expr2_0); - } - } - return None; -} - -// Generated as internal constructor for term clz_offset. -pub fn constructor_clz_offset(ctx: &mut C, arg0: Type, arg1: Reg) -> Option { - let pattern0_0 = arg0; - if pattern0_0 == I8 { - let pattern2_0 = arg1; - // Rule at src/isa/s390x/lower.isle line 818. - let expr0_0: Type = I8; - let expr1_0: i16 = -56; - let expr2_0 = constructor_add_simm16(ctx, expr0_0, pattern2_0, expr1_0)?; - return Some(expr2_0); - } - if pattern0_0 == I16 { - let pattern2_0 = arg1; - // Rule at src/isa/s390x/lower.isle line 819. - let expr0_0: Type = I16; - let expr1_0: i16 = -48; - let expr2_0 = constructor_add_simm16(ctx, expr0_0, pattern2_0, expr1_0)?; - return Some(expr2_0); - } - if pattern0_0 == I32 { - let pattern2_0 = arg1; - // Rule at src/isa/s390x/lower.isle line 820. - let expr0_0: Type = I32; - let expr1_0: i16 = -32; - let expr2_0 = constructor_add_simm16(ctx, expr0_0, pattern2_0, expr1_0)?; - return Some(expr2_0); - } - if pattern0_0 == I64 { - let pattern2_0 = arg1; - // Rule at src/isa/s390x/lower.isle line 821. - let expr0_0: Type = I64; - let expr1_0 = constructor_copy_reg(ctx, expr0_0, pattern2_0)?; - return Some(expr1_0); - } - return None; -} - -// Generated as internal constructor for term ctz_guardbit. -pub fn constructor_ctz_guardbit(ctx: &mut C, arg0: Type) -> Option { - let pattern0_0 = arg0; - if pattern0_0 == I8 { - // Rule at src/isa/s390x/lower.isle line 870. - let expr0_0: u16 = 256; - let expr1_0: u8 = 0; - let expr2_0 = C::uimm16shifted(ctx, expr0_0, expr1_0); - return Some(expr2_0); - } - if pattern0_0 == I16 { - // Rule at src/isa/s390x/lower.isle line 871. - let expr0_0: u16 = 1; - let expr1_0: u8 = 16; - let expr2_0 = C::uimm16shifted(ctx, expr0_0, expr1_0); - return Some(expr2_0); - } - if pattern0_0 == I32 { - // Rule at src/isa/s390x/lower.isle line 872. - let expr0_0: u16 = 1; - let expr1_0: u8 = 32; - let expr2_0 = C::uimm16shifted(ctx, expr0_0, expr1_0); - return Some(expr2_0); - } - return None; -} - -// Generated as internal constructor for term istore8_impl. -pub fn constructor_istore8_impl( - ctx: &mut C, - arg0: MemFlags, - arg1: Value, - arg2: Value, - arg3: Offset32, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - if let Some(pattern2_0) = C::u8_from_value(ctx, pattern1_0) { - let pattern3_0 = arg2; - let pattern4_0 = arg3; - // Rule at src/isa/s390x/lower.isle line 1429. - let expr0_0 = constructor_lower_address(ctx, pattern0_0, pattern3_0, pattern4_0)?; - let expr1_0 = constructor_store8_imm(ctx, pattern2_0, &expr0_0)?; - return Some(expr1_0); - } - let pattern2_0 = arg2; - let pattern3_0 = arg3; - // Rule at src/isa/s390x/lower.isle line 1425. - let expr0_0 = C::put_in_reg(ctx, pattern1_0); - let expr1_0 = constructor_lower_address(ctx, pattern0_0, pattern2_0, pattern3_0)?; - let expr2_0 = constructor_store8(ctx, expr0_0, &expr1_0)?; - return Some(expr2_0); -} - -// Generated as internal constructor for term istore16_impl. -pub fn constructor_istore16_impl( - ctx: &mut C, - arg0: MemFlags, - arg1: Value, - arg2: Value, - arg3: Offset32, -) -> Option { - let pattern0_0 = arg0; - if let Some(()) = C::littleendian(ctx, pattern0_0) { - let pattern2_0 = arg1; - if let Some(pattern3_0) = C::i16_from_swapped_value(ctx, pattern2_0) { - let pattern4_0 = arg2; - let pattern5_0 = arg3; - // Rule at src/isa/s390x/lower.isle line 1455. - let expr0_0 = constructor_lower_address(ctx, pattern0_0, pattern4_0, pattern5_0)?; - let expr1_0 = constructor_store16_imm(ctx, pattern3_0, &expr0_0)?; - return Some(expr1_0); - } - let pattern3_0 = arg2; - let pattern4_0 = arg3; - // Rule at src/isa/s390x/lower.isle line 1447. - let expr0_0 = C::put_in_reg(ctx, pattern2_0); - let expr1_0 = constructor_lower_address(ctx, pattern0_0, pattern3_0, pattern4_0)?; - let expr2_0 = constructor_storerev16(ctx, expr0_0, &expr1_0)?; - return Some(expr2_0); - } - if let Some(()) = C::bigendian(ctx, pattern0_0) { - let pattern2_0 = arg1; - if let Some(pattern3_0) = C::i16_from_value(ctx, pattern2_0) { - let pattern4_0 = arg2; - let pattern5_0 = arg3; - // Rule at src/isa/s390x/lower.isle line 1451. - let expr0_0 = constructor_lower_address(ctx, pattern0_0, pattern4_0, pattern5_0)?; - let expr1_0 = constructor_store16_imm(ctx, pattern3_0, &expr0_0)?; - return Some(expr1_0); - } - let pattern3_0 = arg2; - let pattern4_0 = arg3; - // Rule at src/isa/s390x/lower.isle line 1443. - let expr0_0 = C::put_in_reg(ctx, pattern2_0); - let expr1_0 = constructor_lower_address(ctx, pattern0_0, pattern3_0, pattern4_0)?; - let expr2_0 = constructor_store16(ctx, expr0_0, &expr1_0)?; - return Some(expr2_0); - } - return None; -} - -// Generated as internal constructor for term istore32_impl. -pub fn constructor_istore32_impl( - ctx: &mut C, - arg0: MemFlags, - arg1: Value, - arg2: Value, - arg3: Offset32, -) -> Option { - let pattern0_0 = arg0; - if let Some(()) = C::littleendian(ctx, pattern0_0) { - let pattern2_0 = arg1; - let pattern3_0 = arg2; - let pattern4_0 = arg3; - // Rule at src/isa/s390x/lower.isle line 1477. - let expr0_0 = C::put_in_reg(ctx, pattern2_0); - let expr1_0 = constructor_lower_address(ctx, pattern0_0, pattern3_0, pattern4_0)?; - let expr2_0 = constructor_storerev32(ctx, expr0_0, &expr1_0)?; - return Some(expr2_0); - } - if let Some(()) = C::bigendian(ctx, pattern0_0) { - let pattern2_0 = arg1; - if let Some(pattern3_0) = C::i16_from_value(ctx, pattern2_0) { - let pattern4_0 = arg2; - let pattern5_0 = arg3; - // Rule at src/isa/s390x/lower.isle line 1473. - let expr0_0 = constructor_lower_address(ctx, pattern0_0, pattern4_0, pattern5_0)?; - let expr1_0 = constructor_store32_simm16(ctx, pattern3_0, &expr0_0)?; - return Some(expr1_0); - } - let pattern3_0 = arg2; - let pattern4_0 = arg3; - // Rule at src/isa/s390x/lower.isle line 1469. - let expr0_0 = C::put_in_reg(ctx, pattern2_0); - let expr1_0 = constructor_lower_address(ctx, pattern0_0, pattern3_0, pattern4_0)?; - let expr2_0 = constructor_store32(ctx, expr0_0, &expr1_0)?; - return Some(expr2_0); - } - return None; -} - -// Generated as internal constructor for term istore64_impl. -pub fn constructor_istore64_impl( - ctx: &mut C, - arg0: MemFlags, - arg1: Value, - arg2: Value, - arg3: Offset32, -) -> Option { - let pattern0_0 = arg0; - if let Some(()) = C::littleendian(ctx, pattern0_0) { - let pattern2_0 = arg1; - let pattern3_0 = arg2; - let pattern4_0 = arg3; - // Rule at src/isa/s390x/lower.isle line 1495. - let expr0_0 = C::put_in_reg(ctx, pattern2_0); - let expr1_0 = constructor_lower_address(ctx, pattern0_0, pattern3_0, pattern4_0)?; - let expr2_0 = constructor_storerev64(ctx, expr0_0, &expr1_0)?; - return Some(expr2_0); - } - if let Some(()) = C::bigendian(ctx, pattern0_0) { - let pattern2_0 = arg1; - if let Some(pattern3_0) = C::i16_from_value(ctx, pattern2_0) { - let pattern4_0 = arg2; - let pattern5_0 = arg3; - // Rule at src/isa/s390x/lower.isle line 1491. - let expr0_0 = constructor_lower_address(ctx, pattern0_0, pattern4_0, pattern5_0)?; - let expr1_0 = constructor_store64_simm16(ctx, pattern3_0, &expr0_0)?; - return Some(expr1_0); - } - let pattern3_0 = arg2; - let pattern4_0 = arg3; - // Rule at src/isa/s390x/lower.isle line 1487. - let expr0_0 = C::put_in_reg(ctx, pattern2_0); - let expr1_0 = constructor_lower_address(ctx, pattern0_0, pattern3_0, pattern4_0)?; - let expr2_0 = constructor_store64(ctx, expr0_0, &expr1_0)?; - return Some(expr2_0); - } - return None; -} - -// Generated as internal constructor for term atomic_rmw_body. -pub fn constructor_atomic_rmw_body( - ctx: &mut C, - arg0: &VecMInstBuilder, - arg1: Type, - arg2: MemFlags, - arg3: &AtomicRmwOp, - arg4: WritableReg, - arg5: Reg, - arg6: Reg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - if let Some(()) = C::mie2_enabled(ctx, pattern1_0) { - if let Some(pattern3_0) = C::ty_32_or_64(ctx, pattern1_0) { - let pattern4_0 = arg2; - if let Some(()) = C::littleendian(ctx, pattern4_0) { - let pattern6_0 = arg3; - if let &AtomicRmwOp::Nand = pattern6_0 { - let pattern8_0 = arg4; - let pattern9_0 = arg5; - let pattern10_0 = arg6; - // Rule at src/isa/s390x/lower.isle line 1603. - let expr0_0 = constructor_aluop_and_not(ctx, pattern3_0)?; - let expr1_0 = constructor_bswap_reg(ctx, pattern3_0, pattern10_0)?; - let expr2_0 = constructor_push_alu_reg( - ctx, pattern0_0, &expr0_0, pattern8_0, pattern9_0, expr1_0, - )?; - return Some(expr2_0); - } - } - if let Some(()) = C::bigendian(ctx, pattern4_0) { - let pattern6_0 = arg3; - if let &AtomicRmwOp::Nand = pattern6_0 { - let pattern8_0 = arg4; - let pattern9_0 = arg5; - let pattern10_0 = arg6; - // Rule at src/isa/s390x/lower.isle line 1600. - let expr0_0 = constructor_aluop_and_not(ctx, pattern3_0)?; - let expr1_0 = constructor_push_alu_reg( - ctx, - pattern0_0, - &expr0_0, - pattern8_0, - pattern9_0, - pattern10_0, - )?; - return Some(expr1_0); - } - } - } - } - if let Some(()) = C::mie2_disabled(ctx, pattern1_0) { - if let Some(pattern3_0) = C::ty_32_or_64(ctx, pattern1_0) { - let pattern4_0 = arg2; - if let Some(()) = C::littleendian(ctx, pattern4_0) { - let pattern6_0 = arg3; - if let &AtomicRmwOp::Nand = pattern6_0 { - let pattern8_0 = arg4; - let pattern9_0 = arg5; - let pattern10_0 = arg6; - // Rule at src/isa/s390x/lower.isle line 1610. - let expr0_0 = constructor_aluop_and(ctx, pattern3_0)?; - let expr1_0 = constructor_bswap_reg(ctx, pattern3_0, pattern10_0)?; - let expr2_0 = constructor_push_alu_reg( - ctx, pattern0_0, &expr0_0, pattern8_0, pattern9_0, expr1_0, - )?; - let expr3_0 = - constructor_push_not_reg(ctx, pattern0_0, pattern3_0, pattern8_0, expr2_0)?; - return Some(expr3_0); - } - } - if let Some(()) = C::bigendian(ctx, pattern4_0) { - let pattern6_0 = arg3; - if let &AtomicRmwOp::Nand = pattern6_0 { - let pattern8_0 = arg4; - let pattern9_0 = arg5; - let pattern10_0 = arg6; - // Rule at src/isa/s390x/lower.isle line 1606. - let expr0_0 = constructor_aluop_and(ctx, pattern3_0)?; - let expr1_0 = constructor_push_alu_reg( - ctx, - pattern0_0, - &expr0_0, - pattern8_0, - pattern9_0, - pattern10_0, - )?; - let expr2_0 = - constructor_push_not_reg(ctx, pattern0_0, pattern3_0, pattern8_0, expr1_0)?; - return Some(expr2_0); - } - } - } - } - if let Some(pattern2_0) = C::ty_32_or_64(ctx, pattern1_0) { - let pattern3_0 = arg2; - if let Some(()) = C::littleendian(ctx, pattern3_0) { - let pattern5_0 = arg3; - if let &AtomicRmwOp::Xchg = pattern5_0 { - let pattern7_0 = arg4; - let pattern8_0 = arg5; - let pattern9_0 = arg6; - // Rule at src/isa/s390x/lower.isle line 1592. - let expr0_0 = constructor_bswap_reg(ctx, pattern2_0, pattern9_0)?; - return Some(expr0_0); - } - } - if let Some(()) = C::bigendian(ctx, pattern3_0) { - let pattern5_0 = arg3; - if let &AtomicRmwOp::Xchg = pattern5_0 { - let pattern7_0 = arg4; - let pattern8_0 = arg5; - let pattern9_0 = arg6; - // Rule at src/isa/s390x/lower.isle line 1589. - return Some(pattern9_0); - } - } - } - if let Some(pattern2_0) = C::ty_8_or_16(ctx, pattern1_0) { - let pattern3_0 = arg2; - let pattern4_0 = arg3; - match pattern4_0 { - &AtomicRmwOp::And => { - let pattern6_0 = arg4; - let pattern7_0 = arg5; - let pattern8_0 = arg6; - // Rule at src/isa/s390x/lower.isle line 1620. - let expr0_0 = RxSBGOp::And; - let expr1_0 = constructor_atomic_rmw_body_rxsbg( - ctx, pattern0_0, pattern2_0, pattern3_0, &expr0_0, pattern6_0, pattern7_0, - pattern8_0, - )?; - return Some(expr1_0); - } - &AtomicRmwOp::Nand => { - let pattern6_0 = arg4; - let pattern7_0 = arg5; - let pattern8_0 = arg6; - // Rule at src/isa/s390x/lower.isle line 1626. - let expr0_0 = RxSBGOp::And; - let expr1_0 = constructor_atomic_rmw_body_rxsbg( - ctx, pattern0_0, pattern2_0, pattern3_0, &expr0_0, pattern6_0, pattern7_0, - pattern8_0, - )?; - let expr2_0 = constructor_atomic_rmw_body_invert( - ctx, pattern0_0, pattern2_0, pattern3_0, pattern6_0, expr1_0, - )?; - return Some(expr2_0); - } - &AtomicRmwOp::Or => { - let pattern6_0 = arg4; - let pattern7_0 = arg5; - let pattern8_0 = arg6; - // Rule at src/isa/s390x/lower.isle line 1622. - let expr0_0 = RxSBGOp::Or; - let expr1_0 = constructor_atomic_rmw_body_rxsbg( - ctx, pattern0_0, pattern2_0, pattern3_0, &expr0_0, pattern6_0, pattern7_0, - pattern8_0, - )?; - return Some(expr1_0); - } - &AtomicRmwOp::Xchg => { - let pattern6_0 = arg4; - let pattern7_0 = arg5; - let pattern8_0 = arg6; - // Rule at src/isa/s390x/lower.isle line 1618. - let expr0_0 = RxSBGOp::Insert; - let expr1_0 = constructor_atomic_rmw_body_rxsbg( - ctx, pattern0_0, pattern2_0, pattern3_0, &expr0_0, pattern6_0, pattern7_0, - pattern8_0, - )?; - return Some(expr1_0); - } - &AtomicRmwOp::Xor => { - let pattern6_0 = arg4; - let pattern7_0 = arg5; - let pattern8_0 = arg6; - // Rule at src/isa/s390x/lower.isle line 1624. - let expr0_0 = RxSBGOp::Xor; - let expr1_0 = constructor_atomic_rmw_body_rxsbg( - ctx, pattern0_0, pattern2_0, pattern3_0, &expr0_0, pattern6_0, pattern7_0, - pattern8_0, - )?; - return Some(expr1_0); - } - _ => {} - } - } - let pattern2_0 = arg2; - let pattern3_0 = arg3; - match pattern3_0 { - &AtomicRmwOp::Add => { - let pattern5_0 = arg4; - let pattern6_0 = arg5; - let pattern7_0 = arg6; - // Rule at src/isa/s390x/lower.isle line 1658. - let expr0_0 = constructor_ty_ext32(ctx, pattern1_0)?; - let expr1_0 = constructor_aluop_add(ctx, expr0_0)?; - let expr2_0 = constructor_atomic_rmw_body_addsub( - ctx, pattern0_0, pattern1_0, pattern2_0, &expr1_0, pattern5_0, pattern6_0, - pattern7_0, - )?; - return Some(expr2_0); - } - &AtomicRmwOp::Smax => { - let pattern5_0 = arg4; - let pattern6_0 = arg5; - let pattern7_0 = arg6; - // Rule at src/isa/s390x/lower.isle line 1699. - let expr0_0 = constructor_ty_ext32(ctx, pattern1_0)?; - let expr1_0 = constructor_cmpop_cmps(ctx, expr0_0)?; - let expr2_0 = IntCC::SignedGreaterThan; - let expr3_0 = C::intcc_as_cond(ctx, &expr2_0); - let expr4_0 = constructor_atomic_rmw_body_minmax( - ctx, pattern0_0, pattern1_0, pattern2_0, &expr1_0, &expr3_0, pattern5_0, - pattern6_0, pattern7_0, - )?; - return Some(expr4_0); - } - &AtomicRmwOp::Smin => { - let pattern5_0 = arg4; - let pattern6_0 = arg5; - let pattern7_0 = arg6; - // Rule at src/isa/s390x/lower.isle line 1696. - let expr0_0 = constructor_ty_ext32(ctx, pattern1_0)?; - let expr1_0 = constructor_cmpop_cmps(ctx, expr0_0)?; - let expr2_0 = IntCC::SignedLessThan; - let expr3_0 = C::intcc_as_cond(ctx, &expr2_0); - let expr4_0 = constructor_atomic_rmw_body_minmax( - ctx, pattern0_0, pattern1_0, pattern2_0, &expr1_0, &expr3_0, pattern5_0, - pattern6_0, pattern7_0, - )?; - return Some(expr4_0); - } - &AtomicRmwOp::Sub => { - let pattern5_0 = arg4; - let pattern6_0 = arg5; - let pattern7_0 = arg6; - // Rule at src/isa/s390x/lower.isle line 1660. - let expr0_0 = constructor_ty_ext32(ctx, pattern1_0)?; - let expr1_0 = constructor_aluop_sub(ctx, expr0_0)?; - let expr2_0 = constructor_atomic_rmw_body_addsub( - ctx, pattern0_0, pattern1_0, pattern2_0, &expr1_0, pattern5_0, pattern6_0, - pattern7_0, - )?; - return Some(expr2_0); - } - &AtomicRmwOp::Umax => { - let pattern5_0 = arg4; - let pattern6_0 = arg5; - let pattern7_0 = arg6; - // Rule at src/isa/s390x/lower.isle line 1705. - let expr0_0 = constructor_ty_ext32(ctx, pattern1_0)?; - let expr1_0 = constructor_cmpop_cmpu(ctx, expr0_0)?; - let expr2_0 = IntCC::UnsignedGreaterThan; - let expr3_0 = C::intcc_as_cond(ctx, &expr2_0); - let expr4_0 = constructor_atomic_rmw_body_minmax( - ctx, pattern0_0, pattern1_0, pattern2_0, &expr1_0, &expr3_0, pattern5_0, - pattern6_0, pattern7_0, - )?; - return Some(expr4_0); - } - &AtomicRmwOp::Umin => { - let pattern5_0 = arg4; - let pattern6_0 = arg5; - let pattern7_0 = arg6; - // Rule at src/isa/s390x/lower.isle line 1702. - let expr0_0 = constructor_ty_ext32(ctx, pattern1_0)?; - let expr1_0 = constructor_cmpop_cmpu(ctx, expr0_0)?; - let expr2_0 = IntCC::UnsignedLessThan; - let expr3_0 = C::intcc_as_cond(ctx, &expr2_0); - let expr4_0 = constructor_atomic_rmw_body_minmax( - ctx, pattern0_0, pattern1_0, pattern2_0, &expr1_0, &expr3_0, pattern5_0, - pattern6_0, pattern7_0, - )?; - return Some(expr4_0); - } - _ => {} - } - return None; -} - -// Generated as internal constructor for term atomic_rmw_body_rxsbg. -pub fn constructor_atomic_rmw_body_rxsbg( - ctx: &mut C, - arg0: &VecMInstBuilder, - arg1: Type, - arg2: MemFlags, - arg3: &RxSBGOp, - arg4: WritableReg, - arg5: Reg, - arg6: Reg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - if pattern1_0 == I8 { - let pattern3_0 = arg2; - let pattern4_0 = arg3; - let pattern5_0 = arg4; - let pattern6_0 = arg5; - let pattern7_0 = arg6; - // Rule at src/isa/s390x/lower.isle line 1634. - let expr0_0: u8 = 32; - let expr1_0: u8 = 40; - let expr2_0: i8 = 24; - let expr3_0 = constructor_push_rxsbg( - ctx, pattern0_0, pattern4_0, pattern5_0, pattern6_0, pattern7_0, expr0_0, expr1_0, - expr2_0, - )?; - return Some(expr3_0); - } - if pattern1_0 == I16 { - let pattern3_0 = arg2; - if let Some(()) = C::littleendian(ctx, pattern3_0) { - let pattern5_0 = arg3; - let pattern6_0 = arg4; - let pattern7_0 = arg5; - let pattern8_0 = arg6; - // Rule at src/isa/s390x/lower.isle line 1642. - let expr0_0: Type = I32; - let expr1_0 = constructor_bswap_reg(ctx, expr0_0, pattern8_0)?; - let expr2_0: u8 = 48; - let expr3_0: u8 = 64; - let expr4_0: i8 = -16; - let expr5_0 = constructor_push_rxsbg( - ctx, pattern0_0, pattern5_0, pattern6_0, pattern7_0, expr1_0, expr2_0, expr3_0, - expr4_0, - )?; - return Some(expr5_0); - } - if let Some(()) = C::bigendian(ctx, pattern3_0) { - let pattern5_0 = arg3; - let pattern6_0 = arg4; - let pattern7_0 = arg5; - let pattern8_0 = arg6; - // Rule at src/isa/s390x/lower.isle line 1638. - let expr0_0: u8 = 32; - let expr1_0: u8 = 48; - let expr2_0: i8 = 16; - let expr3_0 = constructor_push_rxsbg( - ctx, pattern0_0, pattern5_0, pattern6_0, pattern7_0, pattern8_0, expr0_0, expr1_0, - expr2_0, - )?; - return Some(expr3_0); - } - } - return None; -} - -// Generated as internal constructor for term atomic_rmw_body_invert. -pub fn constructor_atomic_rmw_body_invert( - ctx: &mut C, - arg0: &VecMInstBuilder, - arg1: Type, - arg2: MemFlags, - arg3: WritableReg, - arg4: Reg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - if pattern1_0 == I8 { - let pattern3_0 = arg2; - let pattern4_0 = arg3; - let pattern5_0 = arg4; - // Rule at src/isa/s390x/lower.isle line 1648. - let expr0_0: Type = I32; - let expr1_0: u32 = 4278190080; - let expr2_0: u8 = 0; - let expr3_0 = C::uimm32shifted(ctx, expr1_0, expr2_0); - let expr4_0 = constructor_push_xor_uimm32shifted( - ctx, pattern0_0, expr0_0, pattern4_0, pattern5_0, expr3_0, - )?; - return Some(expr4_0); - } - if pattern1_0 == I16 { - let pattern3_0 = arg2; - if let Some(()) = C::littleendian(ctx, pattern3_0) { - let pattern5_0 = arg3; - let pattern6_0 = arg4; - // Rule at src/isa/s390x/lower.isle line 1654. - let expr0_0: Type = I32; - let expr1_0: u32 = 65535; - let expr2_0: u8 = 0; - let expr3_0 = C::uimm32shifted(ctx, expr1_0, expr2_0); - let expr4_0 = constructor_push_xor_uimm32shifted( - ctx, pattern0_0, expr0_0, pattern5_0, pattern6_0, expr3_0, - )?; - return Some(expr4_0); - } - if let Some(()) = C::bigendian(ctx, pattern3_0) { - let pattern5_0 = arg3; - let pattern6_0 = arg4; - // Rule at src/isa/s390x/lower.isle line 1651. - let expr0_0: Type = I32; - let expr1_0: u32 = 4294901760; - let expr2_0: u8 = 0; - let expr3_0 = C::uimm32shifted(ctx, expr1_0, expr2_0); - let expr4_0 = constructor_push_xor_uimm32shifted( - ctx, pattern0_0, expr0_0, pattern5_0, pattern6_0, expr3_0, - )?; - return Some(expr4_0); - } - } - return None; -} - -// Generated as internal constructor for term atomic_rmw_body_addsub. -pub fn constructor_atomic_rmw_body_addsub( - ctx: &mut C, - arg0: &VecMInstBuilder, - arg1: Type, - arg2: MemFlags, - arg3: &ALUOp, - arg4: WritableReg, - arg5: Reg, - arg6: Reg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - if pattern1_0 == I8 { - let pattern3_0 = arg2; - let pattern4_0 = arg3; - let pattern5_0 = arg4; - let pattern6_0 = arg5; - let pattern7_0 = arg6; - // Rule at src/isa/s390x/lower.isle line 1677. - let expr0_0: Type = I32; - let expr1_0: u8 = 24; - let expr2_0 = constructor_lshl_imm(ctx, expr0_0, pattern7_0, expr1_0)?; - let expr3_0 = - constructor_push_alu_reg(ctx, pattern0_0, pattern4_0, pattern5_0, pattern6_0, expr2_0)?; - return Some(expr3_0); - } - if pattern1_0 == I16 { - let pattern3_0 = arg2; - if let Some(()) = C::littleendian(ctx, pattern3_0) { - let pattern5_0 = arg3; - let pattern6_0 = arg4; - let pattern7_0 = arg5; - let pattern8_0 = arg6; - // Rule at src/isa/s390x/lower.isle line 1689. - let expr0_0: Type = I32; - let expr1_0: u8 = 16; - let expr2_0 = constructor_lshl_imm(ctx, expr0_0, pattern8_0, expr1_0)?; - let expr3_0: Type = I32; - let expr4_0 = - constructor_push_bswap_reg(ctx, pattern0_0, expr3_0, pattern6_0, pattern7_0)?; - let expr5_0 = constructor_push_alu_reg( - ctx, pattern0_0, pattern5_0, pattern6_0, expr4_0, expr2_0, - )?; - let expr6_0: Type = I32; - let expr7_0 = - constructor_push_bswap_reg(ctx, pattern0_0, expr6_0, pattern6_0, expr5_0)?; - return Some(expr7_0); - } - if let Some(()) = C::bigendian(ctx, pattern3_0) { - let pattern5_0 = arg3; - let pattern6_0 = arg4; - let pattern7_0 = arg5; - let pattern8_0 = arg6; - // Rule at src/isa/s390x/lower.isle line 1681. - let expr0_0: Type = I32; - let expr1_0: u8 = 16; - let expr2_0 = constructor_lshl_imm(ctx, expr0_0, pattern8_0, expr1_0)?; - let expr3_0 = constructor_push_alu_reg( - ctx, pattern0_0, pattern5_0, pattern6_0, pattern7_0, expr2_0, - )?; - return Some(expr3_0); - } - } - if let Some(pattern2_0) = C::ty_32_or_64(ctx, pattern1_0) { - let pattern3_0 = arg2; - if let Some(()) = C::littleendian(ctx, pattern3_0) { - let pattern5_0 = arg3; - let pattern6_0 = arg4; - let pattern7_0 = arg5; - let pattern8_0 = arg6; - // Rule at src/isa/s390x/lower.isle line 1671. - let expr0_0 = - constructor_push_bswap_reg(ctx, pattern0_0, pattern2_0, pattern6_0, pattern7_0)?; - let expr1_0 = constructor_push_alu_reg( - ctx, pattern0_0, pattern5_0, pattern6_0, expr0_0, pattern8_0, - )?; - let expr2_0 = - constructor_push_bswap_reg(ctx, pattern0_0, pattern2_0, pattern6_0, expr1_0)?; - return Some(expr2_0); - } - if let Some(()) = C::bigendian(ctx, pattern3_0) { - let pattern5_0 = arg3; - let pattern6_0 = arg4; - let pattern7_0 = arg5; - let pattern8_0 = arg6; - // Rule at src/isa/s390x/lower.isle line 1667. - let expr0_0 = constructor_push_alu_reg( - ctx, pattern0_0, pattern5_0, pattern6_0, pattern7_0, pattern8_0, - )?; - return Some(expr0_0); - } - } - return None; -} - -// Generated as internal constructor for term atomic_rmw_body_minmax. -pub fn constructor_atomic_rmw_body_minmax( - ctx: &mut C, - arg0: &VecMInstBuilder, - arg1: Type, - arg2: MemFlags, - arg3: &CmpOp, - arg4: &Cond, - arg5: WritableReg, - arg6: Reg, - arg7: Reg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - if pattern1_0 == I8 { - let pattern3_0 = arg2; - let pattern4_0 = arg3; - let pattern5_0 = arg4; - let pattern6_0 = arg5; - let pattern7_0 = arg6; - let pattern8_0 = arg7; - // Rule at src/isa/s390x/lower.isle line 1734. - let expr0_0: Type = I32; - let expr1_0: u8 = 24; - let expr2_0 = constructor_lshl_imm(ctx, expr0_0, pattern8_0, expr1_0)?; - let expr3_0 = constructor_cmp_rr(ctx, pattern4_0, expr2_0, pattern7_0)?; - let expr4_0 = C::invert_cond(ctx, pattern5_0); - let expr5_0 = constructor_push_break_if(ctx, pattern0_0, &expr3_0, &expr4_0)?; - let expr6_0 = RxSBGOp::Insert; - let expr7_0: u8 = 32; - let expr8_0: u8 = 40; - let expr9_0: i8 = 0; - let expr10_0 = constructor_push_rxsbg( - ctx, pattern0_0, &expr6_0, pattern6_0, pattern7_0, expr2_0, expr7_0, expr8_0, expr9_0, - )?; - return Some(expr10_0); - } - if pattern1_0 == I16 { - let pattern3_0 = arg2; - if let Some(()) = C::littleendian(ctx, pattern3_0) { - let pattern5_0 = arg3; - let pattern6_0 = arg4; - let pattern7_0 = arg5; - let pattern8_0 = arg6; - let pattern9_0 = arg7; - // Rule at src/isa/s390x/lower.isle line 1747. - let expr0_0: Type = I32; - let expr1_0: u8 = 16; - let expr2_0 = constructor_lshl_imm(ctx, expr0_0, pattern9_0, expr1_0)?; - let expr3_0: Type = I32; - let expr4_0 = - constructor_push_bswap_reg(ctx, pattern0_0, expr3_0, pattern7_0, pattern8_0)?; - let expr5_0 = constructor_cmp_rr(ctx, pattern5_0, expr2_0, expr4_0)?; - let expr6_0 = C::invert_cond(ctx, pattern6_0); - let expr7_0 = constructor_push_break_if(ctx, pattern0_0, &expr5_0, &expr6_0)?; - let expr8_0 = RxSBGOp::Insert; - let expr9_0: u8 = 32; - let expr10_0: u8 = 48; - let expr11_0: i8 = 0; - let expr12_0 = constructor_push_rxsbg( - ctx, pattern0_0, &expr8_0, pattern7_0, expr4_0, expr2_0, expr9_0, expr10_0, - expr11_0, - )?; - let expr13_0: Type = I32; - let expr14_0 = - constructor_push_bswap_reg(ctx, pattern0_0, expr13_0, pattern7_0, expr12_0)?; - return Some(expr14_0); - } - if let Some(()) = C::bigendian(ctx, pattern3_0) { - let pattern5_0 = arg3; - let pattern6_0 = arg4; - let pattern7_0 = arg5; - let pattern8_0 = arg6; - let pattern9_0 = arg7; - // Rule at src/isa/s390x/lower.isle line 1740. - let expr0_0: Type = I32; - let expr1_0: u8 = 16; - let expr2_0 = constructor_lshl_imm(ctx, expr0_0, pattern9_0, expr1_0)?; - let expr3_0 = constructor_cmp_rr(ctx, pattern5_0, expr2_0, pattern8_0)?; - let expr4_0 = C::invert_cond(ctx, pattern6_0); - let expr5_0 = constructor_push_break_if(ctx, pattern0_0, &expr3_0, &expr4_0)?; - let expr6_0 = RxSBGOp::Insert; - let expr7_0: u8 = 32; - let expr8_0: u8 = 48; - let expr9_0: i8 = 0; - let expr10_0 = constructor_push_rxsbg( - ctx, pattern0_0, &expr6_0, pattern7_0, pattern8_0, expr2_0, expr7_0, expr8_0, - expr9_0, - )?; - return Some(expr10_0); - } - } - if let Some(pattern2_0) = C::ty_32_or_64(ctx, pattern1_0) { - let pattern3_0 = arg2; - if let Some(()) = C::littleendian(ctx, pattern3_0) { - let pattern5_0 = arg3; - let pattern6_0 = arg4; - let pattern7_0 = arg5; - let pattern8_0 = arg6; - let pattern9_0 = arg7; - // Rule at src/isa/s390x/lower.isle line 1722. - let expr0_0 = - constructor_push_bswap_reg(ctx, pattern0_0, pattern2_0, pattern7_0, pattern8_0)?; - let expr1_0 = constructor_cmp_rr(ctx, pattern5_0, pattern9_0, expr0_0)?; - let expr2_0 = C::invert_cond(ctx, pattern6_0); - let expr3_0 = constructor_push_break_if(ctx, pattern0_0, &expr1_0, &expr2_0)?; - let expr4_0 = - constructor_push_bswap_reg(ctx, pattern0_0, pattern2_0, pattern7_0, pattern9_0)?; - return Some(expr4_0); - } - if let Some(()) = C::bigendian(ctx, pattern3_0) { - let pattern5_0 = arg3; - let pattern6_0 = arg4; - let pattern7_0 = arg5; - let pattern8_0 = arg6; - let pattern9_0 = arg7; - // Rule at src/isa/s390x/lower.isle line 1715. - let expr0_0 = constructor_cmp_rr(ctx, pattern5_0, pattern9_0, pattern8_0)?; - let expr1_0 = C::invert_cond(ctx, pattern6_0); - let expr2_0 = constructor_push_break_if(ctx, pattern0_0, &expr0_0, &expr1_0)?; - return Some(pattern9_0); - } - } - return None; -} - -// Generated as internal constructor for term atomic_cas_body. -pub fn constructor_atomic_cas_body( - ctx: &mut C, - arg0: &VecMInstBuilder, - arg1: Type, - arg2: MemFlags, - arg3: WritableReg, - arg4: Reg, - arg5: Reg, - arg6: Reg, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - if pattern1_0 == I8 { - let pattern3_0 = arg2; - let pattern4_0 = arg3; - let pattern5_0 = arg4; - let pattern6_0 = arg5; - let pattern7_0 = arg6; - // Rule at src/isa/s390x/lower.isle line 1799. - let expr0_0 = RxSBGOp::Xor; - let expr1_0: u8 = 32; - let expr2_0: u8 = 40; - let expr3_0: i8 = 24; - let expr4_0 = constructor_rxsbg_test( - ctx, &expr0_0, pattern5_0, pattern6_0, expr1_0, expr2_0, expr3_0, - )?; - let expr5_0 = IntCC::NotEqual; - let expr6_0 = C::intcc_as_cond(ctx, &expr5_0); - let expr7_0 = constructor_push_break_if(ctx, pattern0_0, &expr4_0, &expr6_0)?; - let expr8_0 = RxSBGOp::Insert; - let expr9_0: u8 = 32; - let expr10_0: u8 = 40; - let expr11_0: i8 = 24; - let expr12_0 = constructor_push_rxsbg( - ctx, pattern0_0, &expr8_0, pattern4_0, pattern5_0, pattern7_0, expr9_0, expr10_0, - expr11_0, - )?; - return Some(expr12_0); - } - if pattern1_0 == I16 { - let pattern3_0 = arg2; - if let Some(()) = C::littleendian(ctx, pattern3_0) { - let pattern5_0 = arg3; - let pattern6_0 = arg4; - let pattern7_0 = arg5; - let pattern8_0 = arg6; - // Rule at src/isa/s390x/lower.isle line 1817. - let expr0_0: Type = I32; - let expr1_0 = constructor_bswap_reg(ctx, expr0_0, pattern7_0)?; - let expr2_0: Type = I32; - let expr3_0 = constructor_bswap_reg(ctx, expr2_0, pattern8_0)?; - let expr4_0 = RxSBGOp::Xor; - let expr5_0: u8 = 48; - let expr6_0: u8 = 64; - let expr7_0: i8 = -16; - let expr8_0 = constructor_rxsbg_test( - ctx, &expr4_0, pattern6_0, expr1_0, expr5_0, expr6_0, expr7_0, - )?; - let expr9_0 = IntCC::NotEqual; - let expr10_0 = C::intcc_as_cond(ctx, &expr9_0); - let expr11_0 = constructor_push_break_if(ctx, pattern0_0, &expr8_0, &expr10_0)?; - let expr12_0 = RxSBGOp::Insert; - let expr13_0: u8 = 48; - let expr14_0: u8 = 64; - let expr15_0: i8 = -16; - let expr16_0 = constructor_push_rxsbg( - ctx, pattern0_0, &expr12_0, pattern5_0, pattern6_0, expr3_0, expr13_0, expr14_0, - expr15_0, - )?; - return Some(expr16_0); - } - if let Some(()) = C::bigendian(ctx, pattern3_0) { - let pattern5_0 = arg3; - let pattern6_0 = arg4; - let pattern7_0 = arg5; - let pattern8_0 = arg6; - // Rule at src/isa/s390x/lower.isle line 1806. - let expr0_0 = RxSBGOp::Xor; - let expr1_0: u8 = 32; - let expr2_0: u8 = 48; - let expr3_0: i8 = 16; - let expr4_0 = constructor_rxsbg_test( - ctx, &expr0_0, pattern6_0, pattern7_0, expr1_0, expr2_0, expr3_0, - )?; - let expr5_0 = IntCC::NotEqual; - let expr6_0 = C::intcc_as_cond(ctx, &expr5_0); - let expr7_0 = constructor_push_break_if(ctx, pattern0_0, &expr4_0, &expr6_0)?; - let expr8_0 = RxSBGOp::Insert; - let expr9_0: u8 = 32; - let expr10_0: u8 = 48; - let expr11_0: i8 = 16; - let expr12_0 = constructor_push_rxsbg( - ctx, pattern0_0, &expr8_0, pattern5_0, pattern6_0, pattern8_0, expr9_0, expr10_0, - expr11_0, - )?; - return Some(expr12_0); - } - } - return None; -} - -// Generated as internal constructor for term atomic_store_impl. -pub fn constructor_atomic_store_impl( - ctx: &mut C, - arg0: &SideEffectNoResult, -) -> Option { - let pattern0_0 = arg0; - // Rule at src/isa/s390x/lower.isle line 1863. - let expr0_0 = constructor_side_effect(ctx, pattern0_0)?; - let expr1_0 = constructor_fence_impl(ctx)?; - let expr2_0 = constructor_side_effect(ctx, &expr1_0)?; - return Some(expr2_0); -} - -// Generated as internal constructor for term icmp_val. -pub fn constructor_icmp_val( - ctx: &mut C, - arg0: bool, - arg1: &IntCC, - arg2: Value, - arg3: Value, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - if let Some(()) = C::signed(ctx, pattern1_0) { - let pattern3_0 = arg2; - let pattern4_0 = arg3; - // Rule at src/isa/s390x/lower.isle line 1930. - let expr0_0 = constructor_icmps_val(ctx, pattern0_0, pattern3_0, pattern4_0)?; - let expr1_0 = C::intcc_as_cond(ctx, pattern1_0); - let expr2_0 = constructor_bool(ctx, &expr0_0, &expr1_0)?; - return Some(expr2_0); - } - if let Some(()) = C::unsigned(ctx, pattern1_0) { - let pattern3_0 = arg2; - let pattern4_0 = arg3; - // Rule at src/isa/s390x/lower.isle line 1933. - let expr0_0 = constructor_icmpu_val(ctx, pattern0_0, pattern3_0, pattern4_0)?; - let expr1_0 = C::intcc_as_cond(ctx, pattern1_0); - let expr2_0 = constructor_bool(ctx, &expr0_0, &expr1_0)?; - return Some(expr2_0); - } - return None; -} - -// Generated as internal constructor for term icmps_val. -pub fn constructor_icmps_val( - ctx: &mut C, - arg0: bool, - arg1: Value, - arg2: Value, -) -> Option { - let pattern0_0 = arg0; - if pattern0_0 == true { - let pattern2_0 = arg1; - let pattern3_0 = C::value_type(ctx, pattern2_0); - if let Some(pattern4_0) = C::fits_in_64(ctx, pattern3_0) { - let pattern5_0 = arg2; - if let Some(pattern6_0) = C::sinkable_inst(ctx, pattern5_0) { - let pattern7_0 = C::inst_data(ctx, pattern6_0); - if let &InstructionData::Load { - opcode: ref pattern8_0, - arg: pattern8_1, - flags: pattern8_2, - offset: pattern8_3, - } = &pattern7_0 - { - match pattern8_0 { - &Opcode::Sload16 => { - if let Some(()) = C::bigendian(ctx, pattern8_2) { - // Rule at src/isa/s390x/lower.isle line 1963. - let expr0_0 = C::put_in_reg(ctx, pattern2_0); - let expr1_0 = constructor_sink_sload16(ctx, pattern6_0)?; - let expr2_0 = constructor_icmps_mem_sext16( - ctx, pattern4_0, expr0_0, &expr1_0, - )?; - return Some(expr2_0); - } - } - &Opcode::Sload32 => { - if let Some(()) = C::bigendian(ctx, pattern8_2) { - // Rule at src/isa/s390x/lower.isle line 1965. - let expr0_0 = C::put_in_reg(ctx, pattern2_0); - let expr1_0 = constructor_sink_sload32(ctx, pattern6_0)?; - let expr2_0 = constructor_icmps_mem_sext32( - ctx, pattern4_0, expr0_0, &expr1_0, - )?; - return Some(expr2_0); - } - } - _ => {} - } - } - } - let pattern6_0 = C::value_type(ctx, pattern5_0); - if pattern6_0 == I16 { - if let Some(pattern8_0) = C::sinkable_inst(ctx, pattern5_0) { - let pattern9_0 = C::inst_data(ctx, pattern8_0); - if let &InstructionData::Load { - opcode: ref pattern10_0, - arg: pattern10_1, - flags: pattern10_2, - offset: pattern10_3, - } = &pattern9_0 - { - if let &Opcode::Load = pattern10_0 { - if let Some(()) = C::bigendian(ctx, pattern10_2) { - // Rule at src/isa/s390x/lower.isle line 1959. - let expr0_0 = constructor_ty_ext32(ctx, pattern4_0)?; - let expr1_0 = constructor_put_in_reg_sext32(ctx, pattern2_0)?; - let expr2_0 = constructor_sink_load(ctx, pattern8_0)?; - let expr3_0 = - constructor_icmps_mem_sext16(ctx, expr0_0, expr1_0, &expr2_0)?; - return Some(expr3_0); - } - } - } - } - } - if let Some(pattern7_0) = C::ty_32_or_64(ctx, pattern6_0) { - if let Some(pattern8_0) = C::sinkable_inst(ctx, pattern5_0) { - let pattern9_0 = C::inst_data(ctx, pattern8_0); - if let &InstructionData::Load { - opcode: ref pattern10_0, - arg: pattern10_1, - flags: pattern10_2, - offset: pattern10_3, - } = &pattern9_0 - { - if let &Opcode::Load = pattern10_0 { - if let Some(()) = C::bigendian(ctx, pattern10_2) { - // Rule at src/isa/s390x/lower.isle line 1955. - let expr0_0 = C::put_in_reg(ctx, pattern2_0); - let expr1_0 = constructor_sink_load(ctx, pattern8_0)?; - let expr2_0 = - constructor_icmps_mem(ctx, pattern4_0, expr0_0, &expr1_0)?; - return Some(expr2_0); - } - } - } - } - } - } - } - let pattern1_0 = arg1; - let pattern2_0 = C::value_type(ctx, pattern1_0); - if let Some(pattern3_0) = C::fits_in_64(ctx, pattern2_0) { - let pattern4_0 = arg2; - if let Some(pattern5_0) = C::i16_from_value(ctx, pattern4_0) { - // Rule at src/isa/s390x/lower.isle line 1949. - let expr0_0 = constructor_ty_ext32(ctx, pattern3_0)?; - let expr1_0 = constructor_put_in_reg_sext32(ctx, pattern1_0)?; - let expr2_0 = constructor_icmps_simm16(ctx, expr0_0, expr1_0, pattern5_0)?; - return Some(expr2_0); - } - if let Some(pattern5_0) = C::i32_from_value(ctx, pattern4_0) { - // Rule at src/isa/s390x/lower.isle line 1951. - let expr0_0 = constructor_ty_ext32(ctx, pattern3_0)?; - let expr1_0 = constructor_put_in_reg_sext32(ctx, pattern1_0)?; - let expr2_0 = constructor_icmps_simm32(ctx, expr0_0, expr1_0, pattern5_0)?; - return Some(expr2_0); - } - if let Some(pattern5_0) = C::def_inst(ctx, pattern4_0) { - let pattern6_0 = C::inst_data(ctx, pattern5_0); - if let &InstructionData::Unary { - opcode: ref pattern7_0, - arg: pattern7_1, - } = &pattern6_0 - { - if let &Opcode::Sextend = pattern7_0 { - let pattern9_0 = C::value_type(ctx, pattern7_1); - if pattern9_0 == I32 { - // Rule at src/isa/s390x/lower.isle line 1945. - let expr0_0 = C::put_in_reg(ctx, pattern1_0); - let expr1_0 = C::put_in_reg(ctx, pattern7_1); - let expr2_0 = - constructor_icmps_reg_sext32(ctx, pattern3_0, expr0_0, expr1_0)?; - return Some(expr2_0); - } - } - } - } - // Rule at src/isa/s390x/lower.isle line 1941. - let expr0_0 = constructor_ty_ext32(ctx, pattern3_0)?; - let expr1_0 = constructor_put_in_reg_sext32(ctx, pattern1_0)?; - let expr2_0 = constructor_put_in_reg_sext32(ctx, pattern4_0)?; - let expr3_0 = constructor_icmps_reg(ctx, expr0_0, expr1_0, expr2_0)?; - return Some(expr3_0); - } - return None; -} - -// Generated as internal constructor for term icmpu_val. -pub fn constructor_icmpu_val( - ctx: &mut C, - arg0: bool, - arg1: Value, - arg2: Value, -) -> Option { - let pattern0_0 = arg0; - if pattern0_0 == true { - let pattern2_0 = arg1; - let pattern3_0 = C::value_type(ctx, pattern2_0); - if let Some(pattern4_0) = C::fits_in_64(ctx, pattern3_0) { - let pattern5_0 = arg2; - if let Some(pattern6_0) = C::sinkable_inst(ctx, pattern5_0) { - let pattern7_0 = C::inst_data(ctx, pattern6_0); - if let &InstructionData::Load { - opcode: ref pattern8_0, - arg: pattern8_1, - flags: pattern8_2, - offset: pattern8_3, - } = &pattern7_0 - { - match pattern8_0 { - &Opcode::Uload16 => { - if let Some(()) = C::bigendian(ctx, pattern8_2) { - let mut closure11 = || { - let expr0_0 = constructor_uload16_sym(ctx, pattern6_0)?; - return Some(expr0_0); - }; - if let Some(pattern11_0) = closure11() { - // Rule at src/isa/s390x/lower.isle line 1999. - let expr0_0 = C::put_in_reg(ctx, pattern2_0); - let expr1_0 = constructor_sink_uload16(ctx, pattern11_0)?; - let expr2_0 = constructor_icmpu_mem_zext16( - ctx, pattern4_0, expr0_0, &expr1_0, - )?; - return Some(expr2_0); - } - } - } - &Opcode::Uload32 => { - if let Some(()) = C::bigendian(ctx, pattern8_2) { - // Rule at src/isa/s390x/lower.isle line 2003. - let expr0_0 = C::put_in_reg(ctx, pattern2_0); - let expr1_0 = constructor_sink_uload32(ctx, pattern6_0)?; - let expr2_0 = constructor_icmpu_mem_zext32( - ctx, pattern4_0, expr0_0, &expr1_0, - )?; - return Some(expr2_0); - } - } - _ => {} - } - } - } - let pattern6_0 = C::value_type(ctx, pattern5_0); - if pattern6_0 == I16 { - if let Some(pattern8_0) = C::sinkable_inst(ctx, pattern5_0) { - let pattern9_0 = C::inst_data(ctx, pattern8_0); - if let &InstructionData::Load { - opcode: ref pattern10_0, - arg: pattern10_1, - flags: pattern10_2, - offset: pattern10_3, - } = &pattern9_0 - { - if let &Opcode::Load = pattern10_0 { - if let Some(()) = C::bigendian(ctx, pattern10_2) { - let mut closure13 = || { - let expr0_0 = constructor_load_sym(ctx, pattern8_0)?; - return Some(expr0_0); - }; - if let Some(pattern13_0) = closure13() { - // Rule at src/isa/s390x/lower.isle line 1991. - let expr0_0 = constructor_ty_ext32(ctx, pattern4_0)?; - let expr1_0 = constructor_put_in_reg_zext32(ctx, pattern2_0)?; - let expr2_0 = constructor_sink_load(ctx, pattern13_0)?; - let expr3_0 = constructor_icmpu_mem_zext16( - ctx, expr0_0, expr1_0, &expr2_0, - )?; - return Some(expr3_0); - } - } - } - } - } - } - if let Some(pattern7_0) = C::ty_32_or_64(ctx, pattern6_0) { - if let Some(pattern8_0) = C::sinkable_inst(ctx, pattern5_0) { - let pattern9_0 = C::inst_data(ctx, pattern8_0); - if let &InstructionData::Load { - opcode: ref pattern10_0, - arg: pattern10_1, - flags: pattern10_2, - offset: pattern10_3, - } = &pattern9_0 - { - if let &Opcode::Load = pattern10_0 { - if let Some(()) = C::bigendian(ctx, pattern10_2) { - // Rule at src/isa/s390x/lower.isle line 1985. - let expr0_0 = C::put_in_reg(ctx, pattern2_0); - let expr1_0 = constructor_sink_load(ctx, pattern8_0)?; - let expr2_0 = - constructor_icmpu_mem(ctx, pattern4_0, expr0_0, &expr1_0)?; - return Some(expr2_0); - } - } - } - } - } - } - } - let pattern1_0 = arg1; - let pattern2_0 = C::value_type(ctx, pattern1_0); - if let Some(pattern3_0) = C::fits_in_64(ctx, pattern2_0) { - let pattern4_0 = arg2; - if let Some(pattern5_0) = C::u32_from_value(ctx, pattern4_0) { - // Rule at src/isa/s390x/lower.isle line 1981. - let expr0_0 = constructor_ty_ext32(ctx, pattern3_0)?; - let expr1_0 = constructor_put_in_reg_zext32(ctx, pattern1_0)?; - let expr2_0 = constructor_icmpu_uimm32(ctx, expr0_0, expr1_0, pattern5_0)?; - return Some(expr2_0); - } - if let Some(pattern5_0) = C::def_inst(ctx, pattern4_0) { - let pattern6_0 = C::inst_data(ctx, pattern5_0); - if let &InstructionData::Unary { - opcode: ref pattern7_0, - arg: pattern7_1, - } = &pattern6_0 - { - if let &Opcode::Uextend = pattern7_0 { - let pattern9_0 = C::value_type(ctx, pattern7_1); - if pattern9_0 == I32 { - // Rule at src/isa/s390x/lower.isle line 1977. - let expr0_0 = C::put_in_reg(ctx, pattern1_0); - let expr1_0 = C::put_in_reg(ctx, pattern7_1); - let expr2_0 = - constructor_icmpu_reg_zext32(ctx, pattern3_0, expr0_0, expr1_0)?; - return Some(expr2_0); - } - } - } - } - // Rule at src/isa/s390x/lower.isle line 1973. - let expr0_0 = constructor_ty_ext32(ctx, pattern3_0)?; - let expr1_0 = constructor_put_in_reg_zext32(ctx, pattern1_0)?; - let expr2_0 = constructor_put_in_reg_zext32(ctx, pattern4_0)?; - let expr3_0 = constructor_icmpu_reg(ctx, expr0_0, expr1_0, expr2_0)?; - return Some(expr3_0); - } - return None; -} - -// Generated as internal constructor for term fcmp_val. -pub fn constructor_fcmp_val( - ctx: &mut C, - arg0: &FloatCC, - arg1: Value, - arg2: Value, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = C::value_type(ctx, pattern1_0); - let pattern3_0 = arg2; - // Rule at src/isa/s390x/lower.isle line 2016. - let expr0_0 = C::put_in_reg(ctx, pattern1_0); - let expr1_0 = C::put_in_reg(ctx, pattern3_0); - let expr2_0 = constructor_fcmp_reg(ctx, pattern2_0, expr0_0, expr1_0)?; - let expr3_0 = C::floatcc_as_cond(ctx, pattern0_0); - let expr4_0 = constructor_bool(ctx, &expr2_0, &expr3_0)?; - return Some(expr4_0); -} - -// Generated as internal constructor for term value_nonzero. -pub fn constructor_value_nonzero(ctx: &mut C, arg0: Value) -> Option { - let pattern0_0 = arg0; - if let Some(pattern1_0) = C::def_inst(ctx, pattern0_0) { - let pattern2_0 = C::inst_data(ctx, pattern1_0); - match &pattern2_0 { - &InstructionData::FloatCompare { - opcode: ref pattern3_0, - args: ref pattern3_1, - cond: ref pattern3_2, - } => { - if let &Opcode::Fcmp = pattern3_0 { - let (pattern5_0, pattern5_1) = C::unpack_value_array_2(ctx, pattern3_1); - // Rule at src/isa/s390x/lower.isle line 2044. - let expr0_0 = constructor_fcmp_val(ctx, pattern3_2, pattern5_0, pattern5_1)?; - return Some(expr0_0); - } - } - &InstructionData::IntCompare { - opcode: ref pattern3_0, - args: ref pattern3_1, - cond: ref pattern3_2, - } => { - if let &Opcode::Icmp = pattern3_0 { - let (pattern5_0, pattern5_1) = C::unpack_value_array_2(ctx, pattern3_1); - // Rule at src/isa/s390x/lower.isle line 2043. - let expr0_0: bool = false; - let expr1_0 = - constructor_icmp_val(ctx, expr0_0, pattern3_2, pattern5_0, pattern5_1)?; - return Some(expr1_0); - } - } - &InstructionData::Unary { - opcode: ref pattern3_0, - arg: pattern3_1, - } => { - if let &Opcode::Bint = pattern3_0 { - // Rule at src/isa/s390x/lower.isle line 2042. - let expr0_0 = constructor_value_nonzero(ctx, pattern3_1)?; - return Some(expr0_0); - } - } - _ => {} - } - } - let pattern1_0 = C::value_type(ctx, pattern0_0); - if let Some(pattern2_0) = C::gpr32_ty(ctx, pattern1_0) { - // Rule at src/isa/s390x/lower.isle line 2045. - let expr0_0: Type = I32; - let expr1_0 = constructor_put_in_reg_sext32(ctx, pattern0_0)?; - let expr2_0: i16 = 0; - let expr3_0 = constructor_icmps_simm16(ctx, expr0_0, expr1_0, expr2_0)?; - let expr4_0 = IntCC::NotEqual; - let expr5_0 = C::intcc_as_cond(ctx, &expr4_0); - let expr6_0 = constructor_bool(ctx, &expr3_0, &expr5_0)?; - return Some(expr6_0); - } - if let Some(pattern2_0) = C::gpr64_ty(ctx, pattern1_0) { - // Rule at src/isa/s390x/lower.isle line 2048. - let expr0_0: Type = I64; - let expr1_0 = C::put_in_reg(ctx, pattern0_0); - let expr2_0: i16 = 0; - let expr3_0 = constructor_icmps_simm16(ctx, expr0_0, expr1_0, expr2_0)?; - let expr4_0 = IntCC::NotEqual; - let expr5_0 = C::intcc_as_cond(ctx, &expr4_0); - let expr6_0 = constructor_bool(ctx, &expr3_0, &expr5_0)?; - return Some(expr6_0); - } - return None; -} +include!(concat!(env!("ISLE_DIR"), "/isle_s390x.rs")); diff --git a/cranelift/codegen/src/isa/x64/lower/isle/generated_code.manifest b/cranelift/codegen/src/isa/x64/lower/isle/generated_code.manifest deleted file mode 100644 index d3d12d9397..0000000000 --- a/cranelift/codegen/src/isa/x64/lower/isle/generated_code.manifest +++ /dev/null @@ -1,4 +0,0 @@ -src/clif.isle 443b34b797fc8ace -src/prelude.isle e6c91b0115343ab9 -src/isa/x64/inst.isle 833710d359126637 -src/isa/x64/lower.isle 4c567e9157f84afb diff --git a/cranelift/codegen/src/isa/x64/lower/isle/generated_code.rs b/cranelift/codegen/src/isa/x64/lower/isle/generated_code.rs index c57147a35d..b33af0ac8b 100644 --- a/cranelift/codegen/src/isa/x64/lower/isle/generated_code.rs +++ b/cranelift/codegen/src/isa/x64/lower/isle/generated_code.rs @@ -1,12336 +1,9 @@ -// GENERATED BY ISLE. DO NOT EDIT! -// -// Generated automatically from the instruction-selection DSL code in: -// - src/clif.isle -// - src/prelude.isle -// - src/isa/x64/inst.isle -// - src/isa/x64/lower.isle - +// See https://github.com/rust-lang/rust/issues/47995: we cannot use `#![...]` attributes inside of +// the generated ISLE source below because we include!() it. We must include!() it because its path +// depends on an environment variable; and also because of this, we can't do the `#[path = "..."] +// mod generated_code;` trick either. #![allow(dead_code, unreachable_code, unreachable_patterns)] #![allow(unused_imports, unused_variables, non_snake_case, unused_mut)] #![allow(irrefutable_let_patterns)] -use super::*; // Pulls in all external types. - -/// Context during lowering: an implementation of this trait -/// must be provided with all external constructors and extractors. -/// A mutable borrow is passed along through all lowering logic. -pub trait Context { - fn unpack_value_array_2(&mut self, arg0: &ValueArray2) -> (Value, Value); - fn pack_value_array_2(&mut self, arg0: Value, arg1: Value) -> ValueArray2; - fn unpack_value_array_3(&mut self, arg0: &ValueArray3) -> (Value, Value, Value); - fn pack_value_array_3(&mut self, arg0: Value, arg1: Value, arg2: Value) -> ValueArray3; - fn u32_add(&mut self, arg0: u32, arg1: u32) -> u32; - fn s32_add_fallible(&mut self, arg0: u32, arg1: u32) -> Option; - fn u32_nonnegative(&mut self, arg0: u32) -> Option; - fn offset32(&mut self, arg0: Offset32) -> Option; - fn u32_lteq(&mut self, arg0: u32, arg1: u32) -> Option; - fn simm32(&mut self, arg0: Imm64) -> Option; - fn uimm8(&mut self, arg0: Imm64) -> Option; - fn u8_and(&mut self, arg0: u8, arg1: u8) -> u8; - fn value_reg(&mut self, arg0: Reg) -> ValueRegs; - fn value_regs(&mut self, arg0: Reg, arg1: Reg) -> ValueRegs; - fn value_regs_invalid(&mut self) -> ValueRegs; - fn output_none(&mut self) -> InstOutput; - fn output(&mut self, arg0: ValueRegs) -> InstOutput; - fn output_pair(&mut self, arg0: ValueRegs, arg1: ValueRegs) -> InstOutput; - fn output_builder_new(&mut self) -> InstOutputBuilder; - fn output_builder_push(&mut self, arg0: &InstOutputBuilder, arg1: ValueRegs) -> Unit; - fn output_builder_finish(&mut self, arg0: &InstOutputBuilder) -> InstOutput; - fn temp_writable_reg(&mut self, arg0: Type) -> WritableReg; - fn invalid_reg_etor(&mut self, arg0: Reg) -> Option<()>; - fn invalid_reg(&mut self) -> Reg; - fn valid_reg(&mut self, arg0: Reg) -> Option<()>; - fn put_in_reg(&mut self, arg0: Value) -> Reg; - fn put_in_regs(&mut self, arg0: Value) -> ValueRegs; - fn ensure_in_vreg(&mut self, arg0: Reg, arg1: Type) -> Reg; - fn value_regs_get(&mut self, arg0: ValueRegs, arg1: usize) -> Reg; - fn u8_as_u32(&mut self, arg0: u8) -> Option; - fn u8_as_u64(&mut self, arg0: u8) -> Option; - fn u16_as_u64(&mut self, arg0: u16) -> Option; - fn u32_as_u64(&mut self, arg0: u32) -> Option; - fn i64_as_u64(&mut self, arg0: i64) -> Option; - fn u64_add(&mut self, arg0: u64, arg1: u64) -> Option; - fn u64_sub(&mut self, arg0: u64, arg1: u64) -> Option; - fn u64_and(&mut self, arg0: u64, arg1: u64) -> Option; - fn ty_bits(&mut self, arg0: Type) -> Option; - fn ty_bits_u16(&mut self, arg0: Type) -> u16; - fn ty_bits_u64(&mut self, arg0: Type) -> u64; - fn ty_mask(&mut self, arg0: Type) -> u64; - fn ty_bytes(&mut self, arg0: Type) -> u16; - fn lane_type(&mut self, arg0: Type) -> Type; - fn fits_in_16(&mut self, arg0: Type) -> Option; - fn fits_in_32(&mut self, arg0: Type) -> Option; - fn fits_in_64(&mut self, arg0: Type) -> Option; - fn ty_32_or_64(&mut self, arg0: Type) -> Option; - fn ty_8_or_16(&mut self, arg0: Type) -> Option; - fn ty_int_bool_64(&mut self, arg0: Type) -> Option; - fn ty_int_bool_ref_64(&mut self, arg0: Type) -> Option; - fn ty_int_bool_128(&mut self, arg0: Type) -> Option; - fn ty_scalar_float(&mut self, arg0: Type) -> Option; - fn ty_vec128(&mut self, arg0: Type) -> Option; - fn ty_vec128_int(&mut self, arg0: Type) -> Option; - fn not_i64x2(&mut self, arg0: Type) -> Option<()>; - fn value_list_slice(&mut self, arg0: ValueList) -> ValueSlice; - fn value_slice_empty(&mut self, arg0: ValueSlice) -> Option<()>; - fn value_slice_unwrap(&mut self, arg0: ValueSlice) -> Option<(Value, ValueSlice)>; - fn value_slice_len(&mut self, arg0: ValueSlice) -> usize; - fn value_slice_get(&mut self, arg0: ValueSlice, arg1: usize) -> Value; - fn writable_reg_to_reg(&mut self, arg0: WritableReg) -> Reg; - fn u8_from_uimm8(&mut self, arg0: Uimm8) -> u8; - fn u64_from_imm64(&mut self, arg0: Imm64) -> u64; - fn nonzero_u64_from_imm64(&mut self, arg0: Imm64) -> Option; - fn u64_from_ieee32(&mut self, arg0: Ieee32) -> u64; - fn u64_from_ieee64(&mut self, arg0: Ieee64) -> u64; - fn inst_results(&mut self, arg0: Inst) -> ValueSlice; - fn first_result(&mut self, arg0: Inst) -> Option; - fn inst_data(&mut self, arg0: Inst) -> InstructionData; - fn value_type(&mut self, arg0: Value) -> Type; - fn multi_lane(&mut self, arg0: Type) -> Option<(u8, u16)>; - fn def_inst(&mut self, arg0: Value) -> Option; - fn offset32_to_u32(&mut self, arg0: Offset32) -> u32; - fn emit(&mut self, arg0: &MInst) -> Unit; - fn emit_u64_le_const(&mut self, arg0: u64) -> VCodeConstant; - fn trap_code_division_by_zero(&mut self) -> TrapCode; - fn trap_code_integer_overflow(&mut self) -> TrapCode; - fn trap_code_bad_conversion_to_integer(&mut self) -> TrapCode; - fn avoid_div_traps(&mut self, arg0: Type) -> Option<()>; - fn func_ref_data(&mut self, arg0: FuncRef) -> (SigRef, ExternalName, RelocDistance); - fn symbol_value_data( - &mut self, - arg0: GlobalValue, - ) -> Option<(ExternalName, RelocDistance, i64)>; - fn reloc_distance_near(&mut self, arg0: RelocDistance) -> Option<()>; - fn operand_size_of_type_32_64(&mut self, arg0: Type) -> OperandSize; - fn raw_operand_size_of_type(&mut self, arg0: Type) -> OperandSize; - fn put_in_reg_mem_imm(&mut self, arg0: Value) -> RegMemImm; - fn put_in_reg_mem(&mut self, arg0: Value) -> RegMem; - fn synthetic_amode_to_reg_mem(&mut self, arg0: &SyntheticAmode) -> RegMem; - fn amode_to_synthetic_amode(&mut self, arg0: &Amode) -> SyntheticAmode; - fn amode_with_flags(&mut self, arg0: &Amode, arg1: MemFlags) -> Amode; - fn amode_imm_reg(&mut self, arg0: u32, arg1: Gpr) -> Amode; - fn amode_imm_reg_reg_shift(&mut self, arg0: u32, arg1: Gpr, arg2: Gpr, arg3: u8) -> Amode; - fn sum_extend_fits_in_32_bits( - &mut self, - arg0: Type, - arg1: Imm64, - arg2: Offset32, - ) -> Option; - fn amode_offset(&mut self, arg0: &Amode, arg1: u32) -> Amode; - fn put_masked_in_imm8_gpr(&mut self, arg0: Value, arg1: Type) -> Imm8Gpr; - fn intcc_to_cc(&mut self, arg0: &IntCC) -> CC; - fn encode_fcmp_imm(&mut self, arg0: &FcmpImm) -> u8; - fn imm8_reg_to_imm8_gpr(&mut self, arg0: &Imm8Reg) -> Imm8Gpr; - fn writable_gpr_to_reg(&mut self, arg0: WritableGpr) -> WritableReg; - fn writable_xmm_to_reg(&mut self, arg0: WritableXmm) -> WritableReg; - fn writable_reg_to_xmm(&mut self, arg0: WritableReg) -> WritableXmm; - fn writable_xmm_to_xmm(&mut self, arg0: WritableXmm) -> Xmm; - fn writable_gpr_to_gpr(&mut self, arg0: WritableGpr) -> Gpr; - fn gpr_to_reg(&mut self, arg0: Gpr) -> Reg; - fn gpr_to_gpr_mem(&mut self, arg0: Gpr) -> GprMem; - fn gpr_to_gpr_mem_imm(&mut self, arg0: Gpr) -> GprMemImm; - fn xmm_to_reg(&mut self, arg0: Xmm) -> Reg; - fn xmm_to_xmm_mem_imm(&mut self, arg0: Xmm) -> XmmMemImm; - fn temp_writable_gpr(&mut self) -> WritableGpr; - fn temp_writable_xmm(&mut self) -> WritableXmm; - fn reg_mem_to_xmm_mem(&mut self, arg0: &RegMem) -> XmmMem; - fn gpr_mem_imm_new(&mut self, arg0: &RegMemImm) -> GprMemImm; - fn xmm_mem_imm_new(&mut self, arg0: &RegMemImm) -> XmmMemImm; - fn xmm_to_xmm_mem(&mut self, arg0: Xmm) -> XmmMem; - fn xmm_mem_to_reg_mem(&mut self, arg0: &XmmMem) -> RegMem; - fn gpr_mem_to_reg_mem(&mut self, arg0: &GprMem) -> RegMem; - fn xmm_new(&mut self, arg0: Reg) -> Xmm; - fn gpr_new(&mut self, arg0: Reg) -> Gpr; - fn reg_mem_to_gpr_mem(&mut self, arg0: &RegMem) -> GprMem; - fn reg_to_gpr_mem(&mut self, arg0: Reg) -> GprMem; - fn gpr_to_imm8_gpr(&mut self, arg0: Gpr) -> Imm8Gpr; - fn imm8_to_imm8_gpr(&mut self, arg0: u8) -> Imm8Gpr; - fn xmm0(&mut self) -> WritableXmm; - fn is_xmm_type(&mut self, arg0: Type) -> Option; - fn is_gpr_type(&mut self, arg0: Type) -> Option; - fn is_single_register_type(&mut self, arg0: Type) -> Option; - fn avx512vl_enabled(&mut self, arg0: Type) -> Option<()>; - fn avx512dq_enabled(&mut self, arg0: Type) -> Option<()>; - fn avx512f_enabled(&mut self, arg0: Type) -> Option<()>; - fn avx512bitalg_enabled(&mut self, arg0: Type) -> Option<()>; - fn use_lzcnt(&mut self, arg0: Type) -> Option<()>; - fn use_bmi1(&mut self, arg0: Type) -> Option<()>; - fn use_popcnt(&mut self, arg0: Type) -> Option<()>; - fn imm8_from_value(&mut self, arg0: Value) -> Option; - fn const_to_type_masked_imm8(&mut self, arg0: u64, arg1: Type) -> Imm8Gpr; - fn simm32_from_value(&mut self, arg0: Value) -> Option; - fn simm32_from_imm64(&mut self, arg0: Imm64) -> Option; - fn sinkable_load(&mut self, arg0: Value) -> Option; - fn sink_load(&mut self, arg0: &SinkableLoad) -> RegMemImm; - fn ext_mode(&mut self, arg0: u16, arg1: u16) -> ExtMode; - fn nonzero_u64_fits_in_u32(&mut self, arg0: u64) -> Option; - fn ishl_i8x16_mask_for_const(&mut self, arg0: u32) -> SyntheticAmode; - fn ishl_i8x16_mask_table(&mut self) -> SyntheticAmode; - fn ushr_i8x16_mask_for_const(&mut self, arg0: u32) -> SyntheticAmode; - fn ushr_i8x16_mask_table(&mut self) -> SyntheticAmode; - fn sse_insertps_lane_imm(&mut self, arg0: u8) -> u8; - fn popcount_4bit_table(&mut self) -> VCodeConstant; - fn popcount_low_mask(&mut self) -> VCodeConstant; -} - -/// Internal type SideEffectNoResult: defined at src/prelude.isle line 457. -#[derive(Clone, Debug)] -pub enum SideEffectNoResult { - Inst { inst: MInst }, - Inst2 { inst1: MInst, inst2: MInst }, -} - -/// Internal type ProducesFlags: defined at src/prelude.isle line 484. -#[derive(Clone, Debug)] -pub enum ProducesFlags { - ProducesFlagsSideEffect { inst: MInst }, - ProducesFlagsReturnsReg { inst: MInst, result: Reg }, - ProducesFlagsReturnsResultWithConsumer { inst: MInst, result: Reg }, -} - -/// Internal type ConsumesFlags: defined at src/prelude.isle line 495. -#[derive(Clone, Debug)] -pub enum ConsumesFlags { - ConsumesFlagsReturnsResultWithProducer { - inst: MInst, - result: Reg, - }, - ConsumesFlagsReturnsReg { - inst: MInst, - result: Reg, - }, - ConsumesFlagsTwiceReturnsValueRegs { - inst1: MInst, - inst2: MInst, - result: ValueRegs, - }, - ConsumesFlagsFourTimesReturnsValueRegs { - inst1: MInst, - inst2: MInst, - inst3: MInst, - inst4: MInst, - result: ValueRegs, - }, -} - -/// Internal type MInst: defined at src/isa/x64/inst.isle line 8. -#[derive(Clone)] -pub enum MInst { - Nop { - len: u8, - }, - AluRmiR { - size: OperandSize, - op: AluRmiROpcode, - src1: Gpr, - src2: GprMemImm, - dst: WritableGpr, - }, - AluRM { - size: OperandSize, - op: AluRmiROpcode, - src1_dst: SyntheticAmode, - src2: Gpr, - }, - UnaryRmR { - size: OperandSize, - op: UnaryRmROpcode, - src: GprMem, - dst: WritableGpr, - }, - Not { - size: OperandSize, - src: Gpr, - dst: WritableGpr, - }, - Neg { - size: OperandSize, - src: Gpr, - dst: WritableGpr, - }, - Div { - size: OperandSize, - signed: bool, - divisor: GprMem, - dividend_lo: Gpr, - dividend_hi: Gpr, - dst_quotient: WritableGpr, - dst_remainder: WritableGpr, - }, - MulHi { - size: OperandSize, - signed: bool, - src1: Gpr, - src2: GprMem, - dst_lo: WritableGpr, - dst_hi: WritableGpr, - }, - CheckedDivOrRemSeq { - kind: DivOrRemKind, - size: OperandSize, - dividend_lo: Gpr, - dividend_hi: Gpr, - divisor: WritableGpr, - dst_quotient: WritableGpr, - dst_remainder: WritableGpr, - tmp: OptionWritableGpr, - }, - SignExtendData { - size: OperandSize, - src: Gpr, - dst: WritableGpr, - }, - Imm { - dst_size: OperandSize, - simm64: u64, - dst: WritableGpr, - }, - MovRR { - size: OperandSize, - src: Gpr, - dst: WritableGpr, - }, - MovzxRmR { - ext_mode: ExtMode, - src: GprMem, - dst: WritableGpr, - }, - Mov64MR { - src: SyntheticAmode, - dst: WritableGpr, - }, - LoadEffectiveAddress { - addr: SyntheticAmode, - dst: WritableGpr, - }, - MovsxRmR { - ext_mode: ExtMode, - src: GprMem, - dst: WritableGpr, - }, - MovRM { - size: OperandSize, - src: Gpr, - dst: SyntheticAmode, - }, - ShiftR { - size: OperandSize, - kind: ShiftKind, - src: Gpr, - num_bits: Imm8Gpr, - dst: WritableGpr, - }, - XmmRmiReg { - opcode: SseOpcode, - src1: Xmm, - src2: XmmMemImm, - dst: WritableXmm, - }, - CmpRmiR { - size: OperandSize, - opcode: CmpOpcode, - src: GprMemImm, - dst: Gpr, - }, - Setcc { - cc: CC, - dst: WritableGpr, - }, - Cmove { - size: OperandSize, - cc: CC, - consequent: GprMem, - alternative: Gpr, - dst: WritableGpr, - }, - XmmCmove { - size: OperandSize, - cc: CC, - consequent: XmmMem, - alternative: Xmm, - dst: WritableXmm, - }, - Push64 { - src: GprMemImm, - }, - Pop64 { - dst: WritableGpr, - }, - XmmRmR { - op: SseOpcode, - src1: Xmm, - src2: XmmMem, - dst: WritableXmm, - }, - XmmRmREvex { - op: Avx512Opcode, - src1: XmmMem, - src2: Xmm, - dst: WritableXmm, - }, - XmmUnaryRmR { - op: SseOpcode, - src: XmmMem, - dst: WritableXmm, - }, - XmmUnaryRmREvex { - op: Avx512Opcode, - src: XmmMem, - dst: WritableXmm, - }, - XmmMovRM { - op: SseOpcode, - src: Reg, - dst: SyntheticAmode, - }, - XmmLoadConst { - src: VCodeConstant, - dst: WritableReg, - ty: Type, - }, - XmmToGpr { - op: SseOpcode, - src: Xmm, - dst: WritableGpr, - dst_size: OperandSize, - }, - GprToXmm { - op: SseOpcode, - src: GprMem, - dst: WritableXmm, - src_size: OperandSize, - }, - CvtUint64ToFloatSeq { - dst_size: OperandSize, - src: WritableGpr, - dst: WritableXmm, - tmp_gpr1: WritableGpr, - tmp_gpr2: WritableGpr, - }, - CvtFloatToSintSeq { - dst_size: OperandSize, - src_size: OperandSize, - is_saturating: bool, - src: WritableXmm, - dst: WritableGpr, - tmp_gpr: WritableGpr, - tmp_xmm: WritableXmm, - }, - CvtFloatToUintSeq { - dst_size: OperandSize, - src_size: OperandSize, - is_saturating: bool, - src: WritableXmm, - dst: WritableGpr, - tmp_gpr: WritableGpr, - tmp_xmm: WritableXmm, - }, - XmmMinMaxSeq { - size: OperandSize, - is_min: bool, - lhs: Xmm, - rhs: Xmm, - dst: WritableXmm, - }, - XmmCmpRmR { - op: SseOpcode, - src: XmmMem, - dst: Xmm, - }, - XmmRmRImm { - op: SseOpcode, - src1: Reg, - src2: RegMem, - dst: WritableReg, - imm: u8, - size: OperandSize, - }, - CallKnown { - dest: ExternalName, - uses: VecReg, - defs: VecWritableReg, - opcode: Opcode, - }, - CallUnknown { - dest: RegMem, - uses: VecReg, - defs: VecWritableReg, - opcode: Opcode, - }, - Ret { - rets: VecReg, - }, - EpiloguePlaceholder, - JmpKnown { - dst: MachLabel, - }, - JmpIf { - cc: CC, - taken: MachLabel, - }, - JmpCond { - cc: CC, - taken: MachLabel, - not_taken: MachLabel, - }, - JmpTableSeq { - idx: Reg, - tmp1: WritableReg, - tmp2: WritableReg, - default_target: MachLabel, - targets: VecMachLabel, - targets_for_term: VecMachLabel, - }, - JmpUnknown { - target: RegMem, - }, - TrapIf { - cc: CC, - trap_code: TrapCode, - }, - Hlt, - Ud2 { - trap_code: TrapCode, - }, - LoadExtName { - dst: WritableReg, - name: BoxExternalName, - offset: i64, - }, - LockCmpxchg { - ty: Type, - replacement: Reg, - expected: Reg, - mem: SyntheticAmode, - dst_old: WritableReg, - }, - AtomicRmwSeq { - ty: Type, - op: AtomicRmwOp, - address: Reg, - operand: Reg, - temp: WritableReg, - dst_old: WritableReg, - }, - Fence { - kind: FenceKind, - }, - VirtualSPOffsetAdj { - offset: i64, - }, - XmmUninitializedValue { - dst: WritableXmm, - }, - ElfTlsGetAddr { - symbol: ExternalName, - }, - MachOTlsGetAddr { - symbol: ExternalName, - }, - Unwind { - inst: UnwindInst, - }, - DummyUse { - reg: Reg, - }, -} - -/// Internal type Amode: defined at src/isa/x64/inst.isle line 768. -#[derive(Clone, Debug)] -pub enum Amode { - ImmReg { - simm32: u32, - base: Reg, - flags: MemFlags, - }, - ImmRegRegShift { - simm32: u32, - base: Gpr, - index: Gpr, - shift: u8, - flags: MemFlags, - }, - RipRelative { - target: MachLabel, - }, -} - -/// Internal type ExtendKind: defined at src/isa/x64/inst.isle line 1352. -#[derive(Copy, Clone, PartialEq, Eq, Debug)] -pub enum ExtendKind { - Sign, - Zero, -} - -// Generated as internal constructor for term output_reg. -pub fn constructor_output_reg(ctx: &mut C, arg0: Reg) -> Option { - let pattern0_0 = arg0; - // Rule at src/prelude.isle line 113. - let expr0_0 = C::value_reg(ctx, pattern0_0); - let expr1_0 = C::output(ctx, expr0_0); - return Some(expr1_0); -} - -// Generated as internal constructor for term output_value. -pub fn constructor_output_value(ctx: &mut C, arg0: Value) -> Option { - let pattern0_0 = arg0; - // Rule at src/prelude.isle line 117. - let expr0_0 = C::put_in_regs(ctx, pattern0_0); - let expr1_0 = C::output(ctx, expr0_0); - return Some(expr1_0); -} - -// Generated as internal constructor for term temp_reg. -pub fn constructor_temp_reg(ctx: &mut C, arg0: Type) -> Option { - let pattern0_0 = arg0; - // Rule at src/prelude.isle line 137. - let expr0_0 = C::temp_writable_reg(ctx, pattern0_0); - let expr1_0 = C::writable_reg_to_reg(ctx, expr0_0); - return Some(expr1_0); -} - -// Generated as internal constructor for term lo_reg. -pub fn constructor_lo_reg(ctx: &mut C, arg0: Value) -> Option { - let pattern0_0 = arg0; - // Rule at src/prelude.isle line 182. - let expr0_0 = C::put_in_regs(ctx, pattern0_0); - let expr1_0: usize = 0; - let expr2_0 = C::value_regs_get(ctx, expr0_0, expr1_0); - return Some(expr2_0); -} - -// Generated as internal constructor for term side_effect. -pub fn constructor_side_effect( - ctx: &mut C, - arg0: &SideEffectNoResult, -) -> Option { - let pattern0_0 = arg0; - match pattern0_0 { - &SideEffectNoResult::Inst { - inst: ref pattern1_0, - } => { - // Rule at src/prelude.isle line 465. - let expr0_0 = C::emit(ctx, pattern1_0); - let expr1_0 = C::output_none(ctx); - return Some(expr1_0); - } - &SideEffectNoResult::Inst2 { - inst1: ref pattern1_0, - inst2: ref pattern1_1, - } => { - // Rule at src/prelude.isle line 468. - let expr0_0 = C::emit(ctx, pattern1_0); - let expr1_0 = C::emit(ctx, pattern1_1); - let expr2_0 = C::output_none(ctx); - return Some(expr2_0); - } - _ => {} - } - return None; -} - -// Generated as internal constructor for term side_effect_concat. -pub fn constructor_side_effect_concat( - ctx: &mut C, - arg0: &SideEffectNoResult, - arg1: &SideEffectNoResult, -) -> Option { - let pattern0_0 = arg0; - if let &SideEffectNoResult::Inst { - inst: ref pattern1_0, - } = pattern0_0 - { - let pattern2_0 = arg1; - if let &SideEffectNoResult::Inst { - inst: ref pattern3_0, - } = pattern2_0 - { - // Rule at src/prelude.isle line 474. - let expr0_0 = SideEffectNoResult::Inst2 { - inst1: pattern1_0.clone(), - inst2: pattern3_0.clone(), - }; - return Some(expr0_0); - } - } - return None; -} - -// Generated as internal constructor for term produces_flags_get_reg. -pub fn constructor_produces_flags_get_reg( - ctx: &mut C, - arg0: &ProducesFlags, -) -> Option { - let pattern0_0 = arg0; - if let &ProducesFlags::ProducesFlagsReturnsReg { - inst: ref pattern1_0, - result: pattern1_1, - } = pattern0_0 - { - // Rule at src/prelude.isle line 511. - return Some(pattern1_1); - } - return None; -} - -// Generated as internal constructor for term produces_flags_ignore. -pub fn constructor_produces_flags_ignore( - ctx: &mut C, - arg0: &ProducesFlags, -) -> Option { - let pattern0_0 = arg0; - match pattern0_0 { - &ProducesFlags::ProducesFlagsReturnsReg { - inst: ref pattern1_0, - result: pattern1_1, - } => { - // Rule at src/prelude.isle line 516. - let expr0_0 = ProducesFlags::ProducesFlagsSideEffect { - inst: pattern1_0.clone(), - }; - return Some(expr0_0); - } - &ProducesFlags::ProducesFlagsReturnsResultWithConsumer { - inst: ref pattern1_0, - result: pattern1_1, - } => { - // Rule at src/prelude.isle line 518. - let expr0_0 = ProducesFlags::ProducesFlagsSideEffect { - inst: pattern1_0.clone(), - }; - return Some(expr0_0); - } - _ => {} - } - return None; -} - -// Generated as internal constructor for term consumes_flags_concat. -pub fn constructor_consumes_flags_concat( - ctx: &mut C, - arg0: &ConsumesFlags, - arg1: &ConsumesFlags, -) -> Option { - let pattern0_0 = arg0; - if let &ConsumesFlags::ConsumesFlagsReturnsReg { - inst: ref pattern1_0, - result: pattern1_1, - } = pattern0_0 - { - let pattern2_0 = arg1; - if let &ConsumesFlags::ConsumesFlagsReturnsReg { - inst: ref pattern3_0, - result: pattern3_1, - } = pattern2_0 - { - // Rule at src/prelude.isle line 525. - let expr0_0 = C::value_regs(ctx, pattern1_1, pattern3_1); - let expr1_0 = ConsumesFlags::ConsumesFlagsTwiceReturnsValueRegs { - inst1: pattern1_0.clone(), - inst2: pattern3_0.clone(), - result: expr0_0, - }; - return Some(expr1_0); - } - } - return None; -} - -// Generated as internal constructor for term with_flags. -pub fn constructor_with_flags( - ctx: &mut C, - arg0: &ProducesFlags, - arg1: &ConsumesFlags, -) -> Option { - let pattern0_0 = arg0; - match pattern0_0 { - &ProducesFlags::ProducesFlagsSideEffect { - inst: ref pattern1_0, - } => { - let pattern2_0 = arg1; - match pattern2_0 { - &ConsumesFlags::ConsumesFlagsReturnsReg { - inst: ref pattern3_0, - result: pattern3_1, - } => { - // Rule at src/prelude.isle line 550. - let expr0_0 = C::emit(ctx, pattern1_0); - let expr1_0 = C::emit(ctx, pattern3_0); - let expr2_0 = C::value_reg(ctx, pattern3_1); - return Some(expr2_0); - } - &ConsumesFlags::ConsumesFlagsTwiceReturnsValueRegs { - inst1: ref pattern3_0, - inst2: ref pattern3_1, - result: pattern3_2, - } => { - // Rule at src/prelude.isle line 556. - let expr0_0 = C::emit(ctx, pattern1_0); - let expr1_0 = C::emit(ctx, pattern3_0); - let expr2_0 = C::emit(ctx, pattern3_1); - return Some(pattern3_2); - } - &ConsumesFlags::ConsumesFlagsFourTimesReturnsValueRegs { - inst1: ref pattern3_0, - inst2: ref pattern3_1, - inst3: ref pattern3_2, - inst4: ref pattern3_3, - result: pattern3_4, - } => { - // Rule at src/prelude.isle line 568. - let expr0_0 = C::emit(ctx, pattern1_0); - let expr1_0 = C::emit(ctx, pattern3_0); - let expr2_0 = C::emit(ctx, pattern3_1); - let expr3_0 = C::emit(ctx, pattern3_2); - let expr4_0 = C::emit(ctx, pattern3_3); - return Some(pattern3_4); - } - _ => {} - } - } - &ProducesFlags::ProducesFlagsReturnsResultWithConsumer { - inst: ref pattern1_0, - result: pattern1_1, - } => { - let pattern2_0 = arg1; - if let &ConsumesFlags::ConsumesFlagsReturnsResultWithProducer { - inst: ref pattern3_0, - result: pattern3_1, - } = pattern2_0 - { - // Rule at src/prelude.isle line 544. - let expr0_0 = C::emit(ctx, pattern1_0); - let expr1_0 = C::emit(ctx, pattern3_0); - let expr2_0 = C::value_regs(ctx, pattern1_1, pattern3_1); - return Some(expr2_0); - } - } - _ => {} - } - return None; -} - -// Generated as internal constructor for term with_flags_reg. -pub fn constructor_with_flags_reg( - ctx: &mut C, - arg0: &ProducesFlags, - arg1: &ConsumesFlags, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/prelude.isle line 585. - let expr0_0 = constructor_with_flags(ctx, pattern0_0, pattern1_0)?; - let expr1_0: usize = 0; - let expr2_0 = C::value_regs_get(ctx, expr0_0, expr1_0); - return Some(expr2_0); -} - -// Generated as internal constructor for term operand_size_bits. -pub fn constructor_operand_size_bits(ctx: &mut C, arg0: &OperandSize) -> Option { - let pattern0_0 = arg0; - match pattern0_0 { - &OperandSize::Size8 => { - // Rule at src/isa/x64/inst.isle line 515. - let expr0_0: u16 = 8; - return Some(expr0_0); - } - &OperandSize::Size16 => { - // Rule at src/isa/x64/inst.isle line 516. - let expr0_0: u16 = 16; - return Some(expr0_0); - } - &OperandSize::Size32 => { - // Rule at src/isa/x64/inst.isle line 517. - let expr0_0: u16 = 32; - return Some(expr0_0); - } - &OperandSize::Size64 => { - // Rule at src/isa/x64/inst.isle line 518. - let expr0_0: u16 = 64; - return Some(expr0_0); - } - _ => {} - } - return None; -} - -// Generated as internal constructor for term amode_imm_reg_flags. -pub fn constructor_amode_imm_reg_flags( - ctx: &mut C, - arg0: u32, - arg1: Gpr, - arg2: MemFlags, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/x64/inst.isle line 796. - let expr0_0 = C::amode_imm_reg(ctx, pattern0_0, pattern1_0); - let expr1_0 = C::amode_with_flags(ctx, &expr0_0, pattern2_0); - return Some(expr1_0); -} - -// Generated as internal constructor for term amode_imm_reg_reg_shift_flags. -pub fn constructor_amode_imm_reg_reg_shift_flags( - ctx: &mut C, - arg0: u32, - arg1: Gpr, - arg2: Gpr, - arg3: u8, - arg4: MemFlags, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - let pattern3_0 = arg3; - let pattern4_0 = arg4; - // Rule at src/isa/x64/inst.isle line 803. - let expr0_0 = C::amode_imm_reg_reg_shift(ctx, pattern0_0, pattern1_0, pattern2_0, pattern3_0); - let expr1_0 = C::amode_with_flags(ctx, &expr0_0, pattern4_0); - return Some(expr1_0); -} - -// Generated as internal constructor for term to_amode. -pub fn constructor_to_amode( - ctx: &mut C, - arg0: MemFlags, - arg1: Value, - arg2: Offset32, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/x64/inst.isle line 983. - let expr0_0 = constructor_amode_initial(ctx, pattern0_0, pattern2_0)?; - let expr1_0 = constructor_amode_add(ctx, &expr0_0, pattern1_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term amode_initial. -pub fn constructor_amode_initial( - ctx: &mut C, - arg0: MemFlags, - arg1: Offset32, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - if let Some(pattern2_0) = C::offset32(ctx, pattern1_0) { - // Rule at src/isa/x64/inst.isle line 873. - let expr0_0 = C::invalid_reg(ctx); - let expr1_0 = Amode::ImmReg { - simm32: pattern2_0, - base: expr0_0, - flags: pattern0_0, - }; - return Some(expr1_0); - } - return None; -} - -// Generated as internal constructor for term amode_add. -pub fn constructor_amode_add(ctx: &mut C, arg0: &Amode, arg1: Value) -> Option { - let pattern0_0 = arg0; - match pattern0_0 { - &Amode::ImmReg { - simm32: pattern1_0, - base: pattern1_1, - flags: pattern1_2, - } => { - let pattern2_0 = arg1; - if let Some(pattern3_0) = C::def_inst(ctx, pattern2_0) { - let pattern4_0 = C::inst_data(ctx, pattern3_0); - match &pattern4_0 { - &InstructionData::UnaryImm { - opcode: ref pattern5_0, - imm: pattern5_1, - } => { - if let &Opcode::Iconst = pattern5_0 { - if let Some(pattern7_0) = C::simm32(ctx, pattern5_1) { - let mut closure8 = || { - let expr0_0 = C::s32_add_fallible(ctx, pattern1_0, pattern7_0)?; - return Some(expr0_0); - }; - if let Some(pattern8_0) = closure8() { - // Rule at src/isa/x64/inst.isle line 941. - let expr0_0 = Amode::ImmReg { - simm32: pattern8_0, - base: pattern1_1, - flags: pattern1_2, - }; - return Some(expr0_0); - } - } - } - } - &InstructionData::Unary { - opcode: ref pattern5_0, - arg: pattern5_1, - } => { - match pattern5_0 { - &Opcode::Uextend => { - if let Some(pattern7_0) = C::def_inst(ctx, pattern5_1) { - let pattern8_0 = C::inst_data(ctx, pattern7_0); - if let &InstructionData::UnaryImm { - opcode: ref pattern9_0, - imm: pattern9_1, - } = &pattern8_0 - { - if let &Opcode::Iconst = pattern9_0 { - if let Some(pattern11_0) = C::simm32(ctx, pattern9_1) { - if let Some(pattern12_0) = - C::u32_nonnegative(ctx, pattern11_0) - { - let mut closure13 = || { - let expr0_0 = C::s32_add_fallible( - ctx, - pattern1_0, - pattern12_0, - )?; - return Some(expr0_0); - }; - if let Some(pattern13_0) = closure13() { - // Rule at src/isa/x64/inst.isle line 954. - let expr0_0 = Amode::ImmReg { - simm32: pattern13_0, - base: pattern1_1, - flags: pattern1_2, - }; - return Some(expr0_0); - } - } - } - } - } - } - } - &Opcode::Sextend => { - if let Some(pattern7_0) = C::def_inst(ctx, pattern5_1) { - let pattern8_0 = C::inst_data(ctx, pattern7_0); - if let &InstructionData::UnaryImm { - opcode: ref pattern9_0, - imm: pattern9_1, - } = &pattern8_0 - { - if let &Opcode::Iconst = pattern9_0 { - if let Some(pattern11_0) = C::simm32(ctx, pattern9_1) { - let mut closure12 = || { - let expr0_0 = C::s32_add_fallible( - ctx, - pattern1_0, - pattern11_0, - )?; - return Some(expr0_0); - }; - if let Some(pattern12_0) = closure12() { - // Rule at src/isa/x64/inst.isle line 964. - let expr0_0 = Amode::ImmReg { - simm32: pattern12_0, - base: pattern1_1, - flags: pattern1_2, - }; - return Some(expr0_0); - } - } - } - } - } - } - _ => {} - } - } - _ => {} - } - } - } - &Amode::ImmRegRegShift { - simm32: pattern1_0, - base: pattern1_1, - index: pattern1_2, - shift: pattern1_3, - flags: pattern1_4, - } => { - let pattern2_0 = arg1; - if let Some(pattern3_0) = C::def_inst(ctx, pattern2_0) { - let pattern4_0 = C::inst_data(ctx, pattern3_0); - match &pattern4_0 { - &InstructionData::UnaryImm { - opcode: ref pattern5_0, - imm: pattern5_1, - } => { - if let &Opcode::Iconst = pattern5_0 { - if let Some(pattern7_0) = C::simm32(ctx, pattern5_1) { - let mut closure8 = || { - let expr0_0 = C::s32_add_fallible(ctx, pattern1_0, pattern7_0)?; - return Some(expr0_0); - }; - if let Some(pattern8_0) = closure8() { - // Rule at src/isa/x64/inst.isle line 945. - let expr0_0 = Amode::ImmRegRegShift { - simm32: pattern8_0, - base: pattern1_1, - index: pattern1_2, - shift: pattern1_3, - flags: pattern1_4, - }; - return Some(expr0_0); - } - } - } - } - &InstructionData::Unary { - opcode: ref pattern5_0, - arg: pattern5_1, - } => { - match pattern5_0 { - &Opcode::Uextend => { - if let Some(pattern7_0) = C::def_inst(ctx, pattern5_1) { - let pattern8_0 = C::inst_data(ctx, pattern7_0); - if let &InstructionData::UnaryImm { - opcode: ref pattern9_0, - imm: pattern9_1, - } = &pattern8_0 - { - if let &Opcode::Iconst = pattern9_0 { - if let Some(pattern11_0) = C::simm32(ctx, pattern9_1) { - if let Some(pattern12_0) = - C::u32_nonnegative(ctx, pattern11_0) - { - let mut closure13 = || { - let expr0_0 = C::s32_add_fallible( - ctx, - pattern1_0, - pattern12_0, - )?; - return Some(expr0_0); - }; - if let Some(pattern13_0) = closure13() { - // Rule at src/isa/x64/inst.isle line 958. - let expr0_0 = Amode::ImmRegRegShift { - simm32: pattern13_0, - base: pattern1_1, - index: pattern1_2, - shift: pattern1_3, - flags: pattern1_4, - }; - return Some(expr0_0); - } - } - } - } - } - } - } - &Opcode::Sextend => { - if let Some(pattern7_0) = C::def_inst(ctx, pattern5_1) { - let pattern8_0 = C::inst_data(ctx, pattern7_0); - if let &InstructionData::UnaryImm { - opcode: ref pattern9_0, - imm: pattern9_1, - } = &pattern8_0 - { - if let &Opcode::Iconst = pattern9_0 { - if let Some(pattern11_0) = C::simm32(ctx, pattern9_1) { - let mut closure12 = || { - let expr0_0 = C::s32_add_fallible( - ctx, - pattern1_0, - pattern11_0, - )?; - return Some(expr0_0); - }; - if let Some(pattern12_0) = closure12() { - // Rule at src/isa/x64/inst.isle line 968. - let expr0_0 = Amode::ImmRegRegShift { - simm32: pattern12_0, - base: pattern1_1, - index: pattern1_2, - shift: pattern1_3, - flags: pattern1_4, - }; - return Some(expr0_0); - } - } - } - } - } - } - _ => {} - } - } - _ => {} - } - } - } - _ => {} - } - let pattern0_0 = arg0; - if let &Amode::ImmReg { - simm32: pattern1_0, - base: pattern1_1, - flags: pattern1_2, - } = pattern0_0 - { - let pattern2_0 = arg1; - if let Some(pattern3_0) = C::def_inst(ctx, pattern2_0) { - let pattern4_0 = C::inst_data(ctx, pattern3_0); - match &pattern4_0 { - &InstructionData::Binary { - opcode: ref pattern5_0, - args: ref pattern5_1, - } => { - if let &Opcode::Ishl = pattern5_0 { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - if let Some(pattern8_0) = C::def_inst(ctx, pattern7_1) { - let pattern9_0 = C::inst_data(ctx, pattern8_0); - if let &InstructionData::UnaryImm { - opcode: ref pattern10_0, - imm: pattern10_1, - } = &pattern9_0 - { - if let &Opcode::Iconst = pattern10_0 { - if let Some(pattern12_0) = C::uimm8(ctx, pattern10_1) { - let mut closure13 = || { - return Some(pattern1_1); - }; - if let Some(pattern13_0) = closure13() { - if let Some(()) = C::valid_reg(ctx, pattern13_0) { - let mut closure15 = || { - let expr0_0 = C::u8_as_u32(ctx, pattern12_0)?; - let expr1_0: u32 = 3; - let expr2_0 = - C::u32_lteq(ctx, expr0_0, expr1_0)?; - return Some(expr2_0); - }; - if let Some(pattern15_0) = closure15() { - // Rule at src/isa/x64/inst.isle line 912. - let expr0_0 = C::gpr_new(ctx, pattern1_1); - let expr1_0 = - constructor_put_in_gpr(ctx, pattern7_0)?; - let expr2_0 = Amode::ImmRegRegShift { - simm32: pattern1_0, - base: expr0_0, - index: expr1_0, - shift: pattern12_0, - flags: pattern1_2, - }; - return Some(expr2_0); - } - } - } - } - } - } - } - } - } - &InstructionData::Unary { - opcode: ref pattern5_0, - arg: pattern5_1, - } => { - if let &Opcode::Uextend = pattern5_0 { - if let Some(pattern7_0) = C::def_inst(ctx, pattern5_1) { - let pattern8_0 = C::inst_data(ctx, pattern7_0); - if let &InstructionData::Binary { - opcode: ref pattern9_0, - args: ref pattern9_1, - } = &pattern8_0 - { - if let &Opcode::Ishl = pattern9_0 { - let (pattern11_0, pattern11_1) = - C::unpack_value_array_2(ctx, pattern9_1); - if let Some(pattern12_0) = C::def_inst(ctx, pattern11_0) { - let pattern13_0 = C::inst_data(ctx, pattern12_0); - if let &InstructionData::Binary { - opcode: ref pattern14_0, - args: ref pattern14_1, - } = &pattern13_0 - { - if let &Opcode::Iadd = pattern14_0 { - let (pattern16_0, pattern16_1) = - C::unpack_value_array_2(ctx, pattern14_1); - if let Some(pattern17_0) = - C::def_inst(ctx, pattern11_1) - { - let pattern18_0 = - C::inst_data(ctx, pattern17_0); - if let &InstructionData::UnaryImm { - opcode: ref pattern19_0, - imm: pattern19_1, - } = &pattern18_0 - { - if let &Opcode::Iconst = pattern19_0 { - if let Some(pattern21_0) = - C::uimm8(ctx, pattern19_1) - { - let mut closure22 = || { - return Some(pattern1_1); - }; - if let Some(pattern22_0) = - closure22() - { - if let Some(()) = C::valid_reg( - ctx, - pattern22_0, - ) { - let mut closure24 = || { - let expr0_0 = - C::u8_as_u32( - ctx, - pattern21_0, - )?; - let expr1_0: u32 = 3; - let expr2_0 = - C::u32_lteq( - ctx, expr0_0, - expr1_0, - )?; - return Some(expr2_0); - }; - if let Some(pattern24_0) = - closure24() - { - // Rule at src/isa/x64/inst.isle line 927. - let expr0_0 = - C::gpr_new( - ctx, pattern1_1, - ); - let expr1_0 = constructor_put_in_gpr(ctx, pattern11_0)?; - let expr2_0 = Amode::ImmRegRegShift { - simm32: pattern1_0, - base: expr0_0, - index: expr1_0, - shift: pattern21_0, - flags: pattern1_2, - }; - return Some(expr2_0); - } - } - } - } - } - } - } - } - } - } - if let Some(pattern12_0) = C::def_inst(ctx, pattern11_1) { - let pattern13_0 = C::inst_data(ctx, pattern12_0); - if let &InstructionData::UnaryImm { - opcode: ref pattern14_0, - imm: pattern14_1, - } = &pattern13_0 - { - if let &Opcode::Iconst = pattern14_0 { - if let Some(pattern16_0) = - C::uimm8(ctx, pattern14_1) - { - let mut closure17 = || { - return Some(pattern1_1); - }; - if let Some(pattern17_0) = closure17() { - if let Some(()) = - C::valid_reg(ctx, pattern17_0) - { - let mut closure19 = || { - let expr0_0 = - C::u8_as_u32(ctx, pattern16_0)?; - let expr1_0: u32 = 3; - let expr2_0 = C::u32_lteq( - ctx, expr0_0, expr1_0, - )?; - return Some(expr2_0); - }; - if let Some(pattern19_0) = closure19() { - // Rule at src/isa/x64/inst.isle line 916. - let expr0_0 = - C::gpr_new(ctx, pattern1_1); - let expr1_0: Type = I64; - let expr2_0 = ExtendKind::Zero; - let expr3_0 = - constructor_extend_to_gpr( - ctx, - pattern11_0, - expr1_0, - &expr2_0, - )?; - let expr4_0 = - Amode::ImmRegRegShift { - simm32: pattern1_0, - base: expr0_0, - index: expr3_0, - shift: pattern16_0, - flags: pattern1_2, - }; - return Some(expr4_0); - } - } - } - } - } - } - } - } - } - } - } - } - _ => {} - } - } - } - let pattern1_0 = arg1; - if let Some(pattern2_0) = C::def_inst(ctx, pattern1_0) { - let pattern3_0 = C::inst_data(ctx, pattern2_0); - if let &InstructionData::Binary { - opcode: ref pattern4_0, - args: ref pattern4_1, - } = &pattern3_0 - { - if let &Opcode::Iadd = pattern4_0 { - let (pattern6_0, pattern6_1) = C::unpack_value_array_2(ctx, pattern4_1); - // Rule at src/isa/x64/inst.isle line 887. - let expr0_0 = constructor_amode_add(ctx, pattern0_0, pattern6_0)?; - let expr1_0 = constructor_amode_add(ctx, &expr0_0, pattern6_1)?; - return Some(expr1_0); - } - } - } - let pattern0_0 = arg0; - match pattern0_0 { - &Amode::ImmReg { - simm32: pattern1_0, - base: pattern1_1, - flags: pattern1_2, - } => { - if let Some(()) = C::invalid_reg_etor(ctx, pattern1_1) { - let pattern3_0 = arg1; - // Rule at src/isa/x64/inst.isle line 896. - let expr0_0 = C::put_in_reg(ctx, pattern3_0); - let expr1_0 = Amode::ImmReg { - simm32: pattern1_0, - base: expr0_0, - flags: pattern1_2, - }; - return Some(expr1_0); - } - let pattern2_0 = arg1; - let mut closure3 = || { - return Some(pattern1_1); - }; - if let Some(pattern3_0) = closure3() { - if let Some(()) = C::valid_reg(ctx, pattern3_0) { - // Rule at src/isa/x64/inst.isle line 902. - let expr0_0 = C::gpr_new(ctx, pattern1_1); - let expr1_0 = constructor_put_in_gpr(ctx, pattern2_0)?; - let expr2_0: u8 = 0; - let expr3_0 = Amode::ImmRegRegShift { - simm32: pattern1_0, - base: expr0_0, - index: expr1_0, - shift: expr2_0, - flags: pattern1_2, - }; - return Some(expr3_0); - } - } - } - &Amode::ImmRegRegShift { - simm32: pattern1_0, - base: pattern1_1, - index: pattern1_2, - shift: pattern1_3, - flags: pattern1_4, - } => { - let pattern2_0 = arg1; - // Rule at src/isa/x64/inst.isle line 978. - let expr0_0: Type = I64; - let expr1_0 = constructor_put_in_gpr_mem_imm(ctx, pattern2_0)?; - let expr2_0 = constructor_x64_add(ctx, expr0_0, pattern1_1, &expr1_0)?; - let expr3_0 = Amode::ImmRegRegShift { - simm32: pattern1_0, - base: expr2_0, - index: pattern1_2, - shift: pattern1_3, - flags: pattern1_4, - }; - return Some(expr3_0); - } - _ => {} - } - return None; -} - -// Generated as internal constructor for term reg_to_gpr_mem_imm. -pub fn constructor_reg_to_gpr_mem_imm(ctx: &mut C, arg0: Reg) -> Option { - let pattern0_0 = arg0; - // Rule at src/isa/x64/inst.isle line 1182. - let expr0_0 = C::gpr_new(ctx, pattern0_0); - let expr1_0 = C::gpr_to_gpr_mem_imm(ctx, expr0_0); - return Some(expr1_0); -} - -// Generated as internal constructor for term put_in_gpr. -pub fn constructor_put_in_gpr(ctx: &mut C, arg0: Value) -> Option { - let pattern0_0 = arg0; - // Rule at src/isa/x64/inst.isle line 1189. - let expr0_0 = C::put_in_reg(ctx, pattern0_0); - let expr1_0 = C::gpr_new(ctx, expr0_0); - return Some(expr1_0); -} - -// Generated as internal constructor for term put_in_gpr_mem. -pub fn constructor_put_in_gpr_mem(ctx: &mut C, arg0: Value) -> Option { - let pattern0_0 = arg0; - // Rule at src/isa/x64/inst.isle line 1196. - let expr0_0 = C::put_in_reg_mem(ctx, pattern0_0); - let expr1_0 = C::reg_mem_to_gpr_mem(ctx, &expr0_0); - return Some(expr1_0); -} - -// Generated as internal constructor for term put_in_gpr_mem_imm. -pub fn constructor_put_in_gpr_mem_imm(ctx: &mut C, arg0: Value) -> Option { - let pattern0_0 = arg0; - // Rule at src/isa/x64/inst.isle line 1203. - let expr0_0 = C::put_in_reg_mem_imm(ctx, pattern0_0); - let expr1_0 = C::gpr_mem_imm_new(ctx, &expr0_0); - return Some(expr1_0); -} - -// Generated as internal constructor for term put_in_xmm. -pub fn constructor_put_in_xmm(ctx: &mut C, arg0: Value) -> Option { - let pattern0_0 = arg0; - // Rule at src/isa/x64/inst.isle line 1210. - let expr0_0 = C::put_in_reg(ctx, pattern0_0); - let expr1_0 = C::xmm_new(ctx, expr0_0); - return Some(expr1_0); -} - -// Generated as internal constructor for term put_in_xmm_mem. -pub fn constructor_put_in_xmm_mem(ctx: &mut C, arg0: Value) -> Option { - let pattern0_0 = arg0; - // Rule at src/isa/x64/inst.isle line 1217. - let expr0_0 = C::put_in_reg_mem(ctx, pattern0_0); - let expr1_0 = C::reg_mem_to_xmm_mem(ctx, &expr0_0); - return Some(expr1_0); -} - -// Generated as internal constructor for term put_in_xmm_mem_imm. -pub fn constructor_put_in_xmm_mem_imm(ctx: &mut C, arg0: Value) -> Option { - let pattern0_0 = arg0; - // Rule at src/isa/x64/inst.isle line 1224. - let expr0_0 = C::put_in_reg_mem_imm(ctx, pattern0_0); - let expr1_0 = C::xmm_mem_imm_new(ctx, &expr0_0); - return Some(expr1_0); -} - -// Generated as internal constructor for term output_gpr. -pub fn constructor_output_gpr(ctx: &mut C, arg0: Gpr) -> Option { - let pattern0_0 = arg0; - // Rule at src/isa/x64/inst.isle line 1229. - let expr0_0 = C::gpr_to_reg(ctx, pattern0_0); - let expr1_0 = constructor_output_reg(ctx, expr0_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term value_gprs. -pub fn constructor_value_gprs(ctx: &mut C, arg0: Gpr, arg1: Gpr) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/x64/inst.isle line 1234. - let expr0_0 = C::gpr_to_reg(ctx, pattern0_0); - let expr1_0 = C::gpr_to_reg(ctx, pattern1_0); - let expr2_0 = C::value_regs(ctx, expr0_0, expr1_0); - return Some(expr2_0); -} - -// Generated as internal constructor for term output_xmm. -pub fn constructor_output_xmm(ctx: &mut C, arg0: Xmm) -> Option { - let pattern0_0 = arg0; - // Rule at src/isa/x64/inst.isle line 1239. - let expr0_0 = C::xmm_to_reg(ctx, pattern0_0); - let expr1_0 = constructor_output_reg(ctx, expr0_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term value_regs_get_gpr. -pub fn constructor_value_regs_get_gpr( - ctx: &mut C, - arg0: ValueRegs, - arg1: usize, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/x64/inst.isle line 1246. - let expr0_0 = C::value_regs_get(ctx, pattern0_0, pattern1_0); - let expr1_0 = C::gpr_new(ctx, expr0_0); - return Some(expr1_0); -} - -// Generated as internal constructor for term lo_gpr. -pub fn constructor_lo_gpr(ctx: &mut C, arg0: Value) -> Option { - let pattern0_0 = arg0; - // Rule at src/isa/x64/inst.isle line 1259. - let expr0_0 = constructor_lo_reg(ctx, pattern0_0)?; - let expr1_0 = C::gpr_new(ctx, expr0_0); - return Some(expr1_0); -} - -// Generated as internal constructor for term sink_load_to_gpr_mem_imm. -pub fn constructor_sink_load_to_gpr_mem_imm( - ctx: &mut C, - arg0: &SinkableLoad, -) -> Option { - let pattern0_0 = arg0; - // Rule at src/isa/x64/inst.isle line 1342. - let expr0_0 = C::sink_load(ctx, pattern0_0); - let expr1_0 = C::gpr_mem_imm_new(ctx, &expr0_0); - return Some(expr1_0); -} - -// Generated as internal constructor for term extend_to_gpr. -pub fn constructor_extend_to_gpr( - ctx: &mut C, - arg0: Value, - arg1: Type, - arg2: &ExtendKind, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = C::value_type(ctx, pattern0_0); - let pattern2_0 = arg1; - if pattern2_0 == pattern1_0 { - let pattern4_0 = arg2; - // Rule at src/isa/x64/inst.isle line 1364. - let expr0_0 = constructor_put_in_gpr(ctx, pattern0_0)?; - return Some(expr0_0); - } - let pattern3_0 = arg2; - // Rule at src/isa/x64/inst.isle line 1367. - let expr0_0 = C::ty_bits_u16(ctx, pattern1_0); - let expr1_0 = C::operand_size_of_type_32_64(ctx, pattern2_0); - let expr2_0 = constructor_operand_size_bits(ctx, &expr1_0)?; - let expr3_0 = C::ext_mode(ctx, expr0_0, expr2_0); - let expr4_0 = constructor_put_in_gpr_mem(ctx, pattern0_0)?; - let expr5_0 = constructor_extend(ctx, pattern3_0, pattern2_0, &expr3_0, &expr4_0)?; - return Some(expr5_0); -} - -// Generated as internal constructor for term extend. -pub fn constructor_extend( - ctx: &mut C, - arg0: &ExtendKind, - arg1: Type, - arg2: &ExtMode, - arg3: &GprMem, -) -> Option { - let pattern0_0 = arg0; - match pattern0_0 { - &ExtendKind::Sign => { - let pattern2_0 = arg1; - let pattern3_0 = arg2; - let pattern4_0 = arg3; - // Rule at src/isa/x64/inst.isle line 1387. - let expr0_0 = constructor_x64_movsx(ctx, pattern3_0, pattern4_0)?; - return Some(expr0_0); - } - &ExtendKind::Zero => { - let pattern2_0 = arg1; - let pattern3_0 = arg2; - let pattern4_0 = arg3; - // Rule at src/isa/x64/inst.isle line 1383. - let expr0_0 = constructor_x64_movzx(ctx, pattern3_0, pattern4_0)?; - return Some(expr0_0); - } - _ => {} - } - return None; -} - -// Generated as internal constructor for term sse_xor_op. -pub fn constructor_sse_xor_op(ctx: &mut C, arg0: Type) -> Option { - let pattern0_0 = arg0; - if pattern0_0 == F32X4 { - // Rule at src/isa/x64/inst.isle line 1394. - let expr0_0 = SseOpcode::Xorps; - return Some(expr0_0); - } - if pattern0_0 == F64X2 { - // Rule at src/isa/x64/inst.isle line 1395. - let expr0_0 = SseOpcode::Xorpd; - return Some(expr0_0); - } - if let Some((pattern1_0, pattern1_1)) = C::multi_lane(ctx, pattern0_0) { - // Rule at src/isa/x64/inst.isle line 1396. - let expr0_0 = SseOpcode::Pxor; - return Some(expr0_0); - } - return None; -} - -// Generated as internal constructor for term sse_xor. -pub fn constructor_sse_xor( - ctx: &mut C, - arg0: Type, - arg1: Xmm, - arg2: &XmmMem, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/x64/inst.isle line 1400. - let expr0_0 = constructor_sse_xor_op(ctx, pattern0_0)?; - let expr1_0 = constructor_xmm_rm_r(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term sse_cmp_op. -pub fn constructor_sse_cmp_op(ctx: &mut C, arg0: Type) -> Option { - let pattern0_0 = arg0; - if pattern0_0 == F32X4 { - // Rule at src/isa/x64/inst.isle line 1409. - let expr0_0 = SseOpcode::Cmpps; - return Some(expr0_0); - } - if pattern0_0 == F64X2 { - // Rule at src/isa/x64/inst.isle line 1410. - let expr0_0 = SseOpcode::Cmppd; - return Some(expr0_0); - } - if let Some((pattern1_0, pattern1_1)) = C::multi_lane(ctx, pattern0_0) { - if pattern1_0 == 8 { - if pattern1_1 == 16 { - // Rule at src/isa/x64/inst.isle line 1405. - let expr0_0 = SseOpcode::Pcmpeqb; - return Some(expr0_0); - } - } - if pattern1_0 == 16 { - if pattern1_1 == 8 { - // Rule at src/isa/x64/inst.isle line 1406. - let expr0_0 = SseOpcode::Pcmpeqw; - return Some(expr0_0); - } - } - if pattern1_0 == 32 { - if pattern1_1 == 4 { - // Rule at src/isa/x64/inst.isle line 1407. - let expr0_0 = SseOpcode::Pcmpeqd; - return Some(expr0_0); - } - } - if pattern1_0 == 64 { - if pattern1_1 == 2 { - // Rule at src/isa/x64/inst.isle line 1408. - let expr0_0 = SseOpcode::Pcmpeqq; - return Some(expr0_0); - } - } - } - return None; -} - -// Generated as internal constructor for term vector_all_ones. -pub fn constructor_vector_all_ones(ctx: &mut C, arg0: Type) -> Option { - let pattern0_0 = arg0; - // Rule at src/isa/x64/inst.isle line 1424. - let expr0_0 = C::temp_writable_xmm(ctx); - let expr1_0: Type = I32X4; - let expr2_0 = constructor_sse_cmp_op(ctx, expr1_0)?; - let expr3_0 = C::writable_xmm_to_xmm(ctx, expr0_0); - let expr4_0 = constructor_writable_xmm_to_xmm_mem(ctx, expr0_0)?; - let expr5_0 = MInst::XmmRmR { - op: expr2_0, - src1: expr3_0, - src2: expr4_0, - dst: expr0_0, - }; - let expr6_0 = C::emit(ctx, &expr5_0); - let expr7_0 = C::writable_xmm_to_xmm(ctx, expr0_0); - return Some(expr7_0); -} - -// Generated as internal constructor for term make_i64x2_from_lanes. -pub fn constructor_make_i64x2_from_lanes( - ctx: &mut C, - arg0: &GprMem, - arg1: &GprMem, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/x64/inst.isle line 1434. - let expr0_0 = C::temp_writable_xmm(ctx); - let expr1_0 = C::writable_xmm_to_reg(ctx, expr0_0); - let expr2_0 = MInst::XmmUninitializedValue { dst: expr0_0 }; - let expr3_0 = C::emit(ctx, &expr2_0); - let expr4_0 = SseOpcode::Pinsrd; - let expr5_0 = C::writable_reg_to_reg(ctx, expr1_0); - let expr6_0 = C::gpr_mem_to_reg_mem(ctx, pattern0_0); - let expr7_0: u8 = 0; - let expr8_0 = OperandSize::Size64; - let expr9_0 = MInst::XmmRmRImm { - op: expr4_0, - src1: expr5_0, - src2: expr6_0, - dst: expr1_0, - imm: expr7_0, - size: expr8_0, - }; - let expr10_0 = C::emit(ctx, &expr9_0); - let expr11_0 = SseOpcode::Pinsrd; - let expr12_0 = C::writable_reg_to_reg(ctx, expr1_0); - let expr13_0 = C::gpr_mem_to_reg_mem(ctx, pattern1_0); - let expr14_0: u8 = 1; - let expr15_0 = OperandSize::Size64; - let expr16_0 = MInst::XmmRmRImm { - op: expr11_0, - src1: expr12_0, - src2: expr13_0, - dst: expr1_0, - imm: expr14_0, - size: expr15_0, - }; - let expr17_0 = C::emit(ctx, &expr16_0); - let expr18_0 = C::writable_xmm_to_xmm(ctx, expr0_0); - return Some(expr18_0); -} - -// Generated as internal constructor for term mov_rmi_to_xmm. -pub fn constructor_mov_rmi_to_xmm(ctx: &mut C, arg0: &RegMemImm) -> Option { - let pattern0_0 = arg0; - match pattern0_0 { - &RegMemImm::Imm { simm32: pattern1_0 } => { - // Rule at src/isa/x64/inst.isle line 1455. - let expr0_0 = C::xmm_mem_imm_new(ctx, pattern0_0); - return Some(expr0_0); - } - &RegMemImm::Reg { reg: pattern1_0 } => { - // Rule at src/isa/x64/inst.isle line 1456. - let expr0_0 = SseOpcode::Movd; - let expr1_0 = C::reg_to_gpr_mem(ctx, pattern1_0); - let expr2_0 = OperandSize::Size32; - let expr3_0 = constructor_gpr_to_xmm(ctx, &expr0_0, &expr1_0, &expr2_0)?; - let expr4_0 = C::xmm_to_xmm_mem_imm(ctx, expr3_0); - return Some(expr4_0); - } - &RegMemImm::Mem { - addr: ref pattern1_0, - } => { - // Rule at src/isa/x64/inst.isle line 1454. - let expr0_0 = C::xmm_mem_imm_new(ctx, pattern0_0); - return Some(expr0_0); - } - _ => {} - } - return None; -} - -// Generated as internal constructor for term x64_load. -pub fn constructor_x64_load( - ctx: &mut C, - arg0: Type, - arg1: &SyntheticAmode, - arg2: &ExtKind, -) -> Option { - let pattern0_0 = arg0; - if pattern0_0 == I64 { - let pattern2_0 = arg1; - let pattern3_0 = arg2; - // Rule at src/isa/x64/inst.isle line 1470. - let expr0_0 = C::temp_writable_gpr(ctx); - let expr1_0 = MInst::Mov64MR { - src: pattern2_0.clone(), - dst: expr0_0, - }; - let expr2_0 = C::emit(ctx, &expr1_0); - let expr3_0 = constructor_writable_gpr_to_r_reg(ctx, expr0_0)?; - return Some(expr3_0); - } - if pattern0_0 == F32 { - let pattern2_0 = arg1; - let pattern3_0 = arg2; - // Rule at src/isa/x64/inst.isle line 1475. - let expr0_0 = SseOpcode::Movss; - let expr1_0 = constructor_synthetic_amode_to_xmm_mem(ctx, pattern2_0)?; - let expr2_0 = constructor_xmm_unary_rm_r(ctx, &expr0_0, &expr1_0)?; - let expr3_0 = C::xmm_to_reg(ctx, expr2_0); - return Some(expr3_0); - } - if pattern0_0 == F64 { - let pattern2_0 = arg1; - let pattern3_0 = arg2; - // Rule at src/isa/x64/inst.isle line 1479. - let expr0_0 = SseOpcode::Movsd; - let expr1_0 = constructor_synthetic_amode_to_xmm_mem(ctx, pattern2_0)?; - let expr2_0 = constructor_xmm_unary_rm_r(ctx, &expr0_0, &expr1_0)?; - let expr3_0 = C::xmm_to_reg(ctx, expr2_0); - return Some(expr3_0); - } - if pattern0_0 == F32X4 { - let pattern2_0 = arg1; - let pattern3_0 = arg2; - // Rule at src/isa/x64/inst.isle line 1483. - let expr0_0 = SseOpcode::Movups; - let expr1_0 = constructor_synthetic_amode_to_xmm_mem(ctx, pattern2_0)?; - let expr2_0 = constructor_xmm_unary_rm_r(ctx, &expr0_0, &expr1_0)?; - let expr3_0 = C::xmm_to_reg(ctx, expr2_0); - return Some(expr3_0); - } - if pattern0_0 == F64X2 { - let pattern2_0 = arg1; - let pattern3_0 = arg2; - // Rule at src/isa/x64/inst.isle line 1487. - let expr0_0 = SseOpcode::Movupd; - let expr1_0 = constructor_synthetic_amode_to_xmm_mem(ctx, pattern2_0)?; - let expr2_0 = constructor_xmm_unary_rm_r(ctx, &expr0_0, &expr1_0)?; - let expr3_0 = C::xmm_to_reg(ctx, expr2_0); - return Some(expr3_0); - } - if let Some((pattern1_0, pattern1_1)) = C::multi_lane(ctx, pattern0_0) { - let pattern2_0 = arg1; - let pattern3_0 = arg2; - // Rule at src/isa/x64/inst.isle line 1491. - let expr0_0 = SseOpcode::Movdqu; - let expr1_0 = constructor_synthetic_amode_to_xmm_mem(ctx, pattern2_0)?; - let expr2_0 = constructor_xmm_unary_rm_r(ctx, &expr0_0, &expr1_0)?; - let expr3_0 = C::xmm_to_reg(ctx, expr2_0); - return Some(expr3_0); - } - if let Some(pattern1_0) = C::fits_in_32(ctx, pattern0_0) { - let pattern2_0 = arg1; - let pattern3_0 = arg2; - if let &ExtKind::SignExtend = pattern3_0 { - // Rule at src/isa/x64/inst.isle line 1466. - let expr0_0 = C::ty_bytes(ctx, pattern1_0); - let expr1_0: u16 = 8; - let expr2_0 = C::ext_mode(ctx, expr0_0, expr1_0); - let expr3_0 = constructor_synthetic_amode_to_gpr_mem(ctx, pattern2_0)?; - let expr4_0 = constructor_x64_movsx(ctx, &expr2_0, &expr3_0)?; - let expr5_0 = C::gpr_to_reg(ctx, expr4_0); - return Some(expr5_0); - } - } - return None; -} - -// Generated as internal constructor for term x64_mov. -pub fn constructor_x64_mov(ctx: &mut C, arg0: &Amode) -> Option { - let pattern0_0 = arg0; - // Rule at src/isa/x64/inst.isle line 1496. - let expr0_0 = C::temp_writable_gpr(ctx); - let expr1_0 = C::amode_to_synthetic_amode(ctx, pattern0_0); - let expr2_0 = MInst::Mov64MR { - src: expr1_0, - dst: expr0_0, - }; - let expr3_0 = C::emit(ctx, &expr2_0); - let expr4_0 = constructor_writable_gpr_to_r_reg(ctx, expr0_0)?; - return Some(expr4_0); -} - -// Generated as internal constructor for term x64_movzx. -pub fn constructor_x64_movzx( - ctx: &mut C, - arg0: &ExtMode, - arg1: &GprMem, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/x64/inst.isle line 1502. - let expr0_0 = C::temp_writable_gpr(ctx); - let expr1_0 = MInst::MovzxRmR { - ext_mode: pattern0_0.clone(), - src: pattern1_0.clone(), - dst: expr0_0, - }; - let expr2_0 = C::emit(ctx, &expr1_0); - let expr3_0 = C::writable_gpr_to_gpr(ctx, expr0_0); - return Some(expr3_0); -} - -// Generated as internal constructor for term x64_movsx. -pub fn constructor_x64_movsx( - ctx: &mut C, - arg0: &ExtMode, - arg1: &GprMem, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/x64/inst.isle line 1508. - let expr0_0 = C::temp_writable_gpr(ctx); - let expr1_0 = MInst::MovsxRmR { - ext_mode: pattern0_0.clone(), - src: pattern1_0.clone(), - dst: expr0_0, - }; - let expr2_0 = C::emit(ctx, &expr1_0); - let expr3_0 = C::writable_gpr_to_gpr(ctx, expr0_0); - return Some(expr3_0); -} - -// Generated as internal constructor for term x64_movss_load. -pub fn constructor_x64_movss_load(ctx: &mut C, arg0: &XmmMem) -> Option { - let pattern0_0 = arg0; - // Rule at src/isa/x64/inst.isle line 1514. - let expr0_0 = SseOpcode::Movss; - let expr1_0 = constructor_xmm_unary_rm_r(ctx, &expr0_0, pattern0_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term x64_movsd_load. -pub fn constructor_x64_movsd_load(ctx: &mut C, arg0: &XmmMem) -> Option { - let pattern0_0 = arg0; - // Rule at src/isa/x64/inst.isle line 1518. - let expr0_0 = SseOpcode::Movsd; - let expr1_0 = constructor_xmm_unary_rm_r(ctx, &expr0_0, pattern0_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term x64_movups. -pub fn constructor_x64_movups(ctx: &mut C, arg0: &XmmMem) -> Option { - let pattern0_0 = arg0; - // Rule at src/isa/x64/inst.isle line 1522. - let expr0_0 = SseOpcode::Movups; - let expr1_0 = constructor_xmm_unary_rm_r(ctx, &expr0_0, pattern0_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term x64_movupd. -pub fn constructor_x64_movupd(ctx: &mut C, arg0: &XmmMem) -> Option { - let pattern0_0 = arg0; - // Rule at src/isa/x64/inst.isle line 1526. - let expr0_0 = SseOpcode::Movupd; - let expr1_0 = constructor_xmm_unary_rm_r(ctx, &expr0_0, pattern0_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term x64_movdqu. -pub fn constructor_x64_movdqu(ctx: &mut C, arg0: &XmmMem) -> Option { - let pattern0_0 = arg0; - // Rule at src/isa/x64/inst.isle line 1530. - let expr0_0 = SseOpcode::Movdqu; - let expr1_0 = constructor_xmm_unary_rm_r(ctx, &expr0_0, pattern0_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term x64_pmovsxbw. -pub fn constructor_x64_pmovsxbw(ctx: &mut C, arg0: &XmmMem) -> Option { - let pattern0_0 = arg0; - // Rule at src/isa/x64/inst.isle line 1534. - let expr0_0 = SseOpcode::Pmovsxbw; - let expr1_0 = constructor_xmm_unary_rm_r(ctx, &expr0_0, pattern0_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term x64_pmovzxbw. -pub fn constructor_x64_pmovzxbw(ctx: &mut C, arg0: &XmmMem) -> Option { - let pattern0_0 = arg0; - // Rule at src/isa/x64/inst.isle line 1538. - let expr0_0 = SseOpcode::Pmovzxbw; - let expr1_0 = constructor_xmm_unary_rm_r(ctx, &expr0_0, pattern0_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term x64_pmovsxwd. -pub fn constructor_x64_pmovsxwd(ctx: &mut C, arg0: &XmmMem) -> Option { - let pattern0_0 = arg0; - // Rule at src/isa/x64/inst.isle line 1542. - let expr0_0 = SseOpcode::Pmovsxwd; - let expr1_0 = constructor_xmm_unary_rm_r(ctx, &expr0_0, pattern0_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term x64_pmovzxwd. -pub fn constructor_x64_pmovzxwd(ctx: &mut C, arg0: &XmmMem) -> Option { - let pattern0_0 = arg0; - // Rule at src/isa/x64/inst.isle line 1546. - let expr0_0 = SseOpcode::Pmovzxwd; - let expr1_0 = constructor_xmm_unary_rm_r(ctx, &expr0_0, pattern0_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term x64_pmovsxdq. -pub fn constructor_x64_pmovsxdq(ctx: &mut C, arg0: &XmmMem) -> Option { - let pattern0_0 = arg0; - // Rule at src/isa/x64/inst.isle line 1550. - let expr0_0 = SseOpcode::Pmovsxdq; - let expr1_0 = constructor_xmm_unary_rm_r(ctx, &expr0_0, pattern0_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term x64_pmovzxdq. -pub fn constructor_x64_pmovzxdq(ctx: &mut C, arg0: &XmmMem) -> Option { - let pattern0_0 = arg0; - // Rule at src/isa/x64/inst.isle line 1554. - let expr0_0 = SseOpcode::Pmovzxdq; - let expr1_0 = constructor_xmm_unary_rm_r(ctx, &expr0_0, pattern0_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term x64_movrm. -pub fn constructor_x64_movrm( - ctx: &mut C, - arg0: Type, - arg1: &SyntheticAmode, - arg2: Gpr, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/x64/inst.isle line 1558. - let expr0_0 = C::raw_operand_size_of_type(ctx, pattern0_0); - let expr1_0 = MInst::MovRM { - size: expr0_0, - src: pattern2_0, - dst: pattern1_0.clone(), - }; - let expr2_0 = SideEffectNoResult::Inst { inst: expr1_0 }; - return Some(expr2_0); -} - -// Generated as internal constructor for term x64_xmm_movrm. -pub fn constructor_x64_xmm_movrm( - ctx: &mut C, - arg0: &SseOpcode, - arg1: &SyntheticAmode, - arg2: Xmm, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/x64/inst.isle line 1563. - let expr0_0 = C::xmm_to_reg(ctx, pattern2_0); - let expr1_0 = MInst::XmmMovRM { - op: pattern0_0.clone(), - src: expr0_0, - dst: pattern1_0.clone(), - }; - let expr2_0 = SideEffectNoResult::Inst { inst: expr1_0 }; - return Some(expr2_0); -} - -// Generated as internal constructor for term x64_xmm_load_const. -pub fn constructor_x64_xmm_load_const( - ctx: &mut C, - arg0: Type, - arg1: VCodeConstant, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/x64/inst.isle line 1568. - let expr0_0 = C::temp_writable_xmm(ctx); - let expr1_0 = C::writable_xmm_to_reg(ctx, expr0_0); - let expr2_0 = MInst::XmmLoadConst { - src: pattern1_0, - dst: expr1_0, - ty: pattern0_0, - }; - let expr3_0 = C::emit(ctx, &expr2_0); - let expr4_0 = C::writable_xmm_to_xmm(ctx, expr0_0); - return Some(expr4_0); -} - -// Generated as internal constructor for term alu_rmi_r. -pub fn constructor_alu_rmi_r( - ctx: &mut C, - arg0: Type, - arg1: &AluRmiROpcode, - arg2: Gpr, - arg3: &GprMemImm, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - let pattern3_0 = arg3; - // Rule at src/isa/x64/inst.isle line 1581. - let expr0_0 = C::temp_writable_gpr(ctx); - let expr1_0 = C::operand_size_of_type_32_64(ctx, pattern0_0); - let expr2_0 = MInst::AluRmiR { - size: expr1_0, - op: pattern1_0.clone(), - src1: pattern2_0, - src2: pattern3_0.clone(), - dst: expr0_0, - }; - let expr3_0 = C::emit(ctx, &expr2_0); - let expr4_0 = C::writable_gpr_to_gpr(ctx, expr0_0); - return Some(expr4_0); -} - -// Generated as internal constructor for term x64_add. -pub fn constructor_x64_add( - ctx: &mut C, - arg0: Type, - arg1: Gpr, - arg2: &GprMemImm, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/x64/inst.isle line 1589. - let expr0_0 = AluRmiROpcode::Add; - let expr1_0 = constructor_alu_rmi_r(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term x64_add_with_flags_paired. -pub fn constructor_x64_add_with_flags_paired( - ctx: &mut C, - arg0: Type, - arg1: Gpr, - arg2: &GprMemImm, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/x64/inst.isle line 1597. - let expr0_0 = C::temp_writable_gpr(ctx); - let expr1_0 = C::operand_size_of_type_32_64(ctx, pattern0_0); - let expr2_0 = AluRmiROpcode::Add; - let expr3_0 = MInst::AluRmiR { - size: expr1_0, - op: expr2_0, - src1: pattern1_0, - src2: pattern2_0.clone(), - dst: expr0_0, - }; - let expr4_0 = constructor_writable_gpr_to_r_reg(ctx, expr0_0)?; - let expr5_0 = ProducesFlags::ProducesFlagsReturnsResultWithConsumer { - inst: expr3_0, - result: expr4_0, - }; - return Some(expr5_0); -} - -// Generated as internal constructor for term x64_adc_paired. -pub fn constructor_x64_adc_paired( - ctx: &mut C, - arg0: Type, - arg1: Gpr, - arg2: &GprMemImm, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/x64/inst.isle line 1609. - let expr0_0 = C::temp_writable_gpr(ctx); - let expr1_0 = C::operand_size_of_type_32_64(ctx, pattern0_0); - let expr2_0 = AluRmiROpcode::Adc; - let expr3_0 = MInst::AluRmiR { - size: expr1_0, - op: expr2_0, - src1: pattern1_0, - src2: pattern2_0.clone(), - dst: expr0_0, - }; - let expr4_0 = constructor_writable_gpr_to_r_reg(ctx, expr0_0)?; - let expr5_0 = ConsumesFlags::ConsumesFlagsReturnsResultWithProducer { - inst: expr3_0, - result: expr4_0, - }; - return Some(expr5_0); -} - -// Generated as internal constructor for term x64_sub. -pub fn constructor_x64_sub( - ctx: &mut C, - arg0: Type, - arg1: Gpr, - arg2: &GprMemImm, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/x64/inst.isle line 1621. - let expr0_0 = AluRmiROpcode::Sub; - let expr1_0 = constructor_alu_rmi_r(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term x64_sub_with_flags_paired. -pub fn constructor_x64_sub_with_flags_paired( - ctx: &mut C, - arg0: Type, - arg1: Gpr, - arg2: &GprMemImm, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/x64/inst.isle line 1629. - let expr0_0 = C::temp_writable_gpr(ctx); - let expr1_0 = C::operand_size_of_type_32_64(ctx, pattern0_0); - let expr2_0 = AluRmiROpcode::Sub; - let expr3_0 = MInst::AluRmiR { - size: expr1_0, - op: expr2_0, - src1: pattern1_0, - src2: pattern2_0.clone(), - dst: expr0_0, - }; - let expr4_0 = constructor_writable_gpr_to_r_reg(ctx, expr0_0)?; - let expr5_0 = ProducesFlags::ProducesFlagsReturnsResultWithConsumer { - inst: expr3_0, - result: expr4_0, - }; - return Some(expr5_0); -} - -// Generated as internal constructor for term x64_sbb_paired. -pub fn constructor_x64_sbb_paired( - ctx: &mut C, - arg0: Type, - arg1: Gpr, - arg2: &GprMemImm, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/x64/inst.isle line 1641. - let expr0_0 = C::temp_writable_gpr(ctx); - let expr1_0 = C::operand_size_of_type_32_64(ctx, pattern0_0); - let expr2_0 = AluRmiROpcode::Sbb; - let expr3_0 = MInst::AluRmiR { - size: expr1_0, - op: expr2_0, - src1: pattern1_0, - src2: pattern2_0.clone(), - dst: expr0_0, - }; - let expr4_0 = constructor_writable_gpr_to_r_reg(ctx, expr0_0)?; - let expr5_0 = ConsumesFlags::ConsumesFlagsReturnsResultWithProducer { - inst: expr3_0, - result: expr4_0, - }; - return Some(expr5_0); -} - -// Generated as internal constructor for term x64_mul. -pub fn constructor_x64_mul( - ctx: &mut C, - arg0: Type, - arg1: Gpr, - arg2: &GprMemImm, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/x64/inst.isle line 1653. - let expr0_0 = AluRmiROpcode::Mul; - let expr1_0 = constructor_alu_rmi_r(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term x64_and. -pub fn constructor_x64_and( - ctx: &mut C, - arg0: Type, - arg1: Gpr, - arg2: &GprMemImm, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/x64/inst.isle line 1661. - let expr0_0 = AluRmiROpcode::And; - let expr1_0 = constructor_alu_rmi_r(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term x64_and_with_flags_paired. -pub fn constructor_x64_and_with_flags_paired( - ctx: &mut C, - arg0: Type, - arg1: Gpr, - arg2: &GprMemImm, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/x64/inst.isle line 1668. - let expr0_0 = C::temp_writable_gpr(ctx); - let expr1_0 = C::operand_size_of_type_32_64(ctx, pattern0_0); - let expr2_0 = AluRmiROpcode::And; - let expr3_0 = MInst::AluRmiR { - size: expr1_0, - op: expr2_0, - src1: pattern1_0, - src2: pattern2_0.clone(), - dst: expr0_0, - }; - let expr4_0 = ProducesFlags::ProducesFlagsSideEffect { inst: expr3_0 }; - return Some(expr4_0); -} - -// Generated as internal constructor for term x64_or. -pub fn constructor_x64_or( - ctx: &mut C, - arg0: Type, - arg1: Gpr, - arg2: &GprMemImm, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/x64/inst.isle line 1679. - let expr0_0 = AluRmiROpcode::Or; - let expr1_0 = constructor_alu_rmi_r(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term x64_xor. -pub fn constructor_x64_xor( - ctx: &mut C, - arg0: Type, - arg1: Gpr, - arg2: &GprMemImm, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/x64/inst.isle line 1687. - let expr0_0 = AluRmiROpcode::Xor; - let expr1_0 = constructor_alu_rmi_r(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term imm. -pub fn constructor_imm(ctx: &mut C, arg0: Type, arg1: u64) -> Option { - let pattern0_0 = arg0; - if pattern0_0 == I64 { - let pattern2_0 = arg1; - if let Some(pattern3_0) = C::nonzero_u64_fits_in_u32(ctx, pattern2_0) { - // Rule at src/isa/x64/inst.isle line 1727. - let expr0_0 = C::temp_writable_gpr(ctx); - let expr1_0 = OperandSize::Size32; - let expr2_0 = MInst::Imm { - dst_size: expr1_0, - simm64: pattern3_0, - dst: expr0_0, - }; - let expr3_0 = C::emit(ctx, &expr2_0); - let expr4_0 = constructor_writable_gpr_to_r_reg(ctx, expr0_0)?; - return Some(expr4_0); - } - } - if pattern0_0 == F32 { - let pattern2_0 = arg1; - if pattern2_0 == 0 { - // Rule at src/isa/x64/inst.isle line 1756. - let expr0_0 = C::temp_writable_xmm(ctx); - let expr1_0 = C::writable_xmm_to_xmm(ctx, expr0_0); - let expr2_0 = SseOpcode::Xorps; - let expr3_0 = C::xmm_to_xmm_mem(ctx, expr1_0); - let expr4_0 = MInst::XmmRmR { - op: expr2_0, - src1: expr1_0, - src2: expr3_0, - dst: expr0_0, - }; - let expr5_0 = C::emit(ctx, &expr4_0); - let expr6_0 = C::xmm_to_reg(ctx, expr1_0); - return Some(expr6_0); - } - // Rule at src/isa/x64/inst.isle line 1704. - let expr0_0 = SseOpcode::Movd; - let expr1_0: Type = I32; - let expr2_0 = constructor_imm(ctx, expr1_0, pattern2_0)?; - let expr3_0 = C::reg_to_gpr_mem(ctx, expr2_0); - let expr4_0 = OperandSize::Size32; - let expr5_0 = constructor_gpr_to_xmm(ctx, &expr0_0, &expr3_0, &expr4_0)?; - let expr6_0 = C::xmm_to_reg(ctx, expr5_0); - return Some(expr6_0); - } - if pattern0_0 == F64 { - let pattern2_0 = arg1; - if pattern2_0 == 0 { - // Rule at src/isa/x64/inst.isle line 1768. - let expr0_0 = C::temp_writable_xmm(ctx); - let expr1_0 = C::writable_xmm_to_xmm(ctx, expr0_0); - let expr2_0 = SseOpcode::Xorpd; - let expr3_0 = C::xmm_to_xmm_mem(ctx, expr1_0); - let expr4_0 = MInst::XmmRmR { - op: expr2_0, - src1: expr1_0, - src2: expr3_0, - dst: expr0_0, - }; - let expr5_0 = C::emit(ctx, &expr4_0); - let expr6_0 = C::xmm_to_reg(ctx, expr1_0); - return Some(expr6_0); - } - // Rule at src/isa/x64/inst.isle line 1710. - let expr0_0 = SseOpcode::Movq; - let expr1_0: Type = I64; - let expr2_0 = constructor_imm(ctx, expr1_0, pattern2_0)?; - let expr3_0 = C::reg_to_gpr_mem(ctx, expr2_0); - let expr4_0 = OperandSize::Size64; - let expr5_0 = constructor_gpr_to_xmm(ctx, &expr0_0, &expr3_0, &expr4_0)?; - let expr6_0 = C::xmm_to_reg(ctx, expr5_0); - return Some(expr6_0); - } - if let Some((pattern1_0, pattern1_1)) = C::multi_lane(ctx, pattern0_0) { - let pattern2_0 = arg1; - if pattern2_0 == 0 { - // Rule at src/isa/x64/inst.isle line 1746. - let expr0_0 = C::temp_writable_xmm(ctx); - let expr1_0 = C::writable_xmm_to_xmm(ctx, expr0_0); - let expr2_0 = constructor_sse_xor_op(ctx, pattern0_0)?; - let expr3_0 = C::xmm_to_xmm_mem(ctx, expr1_0); - let expr4_0 = MInst::XmmRmR { - op: expr2_0, - src1: expr1_0, - src2: expr3_0, - dst: expr0_0, - }; - let expr5_0 = C::emit(ctx, &expr4_0); - let expr6_0 = C::xmm_to_reg(ctx, expr1_0); - return Some(expr6_0); - } - } - if let Some(pattern1_0) = C::fits_in_64(ctx, pattern0_0) { - let pattern2_0 = arg1; - if pattern2_0 == 0 { - // Rule at src/isa/x64/inst.isle line 1733. - let expr0_0 = C::temp_writable_gpr(ctx); - let expr1_0 = C::writable_gpr_to_gpr(ctx, expr0_0); - let expr2_0 = C::operand_size_of_type_32_64(ctx, pattern1_0); - let expr3_0 = AluRmiROpcode::Xor; - let expr4_0 = C::gpr_to_gpr_mem_imm(ctx, expr1_0); - let expr5_0 = MInst::AluRmiR { - size: expr2_0, - op: expr3_0, - src1: expr1_0, - src2: expr4_0, - dst: expr0_0, - }; - let expr6_0 = C::emit(ctx, &expr5_0); - let expr7_0 = C::gpr_to_reg(ctx, expr1_0); - return Some(expr7_0); - } - // Rule at src/isa/x64/inst.isle line 1697. - let expr0_0 = C::temp_writable_gpr(ctx); - let expr1_0 = C::operand_size_of_type_32_64(ctx, pattern1_0); - let expr2_0 = MInst::Imm { - dst_size: expr1_0, - simm64: pattern2_0, - dst: expr0_0, - }; - let expr3_0 = C::emit(ctx, &expr2_0); - let expr4_0 = constructor_writable_gpr_to_r_reg(ctx, expr0_0)?; - return Some(expr4_0); - } - return None; -} - -// Generated as internal constructor for term imm_i64. -pub fn constructor_imm_i64(ctx: &mut C, arg0: Type, arg1: i64) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/x64/inst.isle line 1719. - let expr0_0 = C::i64_as_u64(ctx, pattern1_0)?; - let expr1_0 = constructor_imm(ctx, pattern0_0, expr0_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term shift_r. -pub fn constructor_shift_r( - ctx: &mut C, - arg0: Type, - arg1: &ShiftKind, - arg2: Gpr, - arg3: &Imm8Gpr, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - let pattern3_0 = arg3; - // Rule at src/isa/x64/inst.isle line 1781. - let expr0_0 = C::temp_writable_gpr(ctx); - let expr1_0 = C::raw_operand_size_of_type(ctx, pattern0_0); - let expr2_0 = MInst::ShiftR { - size: expr1_0, - kind: pattern1_0.clone(), - src: pattern2_0, - num_bits: pattern3_0.clone(), - dst: expr0_0, - }; - let expr3_0 = C::emit(ctx, &expr2_0); - let expr4_0 = C::writable_gpr_to_gpr(ctx, expr0_0); - return Some(expr4_0); -} - -// Generated as internal constructor for term x64_rotl. -pub fn constructor_x64_rotl( - ctx: &mut C, - arg0: Type, - arg1: Gpr, - arg2: &Imm8Gpr, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/x64/inst.isle line 1791. - let expr0_0 = ShiftKind::RotateLeft; - let expr1_0 = constructor_shift_r(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term x64_rotr. -pub fn constructor_x64_rotr( - ctx: &mut C, - arg0: Type, - arg1: Gpr, - arg2: &Imm8Gpr, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/x64/inst.isle line 1796. - let expr0_0 = ShiftKind::RotateRight; - let expr1_0 = constructor_shift_r(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term x64_shl. -pub fn constructor_x64_shl( - ctx: &mut C, - arg0: Type, - arg1: Gpr, - arg2: &Imm8Gpr, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/x64/inst.isle line 1801. - let expr0_0 = ShiftKind::ShiftLeft; - let expr1_0 = constructor_shift_r(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term x64_shr. -pub fn constructor_x64_shr( - ctx: &mut C, - arg0: Type, - arg1: Gpr, - arg2: &Imm8Gpr, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/x64/inst.isle line 1806. - let expr0_0 = ShiftKind::ShiftRightLogical; - let expr1_0 = constructor_shift_r(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term x64_sar. -pub fn constructor_x64_sar( - ctx: &mut C, - arg0: Type, - arg1: Gpr, - arg2: &Imm8Gpr, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/x64/inst.isle line 1811. - let expr0_0 = ShiftKind::ShiftRightArithmetic; - let expr1_0 = constructor_shift_r(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term cmp_rmi_r. -pub fn constructor_cmp_rmi_r( - ctx: &mut C, - arg0: &OperandSize, - arg1: &CmpOpcode, - arg2: &GprMemImm, - arg3: Gpr, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - let pattern3_0 = arg3; - // Rule at src/isa/x64/inst.isle line 1816. - let expr0_0 = MInst::CmpRmiR { - size: pattern0_0.clone(), - opcode: pattern1_0.clone(), - src: pattern2_0.clone(), - dst: pattern3_0, - }; - let expr1_0 = ProducesFlags::ProducesFlagsSideEffect { inst: expr0_0 }; - return Some(expr1_0); -} - -// Generated as internal constructor for term x64_cmp. -pub fn constructor_x64_cmp( - ctx: &mut C, - arg0: &OperandSize, - arg1: &GprMemImm, - arg2: Gpr, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/x64/inst.isle line 1825. - let expr0_0 = CmpOpcode::Cmp; - let expr1_0 = constructor_cmp_rmi_r(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term x64_cmp_imm. -pub fn constructor_x64_cmp_imm( - ctx: &mut C, - arg0: &OperandSize, - arg1: u32, - arg2: Gpr, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/x64/inst.isle line 1830. - let expr0_0 = CmpOpcode::Cmp; - let expr1_0 = RegMemImm::Imm { simm32: pattern1_0 }; - let expr2_0 = C::gpr_mem_imm_new(ctx, &expr1_0); - let expr3_0 = constructor_cmp_rmi_r(ctx, pattern0_0, &expr0_0, &expr2_0, pattern2_0)?; - return Some(expr3_0); -} - -// Generated as internal constructor for term xmm_cmp_rm_r. -pub fn constructor_xmm_cmp_rm_r( - ctx: &mut C, - arg0: &SseOpcode, - arg1: &XmmMem, - arg2: Xmm, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/x64/inst.isle line 1835. - let expr0_0 = MInst::XmmCmpRmR { - op: pattern0_0.clone(), - src: pattern1_0.clone(), - dst: pattern2_0, - }; - let expr1_0 = ProducesFlags::ProducesFlagsSideEffect { inst: expr0_0 }; - return Some(expr1_0); -} - -// Generated as internal constructor for term x64_ucomis. -pub fn constructor_x64_ucomis( - ctx: &mut C, - arg0: Value, - arg1: Value, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = C::value_type(ctx, pattern0_0); - if pattern1_0 == F32 { - let pattern3_0 = arg1; - // Rule at src/isa/x64/inst.isle line 1841. - let expr0_0 = SseOpcode::Ucomiss; - let expr1_0 = constructor_put_in_xmm(ctx, pattern0_0)?; - let expr2_0 = C::xmm_to_xmm_mem(ctx, expr1_0); - let expr3_0 = constructor_put_in_xmm(ctx, pattern3_0)?; - let expr4_0 = constructor_xmm_cmp_rm_r(ctx, &expr0_0, &expr2_0, expr3_0)?; - return Some(expr4_0); - } - if pattern1_0 == F64 { - let pattern3_0 = arg1; - // Rule at src/isa/x64/inst.isle line 1845. - let expr0_0 = SseOpcode::Ucomisd; - let expr1_0 = constructor_put_in_xmm(ctx, pattern0_0)?; - let expr2_0 = C::xmm_to_xmm_mem(ctx, expr1_0); - let expr3_0 = constructor_put_in_xmm(ctx, pattern3_0)?; - let expr4_0 = constructor_xmm_cmp_rm_r(ctx, &expr0_0, &expr2_0, expr3_0)?; - return Some(expr4_0); - } - return None; -} - -// Generated as internal constructor for term x64_test. -pub fn constructor_x64_test( - ctx: &mut C, - arg0: &OperandSize, - arg1: &GprMemImm, - arg2: Gpr, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/x64/inst.isle line 1850. - let expr0_0 = CmpOpcode::Test; - let expr1_0 = constructor_cmp_rmi_r(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term cmove. -pub fn constructor_cmove( - ctx: &mut C, - arg0: Type, - arg1: &CC, - arg2: &GprMem, - arg3: Gpr, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - let pattern3_0 = arg3; - // Rule at src/isa/x64/inst.isle line 1857. - let expr0_0 = C::temp_writable_gpr(ctx); - let expr1_0 = C::operand_size_of_type_32_64(ctx, pattern0_0); - let expr2_0 = MInst::Cmove { - size: expr1_0, - cc: pattern1_0.clone(), - consequent: pattern2_0.clone(), - alternative: pattern3_0, - dst: expr0_0, - }; - let expr3_0 = constructor_writable_gpr_to_r_reg(ctx, expr0_0)?; - let expr4_0 = ConsumesFlags::ConsumesFlagsReturnsReg { - inst: expr2_0, - result: expr3_0, - }; - return Some(expr4_0); -} - -// Generated as internal constructor for term cmove_xmm. -pub fn constructor_cmove_xmm( - ctx: &mut C, - arg0: Type, - arg1: &CC, - arg2: &XmmMem, - arg3: Xmm, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - let pattern3_0 = arg3; - // Rule at src/isa/x64/inst.isle line 1865. - let expr0_0 = C::temp_writable_xmm(ctx); - let expr1_0 = C::operand_size_of_type_32_64(ctx, pattern0_0); - let expr2_0 = MInst::XmmCmove { - size: expr1_0, - cc: pattern1_0.clone(), - consequent: pattern2_0.clone(), - alternative: pattern3_0, - dst: expr0_0, - }; - let expr3_0 = constructor_writable_xmm_to_r_reg(ctx, expr0_0)?; - let expr4_0 = ConsumesFlags::ConsumesFlagsReturnsReg { - inst: expr2_0, - result: expr3_0, - }; - return Some(expr4_0); -} - -// Generated as internal constructor for term cmove_from_values. -pub fn constructor_cmove_from_values( - ctx: &mut C, - arg0: Type, - arg1: &CC, - arg2: Value, - arg3: Value, -) -> Option { - let pattern0_0 = arg0; - if pattern0_0 == I128 { - let pattern2_0 = arg1; - let pattern3_0 = arg2; - let pattern4_0 = arg3; - // Rule at src/isa/x64/inst.isle line 1876. - let expr0_0 = C::put_in_regs(ctx, pattern3_0); - let expr1_0 = C::put_in_regs(ctx, pattern4_0); - let expr2_0 = C::temp_writable_gpr(ctx); - let expr3_0 = C::temp_writable_gpr(ctx); - let expr4_0 = OperandSize::Size64; - let expr5_0: usize = 0; - let expr6_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr5_0)?; - let expr7_0 = C::gpr_to_gpr_mem(ctx, expr6_0); - let expr8_0: usize = 0; - let expr9_0 = constructor_value_regs_get_gpr(ctx, expr1_0, expr8_0)?; - let expr10_0 = MInst::Cmove { - size: expr4_0, - cc: pattern2_0.clone(), - consequent: expr7_0, - alternative: expr9_0, - dst: expr2_0, - }; - let expr11_0: usize = 1; - let expr12_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr11_0)?; - let expr13_0 = C::gpr_to_gpr_mem(ctx, expr12_0); - let expr14_0: usize = 1; - let expr15_0 = constructor_value_regs_get_gpr(ctx, expr1_0, expr14_0)?; - let expr16_0 = MInst::Cmove { - size: expr4_0, - cc: pattern2_0.clone(), - consequent: expr13_0, - alternative: expr15_0, - dst: expr3_0, - }; - let expr17_0 = constructor_writable_gpr_to_r_reg(ctx, expr2_0)?; - let expr18_0 = constructor_writable_gpr_to_r_reg(ctx, expr3_0)?; - let expr19_0 = C::value_regs(ctx, expr17_0, expr18_0); - let expr20_0 = ConsumesFlags::ConsumesFlagsTwiceReturnsValueRegs { - inst1: expr10_0, - inst2: expr16_0, - result: expr19_0, - }; - return Some(expr20_0); - } - if let Some(pattern1_0) = C::is_xmm_type(ctx, pattern0_0) { - if let Some(pattern2_0) = C::is_single_register_type(ctx, pattern1_0) { - let pattern3_0 = arg1; - let pattern4_0 = arg2; - let pattern5_0 = arg3; - // Rule at src/isa/x64/inst.isle line 1900. - let expr0_0 = constructor_put_in_xmm_mem(ctx, pattern4_0)?; - let expr1_0 = constructor_put_in_xmm(ctx, pattern5_0)?; - let expr2_0 = constructor_cmove_xmm(ctx, pattern2_0, pattern3_0, &expr0_0, expr1_0)?; - return Some(expr2_0); - } - } - if let Some(pattern1_0) = C::is_gpr_type(ctx, pattern0_0) { - if let Some(pattern2_0) = C::is_single_register_type(ctx, pattern1_0) { - let pattern3_0 = arg1; - let pattern4_0 = arg2; - let pattern5_0 = arg3; - // Rule at src/isa/x64/inst.isle line 1897. - let expr0_0 = constructor_put_in_gpr_mem(ctx, pattern4_0)?; - let expr1_0 = constructor_put_in_gpr(ctx, pattern5_0)?; - let expr2_0 = constructor_cmove(ctx, pattern2_0, pattern3_0, &expr0_0, expr1_0)?; - return Some(expr2_0); - } - } - return None; -} - -// Generated as internal constructor for term cmove_or. -pub fn constructor_cmove_or( - ctx: &mut C, - arg0: Type, - arg1: &CC, - arg2: &CC, - arg3: &GprMem, - arg4: Gpr, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - let pattern3_0 = arg3; - let pattern4_0 = arg4; - // Rule at src/isa/x64/inst.isle line 1907. - let expr0_0 = C::temp_writable_gpr(ctx); - let expr1_0 = C::temp_writable_gpr(ctx); - let expr2_0 = C::operand_size_of_type_32_64(ctx, pattern0_0); - let expr3_0 = MInst::Cmove { - size: expr2_0, - cc: pattern1_0.clone(), - consequent: pattern3_0.clone(), - alternative: pattern4_0, - dst: expr1_0, - }; - let expr4_0 = C::writable_gpr_to_gpr(ctx, expr1_0); - let expr5_0 = MInst::Cmove { - size: expr2_0, - cc: pattern2_0.clone(), - consequent: pattern3_0.clone(), - alternative: expr4_0, - dst: expr0_0, - }; - let expr6_0 = constructor_writable_gpr_to_value_regs(ctx, expr0_0)?; - let expr7_0 = ConsumesFlags::ConsumesFlagsTwiceReturnsValueRegs { - inst1: expr3_0, - inst2: expr5_0, - result: expr6_0, - }; - return Some(expr7_0); -} - -// Generated as internal constructor for term cmove_or_xmm. -pub fn constructor_cmove_or_xmm( - ctx: &mut C, - arg0: Type, - arg1: &CC, - arg2: &CC, - arg3: &XmmMem, - arg4: Xmm, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - let pattern3_0 = arg3; - let pattern4_0 = arg4; - // Rule at src/isa/x64/inst.isle line 1919. - let expr0_0 = C::temp_writable_xmm(ctx); - let expr1_0 = C::temp_writable_xmm(ctx); - let expr2_0 = C::operand_size_of_type_32_64(ctx, pattern0_0); - let expr3_0 = MInst::XmmCmove { - size: expr2_0, - cc: pattern1_0.clone(), - consequent: pattern3_0.clone(), - alternative: pattern4_0, - dst: expr1_0, - }; - let expr4_0 = C::writable_xmm_to_xmm(ctx, expr1_0); - let expr5_0 = MInst::XmmCmove { - size: expr2_0, - cc: pattern2_0.clone(), - consequent: pattern3_0.clone(), - alternative: expr4_0, - dst: expr0_0, - }; - let expr6_0 = constructor_writable_xmm_to_value_regs(ctx, expr0_0)?; - let expr7_0 = ConsumesFlags::ConsumesFlagsTwiceReturnsValueRegs { - inst1: expr3_0, - inst2: expr5_0, - result: expr6_0, - }; - return Some(expr7_0); -} - -// Generated as internal constructor for term cmove_or_from_values. -pub fn constructor_cmove_or_from_values( - ctx: &mut C, - arg0: Type, - arg1: &CC, - arg2: &CC, - arg3: Value, - arg4: Value, -) -> Option { - let pattern0_0 = arg0; - if pattern0_0 == I128 { - let pattern2_0 = arg1; - let pattern3_0 = arg2; - let pattern4_0 = arg3; - let pattern5_0 = arg4; - // Rule at src/isa/x64/inst.isle line 1934. - let expr0_0 = C::put_in_regs(ctx, pattern4_0); - let expr1_0 = C::put_in_regs(ctx, pattern5_0); - let expr2_0 = C::temp_writable_gpr(ctx); - let expr3_0 = C::temp_writable_gpr(ctx); - let expr4_0 = C::temp_writable_gpr(ctx); - let expr5_0 = C::temp_writable_gpr(ctx); - let expr6_0 = OperandSize::Size64; - let expr7_0: usize = 0; - let expr8_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr7_0)?; - let expr9_0 = C::gpr_to_gpr_mem(ctx, expr8_0); - let expr10_0: usize = 0; - let expr11_0 = constructor_value_regs_get_gpr(ctx, expr1_0, expr10_0)?; - let expr12_0 = MInst::Cmove { - size: expr6_0, - cc: pattern2_0.clone(), - consequent: expr9_0, - alternative: expr11_0, - dst: expr4_0, - }; - let expr13_0: usize = 0; - let expr14_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr13_0)?; - let expr15_0 = C::gpr_to_gpr_mem(ctx, expr14_0); - let expr16_0 = C::writable_gpr_to_gpr(ctx, expr4_0); - let expr17_0 = MInst::Cmove { - size: expr6_0, - cc: pattern3_0.clone(), - consequent: expr15_0, - alternative: expr16_0, - dst: expr2_0, - }; - let expr18_0: usize = 1; - let expr19_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr18_0)?; - let expr20_0 = C::gpr_to_gpr_mem(ctx, expr19_0); - let expr21_0: usize = 1; - let expr22_0 = constructor_value_regs_get_gpr(ctx, expr1_0, expr21_0)?; - let expr23_0 = MInst::Cmove { - size: expr6_0, - cc: pattern2_0.clone(), - consequent: expr20_0, - alternative: expr22_0, - dst: expr5_0, - }; - let expr24_0: usize = 1; - let expr25_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr24_0)?; - let expr26_0 = C::gpr_to_gpr_mem(ctx, expr25_0); - let expr27_0 = C::writable_gpr_to_gpr(ctx, expr5_0); - let expr28_0 = MInst::Cmove { - size: expr6_0, - cc: pattern3_0.clone(), - consequent: expr26_0, - alternative: expr27_0, - dst: expr3_0, - }; - let expr29_0 = constructor_writable_gpr_to_r_reg(ctx, expr2_0)?; - let expr30_0 = constructor_writable_gpr_to_r_reg(ctx, expr3_0)?; - let expr31_0 = C::value_regs(ctx, expr29_0, expr30_0); - let expr32_0 = ConsumesFlags::ConsumesFlagsFourTimesReturnsValueRegs { - inst1: expr12_0, - inst2: expr17_0, - inst3: expr23_0, - inst4: expr28_0, - result: expr31_0, - }; - return Some(expr32_0); - } - if let Some(pattern1_0) = C::is_xmm_type(ctx, pattern0_0) { - if let Some(pattern2_0) = C::is_single_register_type(ctx, pattern1_0) { - let pattern3_0 = arg1; - let pattern4_0 = arg2; - let pattern5_0 = arg3; - let pattern6_0 = arg4; - // Rule at src/isa/x64/inst.isle line 1956. - let expr0_0 = constructor_put_in_xmm_mem(ctx, pattern5_0)?; - let expr1_0 = constructor_put_in_xmm(ctx, pattern6_0)?; - let expr2_0 = constructor_cmove_or_xmm( - ctx, pattern2_0, pattern3_0, pattern4_0, &expr0_0, expr1_0, - )?; - return Some(expr2_0); - } - } - if let Some(pattern1_0) = C::is_gpr_type(ctx, pattern0_0) { - if let Some(pattern2_0) = C::is_single_register_type(ctx, pattern1_0) { - let pattern3_0 = arg1; - let pattern4_0 = arg2; - let pattern5_0 = arg3; - let pattern6_0 = arg4; - // Rule at src/isa/x64/inst.isle line 1953. - let expr0_0 = constructor_put_in_gpr_mem(ctx, pattern5_0)?; - let expr1_0 = constructor_put_in_gpr(ctx, pattern6_0)?; - let expr2_0 = - constructor_cmove_or(ctx, pattern2_0, pattern3_0, pattern4_0, &expr0_0, expr1_0)?; - return Some(expr2_0); - } - } - return None; -} - -// Generated as internal constructor for term x64_setcc. -pub fn constructor_x64_setcc(ctx: &mut C, arg0: &CC) -> Option { - let pattern0_0 = arg0; - // Rule at src/isa/x64/inst.isle line 1961. - let expr0_0 = C::temp_writable_gpr(ctx); - let expr1_0 = MInst::Setcc { - cc: pattern0_0.clone(), - dst: expr0_0, - }; - let expr2_0 = constructor_writable_gpr_to_r_reg(ctx, expr0_0)?; - let expr3_0 = ConsumesFlags::ConsumesFlagsReturnsReg { - inst: expr1_0, - result: expr2_0, - }; - return Some(expr3_0); -} - -// Generated as internal constructor for term xmm_rm_r. -pub fn constructor_xmm_rm_r( - ctx: &mut C, - arg0: Type, - arg1: &SseOpcode, - arg2: Xmm, - arg3: &XmmMem, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - let pattern3_0 = arg3; - // Rule at src/isa/x64/inst.isle line 1969. - let expr0_0 = C::temp_writable_xmm(ctx); - let expr1_0 = MInst::XmmRmR { - op: pattern1_0.clone(), - src1: pattern2_0, - src2: pattern3_0.clone(), - dst: expr0_0, - }; - let expr2_0 = C::emit(ctx, &expr1_0); - let expr3_0 = C::writable_xmm_to_xmm(ctx, expr0_0); - return Some(expr3_0); -} - -// Generated as internal constructor for term x64_paddb. -pub fn constructor_x64_paddb(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/x64/inst.isle line 1976. - let expr0_0: Type = I8X16; - let expr1_0 = SseOpcode::Paddb; - let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?; - return Some(expr2_0); -} - -// Generated as internal constructor for term x64_paddw. -pub fn constructor_x64_paddw(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/x64/inst.isle line 1981. - let expr0_0: Type = I16X8; - let expr1_0 = SseOpcode::Paddw; - let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?; - return Some(expr2_0); -} - -// Generated as internal constructor for term x64_paddd. -pub fn constructor_x64_paddd(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/x64/inst.isle line 1986. - let expr0_0: Type = I32X4; - let expr1_0 = SseOpcode::Paddd; - let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?; - return Some(expr2_0); -} - -// Generated as internal constructor for term x64_paddq. -pub fn constructor_x64_paddq(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/x64/inst.isle line 1991. - let expr0_0: Type = I64X2; - let expr1_0 = SseOpcode::Paddq; - let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?; - return Some(expr2_0); -} - -// Generated as internal constructor for term x64_paddsb. -pub fn constructor_x64_paddsb(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/x64/inst.isle line 1996. - let expr0_0: Type = I8X16; - let expr1_0 = SseOpcode::Paddsb; - let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?; - return Some(expr2_0); -} - -// Generated as internal constructor for term x64_paddsw. -pub fn constructor_x64_paddsw(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/x64/inst.isle line 2001. - let expr0_0: Type = I16X8; - let expr1_0 = SseOpcode::Paddsw; - let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?; - return Some(expr2_0); -} - -// Generated as internal constructor for term x64_paddusb. -pub fn constructor_x64_paddusb(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/x64/inst.isle line 2006. - let expr0_0: Type = I8X16; - let expr1_0 = SseOpcode::Paddusb; - let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?; - return Some(expr2_0); -} - -// Generated as internal constructor for term x64_paddusw. -pub fn constructor_x64_paddusw(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/x64/inst.isle line 2011. - let expr0_0: Type = I16X8; - let expr1_0 = SseOpcode::Paddusw; - let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?; - return Some(expr2_0); -} - -// Generated as internal constructor for term x64_psubb. -pub fn constructor_x64_psubb(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/x64/inst.isle line 2016. - let expr0_0: Type = I8X16; - let expr1_0 = SseOpcode::Psubb; - let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?; - return Some(expr2_0); -} - -// Generated as internal constructor for term x64_psubw. -pub fn constructor_x64_psubw(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/x64/inst.isle line 2021. - let expr0_0: Type = I16X8; - let expr1_0 = SseOpcode::Psubw; - let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?; - return Some(expr2_0); -} - -// Generated as internal constructor for term x64_psubd. -pub fn constructor_x64_psubd(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/x64/inst.isle line 2026. - let expr0_0: Type = I32X4; - let expr1_0 = SseOpcode::Psubd; - let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?; - return Some(expr2_0); -} - -// Generated as internal constructor for term x64_psubq. -pub fn constructor_x64_psubq(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/x64/inst.isle line 2031. - let expr0_0: Type = I64X2; - let expr1_0 = SseOpcode::Psubq; - let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?; - return Some(expr2_0); -} - -// Generated as internal constructor for term x64_psubsb. -pub fn constructor_x64_psubsb(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/x64/inst.isle line 2036. - let expr0_0: Type = I8X16; - let expr1_0 = SseOpcode::Psubsb; - let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?; - return Some(expr2_0); -} - -// Generated as internal constructor for term x64_psubsw. -pub fn constructor_x64_psubsw(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/x64/inst.isle line 2041. - let expr0_0: Type = I16X8; - let expr1_0 = SseOpcode::Psubsw; - let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?; - return Some(expr2_0); -} - -// Generated as internal constructor for term x64_psubusb. -pub fn constructor_x64_psubusb(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/x64/inst.isle line 2046. - let expr0_0: Type = I8X16; - let expr1_0 = SseOpcode::Psubusb; - let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?; - return Some(expr2_0); -} - -// Generated as internal constructor for term x64_psubusw. -pub fn constructor_x64_psubusw(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/x64/inst.isle line 2051. - let expr0_0: Type = I16X8; - let expr1_0 = SseOpcode::Psubusw; - let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?; - return Some(expr2_0); -} - -// Generated as internal constructor for term x64_pavgb. -pub fn constructor_x64_pavgb(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/x64/inst.isle line 2056. - let expr0_0: Type = I8X16; - let expr1_0 = SseOpcode::Pavgb; - let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?; - return Some(expr2_0); -} - -// Generated as internal constructor for term x64_pavgw. -pub fn constructor_x64_pavgw(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/x64/inst.isle line 2061. - let expr0_0: Type = I16X8; - let expr1_0 = SseOpcode::Pavgw; - let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?; - return Some(expr2_0); -} - -// Generated as internal constructor for term x64_pand. -pub fn constructor_x64_pand(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/x64/inst.isle line 2066. - let expr0_0: Type = F32X4; - let expr1_0 = SseOpcode::Pand; - let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?; - return Some(expr2_0); -} - -// Generated as internal constructor for term x64_andps. -pub fn constructor_x64_andps(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/x64/inst.isle line 2071. - let expr0_0: Type = F32X4; - let expr1_0 = SseOpcode::Andps; - let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?; - return Some(expr2_0); -} - -// Generated as internal constructor for term x64_andpd. -pub fn constructor_x64_andpd(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/x64/inst.isle line 2076. - let expr0_0: Type = F64X2; - let expr1_0 = SseOpcode::Andpd; - let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?; - return Some(expr2_0); -} - -// Generated as internal constructor for term x64_por. -pub fn constructor_x64_por(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/x64/inst.isle line 2081. - let expr0_0: Type = F32X4; - let expr1_0 = SseOpcode::Por; - let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?; - return Some(expr2_0); -} - -// Generated as internal constructor for term x64_orps. -pub fn constructor_x64_orps(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/x64/inst.isle line 2086. - let expr0_0: Type = F32X4; - let expr1_0 = SseOpcode::Orps; - let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?; - return Some(expr2_0); -} - -// Generated as internal constructor for term x64_orpd. -pub fn constructor_x64_orpd(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/x64/inst.isle line 2091. - let expr0_0: Type = F64X2; - let expr1_0 = SseOpcode::Orpd; - let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?; - return Some(expr2_0); -} - -// Generated as internal constructor for term x64_pxor. -pub fn constructor_x64_pxor(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/x64/inst.isle line 2096. - let expr0_0: Type = I8X16; - let expr1_0 = SseOpcode::Pxor; - let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?; - return Some(expr2_0); -} - -// Generated as internal constructor for term x64_xorps. -pub fn constructor_x64_xorps(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/x64/inst.isle line 2101. - let expr0_0: Type = F32X4; - let expr1_0 = SseOpcode::Xorps; - let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?; - return Some(expr2_0); -} - -// Generated as internal constructor for term x64_xorpd. -pub fn constructor_x64_xorpd(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/x64/inst.isle line 2106. - let expr0_0: Type = F64X2; - let expr1_0 = SseOpcode::Xorpd; - let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?; - return Some(expr2_0); -} - -// Generated as internal constructor for term x64_pmullw. -pub fn constructor_x64_pmullw(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/x64/inst.isle line 2111. - let expr0_0: Type = I16X8; - let expr1_0 = SseOpcode::Pmullw; - let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?; - return Some(expr2_0); -} - -// Generated as internal constructor for term x64_pmulld. -pub fn constructor_x64_pmulld(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/x64/inst.isle line 2116. - let expr0_0: Type = I16X8; - let expr1_0 = SseOpcode::Pmulld; - let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?; - return Some(expr2_0); -} - -// Generated as internal constructor for term x64_pmulhw. -pub fn constructor_x64_pmulhw(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/x64/inst.isle line 2121. - let expr0_0: Type = I16X8; - let expr1_0 = SseOpcode::Pmulhw; - let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?; - return Some(expr2_0); -} - -// Generated as internal constructor for term x64_pmulhuw. -pub fn constructor_x64_pmulhuw(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/x64/inst.isle line 2126. - let expr0_0: Type = I16X8; - let expr1_0 = SseOpcode::Pmulhuw; - let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?; - return Some(expr2_0); -} - -// Generated as internal constructor for term x64_pmuldq. -pub fn constructor_x64_pmuldq(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/x64/inst.isle line 2131. - let expr0_0: Type = I16X8; - let expr1_0 = SseOpcode::Pmuldq; - let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?; - return Some(expr2_0); -} - -// Generated as internal constructor for term x64_pmuludq. -pub fn constructor_x64_pmuludq(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/x64/inst.isle line 2136. - let expr0_0: Type = I64X2; - let expr1_0 = SseOpcode::Pmuludq; - let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?; - return Some(expr2_0); -} - -// Generated as internal constructor for term x64_punpckhwd. -pub fn constructor_x64_punpckhwd(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/x64/inst.isle line 2141. - let expr0_0: Type = I16X8; - let expr1_0 = SseOpcode::Punpckhwd; - let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?; - return Some(expr2_0); -} - -// Generated as internal constructor for term x64_punpcklwd. -pub fn constructor_x64_punpcklwd(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/x64/inst.isle line 2146. - let expr0_0: Type = I16X8; - let expr1_0 = SseOpcode::Punpcklwd; - let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?; - return Some(expr2_0); -} - -// Generated as internal constructor for term x64_andnps. -pub fn constructor_x64_andnps(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/x64/inst.isle line 2151. - let expr0_0: Type = F32X4; - let expr1_0 = SseOpcode::Andnps; - let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?; - return Some(expr2_0); -} - -// Generated as internal constructor for term x64_andnpd. -pub fn constructor_x64_andnpd(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/x64/inst.isle line 2156. - let expr0_0: Type = F64X2; - let expr1_0 = SseOpcode::Andnpd; - let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?; - return Some(expr2_0); -} - -// Generated as internal constructor for term x64_pandn. -pub fn constructor_x64_pandn(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/x64/inst.isle line 2161. - let expr0_0: Type = F64X2; - let expr1_0 = SseOpcode::Pandn; - let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?; - return Some(expr2_0); -} - -// Generated as internal constructor for term x64_addss. -pub fn constructor_x64_addss(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/x64/inst.isle line 2166. - let expr0_0: Type = F32; - let expr1_0 = SseOpcode::Addss; - let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?; - return Some(expr2_0); -} - -// Generated as internal constructor for term x64_addsd. -pub fn constructor_x64_addsd(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/x64/inst.isle line 2171. - let expr0_0: Type = F64; - let expr1_0 = SseOpcode::Addsd; - let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?; - return Some(expr2_0); -} - -// Generated as internal constructor for term x64_addps. -pub fn constructor_x64_addps(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/x64/inst.isle line 2176. - let expr0_0: Type = F32; - let expr1_0 = SseOpcode::Addps; - let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?; - return Some(expr2_0); -} - -// Generated as internal constructor for term x64_addpd. -pub fn constructor_x64_addpd(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/x64/inst.isle line 2181. - let expr0_0: Type = F32; - let expr1_0 = SseOpcode::Addpd; - let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?; - return Some(expr2_0); -} - -// Generated as internal constructor for term x64_subss. -pub fn constructor_x64_subss(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/x64/inst.isle line 2186. - let expr0_0: Type = F32; - let expr1_0 = SseOpcode::Subss; - let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?; - return Some(expr2_0); -} - -// Generated as internal constructor for term x64_subsd. -pub fn constructor_x64_subsd(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/x64/inst.isle line 2191. - let expr0_0: Type = F64; - let expr1_0 = SseOpcode::Subsd; - let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?; - return Some(expr2_0); -} - -// Generated as internal constructor for term x64_subps. -pub fn constructor_x64_subps(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/x64/inst.isle line 2196. - let expr0_0: Type = F32; - let expr1_0 = SseOpcode::Subps; - let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?; - return Some(expr2_0); -} - -// Generated as internal constructor for term x64_subpd. -pub fn constructor_x64_subpd(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/x64/inst.isle line 2201. - let expr0_0: Type = F32; - let expr1_0 = SseOpcode::Subpd; - let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?; - return Some(expr2_0); -} - -// Generated as internal constructor for term x64_mulss. -pub fn constructor_x64_mulss(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/x64/inst.isle line 2206. - let expr0_0: Type = F32; - let expr1_0 = SseOpcode::Mulss; - let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?; - return Some(expr2_0); -} - -// Generated as internal constructor for term x64_mulsd. -pub fn constructor_x64_mulsd(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/x64/inst.isle line 2211. - let expr0_0: Type = F64; - let expr1_0 = SseOpcode::Mulsd; - let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?; - return Some(expr2_0); -} - -// Generated as internal constructor for term x64_mulps. -pub fn constructor_x64_mulps(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/x64/inst.isle line 2216. - let expr0_0: Type = F32; - let expr1_0 = SseOpcode::Mulps; - let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?; - return Some(expr2_0); -} - -// Generated as internal constructor for term x64_mulpd. -pub fn constructor_x64_mulpd(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/x64/inst.isle line 2221. - let expr0_0: Type = F32; - let expr1_0 = SseOpcode::Mulpd; - let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?; - return Some(expr2_0); -} - -// Generated as internal constructor for term x64_divss. -pub fn constructor_x64_divss(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/x64/inst.isle line 2226. - let expr0_0: Type = F32; - let expr1_0 = SseOpcode::Divss; - let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?; - return Some(expr2_0); -} - -// Generated as internal constructor for term x64_divsd. -pub fn constructor_x64_divsd(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/x64/inst.isle line 2231. - let expr0_0: Type = F64; - let expr1_0 = SseOpcode::Divsd; - let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?; - return Some(expr2_0); -} - -// Generated as internal constructor for term x64_divps. -pub fn constructor_x64_divps(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/x64/inst.isle line 2236. - let expr0_0: Type = F32; - let expr1_0 = SseOpcode::Divps; - let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?; - return Some(expr2_0); -} - -// Generated as internal constructor for term x64_divpd. -pub fn constructor_x64_divpd(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/x64/inst.isle line 2241. - let expr0_0: Type = F32; - let expr1_0 = SseOpcode::Divpd; - let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?; - return Some(expr2_0); -} - -// Generated as internal constructor for term sse_blend_op. -pub fn constructor_sse_blend_op(ctx: &mut C, arg0: Type) -> Option { - let pattern0_0 = arg0; - if pattern0_0 == F32X4 { - // Rule at src/isa/x64/inst.isle line 2245. - let expr0_0 = SseOpcode::Blendvps; - return Some(expr0_0); - } - if pattern0_0 == F64X2 { - // Rule at src/isa/x64/inst.isle line 2246. - let expr0_0 = SseOpcode::Blendvpd; - return Some(expr0_0); - } - if let Some((pattern1_0, pattern1_1)) = C::multi_lane(ctx, pattern0_0) { - // Rule at src/isa/x64/inst.isle line 2247. - let expr0_0 = SseOpcode::Pblendvb; - return Some(expr0_0); - } - return None; -} - -// Generated as internal constructor for term sse_mov_op. -pub fn constructor_sse_mov_op(ctx: &mut C, arg0: Type) -> Option { - let pattern0_0 = arg0; - if pattern0_0 == F32X4 { - // Rule at src/isa/x64/inst.isle line 2250. - let expr0_0 = SseOpcode::Movaps; - return Some(expr0_0); - } - if pattern0_0 == F64X2 { - // Rule at src/isa/x64/inst.isle line 2251. - let expr0_0 = SseOpcode::Movapd; - return Some(expr0_0); - } - if let Some((pattern1_0, pattern1_1)) = C::multi_lane(ctx, pattern0_0) { - // Rule at src/isa/x64/inst.isle line 2252. - let expr0_0 = SseOpcode::Movdqa; - return Some(expr0_0); - } - return None; -} - -// Generated as internal constructor for term x64_blend. -pub fn constructor_x64_blend( - ctx: &mut C, - arg0: Type, - arg1: &XmmMem, - arg2: &XmmMem, - arg3: Xmm, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - let pattern3_0 = arg3; - // Rule at src/isa/x64/inst.isle line 2256. - let expr0_0 = C::xmm0(ctx); - let expr1_0 = constructor_sse_mov_op(ctx, pattern0_0)?; - let expr2_0 = MInst::XmmUnaryRmR { - op: expr1_0, - src: pattern1_0.clone(), - dst: expr0_0, - }; - let expr3_0 = C::emit(ctx, &expr2_0); - let expr4_0 = constructor_sse_blend_op(ctx, pattern0_0)?; - let expr5_0 = constructor_xmm_rm_r(ctx, pattern0_0, &expr4_0, pattern3_0, pattern2_0)?; - return Some(expr5_0); -} - -// Generated as internal constructor for term x64_blendvpd. -pub fn constructor_x64_blendvpd( - ctx: &mut C, - arg0: Xmm, - arg1: &XmmMem, - arg2: Xmm, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/x64/inst.isle line 2270. - let expr0_0 = C::xmm0(ctx); - let expr1_0 = SseOpcode::Movapd; - let expr2_0 = C::xmm_to_xmm_mem(ctx, pattern2_0); - let expr3_0 = MInst::XmmUnaryRmR { - op: expr1_0, - src: expr2_0, - dst: expr0_0, - }; - let expr4_0 = C::emit(ctx, &expr3_0); - let expr5_0: Type = F64X2; - let expr6_0 = SseOpcode::Blendvpd; - let expr7_0 = constructor_xmm_rm_r(ctx, expr5_0, &expr6_0, pattern0_0, pattern1_0)?; - return Some(expr7_0); -} - -// Generated as internal constructor for term x64_movsd_regmove. -pub fn constructor_x64_movsd_regmove( - ctx: &mut C, - arg0: Xmm, - arg1: &XmmMem, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/x64/inst.isle line 2284. - let expr0_0: Type = I8X16; - let expr1_0 = SseOpcode::Movsd; - let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?; - return Some(expr2_0); -} - -// Generated as internal constructor for term x64_movlhps. -pub fn constructor_x64_movlhps(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/x64/inst.isle line 2289. - let expr0_0: Type = I8X16; - let expr1_0 = SseOpcode::Movlhps; - let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?; - return Some(expr2_0); -} - -// Generated as internal constructor for term x64_pmaxs. -pub fn constructor_x64_pmaxs( - ctx: &mut C, - arg0: Type, - arg1: Xmm, - arg2: &XmmMem, -) -> Option { - let pattern0_0 = arg0; - if pattern0_0 == I8X16 { - let pattern2_0 = arg1; - let pattern3_0 = arg2; - // Rule at src/isa/x64/inst.isle line 2294. - let expr0_0 = constructor_x64_pmaxsb(ctx, pattern2_0, pattern3_0)?; - return Some(expr0_0); - } - if pattern0_0 == I16X8 { - let pattern2_0 = arg1; - let pattern3_0 = arg2; - // Rule at src/isa/x64/inst.isle line 2295. - let expr0_0 = constructor_x64_pmaxsw(ctx, pattern2_0, pattern3_0)?; - return Some(expr0_0); - } - if pattern0_0 == I32X4 { - let pattern2_0 = arg1; - let pattern3_0 = arg2; - // Rule at src/isa/x64/inst.isle line 2296. - let expr0_0 = constructor_x64_pmaxsd(ctx, pattern2_0, pattern3_0)?; - return Some(expr0_0); - } - return None; -} - -// Generated as internal constructor for term x64_pmaxsb. -pub fn constructor_x64_pmaxsb(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/x64/inst.isle line 2299. - let expr0_0: Type = I8X16; - let expr1_0 = SseOpcode::Pmaxsb; - let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?; - return Some(expr2_0); -} - -// Generated as internal constructor for term x64_pmaxsw. -pub fn constructor_x64_pmaxsw(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/x64/inst.isle line 2301. - let expr0_0: Type = I8X16; - let expr1_0 = SseOpcode::Pmaxsw; - let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?; - return Some(expr2_0); -} - -// Generated as internal constructor for term x64_pmaxsd. -pub fn constructor_x64_pmaxsd(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/x64/inst.isle line 2303. - let expr0_0: Type = I8X16; - let expr1_0 = SseOpcode::Pmaxsd; - let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?; - return Some(expr2_0); -} - -// Generated as internal constructor for term x64_pmins. -pub fn constructor_x64_pmins( - ctx: &mut C, - arg0: Type, - arg1: Xmm, - arg2: &XmmMem, -) -> Option { - let pattern0_0 = arg0; - if pattern0_0 == I8X16 { - let pattern2_0 = arg1; - let pattern3_0 = arg2; - // Rule at src/isa/x64/inst.isle line 2307. - let expr0_0 = constructor_x64_pminsb(ctx, pattern2_0, pattern3_0)?; - return Some(expr0_0); - } - if pattern0_0 == I16X8 { - let pattern2_0 = arg1; - let pattern3_0 = arg2; - // Rule at src/isa/x64/inst.isle line 2308. - let expr0_0 = constructor_x64_pminsw(ctx, pattern2_0, pattern3_0)?; - return Some(expr0_0); - } - if pattern0_0 == I32X4 { - let pattern2_0 = arg1; - let pattern3_0 = arg2; - // Rule at src/isa/x64/inst.isle line 2309. - let expr0_0 = constructor_x64_pminsd(ctx, pattern2_0, pattern3_0)?; - return Some(expr0_0); - } - return None; -} - -// Generated as internal constructor for term x64_pminsb. -pub fn constructor_x64_pminsb(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/x64/inst.isle line 2312. - let expr0_0: Type = I8X16; - let expr1_0 = SseOpcode::Pminsb; - let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?; - return Some(expr2_0); -} - -// Generated as internal constructor for term x64_pminsw. -pub fn constructor_x64_pminsw(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/x64/inst.isle line 2314. - let expr0_0: Type = I16X8; - let expr1_0 = SseOpcode::Pminsw; - let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?; - return Some(expr2_0); -} - -// Generated as internal constructor for term x64_pminsd. -pub fn constructor_x64_pminsd(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/x64/inst.isle line 2316. - let expr0_0: Type = I32X4; - let expr1_0 = SseOpcode::Pminsd; - let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?; - return Some(expr2_0); -} - -// Generated as internal constructor for term x64_pmaxu. -pub fn constructor_x64_pmaxu( - ctx: &mut C, - arg0: Type, - arg1: Xmm, - arg2: &XmmMem, -) -> Option { - let pattern0_0 = arg0; - if pattern0_0 == I8X16 { - let pattern2_0 = arg1; - let pattern3_0 = arg2; - // Rule at src/isa/x64/inst.isle line 2320. - let expr0_0 = constructor_x64_pmaxub(ctx, pattern2_0, pattern3_0)?; - return Some(expr0_0); - } - if pattern0_0 == I16X8 { - let pattern2_0 = arg1; - let pattern3_0 = arg2; - // Rule at src/isa/x64/inst.isle line 2321. - let expr0_0 = constructor_x64_pmaxuw(ctx, pattern2_0, pattern3_0)?; - return Some(expr0_0); - } - if pattern0_0 == I32X4 { - let pattern2_0 = arg1; - let pattern3_0 = arg2; - // Rule at src/isa/x64/inst.isle line 2322. - let expr0_0 = constructor_x64_pmaxud(ctx, pattern2_0, pattern3_0)?; - return Some(expr0_0); - } - return None; -} - -// Generated as internal constructor for term x64_pmaxub. -pub fn constructor_x64_pmaxub(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/x64/inst.isle line 2325. - let expr0_0: Type = I8X16; - let expr1_0 = SseOpcode::Pmaxub; - let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?; - return Some(expr2_0); -} - -// Generated as internal constructor for term x64_pmaxuw. -pub fn constructor_x64_pmaxuw(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/x64/inst.isle line 2327. - let expr0_0: Type = I8X16; - let expr1_0 = SseOpcode::Pmaxuw; - let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?; - return Some(expr2_0); -} - -// Generated as internal constructor for term x64_pmaxud. -pub fn constructor_x64_pmaxud(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/x64/inst.isle line 2329. - let expr0_0: Type = I8X16; - let expr1_0 = SseOpcode::Pmaxud; - let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?; - return Some(expr2_0); -} - -// Generated as internal constructor for term x64_pminu. -pub fn constructor_x64_pminu( - ctx: &mut C, - arg0: Type, - arg1: Xmm, - arg2: &XmmMem, -) -> Option { - let pattern0_0 = arg0; - if pattern0_0 == I8X16 { - let pattern2_0 = arg1; - let pattern3_0 = arg2; - // Rule at src/isa/x64/inst.isle line 2333. - let expr0_0 = constructor_x64_pminub(ctx, pattern2_0, pattern3_0)?; - return Some(expr0_0); - } - if pattern0_0 == I16X8 { - let pattern2_0 = arg1; - let pattern3_0 = arg2; - // Rule at src/isa/x64/inst.isle line 2334. - let expr0_0 = constructor_x64_pminuw(ctx, pattern2_0, pattern3_0)?; - return Some(expr0_0); - } - if pattern0_0 == I32X4 { - let pattern2_0 = arg1; - let pattern3_0 = arg2; - // Rule at src/isa/x64/inst.isle line 2335. - let expr0_0 = constructor_x64_pminud(ctx, pattern2_0, pattern3_0)?; - return Some(expr0_0); - } - return None; -} - -// Generated as internal constructor for term x64_pminub. -pub fn constructor_x64_pminub(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/x64/inst.isle line 2338. - let expr0_0: Type = I8X16; - let expr1_0 = SseOpcode::Pminub; - let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?; - return Some(expr2_0); -} - -// Generated as internal constructor for term x64_pminuw. -pub fn constructor_x64_pminuw(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/x64/inst.isle line 2340. - let expr0_0: Type = I8X16; - let expr1_0 = SseOpcode::Pminuw; - let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?; - return Some(expr2_0); -} - -// Generated as internal constructor for term x64_pminud. -pub fn constructor_x64_pminud(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/x64/inst.isle line 2342. - let expr0_0: Type = I8X16; - let expr1_0 = SseOpcode::Pminud; - let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?; - return Some(expr2_0); -} - -// Generated as internal constructor for term x64_punpcklbw. -pub fn constructor_x64_punpcklbw(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/x64/inst.isle line 2346. - let expr0_0: Type = I8X16; - let expr1_0 = SseOpcode::Punpcklbw; - let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?; - return Some(expr2_0); -} - -// Generated as internal constructor for term x64_punpckhbw. -pub fn constructor_x64_punpckhbw(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/x64/inst.isle line 2351. - let expr0_0: Type = I8X16; - let expr1_0 = SseOpcode::Punpckhbw; - let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?; - return Some(expr2_0); -} - -// Generated as internal constructor for term x64_packsswb. -pub fn constructor_x64_packsswb(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/x64/inst.isle line 2356. - let expr0_0: Type = I8X16; - let expr1_0 = SseOpcode::Packsswb; - let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?; - return Some(expr2_0); -} - -// Generated as internal constructor for term xmm_rm_r_imm. -pub fn constructor_xmm_rm_r_imm( - ctx: &mut C, - arg0: &SseOpcode, - arg1: Reg, - arg2: &RegMem, - arg3: u8, - arg4: &OperandSize, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - let pattern3_0 = arg3; - let pattern4_0 = arg4; - // Rule at src/isa/x64/inst.isle line 2361. - let expr0_0 = C::temp_writable_xmm(ctx); - let expr1_0 = C::writable_xmm_to_reg(ctx, expr0_0); - let expr2_0 = MInst::XmmRmRImm { - op: pattern0_0.clone(), - src1: pattern1_0, - src2: pattern2_0.clone(), - dst: expr1_0, - imm: pattern3_0, - size: pattern4_0.clone(), - }; - let expr3_0 = C::emit(ctx, &expr2_0); - let expr4_0 = C::writable_xmm_to_xmm(ctx, expr0_0); - return Some(expr4_0); -} - -// Generated as internal constructor for term x64_palignr. -pub fn constructor_x64_palignr( - ctx: &mut C, - arg0: Xmm, - arg1: &XmmMem, - arg2: u8, - arg3: &OperandSize, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - let pattern3_0 = arg3; - // Rule at src/isa/x64/inst.isle line 2373. - let expr0_0 = SseOpcode::Palignr; - let expr1_0 = C::xmm_to_reg(ctx, pattern0_0); - let expr2_0 = C::xmm_mem_to_reg_mem(ctx, pattern1_0); - let expr3_0 = - constructor_xmm_rm_r_imm(ctx, &expr0_0, expr1_0, &expr2_0, pattern2_0, pattern3_0)?; - return Some(expr3_0); -} - -// Generated as internal constructor for term x64_cmpp. -pub fn constructor_x64_cmpp( - ctx: &mut C, - arg0: Type, - arg1: Xmm, - arg2: &XmmMem, - arg3: &FcmpImm, -) -> Option { - let pattern0_0 = arg0; - if pattern0_0 == F32X4 { - let pattern2_0 = arg1; - let pattern3_0 = arg2; - let pattern4_0 = arg3; - // Rule at src/isa/x64/inst.isle line 2382. - let expr0_0 = constructor_x64_cmpps(ctx, pattern2_0, pattern3_0, pattern4_0)?; - return Some(expr0_0); - } - if pattern0_0 == F64X2 { - let pattern2_0 = arg1; - let pattern3_0 = arg2; - let pattern4_0 = arg3; - // Rule at src/isa/x64/inst.isle line 2383. - let expr0_0 = constructor_x64_cmppd(ctx, pattern2_0, pattern3_0, pattern4_0)?; - return Some(expr0_0); - } - return None; -} - -// Generated as internal constructor for term x64_cmpps. -pub fn constructor_x64_cmpps( - ctx: &mut C, - arg0: Xmm, - arg1: &XmmMem, - arg2: &FcmpImm, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/x64/inst.isle line 2386. - let expr0_0 = SseOpcode::Cmpps; - let expr1_0 = C::xmm_to_reg(ctx, pattern0_0); - let expr2_0 = C::xmm_mem_to_reg_mem(ctx, pattern1_0); - let expr3_0 = C::encode_fcmp_imm(ctx, pattern2_0); - let expr4_0 = OperandSize::Size32; - let expr5_0 = constructor_xmm_rm_r_imm(ctx, &expr0_0, expr1_0, &expr2_0, expr3_0, &expr4_0)?; - return Some(expr5_0); -} - -// Generated as internal constructor for term x64_cmppd. -pub fn constructor_x64_cmppd( - ctx: &mut C, - arg0: Xmm, - arg1: &XmmMem, - arg2: &FcmpImm, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/x64/inst.isle line 2397. - let expr0_0 = SseOpcode::Cmppd; - let expr1_0 = C::xmm_to_reg(ctx, pattern0_0); - let expr2_0 = C::xmm_mem_to_reg_mem(ctx, pattern1_0); - let expr3_0 = C::encode_fcmp_imm(ctx, pattern2_0); - let expr4_0 = OperandSize::Size32; - let expr5_0 = constructor_xmm_rm_r_imm(ctx, &expr0_0, expr1_0, &expr2_0, expr3_0, &expr4_0)?; - return Some(expr5_0); -} - -// Generated as internal constructor for term x64_pinsrb. -pub fn constructor_x64_pinsrb( - ctx: &mut C, - arg0: Xmm, - arg1: &GprMem, - arg2: u8, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/x64/inst.isle line 2406. - let expr0_0 = SseOpcode::Pinsrb; - let expr1_0 = C::xmm_to_reg(ctx, pattern0_0); - let expr2_0 = C::gpr_mem_to_reg_mem(ctx, pattern1_0); - let expr3_0 = OperandSize::Size32; - let expr4_0 = constructor_xmm_rm_r_imm(ctx, &expr0_0, expr1_0, &expr2_0, pattern2_0, &expr3_0)?; - return Some(expr4_0); -} - -// Generated as internal constructor for term x64_pinsrw. -pub fn constructor_x64_pinsrw( - ctx: &mut C, - arg0: Xmm, - arg1: &GprMem, - arg2: u8, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/x64/inst.isle line 2415. - let expr0_0 = SseOpcode::Pinsrw; - let expr1_0 = C::xmm_to_reg(ctx, pattern0_0); - let expr2_0 = C::gpr_mem_to_reg_mem(ctx, pattern1_0); - let expr3_0 = OperandSize::Size32; - let expr4_0 = constructor_xmm_rm_r_imm(ctx, &expr0_0, expr1_0, &expr2_0, pattern2_0, &expr3_0)?; - return Some(expr4_0); -} - -// Generated as internal constructor for term x64_pinsrd. -pub fn constructor_x64_pinsrd( - ctx: &mut C, - arg0: Xmm, - arg1: &GprMem, - arg2: u8, - arg3: &OperandSize, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - let pattern3_0 = arg3; - // Rule at src/isa/x64/inst.isle line 2424. - let expr0_0 = SseOpcode::Pinsrd; - let expr1_0 = C::xmm_to_reg(ctx, pattern0_0); - let expr2_0 = C::gpr_mem_to_reg_mem(ctx, pattern1_0); - let expr3_0 = - constructor_xmm_rm_r_imm(ctx, &expr0_0, expr1_0, &expr2_0, pattern2_0, pattern3_0)?; - return Some(expr3_0); -} - -// Generated as internal constructor for term x64_pmaddwd. -pub fn constructor_x64_pmaddwd(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/x64/inst.isle line 2433. - let expr0_0 = C::temp_writable_xmm(ctx); - let expr1_0 = SseOpcode::Pmaddwd; - let expr2_0 = MInst::XmmRmR { - op: expr1_0, - src1: pattern0_0, - src2: pattern1_0.clone(), - dst: expr0_0, - }; - let expr3_0 = C::emit(ctx, &expr2_0); - let expr4_0 = C::writable_xmm_to_xmm(ctx, expr0_0); - return Some(expr4_0); -} - -// Generated as internal constructor for term x64_insertps. -pub fn constructor_x64_insertps( - ctx: &mut C, - arg0: Xmm, - arg1: &XmmMem, - arg2: u8, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/x64/inst.isle line 2443. - let expr0_0 = SseOpcode::Insertps; - let expr1_0 = C::xmm_to_reg(ctx, pattern0_0); - let expr2_0 = C::xmm_mem_to_reg_mem(ctx, pattern1_0); - let expr3_0 = OperandSize::Size32; - let expr4_0 = constructor_xmm_rm_r_imm(ctx, &expr0_0, expr1_0, &expr2_0, pattern2_0, &expr3_0)?; - return Some(expr4_0); -} - -// Generated as internal constructor for term x64_pshufd. -pub fn constructor_x64_pshufd( - ctx: &mut C, - arg0: &XmmMem, - arg1: u8, - arg2: &OperandSize, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/x64/inst.isle line 2452. - let expr0_0 = C::temp_writable_xmm(ctx); - let expr1_0 = SseOpcode::Pshufd; - let expr2_0 = constructor_writable_xmm_to_r_reg(ctx, expr0_0)?; - let expr3_0 = C::xmm_mem_to_reg_mem(ctx, pattern0_0); - let expr4_0 = C::writable_xmm_to_reg(ctx, expr0_0); - let expr5_0 = MInst::XmmRmRImm { - op: expr1_0, - src1: expr2_0, - src2: expr3_0, - dst: expr4_0, - imm: pattern1_0, - size: pattern2_0.clone(), - }; - let expr6_0 = C::emit(ctx, &expr5_0); - let expr7_0 = C::writable_xmm_to_xmm(ctx, expr0_0); - return Some(expr7_0); -} - -// Generated as internal constructor for term x64_pshufb. -pub fn constructor_x64_pshufb(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/x64/inst.isle line 2464. - let expr0_0 = C::temp_writable_xmm(ctx); - let expr1_0 = SseOpcode::Pshufb; - let expr2_0 = MInst::XmmRmR { - op: expr1_0, - src1: pattern0_0, - src2: pattern1_0.clone(), - dst: expr0_0, - }; - let expr3_0 = C::emit(ctx, &expr2_0); - let expr4_0 = C::writable_xmm_to_xmm(ctx, expr0_0); - return Some(expr4_0); -} - -// Generated as internal constructor for term xmm_unary_rm_r. -pub fn constructor_xmm_unary_rm_r( - ctx: &mut C, - arg0: &SseOpcode, - arg1: &XmmMem, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/x64/inst.isle line 2474. - let expr0_0 = C::temp_writable_xmm(ctx); - let expr1_0 = MInst::XmmUnaryRmR { - op: pattern0_0.clone(), - src: pattern1_0.clone(), - dst: expr0_0, - }; - let expr2_0 = C::emit(ctx, &expr1_0); - let expr3_0 = C::writable_xmm_to_xmm(ctx, expr0_0); - return Some(expr3_0); -} - -// Generated as internal constructor for term x64_pabsb. -pub fn constructor_x64_pabsb(ctx: &mut C, arg0: &XmmMem) -> Option { - let pattern0_0 = arg0; - // Rule at src/isa/x64/inst.isle line 2481. - let expr0_0 = SseOpcode::Pabsb; - let expr1_0 = constructor_xmm_unary_rm_r(ctx, &expr0_0, pattern0_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term x64_pabsw. -pub fn constructor_x64_pabsw(ctx: &mut C, arg0: &XmmMem) -> Option { - let pattern0_0 = arg0; - // Rule at src/isa/x64/inst.isle line 2486. - let expr0_0 = SseOpcode::Pabsw; - let expr1_0 = constructor_xmm_unary_rm_r(ctx, &expr0_0, pattern0_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term x64_pabsd. -pub fn constructor_x64_pabsd(ctx: &mut C, arg0: &XmmMem) -> Option { - let pattern0_0 = arg0; - // Rule at src/isa/x64/inst.isle line 2491. - let expr0_0 = SseOpcode::Pabsd; - let expr1_0 = constructor_xmm_unary_rm_r(ctx, &expr0_0, pattern0_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term xmm_unary_rm_r_evex. -pub fn constructor_xmm_unary_rm_r_evex( - ctx: &mut C, - arg0: &Avx512Opcode, - arg1: &XmmMem, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/x64/inst.isle line 2496. - let expr0_0 = C::temp_writable_xmm(ctx); - let expr1_0 = MInst::XmmUnaryRmREvex { - op: pattern0_0.clone(), - src: pattern1_0.clone(), - dst: expr0_0, - }; - let expr2_0 = C::emit(ctx, &expr1_0); - let expr3_0 = C::writable_xmm_to_xmm(ctx, expr0_0); - return Some(expr3_0); -} - -// Generated as internal constructor for term x64_vpabsq. -pub fn constructor_x64_vpabsq(ctx: &mut C, arg0: &XmmMem) -> Option { - let pattern0_0 = arg0; - // Rule at src/isa/x64/inst.isle line 2503. - let expr0_0 = Avx512Opcode::Vpabsq; - let expr1_0 = constructor_xmm_unary_rm_r_evex(ctx, &expr0_0, pattern0_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term x64_vpopcntb. -pub fn constructor_x64_vpopcntb(ctx: &mut C, arg0: &XmmMem) -> Option { - let pattern0_0 = arg0; - // Rule at src/isa/x64/inst.isle line 2508. - let expr0_0 = Avx512Opcode::Vpopcntb; - let expr1_0 = constructor_xmm_unary_rm_r_evex(ctx, &expr0_0, pattern0_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term xmm_rm_r_evex. -pub fn constructor_xmm_rm_r_evex( - ctx: &mut C, - arg0: &Avx512Opcode, - arg1: &XmmMem, - arg2: Xmm, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/x64/inst.isle line 2513. - let expr0_0 = C::temp_writable_xmm(ctx); - let expr1_0 = MInst::XmmRmREvex { - op: pattern0_0.clone(), - src1: pattern1_0.clone(), - src2: pattern2_0, - dst: expr0_0, - }; - let expr2_0 = C::emit(ctx, &expr1_0); - let expr3_0 = C::writable_xmm_to_xmm(ctx, expr0_0); - return Some(expr3_0); -} - -// Generated as internal constructor for term x64_vpmullq. -pub fn constructor_x64_vpmullq(ctx: &mut C, arg0: &XmmMem, arg1: Xmm) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/x64/inst.isle line 2525. - let expr0_0 = Avx512Opcode::Vpmullq; - let expr1_0 = constructor_xmm_rm_r_evex(ctx, &expr0_0, pattern0_0, pattern1_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term mul_hi. -pub fn constructor_mul_hi( - ctx: &mut C, - arg0: Type, - arg1: bool, - arg2: Gpr, - arg3: &GprMem, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - let pattern3_0 = arg3; - // Rule at src/isa/x64/inst.isle line 2534. - let expr0_0 = C::temp_writable_gpr(ctx); - let expr1_0 = C::temp_writable_gpr(ctx); - let expr2_0 = C::operand_size_of_type_32_64(ctx, pattern0_0); - let expr3_0 = MInst::MulHi { - size: expr2_0, - signed: pattern1_0, - src1: pattern2_0, - src2: pattern3_0.clone(), - dst_lo: expr0_0, - dst_hi: expr1_0, - }; - let expr4_0 = C::emit(ctx, &expr3_0); - let expr5_0 = C::writable_gpr_to_gpr(ctx, expr0_0); - let expr6_0 = C::writable_gpr_to_gpr(ctx, expr1_0); - let expr7_0 = constructor_value_gprs(ctx, expr5_0, expr6_0)?; - return Some(expr7_0); -} - -// Generated as internal constructor for term mulhi_u. -pub fn constructor_mulhi_u( - ctx: &mut C, - arg0: Type, - arg1: Gpr, - arg2: &GprMem, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/x64/inst.isle line 2549. - let expr0_0: bool = false; - let expr1_0 = constructor_mul_hi(ctx, pattern0_0, expr0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term xmm_rmi_xmm. -pub fn constructor_xmm_rmi_xmm( - ctx: &mut C, - arg0: &SseOpcode, - arg1: Xmm, - arg2: &XmmMemImm, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/x64/inst.isle line 2554. - let expr0_0 = C::temp_writable_xmm(ctx); - let expr1_0 = MInst::XmmRmiReg { - opcode: pattern0_0.clone(), - src1: pattern1_0, - src2: pattern2_0.clone(), - dst: expr0_0, - }; - let expr2_0 = C::emit(ctx, &expr1_0); - let expr3_0 = C::writable_xmm_to_xmm(ctx, expr0_0); - return Some(expr3_0); -} - -// Generated as internal constructor for term x64_psllw. -pub fn constructor_x64_psllw(ctx: &mut C, arg0: Xmm, arg1: &XmmMemImm) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/x64/inst.isle line 2564. - let expr0_0 = SseOpcode::Psllw; - let expr1_0 = constructor_xmm_rmi_xmm(ctx, &expr0_0, pattern0_0, pattern1_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term x64_pslld. -pub fn constructor_x64_pslld(ctx: &mut C, arg0: Xmm, arg1: &XmmMemImm) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/x64/inst.isle line 2569. - let expr0_0 = SseOpcode::Pslld; - let expr1_0 = constructor_xmm_rmi_xmm(ctx, &expr0_0, pattern0_0, pattern1_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term x64_psllq. -pub fn constructor_x64_psllq(ctx: &mut C, arg0: Xmm, arg1: &XmmMemImm) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/x64/inst.isle line 2574. - let expr0_0 = SseOpcode::Psllq; - let expr1_0 = constructor_xmm_rmi_xmm(ctx, &expr0_0, pattern0_0, pattern1_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term x64_psrlw. -pub fn constructor_x64_psrlw(ctx: &mut C, arg0: Xmm, arg1: &XmmMemImm) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/x64/inst.isle line 2579. - let expr0_0 = SseOpcode::Psrlw; - let expr1_0 = constructor_xmm_rmi_xmm(ctx, &expr0_0, pattern0_0, pattern1_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term x64_psrld. -pub fn constructor_x64_psrld(ctx: &mut C, arg0: Xmm, arg1: &XmmMemImm) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/x64/inst.isle line 2584. - let expr0_0 = SseOpcode::Psrld; - let expr1_0 = constructor_xmm_rmi_xmm(ctx, &expr0_0, pattern0_0, pattern1_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term x64_psrlq. -pub fn constructor_x64_psrlq(ctx: &mut C, arg0: Xmm, arg1: &XmmMemImm) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/x64/inst.isle line 2589. - let expr0_0 = SseOpcode::Psrlq; - let expr1_0 = constructor_xmm_rmi_xmm(ctx, &expr0_0, pattern0_0, pattern1_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term x64_psraw. -pub fn constructor_x64_psraw(ctx: &mut C, arg0: Xmm, arg1: &XmmMemImm) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/x64/inst.isle line 2594. - let expr0_0 = SseOpcode::Psraw; - let expr1_0 = constructor_xmm_rmi_xmm(ctx, &expr0_0, pattern0_0, pattern1_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term x64_psrad. -pub fn constructor_x64_psrad(ctx: &mut C, arg0: Xmm, arg1: &XmmMemImm) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/x64/inst.isle line 2599. - let expr0_0 = SseOpcode::Psrad; - let expr1_0 = constructor_xmm_rmi_xmm(ctx, &expr0_0, pattern0_0, pattern1_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term x64_pextrd. -pub fn constructor_x64_pextrd( - ctx: &mut C, - arg0: Type, - arg1: Xmm, - arg2: u8, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/x64/inst.isle line 2604. - let expr0_0 = C::temp_writable_gpr(ctx); - let expr1_0 = SseOpcode::Pextrd; - let expr2_0 = constructor_writable_gpr_to_r_reg(ctx, expr0_0)?; - let expr3_0 = C::xmm_to_reg(ctx, pattern1_0); - let expr4_0 = constructor_xmm_to_reg_mem(ctx, expr3_0)?; - let expr5_0 = C::xmm_mem_to_reg_mem(ctx, &expr4_0); - let expr6_0 = C::writable_gpr_to_reg(ctx, expr0_0); - let expr7_0 = C::lane_type(ctx, pattern0_0); - let expr8_0 = C::operand_size_of_type_32_64(ctx, expr7_0); - let expr9_0 = MInst::XmmRmRImm { - op: expr1_0, - src1: expr2_0, - src2: expr5_0, - dst: expr6_0, - imm: pattern2_0, - size: expr8_0, - }; - let expr10_0 = C::emit(ctx, &expr9_0); - let expr11_0 = C::writable_gpr_to_gpr(ctx, expr0_0); - return Some(expr11_0); -} - -// Generated as internal constructor for term gpr_to_xmm. -pub fn constructor_gpr_to_xmm( - ctx: &mut C, - arg0: &SseOpcode, - arg1: &GprMem, - arg2: &OperandSize, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/x64/inst.isle line 2616. - let expr0_0 = C::temp_writable_xmm(ctx); - let expr1_0 = MInst::GprToXmm { - op: pattern0_0.clone(), - src: pattern1_0.clone(), - dst: expr0_0, - src_size: pattern2_0.clone(), - }; - let expr2_0 = C::emit(ctx, &expr1_0); - let expr3_0 = C::writable_xmm_to_xmm(ctx, expr0_0); - return Some(expr3_0); -} - -// Generated as internal constructor for term x64_not. -pub fn constructor_x64_not(ctx: &mut C, arg0: Type, arg1: Gpr) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/x64/inst.isle line 2623. - let expr0_0 = C::temp_writable_gpr(ctx); - let expr1_0 = C::operand_size_of_type_32_64(ctx, pattern0_0); - let expr2_0 = MInst::Not { - size: expr1_0, - src: pattern1_0, - dst: expr0_0, - }; - let expr3_0 = C::emit(ctx, &expr2_0); - let expr4_0 = C::writable_gpr_to_gpr(ctx, expr0_0); - return Some(expr4_0); -} - -// Generated as internal constructor for term x64_neg. -pub fn constructor_x64_neg(ctx: &mut C, arg0: Type, arg1: Gpr) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/x64/inst.isle line 2631. - let expr0_0 = C::temp_writable_gpr(ctx); - let expr1_0 = C::operand_size_of_type_32_64(ctx, pattern0_0); - let expr2_0 = MInst::Neg { - size: expr1_0, - src: pattern1_0, - dst: expr0_0, - }; - let expr3_0 = C::emit(ctx, &expr2_0); - let expr4_0 = C::writable_gpr_to_gpr(ctx, expr0_0); - return Some(expr4_0); -} - -// Generated as internal constructor for term x64_lea. -pub fn constructor_x64_lea(ctx: &mut C, arg0: &SyntheticAmode) -> Option { - let pattern0_0 = arg0; - // Rule at src/isa/x64/inst.isle line 2638. - let expr0_0 = C::temp_writable_gpr(ctx); - let expr1_0 = MInst::LoadEffectiveAddress { - addr: pattern0_0.clone(), - dst: expr0_0, - }; - let expr2_0 = C::emit(ctx, &expr1_0); - let expr3_0 = C::writable_gpr_to_gpr(ctx, expr0_0); - return Some(expr3_0); -} - -// Generated as internal constructor for term x64_ud2. -pub fn constructor_x64_ud2(ctx: &mut C, arg0: &TrapCode) -> Option { - let pattern0_0 = arg0; - // Rule at src/isa/x64/inst.isle line 2645. - let expr0_0 = MInst::Ud2 { - trap_code: pattern0_0.clone(), - }; - let expr1_0 = SideEffectNoResult::Inst { inst: expr0_0 }; - return Some(expr1_0); -} - -// Generated as internal constructor for term x64_hlt. -pub fn constructor_x64_hlt(ctx: &mut C) -> Option { - // Rule at src/isa/x64/inst.isle line 2650. - let expr0_0 = MInst::Hlt; - let expr1_0 = SideEffectNoResult::Inst { inst: expr0_0 }; - return Some(expr1_0); -} - -// Generated as internal constructor for term x64_lzcnt. -pub fn constructor_x64_lzcnt(ctx: &mut C, arg0: Type, arg1: Gpr) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/x64/inst.isle line 2655. - let expr0_0 = C::temp_writable_gpr(ctx); - let expr1_0 = C::operand_size_of_type_32_64(ctx, pattern0_0); - let expr2_0 = UnaryRmROpcode::Lzcnt; - let expr3_0 = C::gpr_to_gpr_mem(ctx, pattern1_0); - let expr4_0 = MInst::UnaryRmR { - size: expr1_0, - op: expr2_0, - src: expr3_0, - dst: expr0_0, - }; - let expr5_0 = C::emit(ctx, &expr4_0); - let expr6_0 = C::writable_gpr_to_gpr(ctx, expr0_0); - return Some(expr6_0); -} - -// Generated as internal constructor for term x64_tzcnt. -pub fn constructor_x64_tzcnt(ctx: &mut C, arg0: Type, arg1: Gpr) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/x64/inst.isle line 2663. - let expr0_0 = C::temp_writable_gpr(ctx); - let expr1_0 = C::operand_size_of_type_32_64(ctx, pattern0_0); - let expr2_0 = UnaryRmROpcode::Tzcnt; - let expr3_0 = C::gpr_to_gpr_mem(ctx, pattern1_0); - let expr4_0 = MInst::UnaryRmR { - size: expr1_0, - op: expr2_0, - src: expr3_0, - dst: expr0_0, - }; - let expr5_0 = C::emit(ctx, &expr4_0); - let expr6_0 = C::writable_gpr_to_gpr(ctx, expr0_0); - return Some(expr6_0); -} - -// Generated as internal constructor for term x64_bsr. -pub fn constructor_x64_bsr( - ctx: &mut C, - arg0: Type, - arg1: Gpr, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/x64/inst.isle line 2671. - let expr0_0 = C::temp_writable_gpr(ctx); - let expr1_0 = C::operand_size_of_type_32_64(ctx, pattern0_0); - let expr2_0 = UnaryRmROpcode::Bsr; - let expr3_0 = C::gpr_to_gpr_mem(ctx, pattern1_0); - let expr4_0 = MInst::UnaryRmR { - size: expr1_0, - op: expr2_0, - src: expr3_0, - dst: expr0_0, - }; - let expr5_0 = constructor_writable_gpr_to_r_reg(ctx, expr0_0)?; - let expr6_0 = ProducesFlags::ProducesFlagsReturnsReg { - inst: expr4_0, - result: expr5_0, - }; - return Some(expr6_0); -} - -// Generated as internal constructor for term bsr_or_else. -pub fn constructor_bsr_or_else( - ctx: &mut C, - arg0: Type, - arg1: Gpr, - arg2: Gpr, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/x64/inst.isle line 2680. - let expr0_0 = constructor_x64_bsr(ctx, pattern0_0, pattern1_0)?; - let expr1_0 = constructor_produces_flags_get_reg(ctx, &expr0_0)?; - let expr2_0 = C::gpr_new(ctx, expr1_0); - let expr3_0 = CC::Z; - let expr4_0 = C::gpr_to_gpr_mem(ctx, pattern2_0); - let expr5_0 = constructor_cmove(ctx, pattern0_0, &expr3_0, &expr4_0, expr2_0)?; - let expr6_0 = constructor_produces_flags_ignore(ctx, &expr0_0)?; - let expr7_0 = constructor_with_flags_reg(ctx, &expr6_0, &expr5_0)?; - let expr8_0 = C::gpr_new(ctx, expr7_0); - return Some(expr8_0); -} - -// Generated as internal constructor for term x64_bsf. -pub fn constructor_x64_bsf( - ctx: &mut C, - arg0: Type, - arg1: Gpr, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/x64/inst.isle line 2691. - let expr0_0 = C::temp_writable_gpr(ctx); - let expr1_0 = C::operand_size_of_type_32_64(ctx, pattern0_0); - let expr2_0 = UnaryRmROpcode::Bsf; - let expr3_0 = C::gpr_to_gpr_mem(ctx, pattern1_0); - let expr4_0 = MInst::UnaryRmR { - size: expr1_0, - op: expr2_0, - src: expr3_0, - dst: expr0_0, - }; - let expr5_0 = constructor_writable_gpr_to_r_reg(ctx, expr0_0)?; - let expr6_0 = ProducesFlags::ProducesFlagsReturnsReg { - inst: expr4_0, - result: expr5_0, - }; - return Some(expr6_0); -} - -// Generated as internal constructor for term bsf_or_else. -pub fn constructor_bsf_or_else( - ctx: &mut C, - arg0: Type, - arg1: Gpr, - arg2: Gpr, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/x64/inst.isle line 2700. - let expr0_0 = constructor_x64_bsf(ctx, pattern0_0, pattern1_0)?; - let expr1_0 = constructor_produces_flags_get_reg(ctx, &expr0_0)?; - let expr2_0 = C::gpr_new(ctx, expr1_0); - let expr3_0 = CC::Z; - let expr4_0 = C::gpr_to_gpr_mem(ctx, pattern2_0); - let expr5_0 = constructor_cmove(ctx, pattern0_0, &expr3_0, &expr4_0, expr2_0)?; - let expr6_0 = constructor_produces_flags_ignore(ctx, &expr0_0)?; - let expr7_0 = constructor_with_flags_reg(ctx, &expr6_0, &expr5_0)?; - let expr8_0 = C::gpr_new(ctx, expr7_0); - return Some(expr8_0); -} - -// Generated as internal constructor for term x64_popcnt. -pub fn constructor_x64_popcnt(ctx: &mut C, arg0: Type, arg1: Gpr) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/x64/inst.isle line 2711. - let expr0_0 = C::temp_writable_gpr(ctx); - let expr1_0 = C::operand_size_of_type_32_64(ctx, pattern0_0); - let expr2_0 = UnaryRmROpcode::Popcnt; - let expr3_0 = C::gpr_to_gpr_mem(ctx, pattern1_0); - let expr4_0 = MInst::UnaryRmR { - size: expr1_0, - op: expr2_0, - src: expr3_0, - dst: expr0_0, - }; - let expr5_0 = C::emit(ctx, &expr4_0); - let expr6_0 = C::writable_gpr_to_gpr(ctx, expr0_0); - return Some(expr6_0); -} - -// Generated as internal constructor for term xmm_min_max_seq. -pub fn constructor_xmm_min_max_seq( - ctx: &mut C, - arg0: Type, - arg1: bool, - arg2: Xmm, - arg3: Xmm, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - let pattern3_0 = arg3; - // Rule at src/isa/x64/inst.isle line 2719. - let expr0_0 = C::temp_writable_xmm(ctx); - let expr1_0 = C::operand_size_of_type_32_64(ctx, pattern0_0); - let expr2_0 = MInst::XmmMinMaxSeq { - size: expr1_0, - is_min: pattern1_0, - lhs: pattern2_0, - rhs: pattern3_0, - dst: expr0_0, - }; - let expr3_0 = C::emit(ctx, &expr2_0); - let expr4_0 = C::writable_xmm_to_xmm(ctx, expr0_0); - return Some(expr4_0); -} - -// Generated as internal constructor for term x64_minss. -pub fn constructor_x64_minss(ctx: &mut C, arg0: Xmm, arg1: Xmm) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/x64/inst.isle line 2727. - let expr0_0 = C::temp_writable_xmm(ctx); - let expr1_0 = SseOpcode::Minss; - let expr2_0 = C::xmm_to_xmm_mem(ctx, pattern1_0); - let expr3_0 = MInst::XmmRmR { - op: expr1_0, - src1: pattern0_0, - src2: expr2_0, - dst: expr0_0, - }; - let expr4_0 = C::emit(ctx, &expr3_0); - let expr5_0 = C::writable_xmm_to_xmm(ctx, expr0_0); - return Some(expr5_0); -} - -// Generated as internal constructor for term x64_minsd. -pub fn constructor_x64_minsd(ctx: &mut C, arg0: Xmm, arg1: Xmm) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/x64/inst.isle line 2734. - let expr0_0 = C::temp_writable_xmm(ctx); - let expr1_0 = SseOpcode::Minsd; - let expr2_0 = C::xmm_to_xmm_mem(ctx, pattern1_0); - let expr3_0 = MInst::XmmRmR { - op: expr1_0, - src1: pattern0_0, - src2: expr2_0, - dst: expr0_0, - }; - let expr4_0 = C::emit(ctx, &expr3_0); - let expr5_0 = C::writable_xmm_to_xmm(ctx, expr0_0); - return Some(expr5_0); -} - -// Generated as internal constructor for term x64_minps. -pub fn constructor_x64_minps(ctx: &mut C, arg0: Xmm, arg1: Xmm) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/x64/inst.isle line 2742. - let expr0_0 = C::temp_writable_xmm(ctx); - let expr1_0 = SseOpcode::Minps; - let expr2_0 = C::xmm_to_xmm_mem(ctx, pattern1_0); - let expr3_0 = MInst::XmmRmR { - op: expr1_0, - src1: pattern0_0, - src2: expr2_0, - dst: expr0_0, - }; - let expr4_0 = C::emit(ctx, &expr3_0); - let expr5_0 = C::writable_xmm_to_xmm(ctx, expr0_0); - return Some(expr5_0); -} - -// Generated as internal constructor for term x64_minpd. -pub fn constructor_x64_minpd(ctx: &mut C, arg0: Xmm, arg1: Xmm) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/x64/inst.isle line 2749. - let expr0_0 = C::temp_writable_xmm(ctx); - let expr1_0 = SseOpcode::Minpd; - let expr2_0 = C::xmm_to_xmm_mem(ctx, pattern1_0); - let expr3_0 = MInst::XmmRmR { - op: expr1_0, - src1: pattern0_0, - src2: expr2_0, - dst: expr0_0, - }; - let expr4_0 = C::emit(ctx, &expr3_0); - let expr5_0 = C::writable_xmm_to_xmm(ctx, expr0_0); - return Some(expr5_0); -} - -// Generated as internal constructor for term x64_maxss. -pub fn constructor_x64_maxss(ctx: &mut C, arg0: Xmm, arg1: Xmm) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/x64/inst.isle line 2756. - let expr0_0 = C::temp_writable_xmm(ctx); - let expr1_0 = SseOpcode::Maxss; - let expr2_0 = C::xmm_to_xmm_mem(ctx, pattern1_0); - let expr3_0 = MInst::XmmRmR { - op: expr1_0, - src1: pattern0_0, - src2: expr2_0, - dst: expr0_0, - }; - let expr4_0 = C::emit(ctx, &expr3_0); - let expr5_0 = C::writable_xmm_to_xmm(ctx, expr0_0); - return Some(expr5_0); -} - -// Generated as internal constructor for term x64_maxsd. -pub fn constructor_x64_maxsd(ctx: &mut C, arg0: Xmm, arg1: Xmm) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/x64/inst.isle line 2763. - let expr0_0 = C::temp_writable_xmm(ctx); - let expr1_0 = SseOpcode::Maxsd; - let expr2_0 = C::xmm_to_xmm_mem(ctx, pattern1_0); - let expr3_0 = MInst::XmmRmR { - op: expr1_0, - src1: pattern0_0, - src2: expr2_0, - dst: expr0_0, - }; - let expr4_0 = C::emit(ctx, &expr3_0); - let expr5_0 = C::writable_xmm_to_xmm(ctx, expr0_0); - return Some(expr5_0); -} - -// Generated as internal constructor for term x64_maxps. -pub fn constructor_x64_maxps(ctx: &mut C, arg0: Xmm, arg1: Xmm) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/x64/inst.isle line 2770. - let expr0_0 = C::temp_writable_xmm(ctx); - let expr1_0 = SseOpcode::Maxps; - let expr2_0 = C::xmm_to_xmm_mem(ctx, pattern1_0); - let expr3_0 = MInst::XmmRmR { - op: expr1_0, - src1: pattern0_0, - src2: expr2_0, - dst: expr0_0, - }; - let expr4_0 = C::emit(ctx, &expr3_0); - let expr5_0 = C::writable_xmm_to_xmm(ctx, expr0_0); - return Some(expr5_0); -} - -// Generated as internal constructor for term x64_maxpd. -pub fn constructor_x64_maxpd(ctx: &mut C, arg0: Xmm, arg1: Xmm) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/x64/inst.isle line 2777. - let expr0_0 = C::temp_writable_xmm(ctx); - let expr1_0 = SseOpcode::Maxpd; - let expr2_0 = C::xmm_to_xmm_mem(ctx, pattern1_0); - let expr3_0 = MInst::XmmRmR { - op: expr1_0, - src1: pattern0_0, - src2: expr2_0, - dst: expr0_0, - }; - let expr4_0 = C::emit(ctx, &expr3_0); - let expr5_0 = C::writable_xmm_to_xmm(ctx, expr0_0); - return Some(expr5_0); -} - -// Generated as internal constructor for term x64_sqrtss. -pub fn constructor_x64_sqrtss(ctx: &mut C, arg0: Xmm) -> Option { - let pattern0_0 = arg0; - // Rule at src/isa/x64/inst.isle line 2785. - let expr0_0 = C::temp_writable_xmm(ctx); - let expr1_0 = SseOpcode::Sqrtss; - let expr2_0 = C::xmm_to_xmm_mem(ctx, pattern0_0); - let expr3_0 = MInst::XmmUnaryRmR { - op: expr1_0, - src: expr2_0, - dst: expr0_0, - }; - let expr4_0 = C::emit(ctx, &expr3_0); - let expr5_0 = C::writable_xmm_to_xmm(ctx, expr0_0); - return Some(expr5_0); -} - -// Generated as internal constructor for term x64_sqrtsd. -pub fn constructor_x64_sqrtsd(ctx: &mut C, arg0: Xmm) -> Option { - let pattern0_0 = arg0; - // Rule at src/isa/x64/inst.isle line 2792. - let expr0_0 = C::temp_writable_xmm(ctx); - let expr1_0 = SseOpcode::Sqrtsd; - let expr2_0 = C::xmm_to_xmm_mem(ctx, pattern0_0); - let expr3_0 = MInst::XmmUnaryRmR { - op: expr1_0, - src: expr2_0, - dst: expr0_0, - }; - let expr4_0 = C::emit(ctx, &expr3_0); - let expr5_0 = C::writable_xmm_to_xmm(ctx, expr0_0); - return Some(expr5_0); -} - -// Generated as internal constructor for term x64_sqrtps. -pub fn constructor_x64_sqrtps(ctx: &mut C, arg0: Xmm) -> Option { - let pattern0_0 = arg0; - // Rule at src/isa/x64/inst.isle line 2799. - let expr0_0 = C::temp_writable_xmm(ctx); - let expr1_0 = SseOpcode::Sqrtps; - let expr2_0 = C::xmm_to_xmm_mem(ctx, pattern0_0); - let expr3_0 = MInst::XmmUnaryRmR { - op: expr1_0, - src: expr2_0, - dst: expr0_0, - }; - let expr4_0 = C::emit(ctx, &expr3_0); - let expr5_0 = C::writable_xmm_to_xmm(ctx, expr0_0); - return Some(expr5_0); -} - -// Generated as internal constructor for term x64_sqrtpd. -pub fn constructor_x64_sqrtpd(ctx: &mut C, arg0: Xmm) -> Option { - let pattern0_0 = arg0; - // Rule at src/isa/x64/inst.isle line 2806. - let expr0_0 = C::temp_writable_xmm(ctx); - let expr1_0 = SseOpcode::Sqrtpd; - let expr2_0 = C::xmm_to_xmm_mem(ctx, pattern0_0); - let expr3_0 = MInst::XmmUnaryRmR { - op: expr1_0, - src: expr2_0, - dst: expr0_0, - }; - let expr4_0 = C::emit(ctx, &expr3_0); - let expr5_0 = C::writable_xmm_to_xmm(ctx, expr0_0); - return Some(expr5_0); -} - -// Generated as internal constructor for term x64_pcmpeq. -pub fn constructor_x64_pcmpeq( - ctx: &mut C, - arg0: Type, - arg1: Xmm, - arg2: &XmmMem, -) -> Option { - let pattern0_0 = arg0; - if pattern0_0 == I8X16 { - let pattern2_0 = arg1; - let pattern3_0 = arg2; - // Rule at src/isa/x64/inst.isle line 2813. - let expr0_0 = constructor_x64_pcmpeqb(ctx, pattern2_0, pattern3_0)?; - return Some(expr0_0); - } - if pattern0_0 == I16X8 { - let pattern2_0 = arg1; - let pattern3_0 = arg2; - // Rule at src/isa/x64/inst.isle line 2814. - let expr0_0 = constructor_x64_pcmpeqw(ctx, pattern2_0, pattern3_0)?; - return Some(expr0_0); - } - if pattern0_0 == I32X4 { - let pattern2_0 = arg1; - let pattern3_0 = arg2; - // Rule at src/isa/x64/inst.isle line 2815. - let expr0_0 = constructor_x64_pcmpeqd(ctx, pattern2_0, pattern3_0)?; - return Some(expr0_0); - } - if pattern0_0 == I64X2 { - let pattern2_0 = arg1; - let pattern3_0 = arg2; - // Rule at src/isa/x64/inst.isle line 2816. - let expr0_0 = constructor_x64_pcmpeqq(ctx, pattern2_0, pattern3_0)?; - return Some(expr0_0); - } - return None; -} - -// Generated as internal constructor for term x64_pcmpeqb. -pub fn constructor_x64_pcmpeqb(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/x64/inst.isle line 2819. - let expr0_0: Type = I8X16; - let expr1_0 = SseOpcode::Pcmpeqb; - let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?; - return Some(expr2_0); -} - -// Generated as internal constructor for term x64_pcmpeqw. -pub fn constructor_x64_pcmpeqw(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/x64/inst.isle line 2821. - let expr0_0: Type = I16X8; - let expr1_0 = SseOpcode::Pcmpeqw; - let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?; - return Some(expr2_0); -} - -// Generated as internal constructor for term x64_pcmpeqd. -pub fn constructor_x64_pcmpeqd(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/x64/inst.isle line 2823. - let expr0_0: Type = I32X4; - let expr1_0 = SseOpcode::Pcmpeqd; - let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?; - return Some(expr2_0); -} - -// Generated as internal constructor for term x64_pcmpeqq. -pub fn constructor_x64_pcmpeqq(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/x64/inst.isle line 2825. - let expr0_0: Type = I64X2; - let expr1_0 = SseOpcode::Pcmpeqq; - let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?; - return Some(expr2_0); -} - -// Generated as internal constructor for term x64_pcmpgt. -pub fn constructor_x64_pcmpgt( - ctx: &mut C, - arg0: Type, - arg1: Xmm, - arg2: &XmmMem, -) -> Option { - let pattern0_0 = arg0; - if pattern0_0 == I8X16 { - let pattern2_0 = arg1; - let pattern3_0 = arg2; - // Rule at src/isa/x64/inst.isle line 2829. - let expr0_0 = constructor_x64_pcmpgtb(ctx, pattern2_0, pattern3_0)?; - return Some(expr0_0); - } - if pattern0_0 == I16X8 { - let pattern2_0 = arg1; - let pattern3_0 = arg2; - // Rule at src/isa/x64/inst.isle line 2830. - let expr0_0 = constructor_x64_pcmpgtw(ctx, pattern2_0, pattern3_0)?; - return Some(expr0_0); - } - if pattern0_0 == I32X4 { - let pattern2_0 = arg1; - let pattern3_0 = arg2; - // Rule at src/isa/x64/inst.isle line 2831. - let expr0_0 = constructor_x64_pcmpgtd(ctx, pattern2_0, pattern3_0)?; - return Some(expr0_0); - } - if pattern0_0 == I64X2 { - let pattern2_0 = arg1; - let pattern3_0 = arg2; - // Rule at src/isa/x64/inst.isle line 2832. - let expr0_0 = constructor_x64_pcmpgtq(ctx, pattern2_0, pattern3_0)?; - return Some(expr0_0); - } - return None; -} - -// Generated as internal constructor for term x64_pcmpgtb. -pub fn constructor_x64_pcmpgtb(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/x64/inst.isle line 2835. - let expr0_0: Type = I8X16; - let expr1_0 = SseOpcode::Pcmpgtb; - let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?; - return Some(expr2_0); -} - -// Generated as internal constructor for term x64_pcmpgtw. -pub fn constructor_x64_pcmpgtw(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/x64/inst.isle line 2837. - let expr0_0: Type = I16X8; - let expr1_0 = SseOpcode::Pcmpgtw; - let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?; - return Some(expr2_0); -} - -// Generated as internal constructor for term x64_pcmpgtd. -pub fn constructor_x64_pcmpgtd(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/x64/inst.isle line 2839. - let expr0_0: Type = I32X4; - let expr1_0 = SseOpcode::Pcmpgtd; - let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?; - return Some(expr2_0); -} - -// Generated as internal constructor for term x64_pcmpgtq. -pub fn constructor_x64_pcmpgtq(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/x64/inst.isle line 2841. - let expr0_0: Type = I64X2; - let expr1_0 = SseOpcode::Pcmpgtq; - let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?; - return Some(expr2_0); -} - -// Generated as internal constructor for term alu_rm. -pub fn constructor_alu_rm( - ctx: &mut C, - arg0: Type, - arg1: &AluRmiROpcode, - arg2: &Amode, - arg3: Gpr, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - let pattern3_0 = arg3; - // Rule at src/isa/x64/inst.isle line 2845. - let expr0_0 = C::operand_size_of_type_32_64(ctx, pattern0_0); - let expr1_0 = C::amode_to_synthetic_amode(ctx, pattern2_0); - let expr2_0 = MInst::AluRM { - size: expr0_0, - op: pattern1_0.clone(), - src1_dst: expr1_0, - src2: pattern3_0, - }; - let expr3_0 = SideEffectNoResult::Inst { inst: expr2_0 }; - return Some(expr3_0); -} - -// Generated as internal constructor for term x64_add_mem. -pub fn constructor_x64_add_mem( - ctx: &mut C, - arg0: Type, - arg1: &Amode, - arg2: Gpr, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/x64/inst.isle line 2850. - let expr0_0 = AluRmiROpcode::Add; - let expr1_0 = constructor_alu_rm(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term x64_sub_mem. -pub fn constructor_x64_sub_mem( - ctx: &mut C, - arg0: Type, - arg1: &Amode, - arg2: Gpr, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/x64/inst.isle line 2854. - let expr0_0 = AluRmiROpcode::Sub; - let expr1_0 = constructor_alu_rm(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term x64_and_mem. -pub fn constructor_x64_and_mem( - ctx: &mut C, - arg0: Type, - arg1: &Amode, - arg2: Gpr, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/x64/inst.isle line 2858. - let expr0_0 = AluRmiROpcode::And; - let expr1_0 = constructor_alu_rm(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term x64_or_mem. -pub fn constructor_x64_or_mem( - ctx: &mut C, - arg0: Type, - arg1: &Amode, - arg2: Gpr, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/x64/inst.isle line 2862. - let expr0_0 = AluRmiROpcode::Or; - let expr1_0 = constructor_alu_rm(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term x64_xor_mem. -pub fn constructor_x64_xor_mem( - ctx: &mut C, - arg0: Type, - arg1: &Amode, - arg2: Gpr, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/x64/inst.isle line 2866. - let expr0_0 = AluRmiROpcode::Xor; - let expr1_0 = constructor_alu_rm(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term reg_to_xmm_mem. -pub fn constructor_reg_to_xmm_mem(ctx: &mut C, arg0: Reg) -> Option { - let pattern0_0 = arg0; - // Rule at src/isa/x64/inst.isle line 2923. - let expr0_0 = C::xmm_new(ctx, pattern0_0); - let expr1_0 = C::xmm_to_xmm_mem(ctx, expr0_0); - return Some(expr1_0); -} - -// Generated as internal constructor for term xmm_to_reg_mem. -pub fn constructor_xmm_to_reg_mem(ctx: &mut C, arg0: Reg) -> Option { - let pattern0_0 = arg0; - // Rule at src/isa/x64/inst.isle line 2926. - let expr0_0 = C::xmm_new(ctx, pattern0_0); - let expr1_0 = C::xmm_to_reg(ctx, expr0_0); - let expr2_0 = RegMem::Reg { reg: expr1_0 }; - let expr3_0 = C::reg_mem_to_xmm_mem(ctx, &expr2_0); - return Some(expr3_0); -} - -// Generated as internal constructor for term writable_gpr_to_r_reg. -pub fn constructor_writable_gpr_to_r_reg( - ctx: &mut C, - arg0: WritableGpr, -) -> Option { - let pattern0_0 = arg0; - // Rule at src/isa/x64/inst.isle line 2930. - let expr0_0 = C::writable_gpr_to_reg(ctx, pattern0_0); - let expr1_0 = C::writable_reg_to_reg(ctx, expr0_0); - return Some(expr1_0); -} - -// Generated as internal constructor for term writable_gpr_to_gpr_mem. -pub fn constructor_writable_gpr_to_gpr_mem( - ctx: &mut C, - arg0: WritableGpr, -) -> Option { - let pattern0_0 = arg0; - // Rule at src/isa/x64/inst.isle line 2933. - let expr0_0 = C::writable_gpr_to_gpr(ctx, pattern0_0); - let expr1_0 = C::gpr_to_gpr_mem(ctx, expr0_0); - return Some(expr1_0); -} - -// Generated as internal constructor for term writable_gpr_to_value_regs. -pub fn constructor_writable_gpr_to_value_regs( - ctx: &mut C, - arg0: WritableGpr, -) -> Option { - let pattern0_0 = arg0; - // Rule at src/isa/x64/inst.isle line 2936. - let expr0_0 = constructor_writable_gpr_to_r_reg(ctx, pattern0_0)?; - let expr1_0 = C::value_reg(ctx, expr0_0); - return Some(expr1_0); -} - -// Generated as internal constructor for term writable_xmm_to_r_reg. -pub fn constructor_writable_xmm_to_r_reg( - ctx: &mut C, - arg0: WritableXmm, -) -> Option { - let pattern0_0 = arg0; - // Rule at src/isa/x64/inst.isle line 2939. - let expr0_0 = C::writable_xmm_to_reg(ctx, pattern0_0); - let expr1_0 = C::writable_reg_to_reg(ctx, expr0_0); - return Some(expr1_0); -} - -// Generated as internal constructor for term writable_xmm_to_xmm_mem. -pub fn constructor_writable_xmm_to_xmm_mem( - ctx: &mut C, - arg0: WritableXmm, -) -> Option { - let pattern0_0 = arg0; - // Rule at src/isa/x64/inst.isle line 2942. - let expr0_0 = C::writable_xmm_to_xmm(ctx, pattern0_0); - let expr1_0 = C::xmm_to_xmm_mem(ctx, expr0_0); - return Some(expr1_0); -} - -// Generated as internal constructor for term writable_xmm_to_value_regs. -pub fn constructor_writable_xmm_to_value_regs( - ctx: &mut C, - arg0: WritableXmm, -) -> Option { - let pattern0_0 = arg0; - // Rule at src/isa/x64/inst.isle line 2945. - let expr0_0 = constructor_writable_xmm_to_r_reg(ctx, pattern0_0)?; - let expr1_0 = C::value_reg(ctx, expr0_0); - return Some(expr1_0); -} - -// Generated as internal constructor for term synthetic_amode_to_gpr_mem. -pub fn constructor_synthetic_amode_to_gpr_mem( - ctx: &mut C, - arg0: &SyntheticAmode, -) -> Option { - let pattern0_0 = arg0; - // Rule at src/isa/x64/inst.isle line 2952. - let expr0_0 = C::synthetic_amode_to_reg_mem(ctx, pattern0_0); - let expr1_0 = C::reg_mem_to_gpr_mem(ctx, &expr0_0); - return Some(expr1_0); -} - -// Generated as internal constructor for term amode_to_gpr_mem. -pub fn constructor_amode_to_gpr_mem(ctx: &mut C, arg0: &Amode) -> Option { - let pattern0_0 = arg0; - // Rule at src/isa/x64/inst.isle line 2950. - let expr0_0 = C::amode_to_synthetic_amode(ctx, pattern0_0); - let expr1_0 = constructor_synthetic_amode_to_gpr_mem(ctx, &expr0_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term amode_to_xmm_mem. -pub fn constructor_amode_to_xmm_mem(ctx: &mut C, arg0: &Amode) -> Option { - let pattern0_0 = arg0; - // Rule at src/isa/x64/inst.isle line 2955. - let expr0_0 = C::amode_to_synthetic_amode(ctx, pattern0_0); - let expr1_0 = constructor_synthetic_amode_to_xmm_mem(ctx, &expr0_0)?; - return Some(expr1_0); -} - -// Generated as internal constructor for term synthetic_amode_to_xmm_mem. -pub fn constructor_synthetic_amode_to_xmm_mem( - ctx: &mut C, - arg0: &SyntheticAmode, -) -> Option { - let pattern0_0 = arg0; - // Rule at src/isa/x64/inst.isle line 2958. - let expr0_0 = C::synthetic_amode_to_reg_mem(ctx, pattern0_0); - let expr1_0 = C::reg_mem_to_xmm_mem(ctx, &expr0_0); - return Some(expr1_0); -} - -// Generated as internal constructor for term lower. -pub fn constructor_lower(ctx: &mut C, arg0: Inst) -> Option { - let pattern0_0 = arg0; - if let Some(pattern1_0) = C::first_result(ctx, pattern0_0) { - let pattern2_0 = C::value_type(ctx, pattern1_0); - if pattern2_0 == I128 { - if let Some(()) = C::use_popcnt(ctx, pattern2_0) { - let pattern5_0 = C::inst_data(ctx, pattern0_0); - if let &InstructionData::Unary { - opcode: ref pattern6_0, - arg: pattern6_1, - } = &pattern5_0 - { - if let &Opcode::Popcnt = pattern6_0 { - // Rule at src/isa/x64/lower.isle line 1876. - let expr0_0: Type = I64; - let expr1_0 = C::put_in_regs(ctx, pattern6_1); - let expr2_0: usize = 0; - let expr3_0 = constructor_value_regs_get_gpr(ctx, expr1_0, expr2_0)?; - let expr4_0 = constructor_x64_popcnt(ctx, expr0_0, expr3_0)?; - let expr5_0: Type = I64; - let expr6_0 = C::put_in_regs(ctx, pattern6_1); - let expr7_0: usize = 1; - let expr8_0 = constructor_value_regs_get_gpr(ctx, expr6_0, expr7_0)?; - let expr9_0 = constructor_x64_popcnt(ctx, expr5_0, expr8_0)?; - let expr10_0: Type = I64; - let expr11_0 = C::gpr_to_gpr_mem_imm(ctx, expr9_0); - let expr12_0 = constructor_x64_add(ctx, expr10_0, expr4_0, &expr11_0)?; - let expr13_0 = C::gpr_to_reg(ctx, expr12_0); - let expr14_0: Type = I64; - let expr15_0: u64 = 0; - let expr16_0 = constructor_imm(ctx, expr14_0, expr15_0)?; - let expr17_0 = C::value_regs(ctx, expr13_0, expr16_0); - let expr18_0 = C::output(ctx, expr17_0); - return Some(expr18_0); - } - } - } - } - if pattern2_0 == I8X16 { - if let Some(()) = C::avx512vl_enabled(ctx, pattern2_0) { - if let Some(()) = C::avx512bitalg_enabled(ctx, pattern2_0) { - let pattern6_0 = C::inst_data(ctx, pattern0_0); - if let &InstructionData::Unary { - opcode: ref pattern7_0, - arg: pattern7_1, - } = &pattern6_0 - { - if let &Opcode::Popcnt = pattern7_0 { - // Rule at src/isa/x64/lower.isle line 1968. - let expr0_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?; - let expr1_0 = constructor_x64_vpopcntb(ctx, &expr0_0)?; - let expr2_0 = constructor_output_xmm(ctx, expr1_0)?; - return Some(expr2_0); - } - } - } - } - } - if let Some(pattern3_0) = C::ty_32_or_64(ctx, pattern2_0) { - if let Some(()) = C::use_lzcnt(ctx, pattern2_0) { - let pattern5_0 = C::inst_data(ctx, pattern0_0); - if let &InstructionData::Unary { - opcode: ref pattern6_0, - arg: pattern6_1, - } = &pattern5_0 - { - if let &Opcode::Clz = pattern6_0 { - // Rule at src/isa/x64/lower.isle line 1784. - let expr0_0 = constructor_put_in_gpr(ctx, pattern6_1)?; - let expr1_0 = constructor_x64_lzcnt(ctx, pattern3_0, expr0_0)?; - let expr2_0 = constructor_output_gpr(ctx, expr1_0)?; - return Some(expr2_0); - } - } - } - if let Some(()) = C::use_bmi1(ctx, pattern2_0) { - let pattern5_0 = C::inst_data(ctx, pattern0_0); - if let &InstructionData::Unary { - opcode: ref pattern6_0, - arg: pattern6_1, - } = &pattern5_0 - { - if let &Opcode::Ctz = pattern6_0 { - // Rule at src/isa/x64/lower.isle line 1826. - let expr0_0 = constructor_put_in_gpr(ctx, pattern6_1)?; - let expr1_0 = constructor_x64_tzcnt(ctx, pattern3_0, expr0_0)?; - let expr2_0 = constructor_output_gpr(ctx, expr1_0)?; - return Some(expr2_0); - } - } - } - if let Some(()) = C::use_popcnt(ctx, pattern2_0) { - let pattern5_0 = C::inst_data(ctx, pattern0_0); - if let &InstructionData::Unary { - opcode: ref pattern6_0, - arg: pattern6_1, - } = &pattern5_0 - { - if let &Opcode::Popcnt = pattern6_0 { - // Rule at src/isa/x64/lower.isle line 1862. - let expr0_0 = constructor_put_in_gpr(ctx, pattern6_1)?; - let expr1_0 = constructor_x64_popcnt(ctx, pattern3_0, expr0_0)?; - let expr2_0 = constructor_output_gpr(ctx, expr1_0)?; - return Some(expr2_0); - } - } - } - } - if let Some(pattern3_0) = C::ty_8_or_16(ctx, pattern2_0) { - if let Some(()) = C::use_popcnt(ctx, pattern2_0) { - let pattern5_0 = C::inst_data(ctx, pattern0_0); - if let &InstructionData::Unary { - opcode: ref pattern6_0, - arg: pattern6_1, - } = &pattern5_0 - { - if let &Opcode::Popcnt = pattern6_0 { - // Rule at src/isa/x64/lower.isle line 1869. - let expr0_0: Type = I32; - let expr1_0: Type = I32; - let expr2_0 = ExtendKind::Zero; - let expr3_0 = - constructor_extend_to_gpr(ctx, pattern6_1, expr1_0, &expr2_0)?; - let expr4_0 = constructor_x64_popcnt(ctx, expr0_0, expr3_0)?; - let expr5_0 = constructor_output_gpr(ctx, expr4_0)?; - return Some(expr5_0); - } - } - } - } - } - let pattern0_0 = arg0; - let pattern1_0 = C::inst_data(ctx, pattern0_0); - match &pattern1_0 { - &InstructionData::NullAry { - opcode: ref pattern2_0, - } => { - if let &Opcode::Debugtrap = pattern2_0 { - // Rule at src/isa/x64/lower.isle line 2254. - let expr0_0 = constructor_x64_hlt(ctx)?; - let expr1_0 = constructor_side_effect(ctx, &expr0_0)?; - return Some(expr1_0); - } - } - &InstructionData::UnaryIeee32 { - opcode: ref pattern2_0, - imm: pattern2_1, - } => { - if let &Opcode::F32const = pattern2_0 { - let pattern4_0 = C::u64_from_ieee32(ctx, pattern2_1); - // Rule at src/isa/x64/lower.isle line 46. - let expr0_0: Type = F32; - let expr1_0 = constructor_imm(ctx, expr0_0, pattern4_0)?; - let expr2_0 = constructor_output_reg(ctx, expr1_0)?; - return Some(expr2_0); - } - } - &InstructionData::UnaryIeee64 { - opcode: ref pattern2_0, - imm: pattern2_1, - } => { - if let &Opcode::F64const = pattern2_0 { - let pattern4_0 = C::u64_from_ieee64(ctx, pattern2_1); - // Rule at src/isa/x64/lower.isle line 51. - let expr0_0: Type = F64; - let expr1_0 = constructor_imm(ctx, expr0_0, pattern4_0)?; - let expr2_0 = constructor_output_reg(ctx, expr1_0)?; - return Some(expr2_0); - } - } - &InstructionData::Trap { - opcode: ref pattern2_0, - code: ref pattern2_1, - } => { - match pattern2_0 { - &Opcode::Trap => { - // Rule at src/isa/x64/lower.isle line 1438. - let expr0_0 = constructor_x64_ud2(ctx, pattern2_1)?; - let expr1_0 = constructor_side_effect(ctx, &expr0_0)?; - return Some(expr1_0); - } - &Opcode::ResumableTrap => { - // Rule at src/isa/x64/lower.isle line 1443. - let expr0_0 = constructor_x64_ud2(ctx, pattern2_1)?; - let expr1_0 = constructor_side_effect(ctx, &expr0_0)?; - return Some(expr1_0); - } - _ => {} - } - } - &InstructionData::Store { - opcode: ref pattern2_0, - args: ref pattern2_1, - flags: pattern2_2, - offset: pattern2_3, - } => { - match pattern2_0 { - &Opcode::Store => { - let (pattern4_0, pattern4_1) = C::unpack_value_array_2(ctx, pattern2_1); - if let Some(pattern5_0) = C::def_inst(ctx, pattern4_0) { - if let Some(pattern6_0) = C::first_result(ctx, pattern5_0) { - let pattern7_0 = C::value_type(ctx, pattern6_0); - if let Some(pattern8_0) = C::ty_32_or_64(ctx, pattern7_0) { - let pattern9_0 = C::inst_data(ctx, pattern5_0); - if let &InstructionData::Binary { - opcode: ref pattern10_0, - args: ref pattern10_1, - } = &pattern9_0 - { - match pattern10_0 { - &Opcode::Iadd => { - let (pattern12_0, pattern12_1) = - C::unpack_value_array_2(ctx, pattern10_1); - if let Some(pattern13_0) = - C::sinkable_load(ctx, pattern12_0) - { - if let Some(pattern14_0) = - C::def_inst(ctx, pattern12_0) - { - let pattern15_0 = - C::inst_data(ctx, pattern14_0); - if let &InstructionData::Load { - opcode: ref pattern16_0, - arg: pattern16_1, - flags: pattern16_2, - offset: pattern16_3, - } = &pattern15_0 - { - if let &Opcode::Load = pattern16_0 { - if pattern4_1 == pattern16_1 { - if pattern2_2 == pattern16_2 { - if pattern2_3 == pattern16_3 { - // Rule at src/isa/x64/lower.isle line 2662. - let expr0_0 = C::sink_load( - ctx, - &pattern13_0, - ); - let expr1_0 = - constructor_to_amode( - ctx, - pattern16_2, - pattern16_1, - pattern16_3, - )?; - let expr2_0 = - constructor_put_in_gpr( - ctx, - pattern12_1, - )?; - let expr3_0 = constructor_x64_add_mem(ctx, pattern8_0, &expr1_0, expr2_0)?; - let expr4_0 = constructor_side_effect(ctx, &expr3_0)?; - return Some(expr4_0); - } - } - } - } - } - } - } - if let Some(pattern13_0) = - C::sinkable_load(ctx, pattern12_1) - { - if let Some(pattern14_0) = - C::def_inst(ctx, pattern12_1) - { - let pattern15_0 = - C::inst_data(ctx, pattern14_0); - if let &InstructionData::Load { - opcode: ref pattern16_0, - arg: pattern16_1, - flags: pattern16_2, - offset: pattern16_3, - } = &pattern15_0 - { - if let &Opcode::Load = pattern16_0 { - if pattern4_1 == pattern16_1 { - if pattern2_2 == pattern16_2 { - if pattern2_3 == pattern16_3 { - // Rule at src/isa/x64/lower.isle line 2676. - let expr0_0 = C::sink_load( - ctx, - &pattern13_0, - ); - let expr1_0 = - constructor_to_amode( - ctx, - pattern16_2, - pattern16_1, - pattern16_3, - )?; - let expr2_0 = - constructor_put_in_gpr( - ctx, - pattern12_0, - )?; - let expr3_0 = constructor_x64_add_mem(ctx, pattern8_0, &expr1_0, expr2_0)?; - let expr4_0 = constructor_side_effect(ctx, &expr3_0)?; - return Some(expr4_0); - } - } - } - } - } - } - } - } - &Opcode::Isub => { - let (pattern12_0, pattern12_1) = - C::unpack_value_array_2(ctx, pattern10_1); - if let Some(pattern13_0) = - C::sinkable_load(ctx, pattern12_0) - { - if let Some(pattern14_0) = - C::def_inst(ctx, pattern12_0) - { - let pattern15_0 = - C::inst_data(ctx, pattern14_0); - if let &InstructionData::Load { - opcode: ref pattern16_0, - arg: pattern16_1, - flags: pattern16_2, - offset: pattern16_3, - } = &pattern15_0 - { - if let &Opcode::Load = pattern16_0 { - if pattern4_1 == pattern16_1 { - if pattern2_2 == pattern16_2 { - if pattern2_3 == pattern16_3 { - // Rule at src/isa/x64/lower.isle line 2690. - let expr0_0 = C::sink_load( - ctx, - &pattern13_0, - ); - let expr1_0 = - constructor_to_amode( - ctx, - pattern16_2, - pattern16_1, - pattern16_3, - )?; - let expr2_0 = - constructor_put_in_gpr( - ctx, - pattern12_1, - )?; - let expr3_0 = constructor_x64_sub_mem(ctx, pattern8_0, &expr1_0, expr2_0)?; - let expr4_0 = constructor_side_effect(ctx, &expr3_0)?; - return Some(expr4_0); - } - } - } - } - } - } - } - } - &Opcode::Band => { - let (pattern12_0, pattern12_1) = - C::unpack_value_array_2(ctx, pattern10_1); - if let Some(pattern13_0) = - C::sinkable_load(ctx, pattern12_0) - { - if let Some(pattern14_0) = - C::def_inst(ctx, pattern12_0) - { - let pattern15_0 = - C::inst_data(ctx, pattern14_0); - if let &InstructionData::Load { - opcode: ref pattern16_0, - arg: pattern16_1, - flags: pattern16_2, - offset: pattern16_3, - } = &pattern15_0 - { - if let &Opcode::Load = pattern16_0 { - if pattern4_1 == pattern16_1 { - if pattern2_2 == pattern16_2 { - if pattern2_3 == pattern16_3 { - // Rule at src/isa/x64/lower.isle line 2704. - let expr0_0 = C::sink_load( - ctx, - &pattern13_0, - ); - let expr1_0 = - constructor_to_amode( - ctx, - pattern16_2, - pattern16_1, - pattern16_3, - )?; - let expr2_0 = - constructor_put_in_gpr( - ctx, - pattern12_1, - )?; - let expr3_0 = constructor_x64_and_mem(ctx, pattern8_0, &expr1_0, expr2_0)?; - let expr4_0 = constructor_side_effect(ctx, &expr3_0)?; - return Some(expr4_0); - } - } - } - } - } - } - } - if let Some(pattern13_0) = - C::sinkable_load(ctx, pattern12_1) - { - if let Some(pattern14_0) = - C::def_inst(ctx, pattern12_1) - { - let pattern15_0 = - C::inst_data(ctx, pattern14_0); - if let &InstructionData::Load { - opcode: ref pattern16_0, - arg: pattern16_1, - flags: pattern16_2, - offset: pattern16_3, - } = &pattern15_0 - { - if let &Opcode::Load = pattern16_0 { - if pattern4_1 == pattern16_1 { - if pattern2_2 == pattern16_2 { - if pattern2_3 == pattern16_3 { - // Rule at src/isa/x64/lower.isle line 2718. - let expr0_0 = C::sink_load( - ctx, - &pattern13_0, - ); - let expr1_0 = - constructor_to_amode( - ctx, - pattern16_2, - pattern16_1, - pattern16_3, - )?; - let expr2_0 = - constructor_put_in_gpr( - ctx, - pattern12_0, - )?; - let expr3_0 = constructor_x64_and_mem(ctx, pattern8_0, &expr1_0, expr2_0)?; - let expr4_0 = constructor_side_effect(ctx, &expr3_0)?; - return Some(expr4_0); - } - } - } - } - } - } - } - } - &Opcode::Bor => { - let (pattern12_0, pattern12_1) = - C::unpack_value_array_2(ctx, pattern10_1); - if let Some(pattern13_0) = - C::sinkable_load(ctx, pattern12_0) - { - if let Some(pattern14_0) = - C::def_inst(ctx, pattern12_0) - { - let pattern15_0 = - C::inst_data(ctx, pattern14_0); - if let &InstructionData::Load { - opcode: ref pattern16_0, - arg: pattern16_1, - flags: pattern16_2, - offset: pattern16_3, - } = &pattern15_0 - { - if let &Opcode::Load = pattern16_0 { - if pattern4_1 == pattern16_1 { - if pattern2_2 == pattern16_2 { - if pattern2_3 == pattern16_3 { - // Rule at src/isa/x64/lower.isle line 2732. - let expr0_0 = C::sink_load( - ctx, - &pattern13_0, - ); - let expr1_0 = - constructor_to_amode( - ctx, - pattern16_2, - pattern16_1, - pattern16_3, - )?; - let expr2_0 = - constructor_put_in_gpr( - ctx, - pattern12_1, - )?; - let expr3_0 = - constructor_x64_or_mem( - ctx, pattern8_0, - &expr1_0, expr2_0, - )?; - let expr4_0 = constructor_side_effect(ctx, &expr3_0)?; - return Some(expr4_0); - } - } - } - } - } - } - } - if let Some(pattern13_0) = - C::sinkable_load(ctx, pattern12_1) - { - if let Some(pattern14_0) = - C::def_inst(ctx, pattern12_1) - { - let pattern15_0 = - C::inst_data(ctx, pattern14_0); - if let &InstructionData::Load { - opcode: ref pattern16_0, - arg: pattern16_1, - flags: pattern16_2, - offset: pattern16_3, - } = &pattern15_0 - { - if let &Opcode::Load = pattern16_0 { - if pattern4_1 == pattern16_1 { - if pattern2_2 == pattern16_2 { - if pattern2_3 == pattern16_3 { - // Rule at src/isa/x64/lower.isle line 2746. - let expr0_0 = C::sink_load( - ctx, - &pattern13_0, - ); - let expr1_0 = - constructor_to_amode( - ctx, - pattern16_2, - pattern16_1, - pattern16_3, - )?; - let expr2_0 = - constructor_put_in_gpr( - ctx, - pattern12_0, - )?; - let expr3_0 = - constructor_x64_or_mem( - ctx, pattern8_0, - &expr1_0, expr2_0, - )?; - let expr4_0 = constructor_side_effect(ctx, &expr3_0)?; - return Some(expr4_0); - } - } - } - } - } - } - } - } - &Opcode::Bxor => { - let (pattern12_0, pattern12_1) = - C::unpack_value_array_2(ctx, pattern10_1); - if let Some(pattern13_0) = - C::sinkable_load(ctx, pattern12_0) - { - if let Some(pattern14_0) = - C::def_inst(ctx, pattern12_0) - { - let pattern15_0 = - C::inst_data(ctx, pattern14_0); - if let &InstructionData::Load { - opcode: ref pattern16_0, - arg: pattern16_1, - flags: pattern16_2, - offset: pattern16_3, - } = &pattern15_0 - { - if let &Opcode::Load = pattern16_0 { - if pattern4_1 == pattern16_1 { - if pattern2_2 == pattern16_2 { - if pattern2_3 == pattern16_3 { - // Rule at src/isa/x64/lower.isle line 2760. - let expr0_0 = C::sink_load( - ctx, - &pattern13_0, - ); - let expr1_0 = - constructor_to_amode( - ctx, - pattern16_2, - pattern16_1, - pattern16_3, - )?; - let expr2_0 = - constructor_put_in_gpr( - ctx, - pattern12_1, - )?; - let expr3_0 = constructor_x64_xor_mem(ctx, pattern8_0, &expr1_0, expr2_0)?; - let expr4_0 = constructor_side_effect(ctx, &expr3_0)?; - return Some(expr4_0); - } - } - } - } - } - } - } - if let Some(pattern13_0) = - C::sinkable_load(ctx, pattern12_1) - { - if let Some(pattern14_0) = - C::def_inst(ctx, pattern12_1) - { - let pattern15_0 = - C::inst_data(ctx, pattern14_0); - if let &InstructionData::Load { - opcode: ref pattern16_0, - arg: pattern16_1, - flags: pattern16_2, - offset: pattern16_3, - } = &pattern15_0 - { - if let &Opcode::Load = pattern16_0 { - if pattern4_1 == pattern16_1 { - if pattern2_2 == pattern16_2 { - if pattern2_3 == pattern16_3 { - // Rule at src/isa/x64/lower.isle line 2774. - let expr0_0 = C::sink_load( - ctx, - &pattern13_0, - ); - let expr1_0 = - constructor_to_amode( - ctx, - pattern16_2, - pattern16_1, - pattern16_3, - )?; - let expr2_0 = - constructor_put_in_gpr( - ctx, - pattern12_0, - )?; - let expr3_0 = constructor_x64_xor_mem(ctx, pattern8_0, &expr1_0, expr2_0)?; - let expr4_0 = constructor_side_effect(ctx, &expr3_0)?; - return Some(expr4_0); - } - } - } - } - } - } - } - } - _ => {} - } - } - } - } - } - let pattern5_0 = C::value_type(ctx, pattern4_0); - if pattern5_0 == F32 { - // Rule at src/isa/x64/lower.isle line 2605. - let expr0_0 = SseOpcode::Movss; - let expr1_0 = - constructor_to_amode(ctx, pattern2_2, pattern4_1, pattern2_3)?; - let expr2_0 = C::amode_to_synthetic_amode(ctx, &expr1_0); - let expr3_0 = constructor_put_in_xmm(ctx, pattern4_0)?; - let expr4_0 = constructor_x64_xmm_movrm(ctx, &expr0_0, &expr2_0, expr3_0)?; - let expr5_0 = constructor_side_effect(ctx, &expr4_0)?; - return Some(expr5_0); - } - if pattern5_0 == F64 { - // Rule at src/isa/x64/lower.isle line 2613. - let expr0_0 = SseOpcode::Movsd; - let expr1_0 = - constructor_to_amode(ctx, pattern2_2, pattern4_1, pattern2_3)?; - let expr2_0 = C::amode_to_synthetic_amode(ctx, &expr1_0); - let expr3_0 = constructor_put_in_xmm(ctx, pattern4_0)?; - let expr4_0 = constructor_x64_xmm_movrm(ctx, &expr0_0, &expr2_0, expr3_0)?; - let expr5_0 = constructor_side_effect(ctx, &expr4_0)?; - return Some(expr5_0); - } - if pattern5_0 == F32X4 { - // Rule at src/isa/x64/lower.isle line 2621. - let expr0_0 = SseOpcode::Movups; - let expr1_0 = - constructor_to_amode(ctx, pattern2_2, pattern4_1, pattern2_3)?; - let expr2_0 = C::amode_to_synthetic_amode(ctx, &expr1_0); - let expr3_0 = constructor_put_in_xmm(ctx, pattern4_0)?; - let expr4_0 = constructor_x64_xmm_movrm(ctx, &expr0_0, &expr2_0, expr3_0)?; - let expr5_0 = constructor_side_effect(ctx, &expr4_0)?; - return Some(expr5_0); - } - if pattern5_0 == F64X2 { - // Rule at src/isa/x64/lower.isle line 2629. - let expr0_0 = SseOpcode::Movupd; - let expr1_0 = - constructor_to_amode(ctx, pattern2_2, pattern4_1, pattern2_3)?; - let expr2_0 = C::amode_to_synthetic_amode(ctx, &expr1_0); - let expr3_0 = constructor_put_in_xmm(ctx, pattern4_0)?; - let expr4_0 = constructor_x64_xmm_movrm(ctx, &expr0_0, &expr2_0, expr3_0)?; - let expr5_0 = constructor_side_effect(ctx, &expr4_0)?; - return Some(expr5_0); - } - if let Some(pattern6_0) = C::ty_int_bool_128(ctx, pattern5_0) { - // Rule at src/isa/x64/lower.isle line 2645. - let expr0_0 = C::put_in_regs(ctx, pattern4_0); - let expr1_0: usize = 0; - let expr2_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr1_0)?; - let expr3_0: usize = 1; - let expr4_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr3_0)?; - let expr5_0 = - constructor_to_amode(ctx, pattern2_2, pattern4_1, pattern2_3)?; - let expr6_0: u32 = 8; - let expr7_0 = C::amode_offset(ctx, &expr5_0, expr6_0); - let expr8_0: Type = I64; - let expr9_0 = C::amode_to_synthetic_amode(ctx, &expr5_0); - let expr10_0 = constructor_x64_movrm(ctx, expr8_0, &expr9_0, expr2_0)?; - let expr11_0: Type = I64; - let expr12_0 = C::amode_to_synthetic_amode(ctx, &expr7_0); - let expr13_0 = constructor_x64_movrm(ctx, expr11_0, &expr12_0, expr4_0)?; - let expr14_0 = constructor_side_effect_concat(ctx, &expr10_0, &expr13_0)?; - let expr15_0 = constructor_side_effect(ctx, &expr14_0)?; - return Some(expr15_0); - } - if let Some(pattern6_0) = C::ty_vec128_int(ctx, pattern5_0) { - // Rule at src/isa/x64/lower.isle line 2637. - let expr0_0 = SseOpcode::Movdqu; - let expr1_0 = - constructor_to_amode(ctx, pattern2_2, pattern4_1, pattern2_3)?; - let expr2_0 = C::amode_to_synthetic_amode(ctx, &expr1_0); - let expr3_0 = constructor_put_in_xmm(ctx, pattern4_0)?; - let expr4_0 = constructor_x64_xmm_movrm(ctx, &expr0_0, &expr2_0, expr3_0)?; - let expr5_0 = constructor_side_effect(ctx, &expr4_0)?; - return Some(expr5_0); - } - if let Some(pattern6_0) = C::is_gpr_type(ctx, pattern5_0) { - // Rule at src/isa/x64/lower.isle line 2586. - let expr0_0 = - constructor_to_amode(ctx, pattern2_2, pattern4_1, pattern2_3)?; - let expr1_0 = C::amode_to_synthetic_amode(ctx, &expr0_0); - let expr2_0 = constructor_put_in_gpr(ctx, pattern4_0)?; - let expr3_0 = constructor_x64_movrm(ctx, pattern6_0, &expr1_0, expr2_0)?; - let expr4_0 = constructor_side_effect(ctx, &expr3_0)?; - return Some(expr4_0); - } - } - &Opcode::Istore8 => { - let (pattern4_0, pattern4_1) = C::unpack_value_array_2(ctx, pattern2_1); - // Rule at src/isa/x64/lower.isle line 2594. - let expr0_0: Type = I8; - let expr1_0 = constructor_to_amode(ctx, pattern2_2, pattern4_1, pattern2_3)?; - let expr2_0 = C::amode_to_synthetic_amode(ctx, &expr1_0); - let expr3_0 = constructor_put_in_gpr(ctx, pattern4_0)?; - let expr4_0 = constructor_x64_movrm(ctx, expr0_0, &expr2_0, expr3_0)?; - let expr5_0 = constructor_side_effect(ctx, &expr4_0)?; - return Some(expr5_0); - } - &Opcode::Istore16 => { - let (pattern4_0, pattern4_1) = C::unpack_value_array_2(ctx, pattern2_1); - // Rule at src/isa/x64/lower.isle line 2597. - let expr0_0: Type = I16; - let expr1_0 = constructor_to_amode(ctx, pattern2_2, pattern4_1, pattern2_3)?; - let expr2_0 = C::amode_to_synthetic_amode(ctx, &expr1_0); - let expr3_0 = constructor_put_in_gpr(ctx, pattern4_0)?; - let expr4_0 = constructor_x64_movrm(ctx, expr0_0, &expr2_0, expr3_0)?; - let expr5_0 = constructor_side_effect(ctx, &expr4_0)?; - return Some(expr5_0); - } - &Opcode::Istore32 => { - let (pattern4_0, pattern4_1) = C::unpack_value_array_2(ctx, pattern2_1); - // Rule at src/isa/x64/lower.isle line 2600. - let expr0_0: Type = I32; - let expr1_0 = constructor_to_amode(ctx, pattern2_2, pattern4_1, pattern2_3)?; - let expr2_0 = C::amode_to_synthetic_amode(ctx, &expr1_0); - let expr3_0 = constructor_put_in_gpr(ctx, pattern4_0)?; - let expr4_0 = constructor_x64_movrm(ctx, expr0_0, &expr2_0, expr3_0)?; - let expr5_0 = constructor_side_effect(ctx, &expr4_0)?; - return Some(expr5_0); - } - _ => {} - } - } - &InstructionData::TernaryImm8 { - opcode: ref pattern2_0, - args: ref pattern2_1, - imm: pattern2_2, - } => { - if let &Opcode::Insertlane = pattern2_0 { - let (pattern4_0, pattern4_1) = C::unpack_value_array_2(ctx, pattern2_1); - let pattern5_0 = C::value_type(ctx, pattern4_0); - let pattern6_0 = C::u8_from_uimm8(ctx, pattern2_2); - // Rule at src/isa/x64/lower.isle line 1302. - let expr0_0 = constructor_put_in_xmm(ctx, pattern4_0)?; - let expr1_0 = C::put_in_reg_mem(ctx, pattern4_1); - let expr2_0 = - constructor_vec_insert_lane(ctx, pattern5_0, expr0_0, &expr1_0, pattern6_0)?; - let expr3_0 = constructor_output_xmm(ctx, expr2_0)?; - return Some(expr3_0); - } - } - &InstructionData::FloatCompare { - opcode: ref pattern2_0, - args: ref pattern2_1, - cond: ref pattern2_2, - } => { - if let &Opcode::Fcmp = pattern2_0 { - let (pattern4_0, pattern4_1) = C::unpack_value_array_2(ctx, pattern2_1); - let pattern5_0 = C::value_type(ctx, pattern4_0); - if let Some(pattern6_0) = C::ty_scalar_float(ctx, pattern5_0) { - match pattern2_2 { - &FloatCC::Equal => { - // Rule at src/isa/x64/lower.isle line 1575. - let expr0_0 = constructor_x64_ucomis(ctx, pattern4_1, pattern4_0)?; - let expr1_0 = CC::NP; - let expr2_0 = constructor_x64_setcc(ctx, &expr1_0)?; - let expr3_0 = CC::Z; - let expr4_0 = constructor_x64_setcc(ctx, &expr3_0)?; - let expr5_0 = - constructor_consumes_flags_concat(ctx, &expr2_0, &expr4_0)?; - let expr6_0 = constructor_with_flags(ctx, &expr0_0, &expr5_0)?; - let expr7_0: usize = 0; - let expr8_0 = constructor_value_regs_get_gpr(ctx, expr6_0, expr7_0)?; - let expr9_0: usize = 1; - let expr10_0 = constructor_value_regs_get_gpr(ctx, expr6_0, expr9_0)?; - let expr11_0: Type = I32; - let expr12_0 = C::gpr_to_gpr_mem_imm(ctx, expr10_0); - let expr13_0 = constructor_x64_and(ctx, expr11_0, expr8_0, &expr12_0)?; - let expr14_0 = constructor_output_gpr(ctx, expr13_0)?; - return Some(expr14_0); - } - &FloatCC::GreaterThan => { - // Rule at src/isa/x64/lower.isle line 1603. - let expr0_0 = constructor_x64_ucomis(ctx, pattern4_1, pattern4_0)?; - let expr1_0 = CC::NBE; - let expr2_0 = constructor_x64_setcc(ctx, &expr1_0)?; - let expr3_0 = constructor_with_flags(ctx, &expr0_0, &expr2_0)?; - let expr4_0 = C::output(ctx, expr3_0); - return Some(expr4_0); - } - &FloatCC::GreaterThanOrEqual => { - // Rule at src/isa/x64/lower.isle line 1605. - let expr0_0 = constructor_x64_ucomis(ctx, pattern4_1, pattern4_0)?; - let expr1_0 = CC::NB; - let expr2_0 = constructor_x64_setcc(ctx, &expr1_0)?; - let expr3_0 = constructor_with_flags(ctx, &expr0_0, &expr2_0)?; - let expr4_0 = C::output(ctx, expr3_0); - return Some(expr4_0); - } - &FloatCC::LessThan => { - // Rule at src/isa/x64/lower.isle line 1615. - let expr0_0 = constructor_x64_ucomis(ctx, pattern4_0, pattern4_1)?; - let expr1_0 = CC::NBE; - let expr2_0 = constructor_x64_setcc(ctx, &expr1_0)?; - let expr3_0 = constructor_with_flags(ctx, &expr0_0, &expr2_0)?; - let expr4_0 = C::output(ctx, expr3_0); - return Some(expr4_0); - } - &FloatCC::LessThanOrEqual => { - // Rule at src/isa/x64/lower.isle line 1618. - let expr0_0 = constructor_x64_ucomis(ctx, pattern4_0, pattern4_1)?; - let expr1_0 = CC::NB; - let expr2_0 = constructor_x64_setcc(ctx, &expr1_0)?; - let expr3_0 = constructor_with_flags(ctx, &expr0_0, &expr2_0)?; - let expr4_0 = C::output(ctx, expr3_0); - return Some(expr4_0); - } - &FloatCC::NotEqual => { - // Rule at src/isa/x64/lower.isle line 1584. - let expr0_0 = constructor_x64_ucomis(ctx, pattern4_1, pattern4_0)?; - let expr1_0 = CC::P; - let expr2_0 = constructor_x64_setcc(ctx, &expr1_0)?; - let expr3_0 = CC::NZ; - let expr4_0 = constructor_x64_setcc(ctx, &expr3_0)?; - let expr5_0 = - constructor_consumes_flags_concat(ctx, &expr2_0, &expr4_0)?; - let expr6_0 = constructor_with_flags(ctx, &expr0_0, &expr5_0)?; - let expr7_0: usize = 0; - let expr8_0 = constructor_value_regs_get_gpr(ctx, expr6_0, expr7_0)?; - let expr9_0: usize = 1; - let expr10_0 = constructor_value_regs_get_gpr(ctx, expr6_0, expr9_0)?; - let expr11_0: Type = I32; - let expr12_0 = C::gpr_to_gpr_mem_imm(ctx, expr10_0); - let expr13_0 = constructor_x64_or(ctx, expr11_0, expr8_0, &expr12_0)?; - let expr14_0 = constructor_output_gpr(ctx, expr13_0)?; - return Some(expr14_0); - } - &FloatCC::Ordered => { - // Rule at src/isa/x64/lower.isle line 1595. - let expr0_0 = constructor_x64_ucomis(ctx, pattern4_1, pattern4_0)?; - let expr1_0 = CC::NP; - let expr2_0 = constructor_x64_setcc(ctx, &expr1_0)?; - let expr3_0 = constructor_with_flags(ctx, &expr0_0, &expr2_0)?; - let expr4_0 = C::output(ctx, expr3_0); - return Some(expr4_0); - } - &FloatCC::OrderedNotEqual => { - // Rule at src/isa/x64/lower.isle line 1599. - let expr0_0 = constructor_x64_ucomis(ctx, pattern4_1, pattern4_0)?; - let expr1_0 = CC::NZ; - let expr2_0 = constructor_x64_setcc(ctx, &expr1_0)?; - let expr3_0 = constructor_with_flags(ctx, &expr0_0, &expr2_0)?; - let expr4_0 = C::output(ctx, expr3_0); - return Some(expr4_0); - } - &FloatCC::Unordered => { - // Rule at src/isa/x64/lower.isle line 1597. - let expr0_0 = constructor_x64_ucomis(ctx, pattern4_1, pattern4_0)?; - let expr1_0 = CC::P; - let expr2_0 = constructor_x64_setcc(ctx, &expr1_0)?; - let expr3_0 = constructor_with_flags(ctx, &expr0_0, &expr2_0)?; - let expr4_0 = C::output(ctx, expr3_0); - return Some(expr4_0); - } - &FloatCC::UnorderedOrEqual => { - // Rule at src/isa/x64/lower.isle line 1601. - let expr0_0 = constructor_x64_ucomis(ctx, pattern4_1, pattern4_0)?; - let expr1_0 = CC::Z; - let expr2_0 = constructor_x64_setcc(ctx, &expr1_0)?; - let expr3_0 = constructor_with_flags(ctx, &expr0_0, &expr2_0)?; - let expr4_0 = C::output(ctx, expr3_0); - return Some(expr4_0); - } - &FloatCC::UnorderedOrGreaterThan => { - // Rule at src/isa/x64/lower.isle line 1621. - let expr0_0 = constructor_x64_ucomis(ctx, pattern4_0, pattern4_1)?; - let expr1_0 = CC::B; - let expr2_0 = constructor_x64_setcc(ctx, &expr1_0)?; - let expr3_0 = constructor_with_flags(ctx, &expr0_0, &expr2_0)?; - let expr4_0 = C::output(ctx, expr3_0); - return Some(expr4_0); - } - &FloatCC::UnorderedOrGreaterThanOrEqual => { - // Rule at src/isa/x64/lower.isle line 1624. - let expr0_0 = constructor_x64_ucomis(ctx, pattern4_0, pattern4_1)?; - let expr1_0 = CC::BE; - let expr2_0 = constructor_x64_setcc(ctx, &expr1_0)?; - let expr3_0 = constructor_with_flags(ctx, &expr0_0, &expr2_0)?; - let expr4_0 = C::output(ctx, expr3_0); - return Some(expr4_0); - } - &FloatCC::UnorderedOrLessThan => { - // Rule at src/isa/x64/lower.isle line 1607. - let expr0_0 = constructor_x64_ucomis(ctx, pattern4_1, pattern4_0)?; - let expr1_0 = CC::B; - let expr2_0 = constructor_x64_setcc(ctx, &expr1_0)?; - let expr3_0 = constructor_with_flags(ctx, &expr0_0, &expr2_0)?; - let expr4_0 = C::output(ctx, expr3_0); - return Some(expr4_0); - } - &FloatCC::UnorderedOrLessThanOrEqual => { - // Rule at src/isa/x64/lower.isle line 1609. - let expr0_0 = constructor_x64_ucomis(ctx, pattern4_1, pattern4_0)?; - let expr1_0 = CC::BE; - let expr2_0 = constructor_x64_setcc(ctx, &expr1_0)?; - let expr3_0 = constructor_with_flags(ctx, &expr0_0, &expr2_0)?; - let expr4_0 = C::output(ctx, expr3_0); - return Some(expr4_0); - } - _ => {} - } - } - if let Some(pattern6_0) = C::ty_vec128(ctx, pattern5_0) { - match pattern2_2 { - &FloatCC::Equal => { - // Rule at src/isa/x64/lower.isle line 1632. - let expr0_0 = constructor_put_in_xmm(ctx, pattern4_0)?; - let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern4_1)?; - let expr2_0 = FcmpImm::Equal; - let expr3_0 = - constructor_x64_cmpp(ctx, pattern6_0, expr0_0, &expr1_0, &expr2_0)?; - let expr4_0 = constructor_output_xmm(ctx, expr3_0)?; - return Some(expr4_0); - } - &FloatCC::GreaterThan => { - // Rule at src/isa/x64/lower.isle line 1652. - let expr0_0 = constructor_put_in_xmm(ctx, pattern4_1)?; - let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern4_0)?; - let expr2_0 = FcmpImm::LessThan; - let expr3_0 = - constructor_x64_cmpp(ctx, pattern6_0, expr0_0, &expr1_0, &expr2_0)?; - let expr4_0 = constructor_output_xmm(ctx, expr3_0)?; - return Some(expr4_0); - } - &FloatCC::GreaterThanOrEqual => { - // Rule at src/isa/x64/lower.isle line 1654. - let expr0_0 = constructor_put_in_xmm(ctx, pattern4_1)?; - let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern4_0)?; - let expr2_0 = FcmpImm::LessThanOrEqual; - let expr3_0 = - constructor_x64_cmpp(ctx, pattern6_0, expr0_0, &expr1_0, &expr2_0)?; - let expr4_0 = constructor_output_xmm(ctx, expr3_0)?; - return Some(expr4_0); - } - &FloatCC::LessThan => { - // Rule at src/isa/x64/lower.isle line 1636. - let expr0_0 = constructor_put_in_xmm(ctx, pattern4_0)?; - let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern4_1)?; - let expr2_0 = FcmpImm::LessThan; - let expr3_0 = - constructor_x64_cmpp(ctx, pattern6_0, expr0_0, &expr1_0, &expr2_0)?; - let expr4_0 = constructor_output_xmm(ctx, expr3_0)?; - return Some(expr4_0); - } - &FloatCC::LessThanOrEqual => { - // Rule at src/isa/x64/lower.isle line 1638. - let expr0_0 = constructor_put_in_xmm(ctx, pattern4_0)?; - let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern4_1)?; - let expr2_0 = FcmpImm::LessThanOrEqual; - let expr3_0 = - constructor_x64_cmpp(ctx, pattern6_0, expr0_0, &expr1_0, &expr2_0)?; - let expr4_0 = constructor_output_xmm(ctx, expr3_0)?; - return Some(expr4_0); - } - &FloatCC::NotEqual => { - // Rule at src/isa/x64/lower.isle line 1634. - let expr0_0 = constructor_put_in_xmm(ctx, pattern4_0)?; - let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern4_1)?; - let expr2_0 = FcmpImm::NotEqual; - let expr3_0 = - constructor_x64_cmpp(ctx, pattern6_0, expr0_0, &expr1_0, &expr2_0)?; - let expr4_0 = constructor_output_xmm(ctx, expr3_0)?; - return Some(expr4_0); - } - &FloatCC::Ordered => { - // Rule at src/isa/x64/lower.isle line 1640. - let expr0_0 = constructor_put_in_xmm(ctx, pattern4_0)?; - let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern4_1)?; - let expr2_0 = FcmpImm::Ordered; - let expr3_0 = - constructor_x64_cmpp(ctx, pattern6_0, expr0_0, &expr1_0, &expr2_0)?; - let expr4_0 = constructor_output_xmm(ctx, expr3_0)?; - return Some(expr4_0); - } - &FloatCC::Unordered => { - // Rule at src/isa/x64/lower.isle line 1642. - let expr0_0 = constructor_put_in_xmm(ctx, pattern4_0)?; - let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern4_1)?; - let expr2_0 = FcmpImm::Unordered; - let expr3_0 = - constructor_x64_cmpp(ctx, pattern6_0, expr0_0, &expr1_0, &expr2_0)?; - let expr4_0 = constructor_output_xmm(ctx, expr3_0)?; - return Some(expr4_0); - } - &FloatCC::UnorderedOrGreaterThan => { - // Rule at src/isa/x64/lower.isle line 1644. - let expr0_0 = constructor_put_in_xmm(ctx, pattern4_0)?; - let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern4_1)?; - let expr2_0 = FcmpImm::UnorderedOrGreaterThan; - let expr3_0 = - constructor_x64_cmpp(ctx, pattern6_0, expr0_0, &expr1_0, &expr2_0)?; - let expr4_0 = constructor_output_xmm(ctx, expr3_0)?; - return Some(expr4_0); - } - &FloatCC::UnorderedOrGreaterThanOrEqual => { - // Rule at src/isa/x64/lower.isle line 1646. - let expr0_0 = constructor_put_in_xmm(ctx, pattern4_0)?; - let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern4_1)?; - let expr2_0 = FcmpImm::UnorderedOrGreaterThanOrEqual; - let expr3_0 = - constructor_x64_cmpp(ctx, pattern6_0, expr0_0, &expr1_0, &expr2_0)?; - let expr4_0 = constructor_output_xmm(ctx, expr3_0)?; - return Some(expr4_0); - } - &FloatCC::UnorderedOrLessThan => { - // Rule at src/isa/x64/lower.isle line 1656. - let expr0_0 = constructor_put_in_xmm(ctx, pattern4_1)?; - let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern4_0)?; - let expr2_0 = FcmpImm::UnorderedOrGreaterThan; - let expr3_0 = - constructor_x64_cmpp(ctx, pattern6_0, expr0_0, &expr1_0, &expr2_0)?; - let expr4_0 = constructor_output_xmm(ctx, expr3_0)?; - return Some(expr4_0); - } - &FloatCC::UnorderedOrLessThanOrEqual => { - // Rule at src/isa/x64/lower.isle line 1658. - let expr0_0 = constructor_put_in_xmm(ctx, pattern4_1)?; - let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern4_0)?; - let expr2_0 = FcmpImm::UnorderedOrGreaterThanOrEqual; - let expr3_0 = - constructor_x64_cmpp(ctx, pattern6_0, expr0_0, &expr1_0, &expr2_0)?; - let expr4_0 = constructor_output_xmm(ctx, expr3_0)?; - return Some(expr4_0); - } - _ => {} - } - } - } - } - &InstructionData::IntCompare { - opcode: ref pattern2_0, - args: ref pattern2_1, - cond: ref pattern2_2, - } => { - if let &Opcode::Icmp = pattern2_0 { - let (pattern4_0, pattern4_1) = C::unpack_value_array_2(ctx, pattern2_1); - let pattern5_0 = C::value_type(ctx, pattern4_0); - if pattern5_0 == I128 { - match pattern2_2 { - &IntCC::Equal => { - // Rule at src/isa/x64/lower.isle line 1526. - let expr0_0 = C::put_in_regs(ctx, pattern4_0); - let expr1_0: usize = 0; - let expr2_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr1_0)?; - let expr3_0 = C::put_in_regs(ctx, pattern4_0); - let expr4_0: usize = 1; - let expr5_0 = constructor_value_regs_get_gpr(ctx, expr3_0, expr4_0)?; - let expr6_0 = C::put_in_regs(ctx, pattern4_1); - let expr7_0: usize = 0; - let expr8_0 = constructor_value_regs_get_gpr(ctx, expr6_0, expr7_0)?; - let expr9_0 = C::put_in_regs(ctx, pattern4_1); - let expr10_0: usize = 1; - let expr11_0 = constructor_value_regs_get_gpr(ctx, expr9_0, expr10_0)?; - let expr12_0 = OperandSize::Size64; - let expr13_0 = C::gpr_to_gpr_mem_imm(ctx, expr8_0); - let expr14_0 = constructor_x64_cmp(ctx, &expr12_0, &expr13_0, expr2_0)?; - let expr15_0 = CC::Z; - let expr16_0 = constructor_x64_setcc(ctx, &expr15_0)?; - let expr17_0 = constructor_with_flags_reg(ctx, &expr14_0, &expr16_0)?; - let expr18_0 = OperandSize::Size64; - let expr19_0 = C::gpr_to_gpr_mem_imm(ctx, expr11_0); - let expr20_0 = constructor_x64_cmp(ctx, &expr18_0, &expr19_0, expr5_0)?; - let expr21_0 = CC::Z; - let expr22_0 = constructor_x64_setcc(ctx, &expr21_0)?; - let expr23_0 = constructor_with_flags_reg(ctx, &expr20_0, &expr22_0)?; - let expr24_0: Type = I64; - let expr25_0 = C::gpr_new(ctx, expr17_0); - let expr26_0 = constructor_reg_to_gpr_mem_imm(ctx, expr23_0)?; - let expr27_0 = constructor_x64_and(ctx, expr24_0, expr25_0, &expr26_0)?; - let expr28_0 = C::gpr_to_reg(ctx, expr27_0); - let expr29_0 = OperandSize::Size64; - let expr30_0: u32 = 1; - let expr31_0 = RegMemImm::Imm { simm32: expr30_0 }; - let expr32_0 = C::gpr_mem_imm_new(ctx, &expr31_0); - let expr33_0 = C::gpr_new(ctx, expr28_0); - let expr34_0 = - constructor_x64_test(ctx, &expr29_0, &expr32_0, expr33_0)?; - let expr35_0 = CC::NZ; - let expr36_0 = constructor_x64_setcc(ctx, &expr35_0)?; - let expr37_0 = constructor_with_flags(ctx, &expr34_0, &expr36_0)?; - let expr38_0 = C::output(ctx, expr37_0); - return Some(expr38_0); - } - &IntCC::NotEqual => { - // Rule at src/isa/x64/lower.isle line 1545. - let expr0_0 = C::put_in_regs(ctx, pattern4_0); - let expr1_0: usize = 0; - let expr2_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr1_0)?; - let expr3_0 = C::put_in_regs(ctx, pattern4_0); - let expr4_0: usize = 1; - let expr5_0 = constructor_value_regs_get_gpr(ctx, expr3_0, expr4_0)?; - let expr6_0 = C::put_in_regs(ctx, pattern4_1); - let expr7_0: usize = 0; - let expr8_0 = constructor_value_regs_get_gpr(ctx, expr6_0, expr7_0)?; - let expr9_0 = C::put_in_regs(ctx, pattern4_1); - let expr10_0: usize = 1; - let expr11_0 = constructor_value_regs_get_gpr(ctx, expr9_0, expr10_0)?; - let expr12_0 = OperandSize::Size64; - let expr13_0 = C::gpr_to_gpr_mem_imm(ctx, expr8_0); - let expr14_0 = constructor_x64_cmp(ctx, &expr12_0, &expr13_0, expr2_0)?; - let expr15_0 = CC::NZ; - let expr16_0 = constructor_x64_setcc(ctx, &expr15_0)?; - let expr17_0 = constructor_with_flags_reg(ctx, &expr14_0, &expr16_0)?; - let expr18_0 = OperandSize::Size64; - let expr19_0 = C::gpr_to_gpr_mem_imm(ctx, expr11_0); - let expr20_0 = constructor_x64_cmp(ctx, &expr18_0, &expr19_0, expr5_0)?; - let expr21_0 = CC::NZ; - let expr22_0 = constructor_x64_setcc(ctx, &expr21_0)?; - let expr23_0 = constructor_with_flags_reg(ctx, &expr20_0, &expr22_0)?; - let expr24_0: Type = I64; - let expr25_0 = C::gpr_new(ctx, expr17_0); - let expr26_0 = constructor_reg_to_gpr_mem_imm(ctx, expr23_0)?; - let expr27_0 = constructor_x64_or(ctx, expr24_0, expr25_0, &expr26_0)?; - let expr28_0 = C::gpr_to_reg(ctx, expr27_0); - let expr29_0 = OperandSize::Size64; - let expr30_0: u32 = 1; - let expr31_0 = RegMemImm::Imm { simm32: expr30_0 }; - let expr32_0 = C::gpr_mem_imm_new(ctx, &expr31_0); - let expr33_0 = C::gpr_new(ctx, expr28_0); - let expr34_0 = - constructor_x64_test(ctx, &expr29_0, &expr32_0, expr33_0)?; - let expr35_0 = CC::NZ; - let expr36_0 = constructor_x64_setcc(ctx, &expr35_0)?; - let expr37_0 = constructor_with_flags(ctx, &expr34_0, &expr36_0)?; - let expr38_0 = C::output(ctx, expr37_0); - return Some(expr38_0); - } - _ => {} - } - } - if pattern5_0 == I64X2 { - match pattern2_2 { - &IntCC::SignedGreaterThanOrEqual => { - // Rule at src/isa/x64/lower.isle line 1511. - let expr0_0: Type = I64X2; - let expr1_0 = constructor_put_in_xmm(ctx, pattern4_1)?; - let expr2_0 = constructor_put_in_xmm_mem(ctx, pattern4_0)?; - let expr3_0 = constructor_x64_pcmpgt(ctx, expr0_0, expr1_0, &expr2_0)?; - let expr4_0: Type = I64X2; - let expr5_0 = constructor_vector_all_ones(ctx, expr4_0)?; - let expr6_0 = C::xmm_to_xmm_mem(ctx, expr5_0); - let expr7_0 = constructor_x64_pxor(ctx, expr3_0, &expr6_0)?; - let expr8_0 = constructor_output_xmm(ctx, expr7_0)?; - return Some(expr8_0); - } - &IntCC::SignedLessThanOrEqual => { - // Rule at src/isa/x64/lower.isle line 1515. - let expr0_0: Type = I64X2; - let expr1_0 = constructor_put_in_xmm(ctx, pattern4_0)?; - let expr2_0 = constructor_put_in_xmm_mem(ctx, pattern4_1)?; - let expr3_0 = constructor_x64_pcmpgt(ctx, expr0_0, expr1_0, &expr2_0)?; - let expr4_0: Type = I64X2; - let expr5_0 = constructor_vector_all_ones(ctx, expr4_0)?; - let expr6_0 = C::xmm_to_xmm_mem(ctx, expr5_0); - let expr7_0 = constructor_x64_pxor(ctx, expr3_0, &expr6_0)?; - let expr8_0 = constructor_output_xmm(ctx, expr7_0)?; - return Some(expr8_0); - } - _ => {} - } - } - if let Some(pattern6_0) = C::fits_in_64(ctx, pattern5_0) { - // Rule at src/isa/x64/lower.isle line 1451. - let expr0_0 = C::raw_operand_size_of_type(ctx, pattern6_0); - let expr1_0 = constructor_put_in_gpr_mem_imm(ctx, pattern4_1)?; - let expr2_0 = constructor_put_in_gpr(ctx, pattern4_0)?; - let expr3_0 = constructor_x64_cmp(ctx, &expr0_0, &expr1_0, expr2_0)?; - let expr4_0 = C::intcc_to_cc(ctx, pattern2_2); - let expr5_0 = constructor_x64_setcc(ctx, &expr4_0)?; - let expr6_0 = constructor_with_flags(ctx, &expr3_0, &expr5_0)?; - let expr7_0 = C::output(ctx, expr6_0); - return Some(expr7_0); - } - if let Some(pattern6_0) = C::ty_vec128(ctx, pattern5_0) { - match pattern2_2 { - &IntCC::Equal => { - // Rule at src/isa/x64/lower.isle line 1460. - let expr0_0 = constructor_put_in_xmm(ctx, pattern4_0)?; - let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern4_1)?; - let expr2_0 = - constructor_x64_pcmpeq(ctx, pattern6_0, expr0_0, &expr1_0)?; - let expr3_0 = constructor_output_xmm(ctx, expr2_0)?; - return Some(expr3_0); - } - &IntCC::NotEqual => { - // Rule at src/isa/x64/lower.isle line 1464. - let expr0_0 = constructor_put_in_xmm(ctx, pattern4_0)?; - let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern4_1)?; - let expr2_0 = - constructor_x64_pcmpeq(ctx, pattern6_0, expr0_0, &expr1_0)?; - let expr3_0 = constructor_vector_all_ones(ctx, pattern6_0)?; - let expr4_0 = C::xmm_to_xmm_mem(ctx, expr3_0); - let expr5_0 = constructor_x64_pxor(ctx, expr2_0, &expr4_0)?; - let expr6_0 = constructor_output_xmm(ctx, expr5_0)?; - return Some(expr6_0); - } - &IntCC::SignedGreaterThan => { - // Rule at src/isa/x64/lower.isle line 1471. - let expr0_0 = constructor_put_in_xmm(ctx, pattern4_0)?; - let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern4_1)?; - let expr2_0 = - constructor_x64_pcmpgt(ctx, pattern6_0, expr0_0, &expr1_0)?; - let expr3_0 = constructor_output_xmm(ctx, expr2_0)?; - return Some(expr3_0); - } - &IntCC::SignedGreaterThanOrEqual => { - // Rule at src/isa/x64/lower.isle line 1496. - let expr0_0 = constructor_put_in_xmm(ctx, pattern4_0)?; - let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern4_1)?; - let expr2_0 = - constructor_x64_pmaxs(ctx, pattern6_0, expr0_0, &expr1_0)?; - let expr3_0 = constructor_put_in_xmm(ctx, pattern4_0)?; - let expr4_0 = C::xmm_to_xmm_mem(ctx, expr2_0); - let expr5_0 = - constructor_x64_pcmpeq(ctx, pattern6_0, expr3_0, &expr4_0)?; - let expr6_0 = constructor_output_xmm(ctx, expr5_0)?; - return Some(expr6_0); - } - &IntCC::SignedLessThan => { - // Rule at src/isa/x64/lower.isle line 1473. - let expr0_0 = constructor_put_in_xmm(ctx, pattern4_1)?; - let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern4_0)?; - let expr2_0 = - constructor_x64_pcmpgt(ctx, pattern6_0, expr0_0, &expr1_0)?; - let expr3_0 = constructor_output_xmm(ctx, expr2_0)?; - return Some(expr3_0); - } - &IntCC::SignedLessThanOrEqual => { - // Rule at src/isa/x64/lower.isle line 1499. - let expr0_0 = constructor_put_in_xmm(ctx, pattern4_0)?; - let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern4_1)?; - let expr2_0 = - constructor_x64_pmins(ctx, pattern6_0, expr0_0, &expr1_0)?; - let expr3_0 = constructor_put_in_xmm(ctx, pattern4_0)?; - let expr4_0 = C::xmm_to_xmm_mem(ctx, expr2_0); - let expr5_0 = - constructor_x64_pcmpeq(ctx, pattern6_0, expr3_0, &expr4_0)?; - let expr6_0 = constructor_output_xmm(ctx, expr5_0)?; - return Some(expr6_0); - } - &IntCC::UnsignedGreaterThan => { - // Rule at src/isa/x64/lower.isle line 1475. - let expr0_0 = constructor_put_in_xmm(ctx, pattern4_0)?; - let expr1_0 = constructor_put_in_xmm(ctx, pattern4_1)?; - let expr2_0 = C::xmm_to_xmm_mem(ctx, expr1_0); - let expr3_0 = - constructor_x64_pmaxu(ctx, pattern6_0, expr0_0, &expr2_0)?; - let expr4_0 = C::xmm_to_xmm_mem(ctx, expr1_0); - let expr5_0 = - constructor_x64_pcmpeq(ctx, pattern6_0, expr3_0, &expr4_0)?; - let expr6_0 = constructor_vector_all_ones(ctx, pattern6_0)?; - let expr7_0 = C::xmm_to_xmm_mem(ctx, expr6_0); - let expr8_0 = constructor_x64_pxor(ctx, expr5_0, &expr7_0)?; - let expr9_0 = constructor_output_xmm(ctx, expr8_0)?; - return Some(expr9_0); - } - &IntCC::UnsignedGreaterThanOrEqual => { - // Rule at src/isa/x64/lower.isle line 1502. - let expr0_0 = constructor_put_in_xmm(ctx, pattern4_0)?; - let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern4_1)?; - let expr2_0 = - constructor_x64_pmaxu(ctx, pattern6_0, expr0_0, &expr1_0)?; - let expr3_0 = constructor_put_in_xmm(ctx, pattern4_0)?; - let expr4_0 = C::xmm_to_xmm_mem(ctx, expr2_0); - let expr5_0 = - constructor_x64_pcmpeq(ctx, pattern6_0, expr3_0, &expr4_0)?; - let expr6_0 = constructor_output_xmm(ctx, expr5_0)?; - return Some(expr6_0); - } - &IntCC::UnsignedLessThan => { - // Rule at src/isa/x64/lower.isle line 1485. - let expr0_0 = constructor_put_in_xmm(ctx, pattern4_0)?; - let expr1_0 = constructor_put_in_xmm(ctx, pattern4_1)?; - let expr2_0 = C::xmm_to_xmm_mem(ctx, expr1_0); - let expr3_0 = - constructor_x64_pminu(ctx, pattern6_0, expr0_0, &expr2_0)?; - let expr4_0 = C::xmm_to_xmm_mem(ctx, expr1_0); - let expr5_0 = - constructor_x64_pcmpeq(ctx, pattern6_0, expr3_0, &expr4_0)?; - let expr6_0 = constructor_vector_all_ones(ctx, pattern6_0)?; - let expr7_0 = C::xmm_to_xmm_mem(ctx, expr6_0); - let expr8_0 = constructor_x64_pxor(ctx, expr5_0, &expr7_0)?; - let expr9_0 = constructor_output_xmm(ctx, expr8_0)?; - return Some(expr9_0); - } - &IntCC::UnsignedLessThanOrEqual => { - // Rule at src/isa/x64/lower.isle line 1505. - let expr0_0 = constructor_put_in_xmm(ctx, pattern4_0)?; - let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern4_1)?; - let expr2_0 = - constructor_x64_pminu(ctx, pattern6_0, expr0_0, &expr1_0)?; - let expr3_0 = constructor_put_in_xmm(ctx, pattern4_0)?; - let expr4_0 = C::xmm_to_xmm_mem(ctx, expr2_0); - let expr5_0 = - constructor_x64_pcmpeq(ctx, pattern6_0, expr3_0, &expr4_0)?; - let expr6_0 = constructor_output_xmm(ctx, expr5_0)?; - return Some(expr6_0); - } - _ => {} - } - } - } - } - &InstructionData::Unary { - opcode: ref pattern2_0, - arg: pattern2_1, - } => { - match pattern2_0 { - &Opcode::IsNull => { - let pattern4_0 = C::value_type(ctx, pattern2_1); - if pattern4_0 == R64 { - // Rule at src/isa/x64/lower.isle line 2097. - let expr0_0 = OperandSize::Size64; - let expr1_0: u32 = 0; - let expr2_0 = constructor_put_in_gpr(ctx, pattern2_1)?; - let expr3_0 = constructor_x64_cmp_imm(ctx, &expr0_0, expr1_0, expr2_0)?; - let expr4_0 = CC::Z; - let expr5_0 = constructor_x64_setcc(ctx, &expr4_0)?; - let expr6_0 = constructor_with_flags(ctx, &expr3_0, &expr5_0)?; - let expr7_0 = C::output(ctx, expr6_0); - return Some(expr7_0); - } - } - &Opcode::IsInvalid => { - let pattern4_0 = C::value_type(ctx, pattern2_1); - if pattern4_0 == R64 { - // Rule at src/isa/x64/lower.isle line 2105. - let expr0_0 = OperandSize::Size64; - let expr1_0: u32 = 4294967295; - let expr2_0 = constructor_put_in_gpr(ctx, pattern2_1)?; - let expr3_0 = constructor_x64_cmp_imm(ctx, &expr0_0, expr1_0, expr2_0)?; - let expr4_0 = CC::Z; - let expr5_0 = constructor_x64_setcc(ctx, &expr4_0)?; - let expr6_0 = constructor_with_flags(ctx, &expr3_0, &expr5_0)?; - let expr7_0 = C::output(ctx, expr6_0); - return Some(expr7_0); - } - } - _ => {} - } - } - _ => {} - } - if let Some(pattern1_0) = C::first_result(ctx, pattern0_0) { - let pattern2_0 = C::value_type(ctx, pattern1_0); - if pattern2_0 == B128 { - let pattern4_0 = C::inst_data(ctx, pattern0_0); - match &pattern4_0 { - &InstructionData::UnaryBool { - opcode: ref pattern5_0, - imm: pattern5_1, - } => { - if let &Opcode::Bconst = pattern5_0 { - if pattern5_1 == true { - // Rule at src/isa/x64/lower.isle line 39. - let expr0_0: Type = B64; - let expr1_0: u64 = 1; - let expr2_0 = constructor_imm(ctx, expr0_0, expr1_0)?; - let expr3_0: Type = B64; - let expr4_0: u64 = 0; - let expr5_0 = constructor_imm(ctx, expr3_0, expr4_0)?; - let expr6_0 = C::value_regs(ctx, expr2_0, expr5_0); - let expr7_0 = C::output(ctx, expr6_0); - return Some(expr7_0); - } - if pattern5_1 == false { - // Rule at src/isa/x64/lower.isle line 34. - let expr0_0: Type = B64; - let expr1_0: u64 = 0; - let expr2_0 = constructor_imm(ctx, expr0_0, expr1_0)?; - let expr3_0: Type = B64; - let expr4_0: u64 = 0; - let expr5_0 = constructor_imm(ctx, expr3_0, expr4_0)?; - let expr6_0 = C::value_regs(ctx, expr2_0, expr5_0); - let expr7_0 = C::output(ctx, expr6_0); - return Some(expr7_0); - } - } - } - &InstructionData::Binary { - opcode: ref pattern5_0, - args: ref pattern5_1, - } => { - match pattern5_0 { - &Opcode::Band => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/x64/lower.isle line 344. - let expr0_0 = C::put_in_regs(ctx, pattern7_0); - let expr1_0: usize = 0; - let expr2_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr1_0)?; - let expr3_0: usize = 1; - let expr4_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr3_0)?; - let expr5_0 = constructor_lo_gpr(ctx, pattern7_1)?; - let expr6_0: Type = I64; - let expr7_0 = C::gpr_to_gpr_mem_imm(ctx, expr5_0); - let expr8_0 = constructor_x64_and(ctx, expr6_0, expr2_0, &expr7_0)?; - let expr9_0 = constructor_value_gprs(ctx, expr8_0, expr4_0)?; - let expr10_0 = C::output(ctx, expr9_0); - return Some(expr10_0); - } - &Opcode::Bor => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/x64/lower.isle line 410. - let expr0_0 = C::put_in_regs(ctx, pattern7_0); - let expr1_0: usize = 0; - let expr2_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr1_0)?; - let expr3_0: usize = 1; - let expr4_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr3_0)?; - let expr5_0 = constructor_lo_gpr(ctx, pattern7_1)?; - let expr6_0: Type = I64; - let expr7_0 = C::gpr_to_gpr_mem_imm(ctx, expr5_0); - let expr8_0 = constructor_x64_or(ctx, expr6_0, expr2_0, &expr7_0)?; - let expr9_0 = constructor_value_gprs(ctx, expr8_0, expr4_0)?; - let expr10_0 = C::output(ctx, expr9_0); - return Some(expr10_0); - } - &Opcode::Bxor => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/x64/lower.isle line 468. - let expr0_0 = C::put_in_regs(ctx, pattern7_0); - let expr1_0: usize = 0; - let expr2_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr1_0)?; - let expr3_0: usize = 1; - let expr4_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr3_0)?; - let expr5_0 = constructor_lo_gpr(ctx, pattern7_1)?; - let expr6_0: Type = I64; - let expr7_0 = C::gpr_to_gpr_mem_imm(ctx, expr5_0); - let expr8_0 = constructor_x64_xor(ctx, expr6_0, expr2_0, &expr7_0)?; - let expr9_0 = constructor_value_gprs(ctx, expr8_0, expr4_0)?; - let expr10_0 = C::output(ctx, expr9_0); - return Some(expr10_0); - } - _ => {} - } - } - &InstructionData::Unary { - opcode: ref pattern5_0, - arg: pattern5_1, - } => { - if let &Opcode::Bnot = pattern5_0 { - // Rule at src/isa/x64/lower.isle line 1269. - let expr0_0 = constructor_i128_not(ctx, pattern5_1)?; - let expr1_0 = C::output(ctx, expr0_0); - return Some(expr1_0); - } - } - _ => {} - } - } - if pattern2_0 == I8 { - let pattern4_0 = C::inst_data(ctx, pattern0_0); - if let &InstructionData::Unary { - opcode: ref pattern5_0, - arg: pattern5_1, - } = &pattern4_0 - { - if let &Opcode::Bitrev = pattern5_0 { - // Rule at src/isa/x64/lower.isle line 2019. - let expr0_0: Type = I32; - let expr1_0 = constructor_put_in_gpr(ctx, pattern5_1)?; - let expr2_0 = constructor_do_bitrev8(ctx, expr0_0, expr1_0)?; - let expr3_0 = constructor_output_gpr(ctx, expr2_0)?; - return Some(expr3_0); - } - } - } - if pattern2_0 == I16 { - let pattern4_0 = C::inst_data(ctx, pattern0_0); - if let &InstructionData::Unary { - opcode: ref pattern5_0, - arg: pattern5_1, - } = &pattern4_0 - { - if let &Opcode::Bitrev = pattern5_0 { - // Rule at src/isa/x64/lower.isle line 2022. - let expr0_0: Type = I32; - let expr1_0 = constructor_put_in_gpr(ctx, pattern5_1)?; - let expr2_0 = constructor_do_bitrev16(ctx, expr0_0, expr1_0)?; - let expr3_0 = constructor_output_gpr(ctx, expr2_0)?; - return Some(expr3_0); - } - } - } - if pattern2_0 == I32 { - let pattern4_0 = C::inst_data(ctx, pattern0_0); - if let &InstructionData::Unary { - opcode: ref pattern5_0, - arg: pattern5_1, - } = &pattern4_0 - { - if let &Opcode::Bitrev = pattern5_0 { - // Rule at src/isa/x64/lower.isle line 2025. - let expr0_0: Type = I32; - let expr1_0 = constructor_put_in_gpr(ctx, pattern5_1)?; - let expr2_0 = constructor_do_bitrev32(ctx, expr0_0, expr1_0)?; - let expr3_0 = constructor_output_gpr(ctx, expr2_0)?; - return Some(expr3_0); - } - } - } - if pattern2_0 == I64 { - let pattern4_0 = C::inst_data(ctx, pattern0_0); - if let &InstructionData::Unary { - opcode: ref pattern5_0, - arg: pattern5_1, - } = &pattern4_0 - { - match pattern5_0 { - &Opcode::Bitrev => { - // Rule at src/isa/x64/lower.isle line 2028. - let expr0_0: Type = I64; - let expr1_0 = constructor_put_in_gpr(ctx, pattern5_1)?; - let expr2_0 = constructor_do_bitrev64(ctx, expr0_0, expr1_0)?; - let expr3_0 = constructor_output_gpr(ctx, expr2_0)?; - return Some(expr3_0); - } - &Opcode::Uextend => { - if let Some(pattern7_0) = C::def_inst(ctx, pattern5_1) { - if let Some(pattern8_0) = C::first_result(ctx, pattern7_0) { - let pattern9_0 = C::value_type(ctx, pattern8_0); - if pattern9_0 == I32 { - let pattern11_0 = C::inst_data(ctx, pattern7_0); - match &pattern11_0 { - &InstructionData::Binary { - opcode: ref pattern12_0, - args: ref pattern12_1, - } => { - match pattern12_0 { - &Opcode::Iadd => { - let (pattern14_0, pattern14_1) = - C::unpack_value_array_2(ctx, pattern12_1); - // Rule at src/isa/x64/lower.isle line 2144. - let expr0_0 = - constructor_output_value(ctx, pattern5_1)?; - return Some(expr0_0); - } - &Opcode::Isub => { - let (pattern14_0, pattern14_1) = - C::unpack_value_array_2(ctx, pattern12_1); - // Rule at src/isa/x64/lower.isle line 2150. - let expr0_0 = - constructor_output_value(ctx, pattern5_1)?; - return Some(expr0_0); - } - &Opcode::Imul => { - let (pattern14_0, pattern14_1) = - C::unpack_value_array_2(ctx, pattern12_1); - // Rule at src/isa/x64/lower.isle line 2153. - let expr0_0 = - constructor_output_value(ctx, pattern5_1)?; - return Some(expr0_0); - } - &Opcode::IaddIfcout => { - let (pattern14_0, pattern14_1) = - C::unpack_value_array_2(ctx, pattern12_1); - // Rule at src/isa/x64/lower.isle line 2147. - let expr0_0 = - constructor_output_value(ctx, pattern5_1)?; - return Some(expr0_0); - } - &Opcode::Band => { - let (pattern14_0, pattern14_1) = - C::unpack_value_array_2(ctx, pattern12_1); - // Rule at src/isa/x64/lower.isle line 2156. - let expr0_0 = - constructor_output_value(ctx, pattern5_1)?; - return Some(expr0_0); - } - &Opcode::Bor => { - let (pattern14_0, pattern14_1) = - C::unpack_value_array_2(ctx, pattern12_1); - // Rule at src/isa/x64/lower.isle line 2159. - let expr0_0 = - constructor_output_value(ctx, pattern5_1)?; - return Some(expr0_0); - } - &Opcode::Bxor => { - let (pattern14_0, pattern14_1) = - C::unpack_value_array_2(ctx, pattern12_1); - // Rule at src/isa/x64/lower.isle line 2162. - let expr0_0 = - constructor_output_value(ctx, pattern5_1)?; - return Some(expr0_0); - } - &Opcode::Ishl => { - let (pattern14_0, pattern14_1) = - C::unpack_value_array_2(ctx, pattern12_1); - // Rule at src/isa/x64/lower.isle line 2165. - let expr0_0 = - constructor_output_value(ctx, pattern5_1)?; - return Some(expr0_0); - } - &Opcode::Ushr => { - let (pattern14_0, pattern14_1) = - C::unpack_value_array_2(ctx, pattern12_1); - // Rule at src/isa/x64/lower.isle line 2168. - let expr0_0 = - constructor_output_value(ctx, pattern5_1)?; - return Some(expr0_0); - } - _ => {} - } - } - &InstructionData::Load { - opcode: ref pattern12_0, - arg: pattern12_1, - flags: pattern12_2, - offset: pattern12_3, - } => { - if let &Opcode::Uload32 = pattern12_0 { - // Rule at src/isa/x64/lower.isle line 2171. - let expr0_0 = - constructor_output_value(ctx, pattern5_1)?; - return Some(expr0_0); - } - } - _ => {} - } - } - } - } - let pattern7_0 = C::value_type(ctx, pattern5_1); - if let Some(pattern8_0) = C::fits_in_32(ctx, pattern7_0) { - // Rule at src/isa/x64/lower.isle line 2126. - let expr0_0: Type = I64; - let expr1_0 = ExtendKind::Zero; - let expr2_0 = - constructor_extend_to_gpr(ctx, pattern5_1, expr0_0, &expr1_0)?; - let expr3_0 = constructor_output_gpr(ctx, expr2_0)?; - return Some(expr3_0); - } - } - _ => {} - } - } - } - if pattern2_0 == I128 { - let pattern4_0 = C::inst_data(ctx, pattern0_0); - match &pattern4_0 { - &InstructionData::UnaryImm { - opcode: ref pattern5_0, - imm: pattern5_1, - } => { - if let &Opcode::Iconst = pattern5_0 { - let pattern7_0 = C::u64_from_imm64(ctx, pattern5_1); - // Rule at src/isa/x64/lower.isle line 15. - let expr0_0: Type = I64; - let expr1_0 = constructor_imm(ctx, expr0_0, pattern7_0)?; - let expr2_0: Type = I64; - let expr3_0: u64 = 0; - let expr4_0 = constructor_imm(ctx, expr2_0, expr3_0)?; - let expr5_0 = C::value_regs(ctx, expr1_0, expr4_0); - let expr6_0 = C::output(ctx, expr5_0); - return Some(expr6_0); - } - } - &InstructionData::Binary { - opcode: ref pattern5_0, - args: ref pattern5_1, - } => { - match pattern5_0 { - &Opcode::Iadd => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/x64/lower.isle line 111. - let expr0_0 = C::put_in_regs(ctx, pattern7_0); - let expr1_0: usize = 0; - let expr2_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr1_0)?; - let expr3_0: usize = 1; - let expr4_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr3_0)?; - let expr5_0 = C::put_in_regs(ctx, pattern7_1); - let expr6_0: usize = 0; - let expr7_0 = constructor_value_regs_get_gpr(ctx, expr5_0, expr6_0)?; - let expr8_0: usize = 1; - let expr9_0 = constructor_value_regs_get_gpr(ctx, expr5_0, expr8_0)?; - let expr10_0: Type = I64; - let expr11_0 = C::gpr_to_gpr_mem_imm(ctx, expr7_0); - let expr12_0 = constructor_x64_add_with_flags_paired( - ctx, expr10_0, expr2_0, &expr11_0, - )?; - let expr13_0: Type = I64; - let expr14_0 = C::gpr_to_gpr_mem_imm(ctx, expr9_0); - let expr15_0 = - constructor_x64_adc_paired(ctx, expr13_0, expr4_0, &expr14_0)?; - let expr16_0 = constructor_with_flags(ctx, &expr12_0, &expr15_0)?; - let expr17_0 = C::output(ctx, expr16_0); - return Some(expr17_0); - } - &Opcode::Isub => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/x64/lower.isle line 257. - let expr0_0 = C::put_in_regs(ctx, pattern7_0); - let expr1_0: usize = 0; - let expr2_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr1_0)?; - let expr3_0: usize = 1; - let expr4_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr3_0)?; - let expr5_0 = C::put_in_regs(ctx, pattern7_1); - let expr6_0: usize = 0; - let expr7_0 = constructor_value_regs_get_gpr(ctx, expr5_0, expr6_0)?; - let expr8_0: usize = 1; - let expr9_0 = constructor_value_regs_get_gpr(ctx, expr5_0, expr8_0)?; - let expr10_0: Type = I64; - let expr11_0 = C::gpr_to_gpr_mem_imm(ctx, expr7_0); - let expr12_0 = constructor_x64_sub_with_flags_paired( - ctx, expr10_0, expr2_0, &expr11_0, - )?; - let expr13_0: Type = I64; - let expr14_0 = C::gpr_to_gpr_mem_imm(ctx, expr9_0); - let expr15_0 = - constructor_x64_sbb_paired(ctx, expr13_0, expr4_0, &expr14_0)?; - let expr16_0 = constructor_with_flags(ctx, &expr12_0, &expr15_0)?; - let expr17_0 = C::output(ctx, expr16_0); - return Some(expr17_0); - } - &Opcode::Imul => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/x64/lower.isle line 957. - let expr0_0 = C::put_in_regs(ctx, pattern7_0); - let expr1_0: usize = 0; - let expr2_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr1_0)?; - let expr3_0: usize = 1; - let expr4_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr3_0)?; - let expr5_0 = C::put_in_regs(ctx, pattern7_1); - let expr6_0: usize = 0; - let expr7_0 = constructor_value_regs_get_gpr(ctx, expr5_0, expr6_0)?; - let expr8_0: usize = 1; - let expr9_0 = constructor_value_regs_get_gpr(ctx, expr5_0, expr8_0)?; - let expr10_0: Type = I64; - let expr11_0 = C::gpr_to_gpr_mem_imm(ctx, expr9_0); - let expr12_0 = constructor_x64_mul(ctx, expr10_0, expr2_0, &expr11_0)?; - let expr13_0: Type = I64; - let expr14_0 = C::gpr_to_gpr_mem_imm(ctx, expr7_0); - let expr15_0 = constructor_x64_mul(ctx, expr13_0, expr4_0, &expr14_0)?; - let expr16_0: Type = I64; - let expr17_0 = C::gpr_to_gpr_mem_imm(ctx, expr15_0); - let expr18_0 = constructor_x64_add(ctx, expr16_0, expr12_0, &expr17_0)?; - let expr19_0: Type = I64; - let expr20_0 = C::gpr_to_gpr_mem(ctx, expr7_0); - let expr21_0 = constructor_mulhi_u(ctx, expr19_0, expr2_0, &expr20_0)?; - let expr22_0: usize = 0; - let expr23_0 = constructor_value_regs_get_gpr(ctx, expr21_0, expr22_0)?; - let expr24_0: usize = 1; - let expr25_0 = constructor_value_regs_get_gpr(ctx, expr21_0, expr24_0)?; - let expr26_0: Type = I64; - let expr27_0 = C::gpr_to_gpr_mem_imm(ctx, expr25_0); - let expr28_0 = constructor_x64_add(ctx, expr26_0, expr18_0, &expr27_0)?; - let expr29_0 = constructor_value_gprs(ctx, expr23_0, expr28_0)?; - let expr30_0 = C::output(ctx, expr29_0); - return Some(expr30_0); - } - &Opcode::Band => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/x64/lower.isle line 334. - let expr0_0 = C::put_in_regs(ctx, pattern7_0); - let expr1_0: usize = 0; - let expr2_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr1_0)?; - let expr3_0: usize = 1; - let expr4_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr3_0)?; - let expr5_0 = C::put_in_regs(ctx, pattern7_1); - let expr6_0: usize = 0; - let expr7_0 = constructor_value_regs_get_gpr(ctx, expr5_0, expr6_0)?; - let expr8_0: usize = 1; - let expr9_0 = constructor_value_regs_get_gpr(ctx, expr5_0, expr8_0)?; - let expr10_0: Type = I64; - let expr11_0 = C::gpr_to_gpr_mem_imm(ctx, expr7_0); - let expr12_0 = constructor_x64_and(ctx, expr10_0, expr2_0, &expr11_0)?; - let expr13_0: Type = I64; - let expr14_0 = C::gpr_to_gpr_mem_imm(ctx, expr9_0); - let expr15_0 = constructor_x64_and(ctx, expr13_0, expr4_0, &expr14_0)?; - let expr16_0 = constructor_value_gprs(ctx, expr12_0, expr15_0)?; - let expr17_0 = C::output(ctx, expr16_0); - return Some(expr17_0); - } - &Opcode::Bor => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/x64/lower.isle line 407. - let expr0_0 = C::put_in_regs(ctx, pattern7_0); - let expr1_0 = C::put_in_regs(ctx, pattern7_1); - let expr2_0 = constructor_or_i128(ctx, expr0_0, expr1_0)?; - let expr3_0 = C::output(ctx, expr2_0); - return Some(expr3_0); - } - &Opcode::Bxor => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/x64/lower.isle line 458. - let expr0_0 = C::put_in_regs(ctx, pattern7_0); - let expr1_0: usize = 0; - let expr2_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr1_0)?; - let expr3_0: usize = 1; - let expr4_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr3_0)?; - let expr5_0 = C::put_in_regs(ctx, pattern7_1); - let expr6_0: usize = 0; - let expr7_0 = constructor_value_regs_get_gpr(ctx, expr5_0, expr6_0)?; - let expr8_0: usize = 1; - let expr9_0 = constructor_value_regs_get_gpr(ctx, expr5_0, expr8_0)?; - let expr10_0: Type = I64; - let expr11_0 = C::gpr_to_gpr_mem_imm(ctx, expr7_0); - let expr12_0 = constructor_x64_xor(ctx, expr10_0, expr2_0, &expr11_0)?; - let expr13_0: Type = I64; - let expr14_0 = C::gpr_to_gpr_mem_imm(ctx, expr9_0); - let expr15_0 = constructor_x64_xor(ctx, expr13_0, expr4_0, &expr14_0)?; - let expr16_0 = constructor_value_gprs(ctx, expr12_0, expr15_0)?; - let expr17_0 = C::output(ctx, expr16_0); - return Some(expr17_0); - } - &Opcode::Rotl => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/x64/lower.isle line 830. - let expr0_0 = C::put_in_regs(ctx, pattern7_0); - let expr1_0 = constructor_lo_gpr(ctx, pattern7_1)?; - let expr2_0 = constructor_shl_i128(ctx, expr0_0, expr1_0)?; - let expr3_0: Type = I64; - let expr4_0: Type = I64; - let expr5_0: u64 = 128; - let expr6_0 = constructor_imm(ctx, expr4_0, expr5_0)?; - let expr7_0 = C::gpr_new(ctx, expr6_0); - let expr8_0 = C::gpr_to_gpr_mem_imm(ctx, expr1_0); - let expr9_0 = constructor_x64_sub(ctx, expr3_0, expr7_0, &expr8_0)?; - let expr10_0 = constructor_shr_i128(ctx, expr0_0, expr9_0)?; - let expr11_0 = constructor_or_i128(ctx, expr2_0, expr10_0)?; - let expr12_0 = C::output(ctx, expr11_0); - return Some(expr12_0); - } - &Opcode::Rotr => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/x64/lower.isle line 870. - let expr0_0 = C::put_in_regs(ctx, pattern7_0); - let expr1_0 = constructor_lo_gpr(ctx, pattern7_1)?; - let expr2_0 = constructor_shr_i128(ctx, expr0_0, expr1_0)?; - let expr3_0: Type = I64; - let expr4_0: Type = I64; - let expr5_0: u64 = 128; - let expr6_0 = constructor_imm(ctx, expr4_0, expr5_0)?; - let expr7_0 = C::gpr_new(ctx, expr6_0); - let expr8_0 = C::gpr_to_gpr_mem_imm(ctx, expr1_0); - let expr9_0 = constructor_x64_sub(ctx, expr3_0, expr7_0, &expr8_0)?; - let expr10_0 = constructor_shl_i128(ctx, expr0_0, expr9_0)?; - let expr11_0 = constructor_or_i128(ctx, expr2_0, expr10_0)?; - let expr12_0 = C::output(ctx, expr11_0); - return Some(expr12_0); - } - &Opcode::Ishl => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/x64/lower.isle line 522. - let expr0_0 = constructor_lo_gpr(ctx, pattern7_1)?; - let expr1_0 = C::put_in_regs(ctx, pattern7_0); - let expr2_0 = constructor_shl_i128(ctx, expr1_0, expr0_0)?; - let expr3_0 = C::output(ctx, expr2_0); - return Some(expr3_0); - } - &Opcode::Ushr => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/x64/lower.isle line 623. - let expr0_0 = constructor_lo_gpr(ctx, pattern7_1)?; - let expr1_0 = C::put_in_regs(ctx, pattern7_0); - let expr2_0 = constructor_shr_i128(ctx, expr1_0, expr0_0)?; - let expr3_0 = C::output(ctx, expr2_0); - return Some(expr3_0); - } - &Opcode::Sshr => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/x64/lower.isle line 728. - let expr0_0 = constructor_lo_gpr(ctx, pattern7_1)?; - let expr1_0 = C::put_in_regs(ctx, pattern7_0); - let expr2_0 = constructor_sar_i128(ctx, expr1_0, expr0_0)?; - let expr3_0 = C::output(ctx, expr2_0); - return Some(expr3_0); - } - _ => {} - } - } - &InstructionData::Unary { - opcode: ref pattern5_0, - arg: pattern5_1, - } => { - match pattern5_0 { - &Opcode::Bnot => { - // Rule at src/isa/x64/lower.isle line 1266. - let expr0_0 = constructor_i128_not(ctx, pattern5_1)?; - let expr1_0 = C::output(ctx, expr0_0); - return Some(expr1_0); - } - &Opcode::Bitrev => { - // Rule at src/isa/x64/lower.isle line 2031. - let expr0_0: Type = I64; - let expr1_0 = C::put_in_regs(ctx, pattern5_1); - let expr2_0: usize = 1; - let expr3_0 = constructor_value_regs_get_gpr(ctx, expr1_0, expr2_0)?; - let expr4_0 = constructor_do_bitrev64(ctx, expr0_0, expr3_0)?; - let expr5_0 = C::gpr_to_reg(ctx, expr4_0); - let expr6_0: Type = I64; - let expr7_0 = C::put_in_regs(ctx, pattern5_1); - let expr8_0: usize = 0; - let expr9_0 = constructor_value_regs_get_gpr(ctx, expr7_0, expr8_0)?; - let expr10_0 = constructor_do_bitrev64(ctx, expr6_0, expr9_0)?; - let expr11_0 = C::gpr_to_reg(ctx, expr10_0); - let expr12_0 = C::value_regs(ctx, expr5_0, expr11_0); - let expr13_0 = C::output(ctx, expr12_0); - return Some(expr13_0); - } - &Opcode::Clz => { - // Rule at src/isa/x64/lower.isle line 1801. - let expr0_0: Type = I64; - let expr1_0: Type = I64; - let expr2_0 = C::put_in_regs(ctx, pattern5_1); - let expr3_0: usize = 1; - let expr4_0 = constructor_value_regs_get_gpr(ctx, expr2_0, expr3_0)?; - let expr5_0 = constructor_do_clz(ctx, expr0_0, expr1_0, expr4_0)?; - let expr6_0: Type = I64; - let expr7_0: Type = I64; - let expr8_0: Type = I64; - let expr9_0 = C::put_in_regs(ctx, pattern5_1); - let expr10_0: usize = 0; - let expr11_0 = constructor_value_regs_get_gpr(ctx, expr9_0, expr10_0)?; - let expr12_0 = constructor_do_clz(ctx, expr7_0, expr8_0, expr11_0)?; - let expr13_0: u32 = 64; - let expr14_0 = RegMemImm::Imm { simm32: expr13_0 }; - let expr15_0 = C::gpr_mem_imm_new(ctx, &expr14_0); - let expr16_0 = constructor_x64_add(ctx, expr6_0, expr12_0, &expr15_0)?; - let expr17_0 = OperandSize::Size64; - let expr18_0: u32 = 64; - let expr19_0 = - constructor_x64_cmp_imm(ctx, &expr17_0, expr18_0, expr5_0)?; - let expr20_0: Type = I64; - let expr21_0 = CC::NZ; - let expr22_0 = C::gpr_to_gpr_mem(ctx, expr5_0); - let expr23_0 = - constructor_cmove(ctx, expr20_0, &expr21_0, &expr22_0, expr16_0)?; - let expr24_0 = constructor_with_flags_reg(ctx, &expr19_0, &expr23_0)?; - let expr25_0 = C::gpr_new(ctx, expr24_0); - let expr26_0 = C::gpr_to_reg(ctx, expr25_0); - let expr27_0: Type = I64; - let expr28_0: u64 = 0; - let expr29_0 = constructor_imm(ctx, expr27_0, expr28_0)?; - let expr30_0 = C::value_regs(ctx, expr26_0, expr29_0); - let expr31_0 = C::output(ctx, expr30_0); - return Some(expr31_0); - } - &Opcode::Ctz => { - // Rule at src/isa/x64/lower.isle line 1843. - let expr0_0: Type = I64; - let expr1_0: Type = I64; - let expr2_0 = C::put_in_regs(ctx, pattern5_1); - let expr3_0: usize = 0; - let expr4_0 = constructor_value_regs_get_gpr(ctx, expr2_0, expr3_0)?; - let expr5_0 = constructor_do_ctz(ctx, expr0_0, expr1_0, expr4_0)?; - let expr6_0: Type = I64; - let expr7_0: Type = I64; - let expr8_0: Type = I64; - let expr9_0 = C::put_in_regs(ctx, pattern5_1); - let expr10_0: usize = 1; - let expr11_0 = constructor_value_regs_get_gpr(ctx, expr9_0, expr10_0)?; - let expr12_0 = constructor_do_ctz(ctx, expr7_0, expr8_0, expr11_0)?; - let expr13_0: u32 = 64; - let expr14_0 = RegMemImm::Imm { simm32: expr13_0 }; - let expr15_0 = C::gpr_mem_imm_new(ctx, &expr14_0); - let expr16_0 = constructor_x64_add(ctx, expr6_0, expr12_0, &expr15_0)?; - let expr17_0 = OperandSize::Size64; - let expr18_0: u32 = 64; - let expr19_0 = - constructor_x64_cmp_imm(ctx, &expr17_0, expr18_0, expr5_0)?; - let expr20_0: Type = I64; - let expr21_0 = CC::Z; - let expr22_0 = C::gpr_to_gpr_mem(ctx, expr16_0); - let expr23_0 = - constructor_cmove(ctx, expr20_0, &expr21_0, &expr22_0, expr5_0)?; - let expr24_0 = constructor_with_flags_reg(ctx, &expr19_0, &expr23_0)?; - let expr25_0 = C::gpr_new(ctx, expr24_0); - let expr26_0 = C::gpr_to_reg(ctx, expr25_0); - let expr27_0: Type = I64; - let expr28_0: u64 = 0; - let expr29_0 = constructor_imm(ctx, expr27_0, expr28_0)?; - let expr30_0 = C::value_regs(ctx, expr26_0, expr29_0); - let expr31_0 = C::output(ctx, expr30_0); - return Some(expr31_0); - } - &Opcode::Popcnt => { - // Rule at src/isa/x64/lower.isle line 1895. - let expr0_0: Type = I64; - let expr1_0 = C::put_in_regs(ctx, pattern5_1); - let expr2_0: usize = 0; - let expr3_0 = constructor_value_regs_get_gpr(ctx, expr1_0, expr2_0)?; - let expr4_0 = constructor_do_popcnt(ctx, expr0_0, expr3_0)?; - let expr5_0: Type = I64; - let expr6_0 = C::put_in_regs(ctx, pattern5_1); - let expr7_0: usize = 1; - let expr8_0 = constructor_value_regs_get_gpr(ctx, expr6_0, expr7_0)?; - let expr9_0 = constructor_do_popcnt(ctx, expr5_0, expr8_0)?; - let expr10_0: Type = I64; - let expr11_0 = C::gpr_to_gpr_mem_imm(ctx, expr9_0); - let expr12_0 = constructor_x64_add(ctx, expr10_0, expr4_0, &expr11_0)?; - let expr13_0 = C::gpr_to_reg(ctx, expr12_0); - let expr14_0: Type = I64; - let expr15_0: u64 = 0; - let expr16_0 = constructor_imm(ctx, expr14_0, expr15_0)?; - let expr17_0 = C::value_regs(ctx, expr13_0, expr16_0); - let expr18_0 = C::output(ctx, expr17_0); - return Some(expr18_0); - } - &Opcode::Bint => { - // Rule at src/isa/x64/lower.isle line 2246. - let expr0_0: Type = I64; - let expr1_0 = constructor_put_in_gpr(ctx, pattern5_1)?; - let expr2_0: u32 = 1; - let expr3_0 = RegMemImm::Imm { simm32: expr2_0 }; - let expr4_0 = C::gpr_mem_imm_new(ctx, &expr3_0); - let expr5_0 = constructor_x64_and(ctx, expr0_0, expr1_0, &expr4_0)?; - let expr6_0 = C::gpr_to_reg(ctx, expr5_0); - let expr7_0: Type = I64; - let expr8_0: u64 = 0; - let expr9_0 = constructor_imm(ctx, expr7_0, expr8_0)?; - let expr10_0 = C::value_regs(ctx, expr6_0, expr9_0); - let expr11_0 = C::output(ctx, expr10_0); - return Some(expr11_0); - } - &Opcode::Uextend => { - let pattern7_0 = C::value_type(ctx, pattern5_1); - if pattern7_0 == I64 { - // Rule at src/isa/x64/lower.isle line 2118. - let expr0_0 = C::put_in_reg(ctx, pattern5_1); - let expr1_0: Type = I64; - let expr2_0: u64 = 0; - let expr3_0 = constructor_imm(ctx, expr1_0, expr2_0)?; - let expr4_0 = C::value_regs(ctx, expr0_0, expr3_0); - let expr5_0 = C::output(ctx, expr4_0); - return Some(expr5_0); - } - if let Some(pattern8_0) = C::fits_in_32(ctx, pattern7_0) { - // Rule at src/isa/x64/lower.isle line 2122. - let expr0_0: Type = I64; - let expr1_0 = ExtendKind::Zero; - let expr2_0 = - constructor_extend_to_gpr(ctx, pattern5_1, expr0_0, &expr1_0)?; - let expr3_0 = C::gpr_to_reg(ctx, expr2_0); - let expr4_0: Type = I64; - let expr5_0: u64 = 0; - let expr6_0 = constructor_imm(ctx, expr4_0, expr5_0)?; - let expr7_0 = C::value_regs(ctx, expr3_0, expr6_0); - let expr8_0 = C::output(ctx, expr7_0); - return Some(expr8_0); - } - } - _ => {} - } - } - &InstructionData::BinaryImm64 { - opcode: ref pattern5_0, - arg: pattern5_1, - imm: pattern5_2, - } => { - if let &Opcode::IaddImm = pattern5_0 { - let pattern7_0 = C::u64_from_imm64(ctx, pattern5_2); - // Rule at src/isa/x64/lower.isle line 210. - let expr0_0 = C::put_in_regs(ctx, pattern5_1); - let expr1_0: usize = 0; - let expr2_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr1_0)?; - let expr3_0: usize = 1; - let expr4_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr3_0)?; - let expr5_0: Type = I64; - let expr6_0 = constructor_imm(ctx, expr5_0, pattern7_0)?; - let expr7_0 = C::gpr_new(ctx, expr6_0); - let expr8_0: Type = I64; - let expr9_0 = C::gpr_to_gpr_mem_imm(ctx, expr7_0); - let expr10_0 = - constructor_x64_add_with_flags_paired(ctx, expr8_0, expr2_0, &expr9_0)?; - let expr11_0: Type = I64; - let expr12_0: u32 = 0; - let expr13_0 = RegMemImm::Imm { simm32: expr12_0 }; - let expr14_0 = C::gpr_mem_imm_new(ctx, &expr13_0); - let expr15_0 = - constructor_x64_adc_paired(ctx, expr11_0, expr4_0, &expr14_0)?; - let expr16_0 = constructor_with_flags(ctx, &expr10_0, &expr15_0)?; - let expr17_0 = C::output(ctx, expr16_0); - return Some(expr17_0); - } - } - _ => {} - } - } - if pattern2_0 == F32 { - let pattern4_0 = C::inst_data(ctx, pattern0_0); - match &pattern4_0 { - &InstructionData::Binary { - opcode: ref pattern5_0, - args: ref pattern5_1, - } => { - match pattern5_0 { - &Opcode::Fadd => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/x64/lower.isle line 2269. - let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?; - let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?; - let expr2_0 = constructor_x64_addss(ctx, expr0_0, &expr1_0)?; - let expr3_0 = constructor_output_xmm(ctx, expr2_0)?; - return Some(expr3_0); - } - &Opcode::Fsub => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/x64/lower.isle line 2280. - let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?; - let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?; - let expr2_0 = constructor_x64_subss(ctx, expr0_0, &expr1_0)?; - let expr3_0 = constructor_output_xmm(ctx, expr2_0)?; - return Some(expr3_0); - } - &Opcode::Fmul => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/x64/lower.isle line 2291. - let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?; - let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?; - let expr2_0 = constructor_x64_mulss(ctx, expr0_0, &expr1_0)?; - let expr3_0 = constructor_output_xmm(ctx, expr2_0)?; - return Some(expr3_0); - } - &Opcode::Fdiv => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/x64/lower.isle line 2302. - let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?; - let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?; - let expr2_0 = constructor_x64_divss(ctx, expr0_0, &expr1_0)?; - let expr3_0 = constructor_output_xmm(ctx, expr2_0)?; - return Some(expr3_0); - } - &Opcode::Fmin => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/x64/lower.isle line 2323. - let expr0_0: Type = F32; - let expr1_0: bool = true; - let expr2_0 = constructor_put_in_xmm(ctx, pattern7_0)?; - let expr3_0 = constructor_put_in_xmm(ctx, pattern7_1)?; - let expr4_0 = constructor_xmm_min_max_seq( - ctx, expr0_0, expr1_0, expr2_0, expr3_0, - )?; - let expr5_0 = constructor_output_xmm(ctx, expr4_0)?; - return Some(expr5_0); - } - &Opcode::FminPseudo => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/x64/lower.isle line 2492. - let expr0_0 = constructor_put_in_xmm(ctx, pattern7_1)?; - let expr1_0 = constructor_put_in_xmm(ctx, pattern7_0)?; - let expr2_0 = constructor_x64_minss(ctx, expr0_0, expr1_0)?; - let expr3_0 = constructor_output_xmm(ctx, expr2_0)?; - return Some(expr3_0); - } - &Opcode::Fmax => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/x64/lower.isle line 2395. - let expr0_0: Type = F32; - let expr1_0: bool = false; - let expr2_0 = constructor_put_in_xmm(ctx, pattern7_0)?; - let expr3_0 = constructor_put_in_xmm(ctx, pattern7_1)?; - let expr4_0 = constructor_xmm_min_max_seq( - ctx, expr0_0, expr1_0, expr2_0, expr3_0, - )?; - let expr5_0 = constructor_output_xmm(ctx, expr4_0)?; - return Some(expr5_0); - } - &Opcode::FmaxPseudo => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/x64/lower.isle line 2503. - let expr0_0 = constructor_put_in_xmm(ctx, pattern7_1)?; - let expr1_0 = constructor_put_in_xmm(ctx, pattern7_0)?; - let expr2_0 = constructor_x64_maxss(ctx, expr0_0, expr1_0)?; - let expr3_0 = constructor_output_xmm(ctx, expr2_0)?; - return Some(expr3_0); - } - _ => {} - } - } - &InstructionData::Unary { - opcode: ref pattern5_0, - arg: pattern5_1, - } => { - if let &Opcode::Sqrt = pattern5_0 { - // Rule at src/isa/x64/lower.isle line 2312. - let expr0_0 = constructor_put_in_xmm(ctx, pattern5_1)?; - let expr1_0 = constructor_x64_sqrtss(ctx, expr0_0)?; - let expr2_0 = constructor_output_xmm(ctx, expr1_0)?; - return Some(expr2_0); - } - } - &InstructionData::Load { - opcode: ref pattern5_0, - arg: pattern5_1, - flags: pattern5_2, - offset: pattern5_3, - } => { - if let &Opcode::Load = pattern5_0 { - // Rule at src/isa/x64/lower.isle line 2546. - let expr0_0 = - constructor_to_amode(ctx, pattern5_2, pattern5_1, pattern5_3)?; - let expr1_0 = constructor_amode_to_xmm_mem(ctx, &expr0_0)?; - let expr2_0 = constructor_x64_movss_load(ctx, &expr1_0)?; - let expr3_0 = constructor_output_xmm(ctx, expr2_0)?; - return Some(expr3_0); - } - } - _ => {} - } - } - if pattern2_0 == F64 { - let pattern4_0 = C::inst_data(ctx, pattern0_0); - match &pattern4_0 { - &InstructionData::Binary { - opcode: ref pattern5_0, - args: ref pattern5_1, - } => { - match pattern5_0 { - &Opcode::Fadd => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/x64/lower.isle line 2271. - let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?; - let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?; - let expr2_0 = constructor_x64_addsd(ctx, expr0_0, &expr1_0)?; - let expr3_0 = constructor_output_xmm(ctx, expr2_0)?; - return Some(expr3_0); - } - &Opcode::Fsub => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/x64/lower.isle line 2282. - let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?; - let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?; - let expr2_0 = constructor_x64_subsd(ctx, expr0_0, &expr1_0)?; - let expr3_0 = constructor_output_xmm(ctx, expr2_0)?; - return Some(expr3_0); - } - &Opcode::Fmul => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/x64/lower.isle line 2293. - let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?; - let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?; - let expr2_0 = constructor_x64_mulsd(ctx, expr0_0, &expr1_0)?; - let expr3_0 = constructor_output_xmm(ctx, expr2_0)?; - return Some(expr3_0); - } - &Opcode::Fdiv => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/x64/lower.isle line 2304. - let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?; - let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?; - let expr2_0 = constructor_x64_divsd(ctx, expr0_0, &expr1_0)?; - let expr3_0 = constructor_output_xmm(ctx, expr2_0)?; - return Some(expr3_0); - } - &Opcode::Fmin => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/x64/lower.isle line 2325. - let expr0_0: Type = F64; - let expr1_0: bool = true; - let expr2_0 = constructor_put_in_xmm(ctx, pattern7_0)?; - let expr3_0 = constructor_put_in_xmm(ctx, pattern7_1)?; - let expr4_0 = constructor_xmm_min_max_seq( - ctx, expr0_0, expr1_0, expr2_0, expr3_0, - )?; - let expr5_0 = constructor_output_xmm(ctx, expr4_0)?; - return Some(expr5_0); - } - &Opcode::FminPseudo => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/x64/lower.isle line 2494. - let expr0_0 = constructor_put_in_xmm(ctx, pattern7_1)?; - let expr1_0 = constructor_put_in_xmm(ctx, pattern7_0)?; - let expr2_0 = constructor_x64_minsd(ctx, expr0_0, expr1_0)?; - let expr3_0 = constructor_output_xmm(ctx, expr2_0)?; - return Some(expr3_0); - } - &Opcode::Fmax => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/x64/lower.isle line 2397. - let expr0_0: Type = F64; - let expr1_0: bool = false; - let expr2_0 = constructor_put_in_xmm(ctx, pattern7_0)?; - let expr3_0 = constructor_put_in_xmm(ctx, pattern7_1)?; - let expr4_0 = constructor_xmm_min_max_seq( - ctx, expr0_0, expr1_0, expr2_0, expr3_0, - )?; - let expr5_0 = constructor_output_xmm(ctx, expr4_0)?; - return Some(expr5_0); - } - &Opcode::FmaxPseudo => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/x64/lower.isle line 2505. - let expr0_0 = constructor_put_in_xmm(ctx, pattern7_1)?; - let expr1_0 = constructor_put_in_xmm(ctx, pattern7_0)?; - let expr2_0 = constructor_x64_maxsd(ctx, expr0_0, expr1_0)?; - let expr3_0 = constructor_output_xmm(ctx, expr2_0)?; - return Some(expr3_0); - } - _ => {} - } - } - &InstructionData::Unary { - opcode: ref pattern5_0, - arg: pattern5_1, - } => { - if let &Opcode::Sqrt = pattern5_0 { - // Rule at src/isa/x64/lower.isle line 2314. - let expr0_0 = constructor_put_in_xmm(ctx, pattern5_1)?; - let expr1_0 = constructor_x64_sqrtsd(ctx, expr0_0)?; - let expr2_0 = constructor_output_xmm(ctx, expr1_0)?; - return Some(expr2_0); - } - } - &InstructionData::Load { - opcode: ref pattern5_0, - arg: pattern5_1, - flags: pattern5_2, - offset: pattern5_3, - } => { - if let &Opcode::Load = pattern5_0 { - // Rule at src/isa/x64/lower.isle line 2548. - let expr0_0 = - constructor_to_amode(ctx, pattern5_2, pattern5_1, pattern5_3)?; - let expr1_0 = constructor_amode_to_xmm_mem(ctx, &expr0_0)?; - let expr2_0 = constructor_x64_movsd_load(ctx, &expr1_0)?; - let expr3_0 = constructor_output_xmm(ctx, expr2_0)?; - return Some(expr3_0); - } - } - _ => {} - } - } - if pattern2_0 == I8X16 { - let pattern4_0 = C::inst_data(ctx, pattern0_0); - match &pattern4_0 { - &InstructionData::Binary { - opcode: ref pattern5_0, - args: ref pattern5_1, - } => { - match pattern5_0 { - &Opcode::Imin => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/x64/lower.isle line 1405. - let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?; - let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?; - let expr2_0 = constructor_x64_pminsb(ctx, expr0_0, &expr1_0)?; - let expr3_0 = constructor_output_xmm(ctx, expr2_0)?; - return Some(expr3_0); - } - &Opcode::Umin => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/x64/lower.isle line 1427. - let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?; - let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?; - let expr2_0 = constructor_x64_pminub(ctx, expr0_0, &expr1_0)?; - let expr3_0 = constructor_output_xmm(ctx, expr2_0)?; - return Some(expr3_0); - } - &Opcode::Imax => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/x64/lower.isle line 1394. - let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?; - let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?; - let expr2_0 = constructor_x64_pmaxsb(ctx, expr0_0, &expr1_0)?; - let expr3_0 = constructor_output_xmm(ctx, expr2_0)?; - return Some(expr3_0); - } - &Opcode::Umax => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/x64/lower.isle line 1416. - let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?; - let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?; - let expr2_0 = constructor_x64_pmaxub(ctx, expr0_0, &expr1_0)?; - let expr3_0 = constructor_output_xmm(ctx, expr2_0)?; - return Some(expr3_0); - } - &Opcode::Ishl => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/x64/lower.isle line 534. - let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?; - let expr1_0 = C::put_in_reg_mem_imm(ctx, pattern7_1); - let expr2_0 = constructor_mov_rmi_to_xmm(ctx, &expr1_0)?; - let expr3_0 = constructor_x64_psllw(ctx, expr0_0, &expr2_0)?; - let expr4_0 = C::put_in_reg_mem_imm(ctx, pattern7_1); - let expr5_0 = constructor_ishl_i8x16_mask(ctx, &expr4_0)?; - let expr6_0: Type = I8X16; - let expr7_0 = ExtKind::None; - let expr8_0 = constructor_x64_load(ctx, expr6_0, &expr5_0, &expr7_0)?; - let expr9_0: Type = I8X16; - let expr10_0 = RegMem::Reg { reg: expr8_0 }; - let expr11_0 = C::reg_mem_to_xmm_mem(ctx, &expr10_0); - let expr12_0 = constructor_sse_and(ctx, expr9_0, expr3_0, &expr11_0)?; - let expr13_0 = constructor_output_xmm(ctx, expr12_0)?; - return Some(expr13_0); - } - &Opcode::Ushr => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/x64/lower.isle line 633. - let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?; - let expr1_0 = C::put_in_reg_mem_imm(ctx, pattern7_1); - let expr2_0 = constructor_mov_rmi_to_xmm(ctx, &expr1_0)?; - let expr3_0 = constructor_x64_psrlw(ctx, expr0_0, &expr2_0)?; - let expr4_0 = C::put_in_reg_mem_imm(ctx, pattern7_1); - let expr5_0 = constructor_ushr_i8x16_mask(ctx, &expr4_0)?; - let expr6_0: Type = I8X16; - let expr7_0 = ExtKind::None; - let expr8_0 = constructor_x64_load(ctx, expr6_0, &expr5_0, &expr7_0)?; - let expr9_0: Type = I8X16; - let expr10_0 = RegMem::Reg { reg: expr8_0 }; - let expr11_0 = C::reg_mem_to_xmm_mem(ctx, &expr10_0); - let expr12_0 = constructor_sse_and(ctx, expr9_0, expr3_0, &expr11_0)?; - let expr13_0 = constructor_output_xmm(ctx, expr12_0)?; - return Some(expr13_0); - } - &Opcode::Sshr => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - let pattern8_0 = C::value_type(ctx, pattern7_1); - // Rule at src/isa/x64/lower.isle line 749. - let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?; - let expr1_0 = C::xmm_to_xmm_mem(ctx, expr0_0); - let expr2_0 = constructor_x64_punpcklbw(ctx, expr0_0, &expr1_0)?; - let expr3_0 = C::xmm_to_xmm_mem(ctx, expr0_0); - let expr4_0 = constructor_x64_punpckhbw(ctx, expr0_0, &expr3_0)?; - let expr5_0 = C::put_in_reg_mem_imm(ctx, pattern7_1); - let expr6_0 = - constructor_sshr_i8x16_bigger_shift(ctx, pattern8_0, &expr5_0)?; - let expr7_0 = constructor_x64_psraw(ctx, expr2_0, &expr6_0)?; - let expr8_0 = constructor_x64_psraw(ctx, expr4_0, &expr6_0)?; - let expr9_0 = C::xmm_to_xmm_mem(ctx, expr8_0); - let expr10_0 = constructor_x64_packsswb(ctx, expr7_0, &expr9_0)?; - let expr11_0 = constructor_output_xmm(ctx, expr10_0)?; - return Some(expr11_0); - } - _ => {} - } - } - &InstructionData::Unary { - opcode: ref pattern5_0, - arg: pattern5_1, - } => { - match pattern5_0 { - &Opcode::Ineg => { - // Rule at src/isa/x64/lower.isle line 889. - let expr0_0: Type = I8X16; - let expr1_0: u64 = 0; - let expr2_0 = constructor_imm(ctx, expr0_0, expr1_0)?; - let expr3_0 = C::xmm_new(ctx, expr2_0); - let expr4_0 = constructor_put_in_xmm_mem(ctx, pattern5_1)?; - let expr5_0 = constructor_x64_psubb(ctx, expr3_0, &expr4_0)?; - let expr6_0 = constructor_output_xmm(ctx, expr5_0)?; - return Some(expr6_0); - } - &Opcode::Iabs => { - // Rule at src/isa/x64/lower.isle line 1210. - let expr0_0 = constructor_put_in_xmm_mem(ctx, pattern5_1)?; - let expr1_0 = constructor_x64_pabsb(ctx, &expr0_0)?; - let expr2_0 = constructor_output_xmm(ctx, expr1_0)?; - return Some(expr2_0); - } - &Opcode::Popcnt => { - // Rule at src/isa/x64/lower.isle line 2002. - let expr0_0 = C::popcount_4bit_table(ctx); - let expr1_0: Type = I8X16; - let expr2_0 = C::popcount_low_mask(ctx); - let expr3_0 = constructor_x64_xmm_load_const(ctx, expr1_0, expr2_0)?; - let expr4_0: Type = I8X16; - let expr5_0 = constructor_put_in_xmm(ctx, pattern5_1)?; - let expr6_0 = C::xmm_to_xmm_mem(ctx, expr3_0); - let expr7_0 = constructor_sse_and(ctx, expr4_0, expr5_0, &expr6_0)?; - let expr8_0 = constructor_put_in_xmm(ctx, pattern5_1)?; - let expr9_0: u32 = 4; - let expr10_0 = RegMemImm::Imm { simm32: expr9_0 }; - let expr11_0 = constructor_mov_rmi_to_xmm(ctx, &expr10_0)?; - let expr12_0 = constructor_x64_psrlw(ctx, expr8_0, &expr11_0)?; - let expr13_0: Type = I8X16; - let expr14_0 = C::xmm_to_xmm_mem(ctx, expr3_0); - let expr15_0 = constructor_sse_and(ctx, expr13_0, expr12_0, &expr14_0)?; - let expr16_0: Type = I8X16; - let expr17_0 = C::popcount_4bit_table(ctx); - let expr18_0 = constructor_x64_xmm_load_const(ctx, expr16_0, expr17_0)?; - let expr19_0 = C::xmm_to_xmm_mem(ctx, expr7_0); - let expr20_0 = constructor_x64_pshufb(ctx, expr18_0, &expr19_0)?; - let expr21_0 = C::xmm_to_xmm_mem(ctx, expr15_0); - let expr22_0 = constructor_x64_pshufb(ctx, expr18_0, &expr21_0)?; - let expr23_0 = C::xmm_to_xmm_mem(ctx, expr22_0); - let expr24_0 = constructor_x64_paddb(ctx, expr20_0, &expr23_0)?; - let expr25_0 = constructor_output_xmm(ctx, expr24_0)?; - return Some(expr25_0); - } - _ => {} - } - } - _ => {} - } - } - if pattern2_0 == I16X8 { - let pattern4_0 = C::inst_data(ctx, pattern0_0); - match &pattern4_0 { - &InstructionData::Binary { - opcode: ref pattern5_0, - args: ref pattern5_1, - } => { - match pattern5_0 { - &Opcode::Imin => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/x64/lower.isle line 1408. - let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?; - let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?; - let expr2_0 = constructor_x64_pminsw(ctx, expr0_0, &expr1_0)?; - let expr3_0 = constructor_output_xmm(ctx, expr2_0)?; - return Some(expr3_0); - } - &Opcode::Umin => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/x64/lower.isle line 1430. - let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?; - let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?; - let expr2_0 = constructor_x64_pminuw(ctx, expr0_0, &expr1_0)?; - let expr3_0 = constructor_output_xmm(ctx, expr2_0)?; - return Some(expr3_0); - } - &Opcode::Imax => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/x64/lower.isle line 1397. - let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?; - let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?; - let expr2_0 = constructor_x64_pmaxsw(ctx, expr0_0, &expr1_0)?; - let expr3_0 = constructor_output_xmm(ctx, expr2_0)?; - return Some(expr3_0); - } - &Opcode::Umax => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/x64/lower.isle line 1419. - let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?; - let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?; - let expr2_0 = constructor_x64_pmaxuw(ctx, expr0_0, &expr1_0)?; - let expr3_0 = constructor_output_xmm(ctx, expr2_0)?; - return Some(expr3_0); - } - &Opcode::Ishl => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/x64/lower.isle line 576. - let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?; - let expr1_0 = C::put_in_reg_mem_imm(ctx, pattern7_1); - let expr2_0 = constructor_mov_rmi_to_xmm(ctx, &expr1_0)?; - let expr3_0 = constructor_x64_psllw(ctx, expr0_0, &expr2_0)?; - let expr4_0 = constructor_output_xmm(ctx, expr3_0)?; - return Some(expr4_0); - } - &Opcode::Ushr => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/x64/lower.isle line 678. - let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?; - let expr1_0 = C::put_in_reg_mem_imm(ctx, pattern7_1); - let expr2_0 = constructor_mov_rmi_to_xmm(ctx, &expr1_0)?; - let expr3_0 = constructor_x64_psrlw(ctx, expr0_0, &expr2_0)?; - let expr4_0 = constructor_output_xmm(ctx, expr3_0)?; - return Some(expr4_0); - } - &Opcode::Sshr => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/x64/lower.isle line 776. - let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?; - let expr1_0 = C::put_in_reg_mem_imm(ctx, pattern7_1); - let expr2_0 = constructor_mov_rmi_to_xmm(ctx, &expr1_0)?; - let expr3_0 = constructor_x64_psraw(ctx, expr0_0, &expr2_0)?; - let expr4_0 = constructor_output_xmm(ctx, expr3_0)?; - return Some(expr4_0); - } - _ => {} - } - } - &InstructionData::Unary { - opcode: ref pattern5_0, - arg: pattern5_1, - } => { - match pattern5_0 { - &Opcode::Ineg => { - // Rule at src/isa/x64/lower.isle line 892. - let expr0_0: Type = I16X8; - let expr1_0: u64 = 0; - let expr2_0 = constructor_imm(ctx, expr0_0, expr1_0)?; - let expr3_0 = C::xmm_new(ctx, expr2_0); - let expr4_0 = constructor_put_in_xmm_mem(ctx, pattern5_1)?; - let expr5_0 = constructor_x64_psubw(ctx, expr3_0, &expr4_0)?; - let expr6_0 = constructor_output_xmm(ctx, expr5_0)?; - return Some(expr6_0); - } - &Opcode::Iabs => { - // Rule at src/isa/x64/lower.isle line 1213. - let expr0_0 = constructor_put_in_xmm_mem(ctx, pattern5_1)?; - let expr1_0 = constructor_x64_pabsw(ctx, &expr0_0)?; - let expr2_0 = constructor_output_xmm(ctx, expr1_0)?; - return Some(expr2_0); - } - _ => {} - } - } - &InstructionData::Load { - opcode: ref pattern5_0, - arg: pattern5_1, - flags: pattern5_2, - offset: pattern5_3, - } => { - match pattern5_0 { - &Opcode::Uload8x8 => { - // Rule at src/isa/x64/lower.isle line 2570. - let expr0_0 = - constructor_to_amode(ctx, pattern5_2, pattern5_1, pattern5_3)?; - let expr1_0 = constructor_amode_to_xmm_mem(ctx, &expr0_0)?; - let expr2_0 = constructor_x64_pmovzxbw(ctx, &expr1_0)?; - let expr3_0 = constructor_output_xmm(ctx, expr2_0)?; - return Some(expr3_0); - } - &Opcode::Sload8x8 => { - // Rule at src/isa/x64/lower.isle line 2568. - let expr0_0 = - constructor_to_amode(ctx, pattern5_2, pattern5_1, pattern5_3)?; - let expr1_0 = constructor_amode_to_xmm_mem(ctx, &expr0_0)?; - let expr2_0 = constructor_x64_pmovsxbw(ctx, &expr1_0)?; - let expr3_0 = constructor_output_xmm(ctx, expr2_0)?; - return Some(expr3_0); - } - _ => {} - } - } - _ => {} - } - } - if pattern2_0 == I32X4 { - let pattern4_0 = C::inst_data(ctx, pattern0_0); - match &pattern4_0 { - &InstructionData::Binary { - opcode: ref pattern5_0, - args: ref pattern5_1, - } => { - match pattern5_0 { - &Opcode::Imin => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/x64/lower.isle line 1411. - let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?; - let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?; - let expr2_0 = constructor_x64_pminsd(ctx, expr0_0, &expr1_0)?; - let expr3_0 = constructor_output_xmm(ctx, expr2_0)?; - return Some(expr3_0); - } - &Opcode::Umin => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/x64/lower.isle line 1433. - let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?; - let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?; - let expr2_0 = constructor_x64_pminud(ctx, expr0_0, &expr1_0)?; - let expr3_0 = constructor_output_xmm(ctx, expr2_0)?; - return Some(expr3_0); - } - &Opcode::Imax => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/x64/lower.isle line 1400. - let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?; - let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?; - let expr2_0 = constructor_x64_pmaxsd(ctx, expr0_0, &expr1_0)?; - let expr3_0 = constructor_output_xmm(ctx, expr2_0)?; - return Some(expr3_0); - } - &Opcode::Umax => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/x64/lower.isle line 1422. - let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?; - let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?; - let expr2_0 = constructor_x64_pmaxud(ctx, expr0_0, &expr1_0)?; - let expr3_0 = constructor_output_xmm(ctx, expr2_0)?; - return Some(expr3_0); - } - &Opcode::Ishl => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/x64/lower.isle line 579. - let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?; - let expr1_0 = C::put_in_reg_mem_imm(ctx, pattern7_1); - let expr2_0 = constructor_mov_rmi_to_xmm(ctx, &expr1_0)?; - let expr3_0 = constructor_x64_pslld(ctx, expr0_0, &expr2_0)?; - let expr4_0 = constructor_output_xmm(ctx, expr3_0)?; - return Some(expr4_0); - } - &Opcode::Ushr => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/x64/lower.isle line 681. - let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?; - let expr1_0 = C::put_in_reg_mem_imm(ctx, pattern7_1); - let expr2_0 = constructor_mov_rmi_to_xmm(ctx, &expr1_0)?; - let expr3_0 = constructor_x64_psrld(ctx, expr0_0, &expr2_0)?; - let expr4_0 = constructor_output_xmm(ctx, expr3_0)?; - return Some(expr4_0); - } - &Opcode::Sshr => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/x64/lower.isle line 779. - let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?; - let expr1_0 = C::put_in_reg_mem_imm(ctx, pattern7_1); - let expr2_0 = constructor_mov_rmi_to_xmm(ctx, &expr1_0)?; - let expr3_0 = constructor_x64_psrad(ctx, expr0_0, &expr2_0)?; - let expr4_0 = constructor_output_xmm(ctx, expr3_0)?; - return Some(expr4_0); - } - &Opcode::WideningPairwiseDotProductS => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/x64/lower.isle line 2259. - let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?; - let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?; - let expr2_0 = constructor_x64_pmaddwd(ctx, expr0_0, &expr1_0)?; - let expr3_0 = constructor_output_xmm(ctx, expr2_0)?; - return Some(expr3_0); - } - _ => {} - } - } - &InstructionData::Unary { - opcode: ref pattern5_0, - arg: pattern5_1, - } => { - match pattern5_0 { - &Opcode::Ineg => { - // Rule at src/isa/x64/lower.isle line 895. - let expr0_0: Type = I32X4; - let expr1_0: u64 = 0; - let expr2_0 = constructor_imm(ctx, expr0_0, expr1_0)?; - let expr3_0 = C::xmm_new(ctx, expr2_0); - let expr4_0 = constructor_put_in_xmm_mem(ctx, pattern5_1)?; - let expr5_0 = constructor_x64_psubd(ctx, expr3_0, &expr4_0)?; - let expr6_0 = constructor_output_xmm(ctx, expr5_0)?; - return Some(expr6_0); - } - &Opcode::Iabs => { - // Rule at src/isa/x64/lower.isle line 1216. - let expr0_0 = constructor_put_in_xmm_mem(ctx, pattern5_1)?; - let expr1_0 = constructor_x64_pabsd(ctx, &expr0_0)?; - let expr2_0 = constructor_output_xmm(ctx, expr1_0)?; - return Some(expr2_0); - } - _ => {} - } - } - &InstructionData::Load { - opcode: ref pattern5_0, - arg: pattern5_1, - flags: pattern5_2, - offset: pattern5_3, - } => { - match pattern5_0 { - &Opcode::Uload16x4 => { - // Rule at src/isa/x64/lower.isle line 2574. - let expr0_0 = - constructor_to_amode(ctx, pattern5_2, pattern5_1, pattern5_3)?; - let expr1_0 = constructor_amode_to_xmm_mem(ctx, &expr0_0)?; - let expr2_0 = constructor_x64_pmovzxwd(ctx, &expr1_0)?; - let expr3_0 = constructor_output_xmm(ctx, expr2_0)?; - return Some(expr3_0); - } - &Opcode::Sload16x4 => { - // Rule at src/isa/x64/lower.isle line 2572. - let expr0_0 = - constructor_to_amode(ctx, pattern5_2, pattern5_1, pattern5_3)?; - let expr1_0 = constructor_amode_to_xmm_mem(ctx, &expr0_0)?; - let expr2_0 = constructor_x64_pmovsxwd(ctx, &expr1_0)?; - let expr3_0 = constructor_output_xmm(ctx, expr2_0)?; - return Some(expr3_0); - } - _ => {} - } - } - _ => {} - } - } - if pattern2_0 == I64X2 { - let pattern4_0 = C::inst_data(ctx, pattern0_0); - match &pattern4_0 { - &InstructionData::Binary { - opcode: ref pattern5_0, - args: ref pattern5_1, - } => { - match pattern5_0 { - &Opcode::Ishl => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/x64/lower.isle line 582. - let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?; - let expr1_0 = C::put_in_reg_mem_imm(ctx, pattern7_1); - let expr2_0 = constructor_mov_rmi_to_xmm(ctx, &expr1_0)?; - let expr3_0 = constructor_x64_psllq(ctx, expr0_0, &expr2_0)?; - let expr4_0 = constructor_output_xmm(ctx, expr3_0)?; - return Some(expr4_0); - } - &Opcode::Ushr => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/x64/lower.isle line 684. - let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?; - let expr1_0 = C::put_in_reg_mem_imm(ctx, pattern7_1); - let expr2_0 = constructor_mov_rmi_to_xmm(ctx, &expr1_0)?; - let expr3_0 = constructor_x64_psrlq(ctx, expr0_0, &expr2_0)?; - let expr4_0 = constructor_output_xmm(ctx, expr3_0)?; - return Some(expr4_0); - } - &Opcode::Sshr => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/x64/lower.isle line 790. - let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?; - let expr1_0: Type = I64; - let expr2_0: u8 = 0; - let expr3_0 = constructor_x64_pextrd(ctx, expr1_0, expr0_0, expr2_0)?; - let expr4_0: Type = I64; - let expr5_0: u8 = 1; - let expr6_0 = constructor_x64_pextrd(ctx, expr4_0, expr0_0, expr5_0)?; - let expr7_0: Type = I64; - let expr8_0 = C::put_masked_in_imm8_gpr(ctx, pattern7_1, expr7_0); - let expr9_0: Type = I64; - let expr10_0 = constructor_x64_sar(ctx, expr9_0, expr3_0, &expr8_0)?; - let expr11_0: Type = I64; - let expr12_0 = constructor_x64_sar(ctx, expr11_0, expr6_0, &expr8_0)?; - let expr13_0 = C::gpr_to_gpr_mem(ctx, expr10_0); - let expr14_0 = C::gpr_to_gpr_mem(ctx, expr12_0); - let expr15_0 = - constructor_make_i64x2_from_lanes(ctx, &expr13_0, &expr14_0)?; - let expr16_0 = constructor_output_xmm(ctx, expr15_0)?; - return Some(expr16_0); - } - _ => {} - } - } - &InstructionData::Unary { - opcode: ref pattern5_0, - arg: pattern5_1, - } => { - match pattern5_0 { - &Opcode::Ineg => { - // Rule at src/isa/x64/lower.isle line 898. - let expr0_0: Type = I64X2; - let expr1_0: u64 = 0; - let expr2_0 = constructor_imm(ctx, expr0_0, expr1_0)?; - let expr3_0 = C::xmm_new(ctx, expr2_0); - let expr4_0 = constructor_put_in_xmm_mem(ctx, pattern5_1)?; - let expr5_0 = constructor_x64_psubq(ctx, expr3_0, &expr4_0)?; - let expr6_0 = constructor_output_xmm(ctx, expr5_0)?; - return Some(expr6_0); - } - &Opcode::Iabs => { - // Rule at src/isa/x64/lower.isle line 1230. - let expr0_0 = constructor_put_in_xmm(ctx, pattern5_1)?; - let expr1_0: Type = I64X2; - let expr2_0: u64 = 0; - let expr3_0 = constructor_imm(ctx, expr1_0, expr2_0)?; - let expr4_0 = C::xmm_new(ctx, expr3_0); - let expr5_0 = C::xmm_to_xmm_mem(ctx, expr0_0); - let expr6_0 = constructor_x64_psubq(ctx, expr4_0, &expr5_0)?; - let expr7_0 = C::xmm_to_xmm_mem(ctx, expr0_0); - let expr8_0 = - constructor_x64_blendvpd(ctx, expr6_0, &expr7_0, expr6_0)?; - let expr9_0 = constructor_output_xmm(ctx, expr8_0)?; - return Some(expr9_0); - } - _ => {} - } - } - &InstructionData::Load { - opcode: ref pattern5_0, - arg: pattern5_1, - flags: pattern5_2, - offset: pattern5_3, - } => { - match pattern5_0 { - &Opcode::Uload32x2 => { - // Rule at src/isa/x64/lower.isle line 2578. - let expr0_0 = - constructor_to_amode(ctx, pattern5_2, pattern5_1, pattern5_3)?; - let expr1_0 = constructor_amode_to_xmm_mem(ctx, &expr0_0)?; - let expr2_0 = constructor_x64_pmovzxdq(ctx, &expr1_0)?; - let expr3_0 = constructor_output_xmm(ctx, expr2_0)?; - return Some(expr3_0); - } - &Opcode::Sload32x2 => { - // Rule at src/isa/x64/lower.isle line 2576. - let expr0_0 = - constructor_to_amode(ctx, pattern5_2, pattern5_1, pattern5_3)?; - let expr1_0 = constructor_amode_to_xmm_mem(ctx, &expr0_0)?; - let expr2_0 = constructor_x64_pmovsxdq(ctx, &expr1_0)?; - let expr3_0 = constructor_output_xmm(ctx, expr2_0)?; - return Some(expr3_0); - } - _ => {} - } - } - _ => {} - } - } - if pattern2_0 == F32X4 { - let pattern4_0 = C::inst_data(ctx, pattern0_0); - match &pattern4_0 { - &InstructionData::Binary { - opcode: ref pattern5_0, - args: ref pattern5_1, - } => { - match pattern5_0 { - &Opcode::Fadd => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/x64/lower.isle line 2273. - let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?; - let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?; - let expr2_0 = constructor_x64_addps(ctx, expr0_0, &expr1_0)?; - let expr3_0 = constructor_output_xmm(ctx, expr2_0)?; - return Some(expr3_0); - } - &Opcode::Fsub => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/x64/lower.isle line 2284. - let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?; - let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?; - let expr2_0 = constructor_x64_subps(ctx, expr0_0, &expr1_0)?; - let expr3_0 = constructor_output_xmm(ctx, expr2_0)?; - return Some(expr3_0); - } - &Opcode::Fmul => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/x64/lower.isle line 2295. - let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?; - let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?; - let expr2_0 = constructor_x64_mulps(ctx, expr0_0, &expr1_0)?; - let expr3_0 = constructor_output_xmm(ctx, expr2_0)?; - return Some(expr3_0); - } - &Opcode::Fdiv => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/x64/lower.isle line 2306. - let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?; - let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?; - let expr2_0 = constructor_x64_divps(ctx, expr0_0, &expr1_0)?; - let expr3_0 = constructor_output_xmm(ctx, expr2_0)?; - return Some(expr3_0); - } - &Opcode::Fmin => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/x64/lower.isle line 2340. - let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?; - let expr1_0 = constructor_put_in_xmm(ctx, pattern7_1)?; - let expr2_0 = constructor_x64_minps(ctx, expr0_0, expr1_0)?; - let expr3_0 = constructor_put_in_xmm(ctx, pattern7_1)?; - let expr4_0 = constructor_put_in_xmm(ctx, pattern7_0)?; - let expr5_0 = constructor_x64_minps(ctx, expr3_0, expr4_0)?; - let expr6_0 = C::xmm_to_xmm_mem(ctx, expr5_0); - let expr7_0 = constructor_x64_orps(ctx, expr2_0, &expr6_0)?; - let expr8_0 = C::xmm_to_xmm_mem(ctx, expr5_0); - let expr9_0 = FcmpImm::Unordered; - let expr10_0 = constructor_x64_cmpps(ctx, expr7_0, &expr8_0, &expr9_0)?; - let expr11_0 = C::xmm_to_xmm_mem(ctx, expr10_0); - let expr12_0 = constructor_x64_orps(ctx, expr7_0, &expr11_0)?; - let expr13_0: u32 = 10; - let expr14_0 = RegMemImm::Imm { simm32: expr13_0 }; - let expr15_0 = constructor_mov_rmi_to_xmm(ctx, &expr14_0)?; - let expr16_0 = constructor_x64_psrld(ctx, expr10_0, &expr15_0)?; - let expr17_0 = C::xmm_to_xmm_mem(ctx, expr12_0); - let expr18_0 = constructor_x64_andnps(ctx, expr16_0, &expr17_0)?; - let expr19_0 = constructor_output_xmm(ctx, expr18_0)?; - return Some(expr19_0); - } - &Opcode::FminPseudo => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/x64/lower.isle line 2496. - let expr0_0 = constructor_put_in_xmm(ctx, pattern7_1)?; - let expr1_0 = constructor_put_in_xmm(ctx, pattern7_0)?; - let expr2_0 = constructor_x64_minps(ctx, expr0_0, expr1_0)?; - let expr3_0 = constructor_output_xmm(ctx, expr2_0)?; - return Some(expr3_0); - } - &Opcode::Fmax => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/x64/lower.isle line 2403. - let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?; - let expr1_0 = constructor_put_in_xmm(ctx, pattern7_1)?; - let expr2_0 = constructor_x64_maxps(ctx, expr0_0, expr1_0)?; - let expr3_0 = constructor_put_in_xmm(ctx, pattern7_1)?; - let expr4_0 = constructor_put_in_xmm(ctx, pattern7_0)?; - let expr5_0 = constructor_x64_maxps(ctx, expr3_0, expr4_0)?; - let expr6_0 = C::xmm_to_xmm_mem(ctx, expr5_0); - let expr7_0 = constructor_x64_xorps(ctx, expr2_0, &expr6_0)?; - let expr8_0 = C::xmm_to_xmm_mem(ctx, expr7_0); - let expr9_0 = constructor_x64_orps(ctx, expr2_0, &expr8_0)?; - let expr10_0 = C::xmm_to_xmm_mem(ctx, expr7_0); - let expr11_0 = constructor_x64_subps(ctx, expr9_0, &expr10_0)?; - let expr12_0 = C::xmm_to_xmm_mem(ctx, expr9_0); - let expr13_0 = FcmpImm::Unordered; - let expr14_0 = - constructor_x64_cmpps(ctx, expr9_0, &expr12_0, &expr13_0)?; - let expr15_0: u32 = 10; - let expr16_0 = RegMemImm::Imm { simm32: expr15_0 }; - let expr17_0 = constructor_mov_rmi_to_xmm(ctx, &expr16_0)?; - let expr18_0 = constructor_x64_psrld(ctx, expr14_0, &expr17_0)?; - let expr19_0 = C::xmm_to_xmm_mem(ctx, expr11_0); - let expr20_0 = constructor_x64_andnps(ctx, expr18_0, &expr19_0)?; - let expr21_0 = constructor_output_xmm(ctx, expr20_0)?; - return Some(expr21_0); - } - &Opcode::FmaxPseudo => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/x64/lower.isle line 2507. - let expr0_0 = constructor_put_in_xmm(ctx, pattern7_1)?; - let expr1_0 = constructor_put_in_xmm(ctx, pattern7_0)?; - let expr2_0 = constructor_x64_maxps(ctx, expr0_0, expr1_0)?; - let expr3_0 = constructor_output_xmm(ctx, expr2_0)?; - return Some(expr3_0); - } - _ => {} - } - } - &InstructionData::Unary { - opcode: ref pattern5_0, - arg: pattern5_1, - } => { - match pattern5_0 { - &Opcode::Sqrt => { - // Rule at src/isa/x64/lower.isle line 2316. - let expr0_0 = constructor_put_in_xmm(ctx, pattern5_1)?; - let expr1_0 = constructor_x64_sqrtps(ctx, expr0_0)?; - let expr2_0 = constructor_output_xmm(ctx, expr1_0)?; - return Some(expr2_0); - } - &Opcode::Fabs => { - // Rule at src/isa/x64/lower.isle line 1238. - let expr0_0 = constructor_put_in_xmm(ctx, pattern5_1)?; - let expr1_0: Type = F32X4; - let expr2_0 = constructor_vector_all_ones(ctx, expr1_0)?; - let expr3_0: u32 = 1; - let expr4_0 = RegMemImm::Imm { simm32: expr3_0 }; - let expr5_0 = constructor_mov_rmi_to_xmm(ctx, &expr4_0)?; - let expr6_0 = constructor_x64_psrld(ctx, expr2_0, &expr5_0)?; - let expr7_0 = C::xmm_to_xmm_mem(ctx, expr6_0); - let expr8_0 = constructor_x64_andps(ctx, expr0_0, &expr7_0)?; - let expr9_0 = constructor_output_xmm(ctx, expr8_0)?; - return Some(expr9_0); - } - _ => {} - } - } - &InstructionData::Load { - opcode: ref pattern5_0, - arg: pattern5_1, - flags: pattern5_2, - offset: pattern5_3, - } => { - if let &Opcode::Load = pattern5_0 { - // Rule at src/isa/x64/lower.isle line 2550. - let expr0_0 = - constructor_to_amode(ctx, pattern5_2, pattern5_1, pattern5_3)?; - let expr1_0 = constructor_amode_to_xmm_mem(ctx, &expr0_0)?; - let expr2_0 = constructor_x64_movups(ctx, &expr1_0)?; - let expr3_0 = constructor_output_xmm(ctx, expr2_0)?; - return Some(expr3_0); - } - } - _ => {} - } - } - if pattern2_0 == F64X2 { - let pattern4_0 = C::inst_data(ctx, pattern0_0); - match &pattern4_0 { - &InstructionData::Binary { - opcode: ref pattern5_0, - args: ref pattern5_1, - } => { - match pattern5_0 { - &Opcode::Fadd => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/x64/lower.isle line 2275. - let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?; - let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?; - let expr2_0 = constructor_x64_addpd(ctx, expr0_0, &expr1_0)?; - let expr3_0 = constructor_output_xmm(ctx, expr2_0)?; - return Some(expr3_0); - } - &Opcode::Fsub => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/x64/lower.isle line 2286. - let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?; - let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?; - let expr2_0 = constructor_x64_subpd(ctx, expr0_0, &expr1_0)?; - let expr3_0 = constructor_output_xmm(ctx, expr2_0)?; - return Some(expr3_0); - } - &Opcode::Fmul => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/x64/lower.isle line 2297. - let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?; - let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?; - let expr2_0 = constructor_x64_mulpd(ctx, expr0_0, &expr1_0)?; - let expr3_0 = constructor_output_xmm(ctx, expr2_0)?; - return Some(expr3_0); - } - &Opcode::Fdiv => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/x64/lower.isle line 2308. - let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?; - let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?; - let expr2_0 = constructor_x64_divpd(ctx, expr0_0, &expr1_0)?; - let expr3_0 = constructor_output_xmm(ctx, expr2_0)?; - return Some(expr3_0); - } - &Opcode::Fmin => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/x64/lower.isle line 2383. - let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?; - let expr1_0 = constructor_put_in_xmm(ctx, pattern7_1)?; - let expr2_0 = constructor_x64_minpd(ctx, expr0_0, expr1_0)?; - let expr3_0 = constructor_put_in_xmm(ctx, pattern7_1)?; - let expr4_0 = constructor_put_in_xmm(ctx, pattern7_0)?; - let expr5_0 = constructor_x64_minpd(ctx, expr3_0, expr4_0)?; - let expr6_0 = C::xmm_to_xmm_mem(ctx, expr5_0); - let expr7_0 = constructor_x64_orpd(ctx, expr2_0, &expr6_0)?; - let expr8_0 = C::xmm_to_xmm_mem(ctx, expr5_0); - let expr9_0 = FcmpImm::Unordered; - let expr10_0 = constructor_x64_cmppd(ctx, expr2_0, &expr8_0, &expr9_0)?; - let expr11_0 = C::xmm_to_xmm_mem(ctx, expr10_0); - let expr12_0 = constructor_x64_orpd(ctx, expr7_0, &expr11_0)?; - let expr13_0: u32 = 13; - let expr14_0 = RegMemImm::Imm { simm32: expr13_0 }; - let expr15_0 = constructor_mov_rmi_to_xmm(ctx, &expr14_0)?; - let expr16_0 = constructor_x64_psrlq(ctx, expr10_0, &expr15_0)?; - let expr17_0 = C::xmm_to_xmm_mem(ctx, expr12_0); - let expr18_0 = constructor_x64_andnpd(ctx, expr16_0, &expr17_0)?; - let expr19_0 = constructor_output_xmm(ctx, expr18_0)?; - return Some(expr19_0); - } - &Opcode::FminPseudo => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/x64/lower.isle line 2498. - let expr0_0 = constructor_put_in_xmm(ctx, pattern7_1)?; - let expr1_0 = constructor_put_in_xmm(ctx, pattern7_0)?; - let expr2_0 = constructor_x64_minpd(ctx, expr0_0, expr1_0)?; - let expr3_0 = constructor_output_xmm(ctx, expr2_0)?; - return Some(expr3_0); - } - &Opcode::Fmax => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/x64/lower.isle line 2446. - let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?; - let expr1_0 = constructor_put_in_xmm(ctx, pattern7_1)?; - let expr2_0 = constructor_x64_maxpd(ctx, expr0_0, expr1_0)?; - let expr3_0 = constructor_put_in_xmm(ctx, pattern7_1)?; - let expr4_0 = constructor_put_in_xmm(ctx, pattern7_0)?; - let expr5_0 = constructor_x64_maxpd(ctx, expr3_0, expr4_0)?; - let expr6_0 = C::xmm_to_xmm_mem(ctx, expr5_0); - let expr7_0 = constructor_x64_xorpd(ctx, expr2_0, &expr6_0)?; - let expr8_0 = C::xmm_to_xmm_mem(ctx, expr7_0); - let expr9_0 = constructor_x64_orpd(ctx, expr2_0, &expr8_0)?; - let expr10_0 = C::xmm_to_xmm_mem(ctx, expr7_0); - let expr11_0 = constructor_x64_subpd(ctx, expr9_0, &expr10_0)?; - let expr12_0 = C::xmm_to_xmm_mem(ctx, expr9_0); - let expr13_0 = FcmpImm::Unordered; - let expr14_0 = - constructor_x64_cmppd(ctx, expr9_0, &expr12_0, &expr13_0)?; - let expr15_0: u32 = 13; - let expr16_0 = RegMemImm::Imm { simm32: expr15_0 }; - let expr17_0 = constructor_mov_rmi_to_xmm(ctx, &expr16_0)?; - let expr18_0 = constructor_x64_psrlq(ctx, expr14_0, &expr17_0)?; - let expr19_0 = C::xmm_to_xmm_mem(ctx, expr11_0); - let expr20_0 = constructor_x64_andnpd(ctx, expr18_0, &expr19_0)?; - let expr21_0 = constructor_output_xmm(ctx, expr20_0)?; - return Some(expr21_0); - } - &Opcode::FmaxPseudo => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/x64/lower.isle line 2509. - let expr0_0 = constructor_put_in_xmm(ctx, pattern7_1)?; - let expr1_0 = constructor_put_in_xmm(ctx, pattern7_0)?; - let expr2_0 = constructor_x64_maxpd(ctx, expr0_0, expr1_0)?; - let expr3_0 = constructor_output_xmm(ctx, expr2_0)?; - return Some(expr3_0); - } - _ => {} - } - } - &InstructionData::Unary { - opcode: ref pattern5_0, - arg: pattern5_1, - } => { - match pattern5_0 { - &Opcode::Sqrt => { - // Rule at src/isa/x64/lower.isle line 2318. - let expr0_0 = constructor_put_in_xmm(ctx, pattern5_1)?; - let expr1_0 = constructor_x64_sqrtpd(ctx, expr0_0)?; - let expr2_0 = constructor_output_xmm(ctx, expr1_0)?; - return Some(expr2_0); - } - &Opcode::Fabs => { - // Rule at src/isa/x64/lower.isle line 1244. - let expr0_0 = constructor_put_in_xmm(ctx, pattern5_1)?; - let expr1_0: Type = F64X2; - let expr2_0 = constructor_vector_all_ones(ctx, expr1_0)?; - let expr3_0: u32 = 1; - let expr4_0 = RegMemImm::Imm { simm32: expr3_0 }; - let expr5_0 = constructor_mov_rmi_to_xmm(ctx, &expr4_0)?; - let expr6_0 = constructor_x64_psrlq(ctx, expr2_0, &expr5_0)?; - let expr7_0 = C::xmm_to_xmm_mem(ctx, expr6_0); - let expr8_0 = constructor_x64_andpd(ctx, expr0_0, &expr7_0)?; - let expr9_0 = constructor_output_xmm(ctx, expr8_0)?; - return Some(expr9_0); - } - _ => {} - } - } - &InstructionData::Load { - opcode: ref pattern5_0, - arg: pattern5_1, - flags: pattern5_2, - offset: pattern5_3, - } => { - if let &Opcode::Load = pattern5_0 { - // Rule at src/isa/x64/lower.isle line 2552. - let expr0_0 = - constructor_to_amode(ctx, pattern5_2, pattern5_1, pattern5_3)?; - let expr1_0 = constructor_amode_to_xmm_mem(ctx, &expr0_0)?; - let expr2_0 = constructor_x64_movupd(ctx, &expr1_0)?; - let expr3_0 = constructor_output_xmm(ctx, expr2_0)?; - return Some(expr3_0); - } - } - _ => {} - } - } - let pattern3_0 = C::inst_data(ctx, pattern0_0); - match &pattern3_0 { - &InstructionData::NullAry { - opcode: ref pattern4_0, - } => { - if let &Opcode::Null = pattern4_0 { - // Rule at src/isa/x64/lower.isle line 56. - let expr0_0: u64 = 0; - let expr1_0 = constructor_imm(ctx, pattern2_0, expr0_0)?; - let expr2_0 = constructor_output_reg(ctx, expr1_0)?; - return Some(expr2_0); - } - } - &InstructionData::Binary { - opcode: ref pattern4_0, - args: ref pattern4_1, - } => { - if let &Opcode::BandNot = pattern4_0 { - let (pattern6_0, pattern6_1) = C::unpack_value_array_2(ctx, pattern4_1); - // Rule at src/isa/x64/lower.isle line 1205. - let expr0_0 = constructor_put_in_xmm(ctx, pattern6_1)?; - let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern6_0)?; - let expr2_0 = constructor_sse_and_not(ctx, pattern2_0, expr0_0, &expr1_0)?; - let expr3_0 = constructor_output_xmm(ctx, expr2_0)?; - return Some(expr3_0); - } - } - &InstructionData::Ternary { - opcode: ref pattern4_0, - args: ref pattern4_1, - } => { - if let &Opcode::Select = pattern4_0 { - let (pattern6_0, pattern6_1, pattern6_2) = - C::unpack_value_array_3(ctx, pattern4_1); - if let Some(pattern7_0) = C::def_inst(ctx, pattern6_0) { - let pattern8_0 = C::inst_data(ctx, pattern7_0); - match &pattern8_0 { - &InstructionData::FloatCompare { - opcode: ref pattern9_0, - args: ref pattern9_1, - cond: ref pattern9_2, - } => { - if let &Opcode::Fcmp = pattern9_0 { - let (pattern11_0, pattern11_1) = - C::unpack_value_array_2(ctx, pattern9_1); - match pattern9_2 { - &FloatCC::Equal => { - // Rule at src/isa/x64/lower.isle line 1746. - let expr0_0 = constructor_x64_ucomis( - ctx, - pattern11_0, - pattern11_1, - )?; - let expr1_0 = CC::NZ; - let expr2_0 = CC::P; - let expr3_0 = constructor_cmove_or_from_values( - ctx, pattern2_0, &expr1_0, &expr2_0, pattern6_2, - pattern6_1, - )?; - let expr4_0 = - constructor_with_flags(ctx, &expr0_0, &expr3_0)?; - let expr5_0 = C::output(ctx, expr4_0); - return Some(expr5_0); - } - &FloatCC::GreaterThan => { - // Rule at src/isa/x64/lower.isle line 1698. - let expr0_0 = constructor_x64_ucomis( - ctx, - pattern11_1, - pattern11_0, - )?; - let expr1_0 = CC::NBE; - let expr2_0 = constructor_cmove_from_values( - ctx, pattern2_0, &expr1_0, pattern6_1, pattern6_2, - )?; - let expr3_0 = - constructor_with_flags(ctx, &expr0_0, &expr2_0)?; - let expr4_0 = C::output(ctx, expr3_0); - return Some(expr4_0); - } - &FloatCC::GreaterThanOrEqual => { - // Rule at src/isa/x64/lower.isle line 1701. - let expr0_0 = constructor_x64_ucomis( - ctx, - pattern11_1, - pattern11_0, - )?; - let expr1_0 = CC::NB; - let expr2_0 = constructor_cmove_from_values( - ctx, pattern2_0, &expr1_0, pattern6_1, pattern6_2, - )?; - let expr3_0 = - constructor_with_flags(ctx, &expr0_0, &expr2_0)?; - let expr4_0 = C::output(ctx, expr3_0); - return Some(expr4_0); - } - &FloatCC::LessThan => { - // Rule at src/isa/x64/lower.isle line 1721. - let expr0_0 = constructor_x64_ucomis( - ctx, - pattern11_0, - pattern11_1, - )?; - let expr1_0 = CC::NBE; - let expr2_0 = constructor_cmove_from_values( - ctx, pattern2_0, &expr1_0, pattern6_1, pattern6_2, - )?; - let expr3_0 = - constructor_with_flags(ctx, &expr0_0, &expr2_0)?; - let expr4_0 = C::output(ctx, expr3_0); - return Some(expr4_0); - } - &FloatCC::LessThanOrEqual => { - // Rule at src/isa/x64/lower.isle line 1724. - let expr0_0 = constructor_x64_ucomis( - ctx, - pattern11_0, - pattern11_1, - )?; - let expr1_0 = CC::NB; - let expr2_0 = constructor_cmove_from_values( - ctx, pattern2_0, &expr1_0, pattern6_1, pattern6_2, - )?; - let expr3_0 = - constructor_with_flags(ctx, &expr0_0, &expr2_0)?; - let expr4_0 = C::output(ctx, expr3_0); - return Some(expr4_0); - } - &FloatCC::NotEqual => { - // Rule at src/isa/x64/lower.isle line 1749. - let expr0_0 = constructor_x64_ucomis( - ctx, - pattern11_0, - pattern11_1, - )?; - let expr1_0 = CC::NZ; - let expr2_0 = CC::P; - let expr3_0 = constructor_cmove_or_from_values( - ctx, pattern2_0, &expr1_0, &expr2_0, pattern6_1, - pattern6_2, - )?; - let expr4_0 = - constructor_with_flags(ctx, &expr0_0, &expr3_0)?; - let expr5_0 = C::output(ctx, expr4_0); - return Some(expr5_0); - } - &FloatCC::Ordered => { - // Rule at src/isa/x64/lower.isle line 1692. - let expr0_0 = constructor_x64_ucomis( - ctx, - pattern11_1, - pattern11_0, - )?; - let expr1_0 = CC::NP; - let expr2_0 = constructor_cmove_from_values( - ctx, pattern2_0, &expr1_0, pattern6_1, pattern6_2, - )?; - let expr3_0 = - constructor_with_flags(ctx, &expr0_0, &expr2_0)?; - let expr4_0 = C::output(ctx, expr3_0); - return Some(expr4_0); - } - &FloatCC::Unordered => { - // Rule at src/isa/x64/lower.isle line 1695. - let expr0_0 = constructor_x64_ucomis( - ctx, - pattern11_1, - pattern11_0, - )?; - let expr1_0 = CC::P; - let expr2_0 = constructor_cmove_from_values( - ctx, pattern2_0, &expr1_0, pattern6_1, pattern6_2, - )?; - let expr3_0 = - constructor_with_flags(ctx, &expr0_0, &expr2_0)?; - let expr4_0 = C::output(ctx, expr3_0); - return Some(expr4_0); - } - &FloatCC::UnorderedOrGreaterThan => { - // Rule at src/isa/x64/lower.isle line 1727. - let expr0_0 = constructor_x64_ucomis( - ctx, - pattern11_0, - pattern11_1, - )?; - let expr1_0 = CC::B; - let expr2_0 = constructor_cmove_from_values( - ctx, pattern2_0, &expr1_0, pattern6_1, pattern6_2, - )?; - let expr3_0 = - constructor_with_flags(ctx, &expr0_0, &expr2_0)?; - let expr4_0 = C::output(ctx, expr3_0); - return Some(expr4_0); - } - &FloatCC::UnorderedOrGreaterThanOrEqual => { - // Rule at src/isa/x64/lower.isle line 1730. - let expr0_0 = constructor_x64_ucomis( - ctx, - pattern11_0, - pattern11_1, - )?; - let expr1_0 = CC::BE; - let expr2_0 = constructor_cmove_from_values( - ctx, pattern2_0, &expr1_0, pattern6_1, pattern6_2, - )?; - let expr3_0 = - constructor_with_flags(ctx, &expr0_0, &expr2_0)?; - let expr4_0 = C::output(ctx, expr3_0); - return Some(expr4_0); - } - &FloatCC::UnorderedOrLessThan => { - // Rule at src/isa/x64/lower.isle line 1704. - let expr0_0 = constructor_x64_ucomis( - ctx, - pattern11_1, - pattern11_0, - )?; - let expr1_0 = CC::B; - let expr2_0 = constructor_cmove_from_values( - ctx, pattern2_0, &expr1_0, pattern6_1, pattern6_2, - )?; - let expr3_0 = - constructor_with_flags(ctx, &expr0_0, &expr2_0)?; - let expr4_0 = C::output(ctx, expr3_0); - return Some(expr4_0); - } - &FloatCC::UnorderedOrLessThanOrEqual => { - // Rule at src/isa/x64/lower.isle line 1707. - let expr0_0 = constructor_x64_ucomis( - ctx, - pattern11_1, - pattern11_0, - )?; - let expr1_0 = CC::BE; - let expr2_0 = constructor_cmove_from_values( - ctx, pattern2_0, &expr1_0, pattern6_1, pattern6_2, - )?; - let expr3_0 = - constructor_with_flags(ctx, &expr0_0, &expr2_0)?; - let expr4_0 = C::output(ctx, expr3_0); - return Some(expr4_0); - } - _ => {} - } - } - } - &InstructionData::IntCompare { - opcode: ref pattern9_0, - args: ref pattern9_1, - cond: ref pattern9_2, - } => { - if let &Opcode::Icmp = pattern9_0 { - let (pattern11_0, pattern11_1) = - C::unpack_value_array_2(ctx, pattern9_1); - let pattern12_0 = C::value_type(ctx, pattern11_0); - if let Some(pattern13_0) = C::fits_in_64(ctx, pattern12_0) { - // Rule at src/isa/x64/lower.isle line 1757. - let expr0_0 = C::raw_operand_size_of_type(ctx, pattern13_0); - let expr1_0 = - constructor_put_in_gpr_mem_imm(ctx, pattern11_1)?; - let expr2_0 = constructor_put_in_gpr(ctx, pattern11_0)?; - let expr3_0 = - constructor_x64_cmp(ctx, &expr0_0, &expr1_0, expr2_0)?; - let expr4_0 = C::intcc_to_cc(ctx, pattern9_2); - let expr5_0 = constructor_cmove_from_values( - ctx, pattern2_0, &expr4_0, pattern6_1, pattern6_2, - )?; - let expr6_0 = - constructor_with_flags(ctx, &expr3_0, &expr5_0)?; - let expr7_0 = C::output(ctx, expr6_0); - return Some(expr7_0); - } - } - } - _ => {} - } - } - let pattern7_0 = C::value_type(ctx, pattern6_0); - if pattern7_0 == B1 { - // Rule at src/isa/x64/lower.isle line 1764. - let expr0_0: Type = B1; - let expr1_0 = C::raw_operand_size_of_type(ctx, expr0_0); - let expr2_0 = constructor_put_in_gpr(ctx, pattern6_0)?; - let expr3_0: u32 = 1; - let expr4_0 = RegMemImm::Imm { simm32: expr3_0 }; - let expr5_0 = C::gpr_mem_imm_new(ctx, &expr4_0); - let expr6_0 = constructor_x64_test(ctx, &expr1_0, &expr5_0, expr2_0)?; - let expr7_0 = CC::NZ; - let expr8_0 = constructor_cmove_from_values( - ctx, pattern2_0, &expr7_0, pattern6_1, pattern6_2, - )?; - let expr9_0 = constructor_with_flags(ctx, &expr6_0, &expr8_0)?; - let expr10_0 = C::output(ctx, expr9_0); - return Some(expr10_0); - } - if let Some(pattern8_0) = C::fits_in_64(ctx, pattern7_0) { - // Rule at src/isa/x64/lower.isle line 1771. - let expr0_0 = C::raw_operand_size_of_type(ctx, pattern8_0); - let expr1_0 = constructor_put_in_gpr(ctx, pattern6_0)?; - let expr2_0 = C::gpr_to_gpr_mem_imm(ctx, expr1_0); - let expr3_0 = constructor_x64_test(ctx, &expr0_0, &expr2_0, expr1_0)?; - let expr4_0 = CC::NZ; - let expr5_0 = constructor_cmove_from_values( - ctx, pattern2_0, &expr4_0, pattern6_1, pattern6_2, - )?; - let expr6_0 = constructor_with_flags(ctx, &expr3_0, &expr5_0)?; - let expr7_0 = C::output(ctx, expr6_0); - return Some(expr7_0); - } - } - } - &InstructionData::Unary { - opcode: ref pattern4_0, - arg: pattern4_1, - } => { - match pattern4_0 { - &Opcode::Breduce => { - let pattern6_0 = C::value_type(ctx, pattern4_1); - if pattern6_0 == pattern2_0 { - // Rule at src/isa/x64/lower.isle line 2232. - let expr0_0 = constructor_output_value(ctx, pattern4_1)?; - return Some(expr0_0); - } - } - &Opcode::Bextend => { - let pattern6_0 = C::value_type(ctx, pattern4_1); - // Rule at src/isa/x64/lower.isle line 2213. - let expr0_0 = - constructor_generic_sextend(ctx, pattern4_1, pattern6_0, pattern2_0)?; - return Some(expr0_0); - } - &Opcode::Ireduce => { - let pattern6_0 = C::value_type(ctx, pattern4_1); - if pattern6_0 == pattern2_0 { - // Rule at src/isa/x64/lower.isle line 2221. - let expr0_0 = constructor_output_value(ctx, pattern4_1)?; - return Some(expr0_0); - } - } - &Opcode::Uextend => { - let pattern6_0 = C::value_type(ctx, pattern4_1); - if pattern6_0 == pattern2_0 { - // Rule at src/isa/x64/lower.isle line 2114. - let expr0_0 = constructor_output_value(ctx, pattern4_1)?; - return Some(expr0_0); - } - } - &Opcode::Sextend => { - let pattern6_0 = C::value_type(ctx, pattern4_1); - // Rule at src/isa/x64/lower.isle line 2207. - let expr0_0 = - constructor_generic_sextend(ctx, pattern4_1, pattern6_0, pattern2_0)?; - return Some(expr0_0); - } - _ => {} - } - } - _ => {} - } - if let Some(()) = C::avx512vl_enabled(ctx, pattern2_0) { - if let Some(()) = C::avx512dq_enabled(ctx, pattern2_0) { - if let Some((pattern5_0, pattern5_1)) = C::multi_lane(ctx, pattern2_0) { - if pattern5_0 == 64 { - if pattern5_1 == 2 { - let pattern8_0 = C::inst_data(ctx, pattern0_0); - if let &InstructionData::Binary { - opcode: ref pattern9_0, - args: ref pattern9_1, - } = &pattern8_0 - { - if let &Opcode::Imul = pattern9_0 { - let (pattern11_0, pattern11_1) = - C::unpack_value_array_2(ctx, pattern9_1); - // Rule at src/isa/x64/lower.isle line 992. - let expr0_0 = constructor_put_in_xmm_mem(ctx, pattern11_0)?; - let expr1_0 = constructor_put_in_xmm(ctx, pattern11_1)?; - let expr2_0 = constructor_x64_vpmullq(ctx, &expr0_0, expr1_0)?; - let expr3_0 = constructor_output_xmm(ctx, expr2_0)?; - return Some(expr3_0); - } - } - } - } - } - } - if let Some(()) = C::avx512f_enabled(ctx, pattern2_0) { - if pattern2_0 == I64X2 { - let pattern6_0 = C::inst_data(ctx, pattern0_0); - if let &InstructionData::Unary { - opcode: ref pattern7_0, - arg: pattern7_1, - } = &pattern6_0 - { - if let &Opcode::Iabs = pattern7_0 { - // Rule at src/isa/x64/lower.isle line 1220. - let expr0_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?; - let expr1_0 = constructor_x64_vpabsq(ctx, &expr0_0)?; - let expr2_0 = constructor_output_xmm(ctx, expr1_0)?; - return Some(expr2_0); - } - } - } - } - } - if let Some((pattern3_0, pattern3_1)) = C::multi_lane(ctx, pattern2_0) { - if pattern3_0 == 8 { - if pattern3_1 == 16 { - let pattern6_0 = C::inst_data(ctx, pattern0_0); - if let &InstructionData::Binary { - opcode: ref pattern7_0, - args: ref pattern7_1, - } = &pattern6_0 - { - match pattern7_0 { - &Opcode::AvgRound => { - let (pattern9_0, pattern9_1) = - C::unpack_value_array_2(ctx, pattern7_1); - // Rule at src/isa/x64/lower.isle line 903. - let expr0_0 = constructor_put_in_xmm(ctx, pattern9_0)?; - let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern9_1)?; - let expr2_0 = constructor_x64_pavgb(ctx, expr0_0, &expr1_0)?; - let expr3_0 = constructor_output_xmm(ctx, expr2_0)?; - return Some(expr3_0); - } - &Opcode::UaddSat => { - let (pattern9_0, pattern9_1) = - C::unpack_value_array_2(ctx, pattern7_1); - // Rule at src/isa/x64/lower.isle line 136. - let expr0_0 = constructor_put_in_xmm(ctx, pattern9_0)?; - let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern9_1)?; - let expr2_0 = constructor_x64_paddusb(ctx, expr0_0, &expr1_0)?; - let expr3_0 = constructor_output_xmm(ctx, expr2_0)?; - return Some(expr3_0); - } - &Opcode::SaddSat => { - let (pattern9_0, pattern9_1) = - C::unpack_value_array_2(ctx, pattern7_1); - // Rule at src/isa/x64/lower.isle line 126. - let expr0_0 = constructor_put_in_xmm(ctx, pattern9_0)?; - let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern9_1)?; - let expr2_0 = constructor_x64_paddsb(ctx, expr0_0, &expr1_0)?; - let expr3_0 = constructor_output_xmm(ctx, expr2_0)?; - return Some(expr3_0); - } - &Opcode::UsubSat => { - let (pattern9_0, pattern9_1) = - C::unpack_value_array_2(ctx, pattern7_1); - // Rule at src/isa/x64/lower.isle line 282. - let expr0_0 = constructor_put_in_xmm(ctx, pattern9_0)?; - let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern9_1)?; - let expr2_0 = constructor_x64_psubusb(ctx, expr0_0, &expr1_0)?; - let expr3_0 = constructor_output_xmm(ctx, expr2_0)?; - return Some(expr3_0); - } - &Opcode::SsubSat => { - let (pattern9_0, pattern9_1) = - C::unpack_value_array_2(ctx, pattern7_1); - // Rule at src/isa/x64/lower.isle line 272. - let expr0_0 = constructor_put_in_xmm(ctx, pattern9_0)?; - let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern9_1)?; - let expr2_0 = constructor_x64_psubsb(ctx, expr0_0, &expr1_0)?; - let expr3_0 = constructor_output_xmm(ctx, expr2_0)?; - return Some(expr3_0); - } - &Opcode::Iadd => { - let (pattern9_0, pattern9_1) = - C::unpack_value_array_2(ctx, pattern7_1); - // Rule at src/isa/x64/lower.isle line 94. - let expr0_0 = constructor_put_in_xmm(ctx, pattern9_0)?; - let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern9_1)?; - let expr2_0 = constructor_x64_paddb(ctx, expr0_0, &expr1_0)?; - let expr3_0 = constructor_output_xmm(ctx, expr2_0)?; - return Some(expr3_0); - } - &Opcode::Isub => { - let (pattern9_0, pattern9_1) = - C::unpack_value_array_2(ctx, pattern7_1); - // Rule at src/isa/x64/lower.isle line 240. - let expr0_0 = constructor_put_in_xmm(ctx, pattern9_0)?; - let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern9_1)?; - let expr2_0 = constructor_x64_psubb(ctx, expr0_0, &expr1_0)?; - let expr3_0 = constructor_output_xmm(ctx, expr2_0)?; - return Some(expr3_0); - } - _ => {} - } - } - } - } - if pattern3_0 == 16 { - if pattern3_1 == 8 { - let pattern6_0 = C::inst_data(ctx, pattern0_0); - if let &InstructionData::Binary { - opcode: ref pattern7_0, - args: ref pattern7_1, - } = &pattern6_0 - { - match pattern7_0 { - &Opcode::AvgRound => { - let (pattern9_0, pattern9_1) = - C::unpack_value_array_2(ctx, pattern7_1); - // Rule at src/isa/x64/lower.isle line 907. - let expr0_0 = constructor_put_in_xmm(ctx, pattern9_0)?; - let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern9_1)?; - let expr2_0 = constructor_x64_pavgw(ctx, expr0_0, &expr1_0)?; - let expr3_0 = constructor_output_xmm(ctx, expr2_0)?; - return Some(expr3_0); - } - &Opcode::UaddSat => { - let (pattern9_0, pattern9_1) = - C::unpack_value_array_2(ctx, pattern7_1); - // Rule at src/isa/x64/lower.isle line 140. - let expr0_0 = constructor_put_in_xmm(ctx, pattern9_0)?; - let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern9_1)?; - let expr2_0 = constructor_x64_paddusw(ctx, expr0_0, &expr1_0)?; - let expr3_0 = constructor_output_xmm(ctx, expr2_0)?; - return Some(expr3_0); - } - &Opcode::SaddSat => { - let (pattern9_0, pattern9_1) = - C::unpack_value_array_2(ctx, pattern7_1); - // Rule at src/isa/x64/lower.isle line 130. - let expr0_0 = constructor_put_in_xmm(ctx, pattern9_0)?; - let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern9_1)?; - let expr2_0 = constructor_x64_paddsw(ctx, expr0_0, &expr1_0)?; - let expr3_0 = constructor_output_xmm(ctx, expr2_0)?; - return Some(expr3_0); - } - &Opcode::UsubSat => { - let (pattern9_0, pattern9_1) = - C::unpack_value_array_2(ctx, pattern7_1); - // Rule at src/isa/x64/lower.isle line 286. - let expr0_0 = constructor_put_in_xmm(ctx, pattern9_0)?; - let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern9_1)?; - let expr2_0 = constructor_x64_psubusw(ctx, expr0_0, &expr1_0)?; - let expr3_0 = constructor_output_xmm(ctx, expr2_0)?; - return Some(expr3_0); - } - &Opcode::SsubSat => { - let (pattern9_0, pattern9_1) = - C::unpack_value_array_2(ctx, pattern7_1); - // Rule at src/isa/x64/lower.isle line 276. - let expr0_0 = constructor_put_in_xmm(ctx, pattern9_0)?; - let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern9_1)?; - let expr2_0 = constructor_x64_psubsw(ctx, expr0_0, &expr1_0)?; - let expr3_0 = constructor_output_xmm(ctx, expr2_0)?; - return Some(expr3_0); - } - &Opcode::Iadd => { - let (pattern9_0, pattern9_1) = - C::unpack_value_array_2(ctx, pattern7_1); - // Rule at src/isa/x64/lower.isle line 98. - let expr0_0 = constructor_put_in_xmm(ctx, pattern9_0)?; - let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern9_1)?; - let expr2_0 = constructor_x64_paddw(ctx, expr0_0, &expr1_0)?; - let expr3_0 = constructor_output_xmm(ctx, expr2_0)?; - return Some(expr3_0); - } - &Opcode::Isub => { - let (pattern9_0, pattern9_1) = - C::unpack_value_array_2(ctx, pattern7_1); - // Rule at src/isa/x64/lower.isle line 244. - let expr0_0 = constructor_put_in_xmm(ctx, pattern9_0)?; - let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern9_1)?; - let expr2_0 = constructor_x64_psubw(ctx, expr0_0, &expr1_0)?; - let expr3_0 = constructor_output_xmm(ctx, expr2_0)?; - return Some(expr3_0); - } - &Opcode::Imul => { - let (pattern9_0, pattern9_1) = - C::unpack_value_array_2(ctx, pattern7_1); - if let Some(pattern10_0) = C::def_inst(ctx, pattern9_0) { - let pattern11_0 = C::inst_data(ctx, pattern10_0); - if let &InstructionData::Unary { - opcode: ref pattern12_0, - arg: pattern12_1, - } = &pattern11_0 - { - match pattern12_0 { - &Opcode::SwidenLow => { - let pattern14_0 = C::value_type(ctx, pattern12_1); - if let Some((pattern15_0, pattern15_1)) = - C::multi_lane(ctx, pattern14_0) - { - if pattern15_0 == 8 { - if pattern15_1 == 16 { - if let Some(pattern18_0) = - C::def_inst(ctx, pattern9_1) - { - let pattern19_0 = - C::inst_data(ctx, pattern18_0); - if let &InstructionData::Unary { - opcode: ref pattern20_0, - arg: pattern20_1, - } = &pattern19_0 - { - if let &Opcode::SwidenLow = - pattern20_0 - { - let pattern22_0 = - C::value_type( - ctx, - pattern20_1, - ); - if let Some(( - pattern23_0, - pattern23_1, - )) = C::multi_lane( - ctx, - pattern22_0, - ) { - if pattern23_0 == 8 { - if pattern23_1 == 16 - { - // Rule at src/isa/x64/lower.isle line 1080. - let expr0_0 = constructor_put_in_xmm_mem(ctx, pattern12_1)?; - let expr1_0 = constructor_x64_pmovsxbw(ctx, &expr0_0)?; - let expr2_0 = constructor_put_in_xmm_mem(ctx, pattern20_1)?; - let expr3_0 = constructor_x64_pmovsxbw(ctx, &expr2_0)?; - let expr4_0 = C::xmm_to_xmm_mem(ctx, expr3_0); - let expr5_0 = constructor_x64_pmullw(ctx, expr1_0, &expr4_0)?; - let expr6_0 = constructor_output_xmm(ctx, expr5_0)?; - return Some( - expr6_0, - ); - } - } - } - } - } - } - } - } - } - } - &Opcode::SwidenHigh => { - let pattern14_0 = C::value_type(ctx, pattern12_1); - if let Some((pattern15_0, pattern15_1)) = - C::multi_lane(ctx, pattern14_0) - { - if pattern15_0 == 8 { - if pattern15_1 == 16 { - if let Some(pattern18_0) = - C::def_inst(ctx, pattern9_1) - { - let pattern19_0 = - C::inst_data(ctx, pattern18_0); - if let &InstructionData::Unary { - opcode: ref pattern20_0, - arg: pattern20_1, - } = &pattern19_0 - { - if let &Opcode::SwidenHigh = - pattern20_0 - { - let pattern22_0 = - C::value_type( - ctx, - pattern20_1, - ); - if let Some(( - pattern23_0, - pattern23_1, - )) = C::multi_lane( - ctx, - pattern22_0, - ) { - if pattern23_0 == 8 { - if pattern23_1 == 16 - { - // Rule at src/isa/x64/lower.isle line 1040. - let expr0_0 = constructor_put_in_xmm(ctx, pattern12_1)?; - let expr1_0 = C::xmm_to_xmm_mem(ctx, expr0_0); - let expr2_0: u8 = 8; - let expr3_0 = OperandSize::Size32; - let expr4_0 = constructor_x64_palignr(ctx, expr0_0, &expr1_0, expr2_0, &expr3_0)?; - let expr5_0 = C::xmm_to_xmm_mem(ctx, expr4_0); - let expr6_0 = constructor_x64_pmovsxbw(ctx, &expr5_0)?; - let expr7_0 = constructor_put_in_xmm(ctx, pattern20_1)?; - let expr8_0 = C::xmm_to_xmm_mem(ctx, expr7_0); - let expr9_0: u8 = 8; - let expr10_0 = OperandSize::Size32; - let expr11_0 = constructor_x64_palignr(ctx, expr7_0, &expr8_0, expr9_0, &expr10_0)?; - let expr12_0 = C::xmm_to_xmm_mem(ctx, expr11_0); - let expr13_0 = constructor_x64_pmovsxbw(ctx, &expr12_0)?; - let expr14_0 = C::xmm_to_xmm_mem(ctx, expr13_0); - let expr15_0 = constructor_x64_pmullw(ctx, expr6_0, &expr14_0)?; - let expr16_0 = constructor_output_xmm(ctx, expr15_0)?; - return Some( - expr16_0, - ); - } - } - } - } - } - } - } - } - } - } - &Opcode::UwidenLow => { - let pattern14_0 = C::value_type(ctx, pattern12_1); - if let Some((pattern15_0, pattern15_1)) = - C::multi_lane(ctx, pattern14_0) - { - if pattern15_0 == 8 { - if pattern15_1 == 16 { - if let Some(pattern18_0) = - C::def_inst(ctx, pattern9_1) - { - let pattern19_0 = - C::inst_data(ctx, pattern18_0); - if let &InstructionData::Unary { - opcode: ref pattern20_0, - arg: pattern20_1, - } = &pattern19_0 - { - if let &Opcode::UwidenLow = - pattern20_0 - { - let pattern22_0 = - C::value_type( - ctx, - pattern20_1, - ); - if let Some(( - pattern23_0, - pattern23_1, - )) = C::multi_lane( - ctx, - pattern22_0, - ) { - if pattern23_0 == 8 { - if pattern23_1 == 16 - { - // Rule at src/isa/x64/lower.isle line 1156. - let expr0_0 = constructor_put_in_xmm_mem(ctx, pattern12_1)?; - let expr1_0 = constructor_x64_pmovzxbw(ctx, &expr0_0)?; - let expr2_0 = constructor_put_in_xmm_mem(ctx, pattern20_1)?; - let expr3_0 = constructor_x64_pmovzxbw(ctx, &expr2_0)?; - let expr4_0 = C::xmm_to_xmm_mem(ctx, expr3_0); - let expr5_0 = constructor_x64_pmullw(ctx, expr1_0, &expr4_0)?; - let expr6_0 = constructor_output_xmm(ctx, expr5_0)?; - return Some( - expr6_0, - ); - } - } - } - } - } - } - } - } - } - } - &Opcode::UwidenHigh => { - let pattern14_0 = C::value_type(ctx, pattern12_1); - if let Some((pattern15_0, pattern15_1)) = - C::multi_lane(ctx, pattern14_0) - { - if pattern15_0 == 8 { - if pattern15_1 == 16 { - if let Some(pattern18_0) = - C::def_inst(ctx, pattern9_1) - { - let pattern19_0 = - C::inst_data(ctx, pattern18_0); - if let &InstructionData::Unary { - opcode: ref pattern20_0, - arg: pattern20_1, - } = &pattern19_0 - { - if let &Opcode::UwidenHigh = - pattern20_0 - { - let pattern22_0 = - C::value_type( - ctx, - pattern20_1, - ); - if let Some(( - pattern23_0, - pattern23_1, - )) = C::multi_lane( - ctx, - pattern22_0, - ) { - if pattern23_0 == 8 { - if pattern23_1 == 16 - { - // Rule at src/isa/x64/lower.isle line 1116. - let expr0_0 = constructor_put_in_xmm(ctx, pattern12_1)?; - let expr1_0 = C::xmm_to_xmm_mem(ctx, expr0_0); - let expr2_0: u8 = 8; - let expr3_0 = OperandSize::Size32; - let expr4_0 = constructor_x64_palignr(ctx, expr0_0, &expr1_0, expr2_0, &expr3_0)?; - let expr5_0 = C::xmm_to_xmm_mem(ctx, expr4_0); - let expr6_0 = constructor_x64_pmovzxbw(ctx, &expr5_0)?; - let expr7_0 = constructor_put_in_xmm(ctx, pattern20_1)?; - let expr8_0 = C::xmm_to_xmm_mem(ctx, expr7_0); - let expr9_0: u8 = 8; - let expr10_0 = OperandSize::Size32; - let expr11_0 = constructor_x64_palignr(ctx, expr7_0, &expr8_0, expr9_0, &expr10_0)?; - let expr12_0 = C::xmm_to_xmm_mem(ctx, expr11_0); - let expr13_0 = constructor_x64_pmovzxbw(ctx, &expr12_0)?; - let expr14_0 = C::xmm_to_xmm_mem(ctx, expr13_0); - let expr15_0 = constructor_x64_pmullw(ctx, expr6_0, &expr14_0)?; - let expr16_0 = constructor_output_xmm(ctx, expr15_0)?; - return Some( - expr16_0, - ); - } - } - } - } - } - } - } - } - } - } - _ => {} - } - } - } - // Rule at src/isa/x64/lower.isle line 984. - let expr0_0 = constructor_put_in_xmm(ctx, pattern9_0)?; - let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern9_1)?; - let expr2_0 = constructor_x64_pmullw(ctx, expr0_0, &expr1_0)?; - let expr3_0 = constructor_output_xmm(ctx, expr2_0)?; - return Some(expr3_0); - } - _ => {} - } - } - } - } - if pattern3_0 == 32 { - if pattern3_1 == 4 { - let pattern6_0 = C::inst_data(ctx, pattern0_0); - if let &InstructionData::Binary { - opcode: ref pattern7_0, - args: ref pattern7_1, - } = &pattern6_0 - { - match pattern7_0 { - &Opcode::Iadd => { - let (pattern9_0, pattern9_1) = - C::unpack_value_array_2(ctx, pattern7_1); - // Rule at src/isa/x64/lower.isle line 102. - let expr0_0 = constructor_put_in_xmm(ctx, pattern9_0)?; - let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern9_1)?; - let expr2_0 = constructor_x64_paddd(ctx, expr0_0, &expr1_0)?; - let expr3_0 = constructor_output_xmm(ctx, expr2_0)?; - return Some(expr3_0); - } - &Opcode::Isub => { - let (pattern9_0, pattern9_1) = - C::unpack_value_array_2(ctx, pattern7_1); - // Rule at src/isa/x64/lower.isle line 248. - let expr0_0 = constructor_put_in_xmm(ctx, pattern9_0)?; - let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern9_1)?; - let expr2_0 = constructor_x64_psubd(ctx, expr0_0, &expr1_0)?; - let expr3_0 = constructor_output_xmm(ctx, expr2_0)?; - return Some(expr3_0); - } - &Opcode::Imul => { - let (pattern9_0, pattern9_1) = - C::unpack_value_array_2(ctx, pattern7_1); - if let Some(pattern10_0) = C::def_inst(ctx, pattern9_0) { - let pattern11_0 = C::inst_data(ctx, pattern10_0); - if let &InstructionData::Unary { - opcode: ref pattern12_0, - arg: pattern12_1, - } = &pattern11_0 - { - match pattern12_0 { - &Opcode::SwidenLow => { - let pattern14_0 = C::value_type(ctx, pattern12_1); - if let Some((pattern15_0, pattern15_1)) = - C::multi_lane(ctx, pattern14_0) - { - if pattern15_0 == 16 { - if pattern15_1 == 8 { - if let Some(pattern18_0) = - C::def_inst(ctx, pattern9_1) - { - let pattern19_0 = - C::inst_data(ctx, pattern18_0); - if let &InstructionData::Unary { - opcode: ref pattern20_0, - arg: pattern20_1, - } = &pattern19_0 - { - if let &Opcode::SwidenLow = - pattern20_0 - { - let pattern22_0 = - C::value_type( - ctx, - pattern20_1, - ); - if let Some(( - pattern23_0, - pattern23_1, - )) = C::multi_lane( - ctx, - pattern22_0, - ) { - if pattern23_0 == 16 { - if pattern23_1 == 8 - { - // Rule at src/isa/x64/lower.isle line 1090. - let expr0_0 = constructor_put_in_xmm(ctx, pattern12_1)?; - let expr1_0 = constructor_put_in_xmm(ctx, pattern20_1)?; - let expr2_0 = C::xmm_to_xmm_mem(ctx, expr1_0); - let expr3_0 = constructor_x64_pmullw(ctx, expr0_0, &expr2_0)?; - let expr4_0 = C::xmm_to_xmm_mem(ctx, expr1_0); - let expr5_0 = constructor_x64_pmulhw(ctx, expr0_0, &expr4_0)?; - let expr6_0 = C::xmm_to_xmm_mem(ctx, expr5_0); - let expr7_0 = constructor_x64_punpcklwd(ctx, expr3_0, &expr6_0)?; - let expr8_0 = constructor_output_xmm(ctx, expr7_0)?; - return Some( - expr8_0, - ); - } - } - } - } - } - } - } - } - } - } - &Opcode::SwidenHigh => { - let pattern14_0 = C::value_type(ctx, pattern12_1); - if let Some((pattern15_0, pattern15_1)) = - C::multi_lane(ctx, pattern14_0) - { - if pattern15_0 == 16 { - if pattern15_1 == 8 { - if let Some(pattern18_0) = - C::def_inst(ctx, pattern9_1) - { - let pattern19_0 = - C::inst_data(ctx, pattern18_0); - if let &InstructionData::Unary { - opcode: ref pattern20_0, - arg: pattern20_1, - } = &pattern19_0 - { - if let &Opcode::SwidenHigh = - pattern20_0 - { - let pattern22_0 = - C::value_type( - ctx, - pattern20_1, - ); - if let Some(( - pattern23_0, - pattern23_1, - )) = C::multi_lane( - ctx, - pattern22_0, - ) { - if pattern23_0 == 16 { - if pattern23_1 == 8 - { - // Rule at src/isa/x64/lower.isle line 1054. - let expr0_0 = constructor_put_in_xmm(ctx, pattern12_1)?; - let expr1_0 = constructor_put_in_xmm(ctx, pattern20_1)?; - let expr2_0 = C::xmm_to_xmm_mem(ctx, expr1_0); - let expr3_0 = constructor_x64_pmullw(ctx, expr0_0, &expr2_0)?; - let expr4_0 = C::xmm_to_xmm_mem(ctx, expr1_0); - let expr5_0 = constructor_x64_pmulhw(ctx, expr0_0, &expr4_0)?; - let expr6_0 = C::xmm_to_xmm_mem(ctx, expr5_0); - let expr7_0 = constructor_x64_punpckhwd(ctx, expr3_0, &expr6_0)?; - let expr8_0 = constructor_output_xmm(ctx, expr7_0)?; - return Some( - expr8_0, - ); - } - } - } - } - } - } - } - } - } - } - &Opcode::UwidenLow => { - let pattern14_0 = C::value_type(ctx, pattern12_1); - if let Some((pattern15_0, pattern15_1)) = - C::multi_lane(ctx, pattern14_0) - { - if pattern15_0 == 16 { - if pattern15_1 == 8 { - if let Some(pattern18_0) = - C::def_inst(ctx, pattern9_1) - { - let pattern19_0 = - C::inst_data(ctx, pattern18_0); - if let &InstructionData::Unary { - opcode: ref pattern20_0, - arg: pattern20_1, - } = &pattern19_0 - { - if let &Opcode::UwidenLow = - pattern20_0 - { - let pattern22_0 = - C::value_type( - ctx, - pattern20_1, - ); - if let Some(( - pattern23_0, - pattern23_1, - )) = C::multi_lane( - ctx, - pattern22_0, - ) { - if pattern23_0 == 16 { - if pattern23_1 == 8 - { - // Rule at src/isa/x64/lower.isle line 1166. - let expr0_0 = constructor_put_in_xmm(ctx, pattern12_1)?; - let expr1_0 = constructor_put_in_xmm(ctx, pattern20_1)?; - let expr2_0 = C::xmm_to_xmm_mem(ctx, expr1_0); - let expr3_0 = constructor_x64_pmullw(ctx, expr0_0, &expr2_0)?; - let expr4_0 = C::xmm_to_xmm_mem(ctx, expr1_0); - let expr5_0 = constructor_x64_pmulhuw(ctx, expr0_0, &expr4_0)?; - let expr6_0 = C::xmm_to_xmm_mem(ctx, expr5_0); - let expr7_0 = constructor_x64_punpcklwd(ctx, expr3_0, &expr6_0)?; - let expr8_0 = constructor_output_xmm(ctx, expr7_0)?; - return Some( - expr8_0, - ); - } - } - } - } - } - } - } - } - } - } - &Opcode::UwidenHigh => { - let pattern14_0 = C::value_type(ctx, pattern12_1); - if let Some((pattern15_0, pattern15_1)) = - C::multi_lane(ctx, pattern14_0) - { - if pattern15_0 == 16 { - if pattern15_1 == 8 { - if let Some(pattern18_0) = - C::def_inst(ctx, pattern9_1) - { - let pattern19_0 = - C::inst_data(ctx, pattern18_0); - if let &InstructionData::Unary { - opcode: ref pattern20_0, - arg: pattern20_1, - } = &pattern19_0 - { - if let &Opcode::UwidenHigh = - pattern20_0 - { - let pattern22_0 = - C::value_type( - ctx, - pattern20_1, - ); - if let Some(( - pattern23_0, - pattern23_1, - )) = C::multi_lane( - ctx, - pattern22_0, - ) { - if pattern23_0 == 16 { - if pattern23_1 == 8 - { - // Rule at src/isa/x64/lower.isle line 1130. - let expr0_0 = constructor_put_in_xmm(ctx, pattern12_1)?; - let expr1_0 = constructor_put_in_xmm(ctx, pattern20_1)?; - let expr2_0 = C::xmm_to_xmm_mem(ctx, expr1_0); - let expr3_0 = constructor_x64_pmullw(ctx, expr0_0, &expr2_0)?; - let expr4_0 = C::xmm_to_xmm_mem(ctx, expr1_0); - let expr5_0 = constructor_x64_pmulhuw(ctx, expr0_0, &expr4_0)?; - let expr6_0 = C::xmm_to_xmm_mem(ctx, expr5_0); - let expr7_0 = constructor_x64_punpckhwd(ctx, expr3_0, &expr6_0)?; - let expr8_0 = constructor_output_xmm(ctx, expr7_0)?; - return Some( - expr8_0, - ); - } - } - } - } - } - } - } - } - } - } - _ => {} - } - } - } - // Rule at src/isa/x64/lower.isle line 987. - let expr0_0 = constructor_put_in_xmm(ctx, pattern9_0)?; - let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern9_1)?; - let expr2_0 = constructor_x64_pmulld(ctx, expr0_0, &expr1_0)?; - let expr3_0 = constructor_output_xmm(ctx, expr2_0)?; - return Some(expr3_0); - } - _ => {} - } - } - } - } - if pattern3_0 == 64 { - if pattern3_1 == 2 { - let pattern6_0 = C::inst_data(ctx, pattern0_0); - if let &InstructionData::Binary { - opcode: ref pattern7_0, - args: ref pattern7_1, - } = &pattern6_0 - { - match pattern7_0 { - &Opcode::Iadd => { - let (pattern9_0, pattern9_1) = - C::unpack_value_array_2(ctx, pattern7_1); - // Rule at src/isa/x64/lower.isle line 106. - let expr0_0 = constructor_put_in_xmm(ctx, pattern9_0)?; - let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern9_1)?; - let expr2_0 = constructor_x64_paddq(ctx, expr0_0, &expr1_0)?; - let expr3_0 = constructor_output_xmm(ctx, expr2_0)?; - return Some(expr3_0); - } - &Opcode::Isub => { - let (pattern9_0, pattern9_1) = - C::unpack_value_array_2(ctx, pattern7_1); - // Rule at src/isa/x64/lower.isle line 252. - let expr0_0 = constructor_put_in_xmm(ctx, pattern9_0)?; - let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern9_1)?; - let expr2_0 = constructor_x64_psubq(ctx, expr0_0, &expr1_0)?; - let expr3_0 = constructor_output_xmm(ctx, expr2_0)?; - return Some(expr3_0); - } - &Opcode::Imul => { - let (pattern9_0, pattern9_1) = - C::unpack_value_array_2(ctx, pattern7_1); - if let Some(pattern10_0) = C::def_inst(ctx, pattern9_0) { - let pattern11_0 = C::inst_data(ctx, pattern10_0); - if let &InstructionData::Unary { - opcode: ref pattern12_0, - arg: pattern12_1, - } = &pattern11_0 - { - match pattern12_0 { - &Opcode::SwidenLow => { - let pattern14_0 = C::value_type(ctx, pattern12_1); - if let Some((pattern15_0, pattern15_1)) = - C::multi_lane(ctx, pattern14_0) - { - if pattern15_0 == 32 { - if pattern15_1 == 4 { - if let Some(pattern18_0) = - C::def_inst(ctx, pattern9_1) - { - let pattern19_0 = - C::inst_data(ctx, pattern18_0); - if let &InstructionData::Unary { - opcode: ref pattern20_0, - arg: pattern20_1, - } = &pattern19_0 - { - if let &Opcode::SwidenLow = - pattern20_0 - { - let pattern22_0 = - C::value_type( - ctx, - pattern20_1, - ); - if let Some(( - pattern23_0, - pattern23_1, - )) = C::multi_lane( - ctx, - pattern22_0, - ) { - if pattern23_0 == 32 { - if pattern23_1 == 4 - { - // Rule at src/isa/x64/lower.isle line 1102. - let expr0_0 = constructor_put_in_xmm_mem(ctx, pattern12_1)?; - let expr1_0: u8 = 80; - let expr2_0 = OperandSize::Size32; - let expr3_0 = constructor_x64_pshufd(ctx, &expr0_0, expr1_0, &expr2_0)?; - let expr4_0 = constructor_put_in_xmm_mem(ctx, pattern20_1)?; - let expr5_0: u8 = 80; - let expr6_0 = OperandSize::Size32; - let expr7_0 = constructor_x64_pshufd(ctx, &expr4_0, expr5_0, &expr6_0)?; - let expr8_0 = C::xmm_to_xmm_mem(ctx, expr7_0); - let expr9_0 = constructor_x64_pmuldq(ctx, expr3_0, &expr8_0)?; - let expr10_0 = constructor_output_xmm(ctx, expr9_0)?; - return Some( - expr10_0, - ); - } - } - } - } - } - } - } - } - } - } - &Opcode::SwidenHigh => { - let pattern14_0 = C::value_type(ctx, pattern12_1); - if let Some((pattern15_0, pattern15_1)) = - C::multi_lane(ctx, pattern14_0) - { - if pattern15_0 == 32 { - if pattern15_1 == 4 { - if let Some(pattern18_0) = - C::def_inst(ctx, pattern9_1) - { - let pattern19_0 = - C::inst_data(ctx, pattern18_0); - if let &InstructionData::Unary { - opcode: ref pattern20_0, - arg: pattern20_1, - } = &pattern19_0 - { - if let &Opcode::SwidenHigh = - pattern20_0 - { - let pattern22_0 = - C::value_type( - ctx, - pattern20_1, - ); - if let Some(( - pattern23_0, - pattern23_1, - )) = C::multi_lane( - ctx, - pattern22_0, - ) { - if pattern23_0 == 32 { - if pattern23_1 == 4 - { - // Rule at src/isa/x64/lower.isle line 1066. - let expr0_0 = constructor_put_in_xmm_mem(ctx, pattern12_1)?; - let expr1_0: u8 = 250; - let expr2_0 = OperandSize::Size32; - let expr3_0 = constructor_x64_pshufd(ctx, &expr0_0, expr1_0, &expr2_0)?; - let expr4_0 = constructor_put_in_xmm_mem(ctx, pattern20_1)?; - let expr5_0: u8 = 250; - let expr6_0 = OperandSize::Size32; - let expr7_0 = constructor_x64_pshufd(ctx, &expr4_0, expr5_0, &expr6_0)?; - let expr8_0 = C::xmm_to_xmm_mem(ctx, expr7_0); - let expr9_0 = constructor_x64_pmuldq(ctx, expr3_0, &expr8_0)?; - let expr10_0 = constructor_output_xmm(ctx, expr9_0)?; - return Some( - expr10_0, - ); - } - } - } - } - } - } - } - } - } - } - &Opcode::UwidenLow => { - let pattern14_0 = C::value_type(ctx, pattern12_1); - if let Some((pattern15_0, pattern15_1)) = - C::multi_lane(ctx, pattern14_0) - { - if pattern15_0 == 32 { - if pattern15_1 == 4 { - if let Some(pattern18_0) = - C::def_inst(ctx, pattern9_1) - { - let pattern19_0 = - C::inst_data(ctx, pattern18_0); - if let &InstructionData::Unary { - opcode: ref pattern20_0, - arg: pattern20_1, - } = &pattern19_0 - { - if let &Opcode::UwidenLow = - pattern20_0 - { - let pattern22_0 = - C::value_type( - ctx, - pattern20_1, - ); - if let Some(( - pattern23_0, - pattern23_1, - )) = C::multi_lane( - ctx, - pattern22_0, - ) { - if pattern23_0 == 32 { - if pattern23_1 == 4 - { - // Rule at src/isa/x64/lower.isle line 1178. - let expr0_0 = constructor_put_in_xmm_mem(ctx, pattern12_1)?; - let expr1_0: u8 = 80; - let expr2_0 = OperandSize::Size32; - let expr3_0 = constructor_x64_pshufd(ctx, &expr0_0, expr1_0, &expr2_0)?; - let expr4_0 = constructor_put_in_xmm_mem(ctx, pattern20_1)?; - let expr5_0: u8 = 80; - let expr6_0 = OperandSize::Size32; - let expr7_0 = constructor_x64_pshufd(ctx, &expr4_0, expr5_0, &expr6_0)?; - let expr8_0 = C::xmm_to_xmm_mem(ctx, expr7_0); - let expr9_0 = constructor_x64_pmuludq(ctx, expr3_0, &expr8_0)?; - let expr10_0 = constructor_output_xmm(ctx, expr9_0)?; - return Some( - expr10_0, - ); - } - } - } - } - } - } - } - } - } - } - &Opcode::UwidenHigh => { - let pattern14_0 = C::value_type(ctx, pattern12_1); - if let Some((pattern15_0, pattern15_1)) = - C::multi_lane(ctx, pattern14_0) - { - if pattern15_0 == 32 { - if pattern15_1 == 4 { - if let Some(pattern18_0) = - C::def_inst(ctx, pattern9_1) - { - let pattern19_0 = - C::inst_data(ctx, pattern18_0); - if let &InstructionData::Unary { - opcode: ref pattern20_0, - arg: pattern20_1, - } = &pattern19_0 - { - if let &Opcode::UwidenHigh = - pattern20_0 - { - let pattern22_0 = - C::value_type( - ctx, - pattern20_1, - ); - if let Some(( - pattern23_0, - pattern23_1, - )) = C::multi_lane( - ctx, - pattern22_0, - ) { - if pattern23_0 == 32 { - if pattern23_1 == 4 - { - // Rule at src/isa/x64/lower.isle line 1142. - let expr0_0 = constructor_put_in_xmm_mem(ctx, pattern12_1)?; - let expr1_0: u8 = 250; - let expr2_0 = OperandSize::Size32; - let expr3_0 = constructor_x64_pshufd(ctx, &expr0_0, expr1_0, &expr2_0)?; - let expr4_0 = constructor_put_in_xmm_mem(ctx, pattern20_1)?; - let expr5_0: u8 = 250; - let expr6_0 = OperandSize::Size32; - let expr7_0 = constructor_x64_pshufd(ctx, &expr4_0, expr5_0, &expr6_0)?; - let expr8_0 = C::xmm_to_xmm_mem(ctx, expr7_0); - let expr9_0 = constructor_x64_pmuludq(ctx, expr3_0, &expr8_0)?; - let expr10_0 = constructor_output_xmm(ctx, expr9_0)?; - return Some( - expr10_0, - ); - } - } - } - } - } - } - } - } - } - } - _ => {} - } - } - } - // Rule at src/isa/x64/lower.isle line 1018. - let expr0_0 = constructor_put_in_xmm(ctx, pattern9_0)?; - let expr1_0 = constructor_put_in_xmm(ctx, pattern9_1)?; - let expr2_0: u32 = 32; - let expr3_0 = RegMemImm::Imm { simm32: expr2_0 }; - let expr4_0 = constructor_mov_rmi_to_xmm(ctx, &expr3_0)?; - let expr5_0 = constructor_x64_psrlq(ctx, expr0_0, &expr4_0)?; - let expr6_0 = C::xmm_to_xmm_mem(ctx, expr1_0); - let expr7_0 = constructor_x64_pmuludq(ctx, expr5_0, &expr6_0)?; - let expr8_0: u32 = 32; - let expr9_0 = RegMemImm::Imm { simm32: expr8_0 }; - let expr10_0 = constructor_mov_rmi_to_xmm(ctx, &expr9_0)?; - let expr11_0 = constructor_x64_psrlq(ctx, expr1_0, &expr10_0)?; - let expr12_0 = C::xmm_to_xmm_mem(ctx, expr11_0); - let expr13_0 = constructor_x64_pmuludq(ctx, expr0_0, &expr12_0)?; - let expr14_0 = C::xmm_to_xmm_mem(ctx, expr13_0); - let expr15_0 = constructor_x64_paddq(ctx, expr7_0, &expr14_0)?; - let expr16_0: u32 = 32; - let expr17_0 = RegMemImm::Imm { simm32: expr16_0 }; - let expr18_0 = constructor_mov_rmi_to_xmm(ctx, &expr17_0)?; - let expr19_0 = constructor_x64_psllq(ctx, expr15_0, &expr18_0)?; - let expr20_0 = C::xmm_to_xmm_mem(ctx, expr1_0); - let expr21_0 = constructor_x64_pmuludq(ctx, expr0_0, &expr20_0)?; - let expr22_0 = C::xmm_to_xmm_mem(ctx, expr19_0); - let expr23_0 = constructor_x64_paddq(ctx, expr21_0, &expr22_0)?; - let expr24_0 = constructor_output_xmm(ctx, expr23_0)?; - return Some(expr24_0); - } - _ => {} - } - } - } - } - let pattern4_0 = C::inst_data(ctx, pattern0_0); - match &pattern4_0 { - &InstructionData::Binary { - opcode: ref pattern5_0, - args: ref pattern5_1, - } => { - match pattern5_0 { - &Opcode::Band => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/x64/lower.isle line 328. - let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?; - let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?; - let expr2_0 = constructor_sse_and(ctx, pattern2_0, expr0_0, &expr1_0)?; - let expr3_0 = constructor_output_xmm(ctx, expr2_0)?; - return Some(expr3_0); - } - &Opcode::Bor => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/x64/lower.isle line 392. - let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?; - let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?; - let expr2_0 = constructor_sse_or(ctx, pattern2_0, expr0_0, &expr1_0)?; - let expr3_0 = constructor_output_xmm(ctx, expr2_0)?; - return Some(expr3_0); - } - &Opcode::Bxor => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/x64/lower.isle line 453. - let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?; - let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?; - let expr2_0 = constructor_sse_xor(ctx, pattern2_0, expr0_0, &expr1_0)?; - let expr3_0 = constructor_output_xmm(ctx, expr2_0)?; - return Some(expr3_0); - } - _ => {} - } - } - &InstructionData::Ternary { - opcode: ref pattern5_0, - args: ref pattern5_1, - } => { - match pattern5_0 { - &Opcode::Bitselect => { - let (pattern7_0, pattern7_1, pattern7_2) = - C::unpack_value_array_3(ctx, pattern5_1); - // Rule at src/isa/x64/lower.isle line 1279. - let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?; - let expr1_0 = constructor_put_in_xmm(ctx, pattern7_1)?; - let expr2_0 = C::xmm_to_xmm_mem(ctx, expr0_0); - let expr3_0 = constructor_sse_and(ctx, pattern2_0, expr1_0, &expr2_0)?; - let expr4_0 = constructor_put_in_xmm_mem(ctx, pattern7_2)?; - let expr5_0 = - constructor_sse_and_not(ctx, pattern2_0, expr0_0, &expr4_0)?; - let expr6_0 = C::xmm_to_xmm_mem(ctx, expr3_0); - let expr7_0 = constructor_sse_or(ctx, pattern2_0, expr5_0, &expr6_0)?; - let expr8_0 = constructor_output_xmm(ctx, expr7_0)?; - return Some(expr8_0); - } - &Opcode::Vselect => { - let (pattern7_0, pattern7_1, pattern7_2) = - C::unpack_value_array_3(ctx, pattern5_1); - // Rule at src/isa/x64/lower.isle line 1293. - let expr0_0 = constructor_put_in_xmm_mem(ctx, pattern7_0)?; - let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?; - let expr2_0 = constructor_put_in_xmm(ctx, pattern7_2)?; - let expr3_0 = constructor_x64_blend( - ctx, pattern2_0, &expr0_0, &expr1_0, expr2_0, - )?; - let expr4_0 = constructor_output_xmm(ctx, expr3_0)?; - return Some(expr4_0); - } - _ => {} - } - } - &InstructionData::Unary { - opcode: ref pattern5_0, - arg: pattern5_1, - } => { - if let &Opcode::Bnot = pattern5_0 { - // Rule at src/isa/x64/lower.isle line 1274. - let expr0_0 = constructor_put_in_xmm(ctx, pattern5_1)?; - let expr1_0 = constructor_vector_all_ones(ctx, pattern2_0)?; - let expr2_0 = C::xmm_to_xmm_mem(ctx, expr1_0); - let expr3_0 = constructor_sse_xor(ctx, pattern2_0, expr0_0, &expr2_0)?; - let expr4_0 = constructor_output_xmm(ctx, expr3_0)?; - return Some(expr4_0); - } - } - _ => {} - } - } - if let Some(pattern3_0) = C::fits_in_32(ctx, pattern2_0) { - let pattern4_0 = C::inst_data(ctx, pattern0_0); - if let &InstructionData::Unary { - opcode: ref pattern5_0, - arg: pattern5_1, - } = &pattern4_0 - { - if let &Opcode::Uextend = pattern5_0 { - let pattern7_0 = C::value_type(ctx, pattern5_1); - if let Some(pattern8_0) = C::fits_in_32(ctx, pattern7_0) { - // Rule at src/isa/x64/lower.isle line 2130. - let expr0_0: Type = I32; - let expr1_0 = ExtendKind::Zero; - let expr2_0 = - constructor_extend_to_gpr(ctx, pattern5_1, expr0_0, &expr1_0)?; - let expr3_0 = constructor_output_gpr(ctx, expr2_0)?; - return Some(expr3_0); - } - } - } - if let Some(pattern4_0) = C::is_gpr_type(ctx, pattern2_0) { - let pattern5_0 = C::inst_data(ctx, pattern0_0); - if let &InstructionData::Load { - opcode: ref pattern6_0, - arg: pattern6_1, - flags: pattern6_2, - offset: pattern6_3, - } = &pattern5_0 - { - if let &Opcode::Load = pattern6_0 { - // Rule at src/isa/x64/lower.isle line 2520. - let expr0_0 = C::ty_bits_u16(ctx, pattern3_0); - let expr1_0: u16 = 64; - let expr2_0 = C::ext_mode(ctx, expr0_0, expr1_0); - let expr3_0 = - constructor_to_amode(ctx, pattern6_2, pattern6_1, pattern6_3)?; - let expr4_0 = constructor_amode_to_gpr_mem(ctx, &expr3_0)?; - let expr5_0 = constructor_x64_movzx(ctx, &expr2_0, &expr4_0)?; - let expr6_0 = constructor_output_gpr(ctx, expr5_0)?; - return Some(expr6_0); - } - } - } - } - if let Some(pattern3_0) = C::fits_in_64(ctx, pattern2_0) { - let pattern4_0 = C::inst_data(ctx, pattern0_0); - match &pattern4_0 { - &InstructionData::UnaryImm { - opcode: ref pattern5_0, - imm: pattern5_1, - } => { - if let &Opcode::Iconst = pattern5_0 { - let pattern7_0 = C::u64_from_imm64(ctx, pattern5_1); - // Rule at src/isa/x64/lower.isle line 10. - let expr0_0 = constructor_imm(ctx, pattern3_0, pattern7_0)?; - let expr1_0 = constructor_output_reg(ctx, expr0_0)?; - return Some(expr1_0); - } - } - &InstructionData::UnaryBool { - opcode: ref pattern5_0, - imm: pattern5_1, - } => { - if let &Opcode::Bconst = pattern5_0 { - if pattern5_1 == true { - // Rule at src/isa/x64/lower.isle line 28. - let expr0_0: u64 = 1; - let expr1_0 = constructor_imm(ctx, pattern3_0, expr0_0)?; - let expr2_0 = constructor_output_reg(ctx, expr1_0)?; - return Some(expr2_0); - } - if pattern5_1 == false { - // Rule at src/isa/x64/lower.isle line 24. - let expr0_0: u64 = 0; - let expr1_0 = constructor_imm(ctx, pattern3_0, expr0_0)?; - let expr2_0 = constructor_output_reg(ctx, expr1_0)?; - return Some(expr2_0); - } - } - } - &InstructionData::Binary { - opcode: ref pattern5_0, - args: ref pattern5_1, - } => { - match pattern5_0 { - &Opcode::Imin => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/x64/lower.isle line 1386. - let expr0_0 = CC::L; - let expr1_0 = constructor_cmp_and_choose( - ctx, pattern3_0, &expr0_0, pattern7_0, pattern7_1, - )?; - let expr2_0 = C::output(ctx, expr1_0); - return Some(expr2_0); - } - &Opcode::Umin => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/x64/lower.isle line 1380. - let expr0_0 = CC::B; - let expr1_0 = constructor_cmp_and_choose( - ctx, pattern3_0, &expr0_0, pattern7_0, pattern7_1, - )?; - let expr2_0 = C::output(ctx, expr1_0); - return Some(expr2_0); - } - &Opcode::Imax => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/x64/lower.isle line 1389. - let expr0_0 = CC::NL; - let expr1_0 = constructor_cmp_and_choose( - ctx, pattern3_0, &expr0_0, pattern7_0, pattern7_1, - )?; - let expr2_0 = C::output(ctx, expr1_0); - return Some(expr2_0); - } - &Opcode::Umax => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/x64/lower.isle line 1383. - let expr0_0 = CC::NB; - let expr1_0 = constructor_cmp_and_choose( - ctx, pattern3_0, &expr0_0, pattern7_0, pattern7_1, - )?; - let expr2_0 = C::output(ctx, expr1_0); - return Some(expr2_0); - } - &Opcode::Iadd => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - if let Some(pattern8_0) = C::simm32_from_value(ctx, pattern7_0) { - // Rule at src/isa/x64/lower.isle line 74. - let expr0_0 = constructor_put_in_gpr(ctx, pattern7_1)?; - let expr1_0 = - constructor_x64_add(ctx, pattern3_0, expr0_0, &pattern8_0)?; - let expr2_0 = constructor_output_gpr(ctx, expr1_0)?; - return Some(expr2_0); - } - if let Some(pattern8_0) = C::sinkable_load(ctx, pattern7_0) { - // Rule at src/isa/x64/lower.isle line 86. - let expr0_0 = constructor_put_in_gpr(ctx, pattern7_1)?; - let expr1_0 = - constructor_sink_load_to_gpr_mem_imm(ctx, &pattern8_0)?; - let expr2_0 = - constructor_x64_add(ctx, pattern3_0, expr0_0, &expr1_0)?; - let expr3_0 = constructor_output_gpr(ctx, expr2_0)?; - return Some(expr3_0); - } - if let Some(pattern8_0) = C::simm32_from_value(ctx, pattern7_1) { - // Rule at src/isa/x64/lower.isle line 70. - let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?; - let expr1_0 = - constructor_x64_add(ctx, pattern3_0, expr0_0, &pattern8_0)?; - let expr2_0 = constructor_output_gpr(ctx, expr1_0)?; - return Some(expr2_0); - } - if let Some(pattern8_0) = C::sinkable_load(ctx, pattern7_1) { - // Rule at src/isa/x64/lower.isle line 80. - let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?; - let expr1_0 = - constructor_sink_load_to_gpr_mem_imm(ctx, &pattern8_0)?; - let expr2_0 = - constructor_x64_add(ctx, pattern3_0, expr0_0, &expr1_0)?; - let expr3_0 = constructor_output_gpr(ctx, expr2_0)?; - return Some(expr3_0); - } - // Rule at src/isa/x64/lower.isle line 64. - let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?; - let expr1_0 = constructor_put_in_gpr_mem_imm(ctx, pattern7_1)?; - let expr2_0 = constructor_x64_add(ctx, pattern3_0, expr0_0, &expr1_0)?; - let expr3_0 = constructor_output_gpr(ctx, expr2_0)?; - return Some(expr3_0); - } - &Opcode::Isub => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - if let Some(pattern8_0) = C::simm32_from_value(ctx, pattern7_1) { - // Rule at src/isa/x64/lower.isle line 228. - let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?; - let expr1_0 = - constructor_x64_sub(ctx, pattern3_0, expr0_0, &pattern8_0)?; - let expr2_0 = constructor_output_gpr(ctx, expr1_0)?; - return Some(expr2_0); - } - if let Some(pattern8_0) = C::sinkable_load(ctx, pattern7_1) { - // Rule at src/isa/x64/lower.isle line 233. - let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?; - let expr1_0 = - constructor_sink_load_to_gpr_mem_imm(ctx, &pattern8_0)?; - let expr2_0 = - constructor_x64_sub(ctx, pattern3_0, expr0_0, &expr1_0)?; - let expr3_0 = constructor_output_gpr(ctx, expr2_0)?; - return Some(expr3_0); - } - // Rule at src/isa/x64/lower.isle line 223. - let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?; - let expr1_0 = constructor_put_in_gpr_mem_imm(ctx, pattern7_1)?; - let expr2_0 = constructor_x64_sub(ctx, pattern3_0, expr0_0, &expr1_0)?; - let expr3_0 = constructor_output_gpr(ctx, expr2_0)?; - return Some(expr3_0); - } - &Opcode::Imul => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - if let Some(pattern8_0) = C::simm32_from_value(ctx, pattern7_0) { - // Rule at src/isa/x64/lower.isle line 925. - let expr0_0 = constructor_put_in_gpr(ctx, pattern7_1)?; - let expr1_0 = - constructor_x64_mul(ctx, pattern3_0, expr0_0, &pattern8_0)?; - let expr2_0 = constructor_output_gpr(ctx, expr1_0)?; - return Some(expr2_0); - } - if let Some(pattern8_0) = C::sinkable_load(ctx, pattern7_0) { - // Rule at src/isa/x64/lower.isle line 937. - let expr0_0 = constructor_put_in_gpr(ctx, pattern7_1)?; - let expr1_0 = - constructor_sink_load_to_gpr_mem_imm(ctx, &pattern8_0)?; - let expr2_0 = - constructor_x64_mul(ctx, pattern3_0, expr0_0, &expr1_0)?; - let expr3_0 = constructor_output_gpr(ctx, expr2_0)?; - return Some(expr3_0); - } - if let Some(pattern8_0) = C::simm32_from_value(ctx, pattern7_1) { - // Rule at src/isa/x64/lower.isle line 921. - let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?; - let expr1_0 = - constructor_x64_mul(ctx, pattern3_0, expr0_0, &pattern8_0)?; - let expr2_0 = constructor_output_gpr(ctx, expr1_0)?; - return Some(expr2_0); - } - if let Some(pattern8_0) = C::sinkable_load(ctx, pattern7_1) { - // Rule at src/isa/x64/lower.isle line 931. - let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?; - let expr1_0 = - constructor_sink_load_to_gpr_mem_imm(ctx, &pattern8_0)?; - let expr2_0 = - constructor_x64_mul(ctx, pattern3_0, expr0_0, &expr1_0)?; - let expr3_0 = constructor_output_gpr(ctx, expr2_0)?; - return Some(expr3_0); - } - // Rule at src/isa/x64/lower.isle line 916. - let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?; - let expr1_0 = constructor_put_in_gpr_mem_imm(ctx, pattern7_1)?; - let expr2_0 = constructor_x64_mul(ctx, pattern3_0, expr0_0, &expr1_0)?; - let expr3_0 = constructor_output_gpr(ctx, expr2_0)?; - return Some(expr3_0); - } - &Opcode::IaddIfcout => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - if let Some(pattern8_0) = C::simm32_from_value(ctx, pattern7_0) { - // Rule at src/isa/x64/lower.isle line 171. - let expr0_0 = constructor_put_in_gpr(ctx, pattern7_1)?; - let expr1_0 = - constructor_x64_add(ctx, pattern3_0, expr0_0, &pattern8_0)?; - let expr2_0 = C::gpr_to_reg(ctx, expr1_0); - let expr3_0 = constructor_output_ifcout(ctx, expr2_0)?; - return Some(expr3_0); - } - if let Some(pattern8_0) = C::sinkable_load(ctx, pattern7_0) { - // Rule at src/isa/x64/lower.isle line 181. - let expr0_0 = constructor_put_in_gpr(ctx, pattern7_1)?; - let expr1_0 = - constructor_sink_load_to_gpr_mem_imm(ctx, &pattern8_0)?; - let expr2_0 = - constructor_x64_add(ctx, pattern3_0, expr0_0, &expr1_0)?; - let expr3_0 = C::gpr_to_reg(ctx, expr2_0); - let expr4_0 = constructor_output_ifcout(ctx, expr3_0)?; - return Some(expr4_0); - } - if let Some(pattern8_0) = C::simm32_from_value(ctx, pattern7_1) { - // Rule at src/isa/x64/lower.isle line 167. - let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?; - let expr1_0 = - constructor_x64_add(ctx, pattern3_0, expr0_0, &pattern8_0)?; - let expr2_0 = C::gpr_to_reg(ctx, expr1_0); - let expr3_0 = constructor_output_ifcout(ctx, expr2_0)?; - return Some(expr3_0); - } - if let Some(pattern8_0) = C::sinkable_load(ctx, pattern7_1) { - // Rule at src/isa/x64/lower.isle line 177. - let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?; - let expr1_0 = - constructor_sink_load_to_gpr_mem_imm(ctx, &pattern8_0)?; - let expr2_0 = - constructor_x64_add(ctx, pattern3_0, expr0_0, &expr1_0)?; - let expr3_0 = C::gpr_to_reg(ctx, expr2_0); - let expr4_0 = constructor_output_ifcout(ctx, expr3_0)?; - return Some(expr4_0); - } - // Rule at src/isa/x64/lower.isle line 161. - let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?; - let expr1_0 = constructor_put_in_gpr_mem_imm(ctx, pattern7_1)?; - let expr2_0 = constructor_x64_add(ctx, pattern3_0, expr0_0, &expr1_0)?; - let expr3_0 = C::gpr_to_reg(ctx, expr2_0); - let expr4_0 = constructor_output_ifcout(ctx, expr3_0)?; - return Some(expr4_0); - } - &Opcode::Band => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - if let Some(pattern8_0) = C::simm32_from_value(ctx, pattern7_0) { - // Rule at src/isa/x64/lower.isle line 317. - let expr0_0 = constructor_put_in_gpr(ctx, pattern7_1)?; - let expr1_0 = - constructor_x64_and(ctx, pattern3_0, expr0_0, &pattern8_0)?; - let expr2_0 = constructor_output_gpr(ctx, expr1_0)?; - return Some(expr2_0); - } - if let Some(pattern8_0) = C::sinkable_load(ctx, pattern7_0) { - // Rule at src/isa/x64/lower.isle line 305. - let expr0_0 = constructor_put_in_gpr(ctx, pattern7_1)?; - let expr1_0 = - constructor_sink_load_to_gpr_mem_imm(ctx, &pattern8_0)?; - let expr2_0 = - constructor_x64_and(ctx, pattern3_0, expr0_0, &expr1_0)?; - let expr3_0 = constructor_output_gpr(ctx, expr2_0)?; - return Some(expr3_0); - } - if let Some(pattern8_0) = C::simm32_from_value(ctx, pattern7_1) { - // Rule at src/isa/x64/lower.isle line 313. - let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?; - let expr1_0 = - constructor_x64_and(ctx, pattern3_0, expr0_0, &pattern8_0)?; - let expr2_0 = constructor_output_gpr(ctx, expr1_0)?; - return Some(expr2_0); - } - if let Some(pattern8_0) = C::sinkable_load(ctx, pattern7_1) { - // Rule at src/isa/x64/lower.isle line 300. - let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?; - let expr1_0 = - constructor_sink_load_to_gpr_mem_imm(ctx, &pattern8_0)?; - let expr2_0 = - constructor_x64_and(ctx, pattern3_0, expr0_0, &expr1_0)?; - let expr3_0 = constructor_output_gpr(ctx, expr2_0)?; - return Some(expr3_0); - } - // Rule at src/isa/x64/lower.isle line 295. - let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?; - let expr1_0 = constructor_put_in_gpr_mem_imm(ctx, pattern7_1)?; - let expr2_0 = constructor_x64_and(ctx, pattern3_0, expr0_0, &expr1_0)?; - let expr3_0 = constructor_output_gpr(ctx, expr2_0)?; - return Some(expr3_0); - } - &Opcode::Bor => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - if let Some(pattern8_0) = C::simm32_from_value(ctx, pattern7_0) { - // Rule at src/isa/x64/lower.isle line 381. - let expr0_0 = constructor_put_in_gpr(ctx, pattern7_1)?; - let expr1_0 = - constructor_x64_or(ctx, pattern3_0, expr0_0, &pattern8_0)?; - let expr2_0 = constructor_output_gpr(ctx, expr1_0)?; - return Some(expr2_0); - } - if let Some(pattern8_0) = C::sinkable_load(ctx, pattern7_0) { - // Rule at src/isa/x64/lower.isle line 370. - let expr0_0 = constructor_put_in_gpr(ctx, pattern7_1)?; - let expr1_0 = - constructor_sink_load_to_gpr_mem_imm(ctx, &pattern8_0)?; - let expr2_0 = - constructor_x64_or(ctx, pattern3_0, expr0_0, &expr1_0)?; - let expr3_0 = constructor_output_gpr(ctx, expr2_0)?; - return Some(expr3_0); - } - if let Some(pattern8_0) = C::simm32_from_value(ctx, pattern7_1) { - // Rule at src/isa/x64/lower.isle line 377. - let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?; - let expr1_0 = - constructor_x64_or(ctx, pattern3_0, expr0_0, &pattern8_0)?; - let expr2_0 = constructor_output_gpr(ctx, expr1_0)?; - return Some(expr2_0); - } - if let Some(pattern8_0) = C::sinkable_load(ctx, pattern7_1) { - // Rule at src/isa/x64/lower.isle line 365. - let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?; - let expr1_0 = - constructor_sink_load_to_gpr_mem_imm(ctx, &pattern8_0)?; - let expr2_0 = - constructor_x64_or(ctx, pattern3_0, expr0_0, &expr1_0)?; - let expr3_0 = constructor_output_gpr(ctx, expr2_0)?; - return Some(expr3_0); - } - // Rule at src/isa/x64/lower.isle line 360. - let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?; - let expr1_0 = constructor_put_in_gpr_mem_imm(ctx, pattern7_1)?; - let expr2_0 = constructor_x64_or(ctx, pattern3_0, expr0_0, &expr1_0)?; - let expr3_0 = constructor_output_gpr(ctx, expr2_0)?; - return Some(expr3_0); - } - &Opcode::Bxor => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - if let Some(pattern8_0) = C::simm32_from_value(ctx, pattern7_0) { - // Rule at src/isa/x64/lower.isle line 447. - let expr0_0 = constructor_put_in_gpr(ctx, pattern7_1)?; - let expr1_0 = - constructor_x64_xor(ctx, pattern3_0, expr0_0, &pattern8_0)?; - let expr2_0 = constructor_output_gpr(ctx, expr1_0)?; - return Some(expr2_0); - } - if let Some(pattern8_0) = C::sinkable_load(ctx, pattern7_0) { - // Rule at src/isa/x64/lower.isle line 436. - let expr0_0 = constructor_put_in_gpr(ctx, pattern7_1)?; - let expr1_0 = - constructor_sink_load_to_gpr_mem_imm(ctx, &pattern8_0)?; - let expr2_0 = - constructor_x64_xor(ctx, pattern3_0, expr0_0, &expr1_0)?; - let expr3_0 = constructor_output_gpr(ctx, expr2_0)?; - return Some(expr3_0); - } - if let Some(pattern8_0) = C::simm32_from_value(ctx, pattern7_1) { - // Rule at src/isa/x64/lower.isle line 443. - let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?; - let expr1_0 = - constructor_x64_xor(ctx, pattern3_0, expr0_0, &pattern8_0)?; - let expr2_0 = constructor_output_gpr(ctx, expr1_0)?; - return Some(expr2_0); - } - if let Some(pattern8_0) = C::sinkable_load(ctx, pattern7_1) { - // Rule at src/isa/x64/lower.isle line 431. - let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?; - let expr1_0 = - constructor_sink_load_to_gpr_mem_imm(ctx, &pattern8_0)?; - let expr2_0 = - constructor_x64_xor(ctx, pattern3_0, expr0_0, &expr1_0)?; - let expr3_0 = constructor_output_gpr(ctx, expr2_0)?; - return Some(expr3_0); - } - // Rule at src/isa/x64/lower.isle line 426. - let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?; - let expr1_0 = constructor_put_in_gpr_mem_imm(ctx, pattern7_1)?; - let expr2_0 = constructor_x64_xor(ctx, pattern3_0, expr0_0, &expr1_0)?; - let expr3_0 = constructor_output_gpr(ctx, expr2_0)?; - return Some(expr3_0); - } - &Opcode::Ishl => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/x64/lower.isle line 483. - let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?; - let expr1_0 = C::put_masked_in_imm8_gpr(ctx, pattern7_1, pattern3_0); - let expr2_0 = constructor_x64_shl(ctx, pattern3_0, expr0_0, &expr1_0)?; - let expr3_0 = constructor_output_gpr(ctx, expr2_0)?; - return Some(expr3_0); - } - &Opcode::Ushr => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/x64/lower.isle line 589. - let expr0_0 = ExtendKind::Zero; - let expr1_0 = - constructor_extend_to_gpr(ctx, pattern7_0, pattern3_0, &expr0_0)?; - let expr2_0 = C::put_masked_in_imm8_gpr(ctx, pattern7_1, pattern3_0); - let expr3_0 = constructor_x64_shr(ctx, pattern3_0, expr1_0, &expr2_0)?; - let expr4_0 = constructor_output_gpr(ctx, expr3_0)?; - return Some(expr4_0); - } - &Opcode::Sshr => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - // Rule at src/isa/x64/lower.isle line 691. - let expr0_0 = ExtendKind::Sign; - let expr1_0 = - constructor_extend_to_gpr(ctx, pattern7_0, pattern3_0, &expr0_0)?; - let expr2_0 = C::put_masked_in_imm8_gpr(ctx, pattern7_1, pattern3_0); - let expr3_0 = constructor_x64_sar(ctx, pattern3_0, expr1_0, &expr2_0)?; - let expr4_0 = constructor_output_gpr(ctx, expr3_0)?; - return Some(expr4_0); - } - _ => {} - } - } - &InstructionData::Unary { - opcode: ref pattern5_0, - arg: pattern5_1, - } => { - match pattern5_0 { - &Opcode::Ineg => { - // Rule at src/isa/x64/lower.isle line 884. - let expr0_0 = constructor_put_in_gpr(ctx, pattern5_1)?; - let expr1_0 = constructor_x64_neg(ctx, pattern3_0, expr0_0)?; - let expr2_0 = constructor_output_gpr(ctx, expr1_0)?; - return Some(expr2_0); - } - &Opcode::Bnot => { - // Rule at src/isa/x64/lower.isle line 1253. - let expr0_0 = constructor_put_in_gpr(ctx, pattern5_1)?; - let expr1_0 = constructor_x64_not(ctx, pattern3_0, expr0_0)?; - let expr2_0 = constructor_output_gpr(ctx, expr1_0)?; - return Some(expr2_0); - } - &Opcode::Breduce => { - // Rule at src/isa/x64/lower.isle line 2235. - let expr0_0 = C::put_in_regs(ctx, pattern5_1); - let expr1_0: usize = 0; - let expr2_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr1_0)?; - let expr3_0 = constructor_output_gpr(ctx, expr2_0)?; - return Some(expr3_0); - } - &Opcode::Bint => { - // Rule at src/isa/x64/lower.isle line 2243. - let expr0_0 = constructor_put_in_gpr(ctx, pattern5_1)?; - let expr1_0: u32 = 1; - let expr2_0 = RegMemImm::Imm { simm32: expr1_0 }; - let expr3_0 = C::gpr_mem_imm_new(ctx, &expr2_0); - let expr4_0 = constructor_x64_and(ctx, pattern3_0, expr0_0, &expr3_0)?; - let expr5_0 = constructor_output_gpr(ctx, expr4_0)?; - return Some(expr5_0); - } - &Opcode::Ireduce => { - // Rule at src/isa/x64/lower.isle line 2227. - let expr0_0 = C::put_in_regs(ctx, pattern5_1); - let expr1_0: usize = 0; - let expr2_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr1_0)?; - let expr3_0 = constructor_output_gpr(ctx, expr2_0)?; - return Some(expr3_0); - } - _ => {} - } - } - &InstructionData::BinaryImm64 { - opcode: ref pattern5_0, - arg: pattern5_1, - imm: pattern5_2, - } => { - if let &Opcode::IaddImm = pattern5_0 { - let pattern7_0 = C::u64_from_imm64(ctx, pattern5_2); - // Rule at src/isa/x64/lower.isle line 196. - let expr0_0 = constructor_put_in_gpr(ctx, pattern5_1)?; - let expr1_0 = constructor_imm(ctx, pattern3_0, pattern7_0)?; - let expr2_0 = constructor_reg_to_gpr_mem_imm(ctx, expr1_0)?; - let expr3_0 = constructor_x64_add(ctx, pattern3_0, expr0_0, &expr2_0)?; - let expr4_0 = constructor_output_gpr(ctx, expr3_0)?; - return Some(expr4_0); - } - } - _ => {} - } - } - if let Some(pattern3_0) = C::ty_32_or_64(ctx, pattern2_0) { - let pattern4_0 = C::inst_data(ctx, pattern0_0); - match &pattern4_0 { - &InstructionData::Binary { - opcode: ref pattern5_0, - args: ref pattern5_1, - } => { - match pattern5_0 { - &Opcode::Rotl => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - if let Some(pattern8_0) = C::def_inst(ctx, pattern7_1) { - let pattern9_0 = C::inst_data(ctx, pattern8_0); - if let &InstructionData::UnaryImm { - opcode: ref pattern10_0, - imm: pattern10_1, - } = &pattern9_0 - { - if let &Opcode::Iconst = pattern10_0 { - let pattern12_0 = C::u64_from_imm64(ctx, pattern10_1); - // Rule at src/isa/x64/lower.isle line 823. - let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?; - let expr1_0 = C::const_to_type_masked_imm8( - ctx, - pattern12_0, - pattern3_0, - ); - let expr2_0 = constructor_x64_rotl( - ctx, pattern3_0, expr0_0, &expr1_0, - )?; - let expr3_0 = constructor_output_gpr(ctx, expr2_0)?; - return Some(expr3_0); - } - } - } - // Rule at src/isa/x64/lower.isle line 817. - let expr0_0 = constructor_lo_gpr(ctx, pattern7_1)?; - let expr1_0 = constructor_put_in_gpr(ctx, pattern7_0)?; - let expr2_0 = C::gpr_to_imm8_gpr(ctx, expr0_0); - let expr3_0 = constructor_x64_rotl(ctx, pattern3_0, expr1_0, &expr2_0)?; - let expr4_0 = constructor_output_gpr(ctx, expr3_0)?; - return Some(expr4_0); - } - &Opcode::Rotr => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - if let Some(pattern8_0) = C::def_inst(ctx, pattern7_1) { - let pattern9_0 = C::inst_data(ctx, pattern8_0); - if let &InstructionData::UnaryImm { - opcode: ref pattern10_0, - imm: pattern10_1, - } = &pattern9_0 - { - if let &Opcode::Iconst = pattern10_0 { - let pattern12_0 = C::u64_from_imm64(ctx, pattern10_1); - // Rule at src/isa/x64/lower.isle line 863. - let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?; - let expr1_0 = C::const_to_type_masked_imm8( - ctx, - pattern12_0, - pattern3_0, - ); - let expr2_0 = constructor_x64_rotr( - ctx, pattern3_0, expr0_0, &expr1_0, - )?; - let expr3_0 = constructor_output_gpr(ctx, expr2_0)?; - return Some(expr3_0); - } - } - } - // Rule at src/isa/x64/lower.isle line 857. - let expr0_0 = constructor_lo_gpr(ctx, pattern7_1)?; - let expr1_0 = constructor_put_in_gpr(ctx, pattern7_0)?; - let expr2_0 = C::gpr_to_imm8_gpr(ctx, expr0_0); - let expr3_0 = constructor_x64_rotr(ctx, pattern3_0, expr1_0, &expr2_0)?; - let expr4_0 = constructor_output_gpr(ctx, expr3_0)?; - return Some(expr4_0); - } - _ => {} - } - } - &InstructionData::Unary { - opcode: ref pattern5_0, - arg: pattern5_1, - } => { - match pattern5_0 { - &Opcode::Clz => { - // Rule at src/isa/x64/lower.isle line 1791. - let expr0_0 = constructor_put_in_gpr(ctx, pattern5_1)?; - let expr1_0 = constructor_do_clz(ctx, pattern3_0, pattern3_0, expr0_0)?; - let expr2_0 = constructor_output_gpr(ctx, expr1_0)?; - return Some(expr2_0); - } - &Opcode::Ctz => { - // Rule at src/isa/x64/lower.isle line 1833. - let expr0_0 = constructor_put_in_gpr(ctx, pattern5_1)?; - let expr1_0 = constructor_do_ctz(ctx, pattern3_0, pattern3_0, expr0_0)?; - let expr2_0 = constructor_output_gpr(ctx, expr1_0)?; - return Some(expr2_0); - } - &Opcode::Popcnt => { - // Rule at src/isa/x64/lower.isle line 1885. - let expr0_0 = constructor_put_in_gpr(ctx, pattern5_1)?; - let expr1_0 = constructor_do_popcnt(ctx, pattern3_0, expr0_0)?; - let expr2_0 = constructor_output_gpr(ctx, expr1_0)?; - return Some(expr2_0); - } - _ => {} - } - } - _ => {} - } - } - if let Some(pattern3_0) = C::ty_8_or_16(ctx, pattern2_0) { - let pattern4_0 = C::inst_data(ctx, pattern0_0); - match &pattern4_0 { - &InstructionData::Binary { - opcode: ref pattern5_0, - args: ref pattern5_1, - } => { - match pattern5_0 { - &Opcode::Rotl => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - if let Some(pattern8_0) = C::def_inst(ctx, pattern7_1) { - let pattern9_0 = C::inst_data(ctx, pattern8_0); - if let &InstructionData::UnaryImm { - opcode: ref pattern10_0, - imm: pattern10_1, - } = &pattern9_0 - { - if let &Opcode::Iconst = pattern10_0 { - let pattern12_0 = C::u64_from_imm64(ctx, pattern10_1); - // Rule at src/isa/x64/lower.isle line 809. - let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?; - let expr1_0 = C::const_to_type_masked_imm8( - ctx, - pattern12_0, - pattern3_0, - ); - let expr2_0 = constructor_x64_rotl( - ctx, pattern3_0, expr0_0, &expr1_0, - )?; - let expr3_0 = constructor_output_gpr(ctx, expr2_0)?; - return Some(expr3_0); - } - } - } - // Rule at src/isa/x64/lower.isle line 805. - let expr0_0: Type = I32; - let expr1_0 = ExtendKind::Zero; - let expr2_0 = - constructor_extend_to_gpr(ctx, pattern7_1, expr0_0, &expr1_0)?; - let expr3_0 = constructor_put_in_gpr(ctx, pattern7_0)?; - let expr4_0 = C::gpr_to_imm8_gpr(ctx, expr2_0); - let expr5_0 = constructor_x64_rotl(ctx, pattern3_0, expr3_0, &expr4_0)?; - let expr6_0 = constructor_output_gpr(ctx, expr5_0)?; - return Some(expr6_0); - } - &Opcode::Rotr => { - let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1); - if let Some(pattern8_0) = C::def_inst(ctx, pattern7_1) { - let pattern9_0 = C::inst_data(ctx, pattern8_0); - if let &InstructionData::UnaryImm { - opcode: ref pattern10_0, - imm: pattern10_1, - } = &pattern9_0 - { - if let &Opcode::Iconst = pattern10_0 { - let pattern12_0 = C::u64_from_imm64(ctx, pattern10_1); - // Rule at src/isa/x64/lower.isle line 849. - let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?; - let expr1_0 = C::const_to_type_masked_imm8( - ctx, - pattern12_0, - pattern3_0, - ); - let expr2_0 = constructor_x64_rotr( - ctx, pattern3_0, expr0_0, &expr1_0, - )?; - let expr3_0 = constructor_output_gpr(ctx, expr2_0)?; - return Some(expr3_0); - } - } - } - // Rule at src/isa/x64/lower.isle line 845. - let expr0_0: Type = I32; - let expr1_0 = ExtendKind::Zero; - let expr2_0 = - constructor_extend_to_gpr(ctx, pattern7_1, expr0_0, &expr1_0)?; - let expr3_0 = constructor_put_in_gpr(ctx, pattern7_0)?; - let expr4_0 = C::gpr_to_imm8_gpr(ctx, expr2_0); - let expr5_0 = constructor_x64_rotr(ctx, pattern3_0, expr3_0, &expr4_0)?; - let expr6_0 = constructor_output_gpr(ctx, expr5_0)?; - return Some(expr6_0); - } - _ => {} - } - } - &InstructionData::Unary { - opcode: ref pattern5_0, - arg: pattern5_1, - } => { - match pattern5_0 { - &Opcode::Clz => { - // Rule at src/isa/x64/lower.isle line 1796. - let expr0_0: Type = I32; - let expr1_0: Type = I32; - let expr2_0 = ExtendKind::Zero; - let expr3_0 = - constructor_extend_to_gpr(ctx, pattern5_1, expr1_0, &expr2_0)?; - let expr4_0 = constructor_do_clz(ctx, expr0_0, pattern3_0, expr3_0)?; - let expr5_0 = constructor_output_gpr(ctx, expr4_0)?; - return Some(expr5_0); - } - &Opcode::Ctz => { - // Rule at src/isa/x64/lower.isle line 1838. - let expr0_0: Type = I32; - let expr1_0: Type = I32; - let expr2_0 = ExtendKind::Zero; - let expr3_0 = - constructor_extend_to_gpr(ctx, pattern5_1, expr1_0, &expr2_0)?; - let expr4_0 = constructor_do_ctz(ctx, expr0_0, pattern3_0, expr3_0)?; - let expr5_0 = constructor_output_gpr(ctx, expr4_0)?; - return Some(expr5_0); - } - &Opcode::Popcnt => { - // Rule at src/isa/x64/lower.isle line 1890. - let expr0_0: Type = I32; - let expr1_0: Type = I32; - let expr2_0 = ExtendKind::Zero; - let expr3_0 = - constructor_extend_to_gpr(ctx, pattern5_1, expr1_0, &expr2_0)?; - let expr4_0 = constructor_do_popcnt(ctx, expr0_0, expr3_0)?; - let expr5_0 = constructor_output_gpr(ctx, expr4_0)?; - return Some(expr5_0); - } - _ => {} - } - } - _ => {} - } - } - if let Some(pattern3_0) = C::ty_int_bool_ref_64(ctx, pattern2_0) { - let pattern4_0 = C::inst_data(ctx, pattern0_0); - if let &InstructionData::Load { - opcode: ref pattern5_0, - arg: pattern5_1, - flags: pattern5_2, - offset: pattern5_3, - } = &pattern4_0 - { - if let &Opcode::Load = pattern5_0 { - // Rule at src/isa/x64/lower.isle line 2524. - let expr0_0 = constructor_to_amode(ctx, pattern5_2, pattern5_1, pattern5_3)?; - let expr1_0 = constructor_x64_mov(ctx, &expr0_0)?; - let expr2_0 = constructor_output_reg(ctx, expr1_0)?; - return Some(expr2_0); - } - } - } - if let Some(pattern3_0) = C::ty_int_bool_128(ctx, pattern2_0) { - let pattern4_0 = C::inst_data(ctx, pattern0_0); - if let &InstructionData::Load { - opcode: ref pattern5_0, - arg: pattern5_1, - flags: pattern5_2, - offset: pattern5_3, - } = &pattern4_0 - { - if let &Opcode::Load = pattern5_0 { - // Rule at src/isa/x64/lower.isle line 2558. - let expr0_0 = constructor_to_amode(ctx, pattern5_2, pattern5_1, pattern5_3)?; - let expr1_0: u32 = 8; - let expr2_0 = C::amode_offset(ctx, &expr0_0, expr1_0); - let expr3_0 = constructor_x64_mov(ctx, &expr0_0)?; - let expr4_0 = constructor_x64_mov(ctx, &expr2_0)?; - let expr5_0 = C::value_regs(ctx, expr3_0, expr4_0); - let expr6_0 = C::output(ctx, expr5_0); - return Some(expr6_0); - } - } - } - if let Some(pattern3_0) = C::ty_vec128(ctx, pattern2_0) { - let pattern4_0 = C::inst_data(ctx, pattern0_0); - if let &InstructionData::Load { - opcode: ref pattern5_0, - arg: pattern5_1, - flags: pattern5_2, - offset: pattern5_3, - } = &pattern4_0 - { - if let &Opcode::Load = pattern5_0 { - // Rule at src/isa/x64/lower.isle line 2554. - let expr0_0 = constructor_to_amode(ctx, pattern5_2, pattern5_1, pattern5_3)?; - let expr1_0 = constructor_amode_to_xmm_mem(ctx, &expr0_0)?; - let expr2_0 = constructor_x64_movdqu(ctx, &expr1_0)?; - let expr3_0 = constructor_output_xmm(ctx, expr2_0)?; - return Some(expr3_0); - } - } - } - if let Some(pattern3_0) = C::is_gpr_type(ctx, pattern2_0) { - let pattern4_0 = C::inst_data(ctx, pattern0_0); - if let &InstructionData::Load { - opcode: ref pattern5_0, - arg: pattern5_1, - flags: pattern5_2, - offset: pattern5_3, - } = &pattern4_0 - { - match pattern5_0 { - &Opcode::Uload8 => { - // Rule at src/isa/x64/lower.isle line 2529. - let expr0_0 = ExtMode::BQ; - let expr1_0 = - constructor_to_amode(ctx, pattern5_2, pattern5_1, pattern5_3)?; - let expr2_0 = constructor_amode_to_gpr_mem(ctx, &expr1_0)?; - let expr3_0 = constructor_x64_movzx(ctx, &expr0_0, &expr2_0)?; - let expr4_0 = constructor_output_gpr(ctx, expr3_0)?; - return Some(expr4_0); - } - &Opcode::Sload8 => { - // Rule at src/isa/x64/lower.isle line 2531. - let expr0_0 = ExtMode::BQ; - let expr1_0 = - constructor_to_amode(ctx, pattern5_2, pattern5_1, pattern5_3)?; - let expr2_0 = constructor_amode_to_gpr_mem(ctx, &expr1_0)?; - let expr3_0 = constructor_x64_movsx(ctx, &expr0_0, &expr2_0)?; - let expr4_0 = constructor_output_gpr(ctx, expr3_0)?; - return Some(expr4_0); - } - &Opcode::Uload16 => { - // Rule at src/isa/x64/lower.isle line 2533. - let expr0_0 = ExtMode::WQ; - let expr1_0 = - constructor_to_amode(ctx, pattern5_2, pattern5_1, pattern5_3)?; - let expr2_0 = constructor_amode_to_gpr_mem(ctx, &expr1_0)?; - let expr3_0 = constructor_x64_movzx(ctx, &expr0_0, &expr2_0)?; - let expr4_0 = constructor_output_gpr(ctx, expr3_0)?; - return Some(expr4_0); - } - &Opcode::Sload16 => { - // Rule at src/isa/x64/lower.isle line 2535. - let expr0_0 = ExtMode::WQ; - let expr1_0 = - constructor_to_amode(ctx, pattern5_2, pattern5_1, pattern5_3)?; - let expr2_0 = constructor_amode_to_gpr_mem(ctx, &expr1_0)?; - let expr3_0 = constructor_x64_movsx(ctx, &expr0_0, &expr2_0)?; - let expr4_0 = constructor_output_gpr(ctx, expr3_0)?; - return Some(expr4_0); - } - &Opcode::Uload32 => { - // Rule at src/isa/x64/lower.isle line 2537. - let expr0_0 = ExtMode::LQ; - let expr1_0 = - constructor_to_amode(ctx, pattern5_2, pattern5_1, pattern5_3)?; - let expr2_0 = constructor_amode_to_gpr_mem(ctx, &expr1_0)?; - let expr3_0 = constructor_x64_movzx(ctx, &expr0_0, &expr2_0)?; - let expr4_0 = constructor_output_gpr(ctx, expr3_0)?; - return Some(expr4_0); - } - &Opcode::Sload32 => { - // Rule at src/isa/x64/lower.isle line 2539. - let expr0_0 = ExtMode::LQ; - let expr1_0 = - constructor_to_amode(ctx, pattern5_2, pattern5_1, pattern5_3)?; - let expr2_0 = constructor_amode_to_gpr_mem(ctx, &expr1_0)?; - let expr3_0 = constructor_x64_movsx(ctx, &expr0_0, &expr2_0)?; - let expr4_0 = constructor_output_gpr(ctx, expr3_0)?; - return Some(expr4_0); - } - _ => {} - } - } - } - } - return None; -} - -// Generated as internal constructor for term output_ifcout. -pub fn constructor_output_ifcout(ctx: &mut C, arg0: Reg) -> Option { - let pattern0_0 = arg0; - // Rule at src/isa/x64/lower.isle line 157. - let expr0_0 = C::value_reg(ctx, pattern0_0); - let expr1_0 = C::value_regs_invalid(ctx); - let expr2_0 = C::output_pair(ctx, expr0_0, expr1_0); - return Some(expr2_0); -} - -// Generated as internal constructor for term sse_and. -pub fn constructor_sse_and( - ctx: &mut C, - arg0: Type, - arg1: Xmm, - arg2: &XmmMem, -) -> Option { - let pattern0_0 = arg0; - if pattern0_0 == F32X4 { - let pattern2_0 = arg1; - let pattern3_0 = arg2; - // Rule at src/isa/x64/lower.isle line 324. - let expr0_0 = constructor_x64_andps(ctx, pattern2_0, pattern3_0)?; - return Some(expr0_0); - } - if pattern0_0 == F64X2 { - let pattern2_0 = arg1; - let pattern3_0 = arg2; - // Rule at src/isa/x64/lower.isle line 325. - let expr0_0 = constructor_x64_andpd(ctx, pattern2_0, pattern3_0)?; - return Some(expr0_0); - } - if let Some((pattern1_0, pattern1_1)) = C::multi_lane(ctx, pattern0_0) { - let pattern2_0 = arg1; - let pattern3_0 = arg2; - // Rule at src/isa/x64/lower.isle line 326. - let expr0_0 = constructor_x64_pand(ctx, pattern2_0, pattern3_0)?; - return Some(expr0_0); - } - return None; -} - -// Generated as internal constructor for term sse_or. -pub fn constructor_sse_or( - ctx: &mut C, - arg0: Type, - arg1: Xmm, - arg2: &XmmMem, -) -> Option { - let pattern0_0 = arg0; - if pattern0_0 == F32X4 { - let pattern2_0 = arg1; - let pattern3_0 = arg2; - // Rule at src/isa/x64/lower.isle line 388. - let expr0_0 = constructor_x64_orps(ctx, pattern2_0, pattern3_0)?; - return Some(expr0_0); - } - if pattern0_0 == F64X2 { - let pattern2_0 = arg1; - let pattern3_0 = arg2; - // Rule at src/isa/x64/lower.isle line 389. - let expr0_0 = constructor_x64_orpd(ctx, pattern2_0, pattern3_0)?; - return Some(expr0_0); - } - if let Some((pattern1_0, pattern1_1)) = C::multi_lane(ctx, pattern0_0) { - let pattern2_0 = arg1; - let pattern3_0 = arg2; - // Rule at src/isa/x64/lower.isle line 390. - let expr0_0 = constructor_x64_por(ctx, pattern2_0, pattern3_0)?; - return Some(expr0_0); - } - return None; -} - -// Generated as internal constructor for term or_i128. -pub fn constructor_or_i128( - ctx: &mut C, - arg0: ValueRegs, - arg1: ValueRegs, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/x64/lower.isle line 399. - let expr0_0: usize = 0; - let expr1_0 = constructor_value_regs_get_gpr(ctx, pattern0_0, expr0_0)?; - let expr2_0: usize = 1; - let expr3_0 = constructor_value_regs_get_gpr(ctx, pattern0_0, expr2_0)?; - let expr4_0: usize = 0; - let expr5_0 = constructor_value_regs_get_gpr(ctx, pattern1_0, expr4_0)?; - let expr6_0: usize = 1; - let expr7_0 = constructor_value_regs_get_gpr(ctx, pattern1_0, expr6_0)?; - let expr8_0: Type = I64; - let expr9_0 = C::gpr_to_gpr_mem_imm(ctx, expr5_0); - let expr10_0 = constructor_x64_or(ctx, expr8_0, expr1_0, &expr9_0)?; - let expr11_0: Type = I64; - let expr12_0 = C::gpr_to_gpr_mem_imm(ctx, expr7_0); - let expr13_0 = constructor_x64_or(ctx, expr11_0, expr3_0, &expr12_0)?; - let expr14_0 = constructor_value_gprs(ctx, expr10_0, expr13_0)?; - return Some(expr14_0); -} - -// Generated as internal constructor for term shl_i128. -pub fn constructor_shl_i128( - ctx: &mut C, - arg0: ValueRegs, - arg1: Gpr, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/x64/lower.isle line 489. - let expr0_0: usize = 0; - let expr1_0 = constructor_value_regs_get_gpr(ctx, pattern0_0, expr0_0)?; - let expr2_0: usize = 1; - let expr3_0 = constructor_value_regs_get_gpr(ctx, pattern0_0, expr2_0)?; - let expr4_0: Type = I64; - let expr5_0 = C::gpr_to_imm8_gpr(ctx, pattern1_0); - let expr6_0 = constructor_x64_shl(ctx, expr4_0, expr1_0, &expr5_0)?; - let expr7_0: Type = I64; - let expr8_0 = C::gpr_to_imm8_gpr(ctx, pattern1_0); - let expr9_0 = constructor_x64_shl(ctx, expr7_0, expr3_0, &expr8_0)?; - let expr10_0: Type = I64; - let expr11_0: Type = I64; - let expr12_0: Type = I64; - let expr13_0: u64 = 64; - let expr14_0 = constructor_imm(ctx, expr12_0, expr13_0)?; - let expr15_0 = C::gpr_new(ctx, expr14_0); - let expr16_0 = C::gpr_to_gpr_mem_imm(ctx, pattern1_0); - let expr17_0 = constructor_x64_sub(ctx, expr11_0, expr15_0, &expr16_0)?; - let expr18_0 = C::gpr_to_imm8_gpr(ctx, expr17_0); - let expr19_0 = constructor_x64_shr(ctx, expr10_0, expr1_0, &expr18_0)?; - let expr20_0: Type = I64; - let expr21_0: u64 = 0; - let expr22_0 = constructor_imm(ctx, expr20_0, expr21_0)?; - let expr23_0 = C::gpr_new(ctx, expr22_0); - let expr24_0 = OperandSize::Size64; - let expr25_0: u32 = 127; - let expr26_0 = RegMemImm::Imm { simm32: expr25_0 }; - let expr27_0 = C::gpr_mem_imm_new(ctx, &expr26_0); - let expr28_0 = constructor_x64_test(ctx, &expr24_0, &expr27_0, pattern1_0)?; - let expr29_0: Type = I64; - let expr30_0 = CC::Z; - let expr31_0 = C::gpr_to_gpr_mem(ctx, expr23_0); - let expr32_0 = constructor_cmove(ctx, expr29_0, &expr30_0, &expr31_0, expr19_0)?; - let expr33_0 = constructor_with_flags_reg(ctx, &expr28_0, &expr32_0)?; - let expr34_0 = C::gpr_new(ctx, expr33_0); - let expr35_0: Type = I64; - let expr36_0 = C::gpr_to_gpr_mem_imm(ctx, expr9_0); - let expr37_0 = constructor_x64_or(ctx, expr35_0, expr34_0, &expr36_0)?; - let expr38_0 = OperandSize::Size64; - let expr39_0: u32 = 64; - let expr40_0 = RegMemImm::Imm { simm32: expr39_0 }; - let expr41_0 = C::gpr_mem_imm_new(ctx, &expr40_0); - let expr42_0 = constructor_x64_test(ctx, &expr38_0, &expr41_0, pattern1_0)?; - let expr43_0: Type = I64; - let expr44_0 = CC::Z; - let expr45_0 = C::gpr_to_gpr_mem(ctx, expr6_0); - let expr46_0 = constructor_cmove(ctx, expr43_0, &expr44_0, &expr45_0, expr23_0)?; - let expr47_0: Type = I64; - let expr48_0 = CC::Z; - let expr49_0 = C::gpr_to_gpr_mem(ctx, expr37_0); - let expr50_0 = constructor_cmove(ctx, expr47_0, &expr48_0, &expr49_0, expr6_0)?; - let expr51_0 = constructor_consumes_flags_concat(ctx, &expr46_0, &expr50_0)?; - let expr52_0 = constructor_with_flags(ctx, &expr42_0, &expr51_0)?; - return Some(expr52_0); -} - -// Generated as internal constructor for term ishl_i8x16_mask. -pub fn constructor_ishl_i8x16_mask( - ctx: &mut C, - arg0: &RegMemImm, -) -> Option { - let pattern0_0 = arg0; - match pattern0_0 { - &RegMemImm::Imm { simm32: pattern1_0 } => { - // Rule at src/isa/x64/lower.isle line 552. - let expr0_0 = C::ishl_i8x16_mask_for_const(ctx, pattern1_0); - return Some(expr0_0); - } - &RegMemImm::Reg { reg: pattern1_0 } => { - // Rule at src/isa/x64/lower.isle line 561. - let expr0_0 = C::ishl_i8x16_mask_table(ctx); - let expr1_0 = constructor_x64_lea(ctx, &expr0_0)?; - let expr2_0: Type = I64; - let expr3_0 = C::gpr_new(ctx, pattern1_0); - let expr4_0: u8 = 4; - let expr5_0 = C::imm8_to_imm8_gpr(ctx, expr4_0); - let expr6_0 = constructor_x64_shl(ctx, expr2_0, expr3_0, &expr5_0)?; - let expr7_0: u32 = 0; - let expr8_0: u8 = 0; - let expr9_0 = C::amode_imm_reg_reg_shift(ctx, expr7_0, expr1_0, expr6_0, expr8_0); - let expr10_0 = C::amode_to_synthetic_amode(ctx, &expr9_0); - return Some(expr10_0); - } - &RegMemImm::Mem { - addr: ref pattern1_0, - } => { - // Rule at src/isa/x64/lower.isle line 571. - let expr0_0: Type = I64; - let expr1_0 = ExtKind::None; - let expr2_0 = constructor_x64_load(ctx, expr0_0, pattern1_0, &expr1_0)?; - let expr3_0 = RegMemImm::Reg { reg: expr2_0 }; - let expr4_0 = constructor_ishl_i8x16_mask(ctx, &expr3_0)?; - return Some(expr4_0); - } - _ => {} - } - return None; -} - -// Generated as internal constructor for term shr_i128. -pub fn constructor_shr_i128( - ctx: &mut C, - arg0: ValueRegs, - arg1: Gpr, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/x64/lower.isle line 596. - let expr0_0: usize = 0; - let expr1_0 = constructor_value_regs_get_gpr(ctx, pattern0_0, expr0_0)?; - let expr2_0: usize = 1; - let expr3_0 = constructor_value_regs_get_gpr(ctx, pattern0_0, expr2_0)?; - let expr4_0: Type = I64; - let expr5_0 = C::gpr_to_imm8_gpr(ctx, pattern1_0); - let expr6_0 = constructor_x64_shr(ctx, expr4_0, expr1_0, &expr5_0)?; - let expr7_0: Type = I64; - let expr8_0 = C::gpr_to_imm8_gpr(ctx, pattern1_0); - let expr9_0 = constructor_x64_shr(ctx, expr7_0, expr3_0, &expr8_0)?; - let expr10_0: Type = I64; - let expr11_0: Type = I64; - let expr12_0: Type = I64; - let expr13_0: u64 = 64; - let expr14_0 = constructor_imm(ctx, expr12_0, expr13_0)?; - let expr15_0 = C::gpr_new(ctx, expr14_0); - let expr16_0 = C::gpr_to_gpr_mem_imm(ctx, pattern1_0); - let expr17_0 = constructor_x64_sub(ctx, expr11_0, expr15_0, &expr16_0)?; - let expr18_0 = C::gpr_to_imm8_gpr(ctx, expr17_0); - let expr19_0 = constructor_x64_shl(ctx, expr10_0, expr3_0, &expr18_0)?; - let expr20_0 = OperandSize::Size64; - let expr21_0: u32 = 127; - let expr22_0 = RegMemImm::Imm { simm32: expr21_0 }; - let expr23_0 = C::gpr_mem_imm_new(ctx, &expr22_0); - let expr24_0 = constructor_x64_test(ctx, &expr20_0, &expr23_0, pattern1_0)?; - let expr25_0: Type = I64; - let expr26_0 = CC::Z; - let expr27_0: Type = I64; - let expr28_0: u64 = 0; - let expr29_0 = constructor_imm(ctx, expr27_0, expr28_0)?; - let expr30_0 = C::reg_to_gpr_mem(ctx, expr29_0); - let expr31_0 = constructor_cmove(ctx, expr25_0, &expr26_0, &expr30_0, expr19_0)?; - let expr32_0 = constructor_with_flags_reg(ctx, &expr24_0, &expr31_0)?; - let expr33_0 = C::gpr_new(ctx, expr32_0); - let expr34_0: Type = I64; - let expr35_0 = C::gpr_to_gpr_mem_imm(ctx, expr6_0); - let expr36_0 = constructor_x64_or(ctx, expr34_0, expr33_0, &expr35_0)?; - let expr37_0 = OperandSize::Size64; - let expr38_0: u32 = 64; - let expr39_0 = RegMemImm::Imm { simm32: expr38_0 }; - let expr40_0 = C::gpr_mem_imm_new(ctx, &expr39_0); - let expr41_0 = constructor_x64_test(ctx, &expr37_0, &expr40_0, pattern1_0)?; - let expr42_0: Type = I64; - let expr43_0 = CC::Z; - let expr44_0 = C::gpr_to_gpr_mem(ctx, expr36_0); - let expr45_0 = constructor_cmove(ctx, expr42_0, &expr43_0, &expr44_0, expr9_0)?; - let expr46_0: Type = I64; - let expr47_0 = CC::Z; - let expr48_0 = C::gpr_to_gpr_mem(ctx, expr9_0); - let expr49_0: Type = I64; - let expr50_0: u64 = 0; - let expr51_0 = constructor_imm(ctx, expr49_0, expr50_0)?; - let expr52_0 = C::gpr_new(ctx, expr51_0); - let expr53_0 = constructor_cmove(ctx, expr46_0, &expr47_0, &expr48_0, expr52_0)?; - let expr54_0 = constructor_consumes_flags_concat(ctx, &expr45_0, &expr53_0)?; - let expr55_0 = constructor_with_flags(ctx, &expr41_0, &expr54_0)?; - return Some(expr55_0); -} - -// Generated as internal constructor for term ushr_i8x16_mask. -pub fn constructor_ushr_i8x16_mask( - ctx: &mut C, - arg0: &RegMemImm, -) -> Option { - let pattern0_0 = arg0; - match pattern0_0 { - &RegMemImm::Imm { simm32: pattern1_0 } => { - // Rule at src/isa/x64/lower.isle line 653. - let expr0_0 = C::ushr_i8x16_mask_for_const(ctx, pattern1_0); - return Some(expr0_0); - } - &RegMemImm::Reg { reg: pattern1_0 } => { - // Rule at src/isa/x64/lower.isle line 662. - let expr0_0 = C::ushr_i8x16_mask_table(ctx); - let expr1_0 = constructor_x64_lea(ctx, &expr0_0)?; - let expr2_0: Type = I64; - let expr3_0 = C::gpr_new(ctx, pattern1_0); - let expr4_0: u8 = 4; - let expr5_0 = C::imm8_to_imm8_gpr(ctx, expr4_0); - let expr6_0 = constructor_x64_shl(ctx, expr2_0, expr3_0, &expr5_0)?; - let expr7_0: u32 = 0; - let expr8_0: u8 = 0; - let expr9_0 = C::amode_imm_reg_reg_shift(ctx, expr7_0, expr1_0, expr6_0, expr8_0); - let expr10_0 = C::amode_to_synthetic_amode(ctx, &expr9_0); - return Some(expr10_0); - } - &RegMemImm::Mem { - addr: ref pattern1_0, - } => { - // Rule at src/isa/x64/lower.isle line 673. - let expr0_0: Type = I64; - let expr1_0 = ExtKind::None; - let expr2_0 = constructor_x64_load(ctx, expr0_0, pattern1_0, &expr1_0)?; - let expr3_0 = RegMemImm::Reg { reg: expr2_0 }; - let expr4_0 = constructor_ushr_i8x16_mask(ctx, &expr3_0)?; - return Some(expr4_0); - } - _ => {} - } - return None; -} - -// Generated as internal constructor for term sar_i128. -pub fn constructor_sar_i128( - ctx: &mut C, - arg0: ValueRegs, - arg1: Gpr, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/x64/lower.isle line 698. - let expr0_0: usize = 0; - let expr1_0 = constructor_value_regs_get_gpr(ctx, pattern0_0, expr0_0)?; - let expr2_0: usize = 1; - let expr3_0 = constructor_value_regs_get_gpr(ctx, pattern0_0, expr2_0)?; - let expr4_0: Type = I64; - let expr5_0 = C::gpr_to_imm8_gpr(ctx, pattern1_0); - let expr6_0 = constructor_x64_shr(ctx, expr4_0, expr1_0, &expr5_0)?; - let expr7_0: Type = I64; - let expr8_0 = C::gpr_to_imm8_gpr(ctx, pattern1_0); - let expr9_0 = constructor_x64_sar(ctx, expr7_0, expr3_0, &expr8_0)?; - let expr10_0: Type = I64; - let expr11_0: Type = I64; - let expr12_0: Type = I64; - let expr13_0: u64 = 64; - let expr14_0 = constructor_imm(ctx, expr12_0, expr13_0)?; - let expr15_0 = C::gpr_new(ctx, expr14_0); - let expr16_0 = C::gpr_to_gpr_mem_imm(ctx, pattern1_0); - let expr17_0 = constructor_x64_sub(ctx, expr11_0, expr15_0, &expr16_0)?; - let expr18_0 = C::gpr_to_imm8_gpr(ctx, expr17_0); - let expr19_0 = constructor_x64_shl(ctx, expr10_0, expr3_0, &expr18_0)?; - let expr20_0 = OperandSize::Size64; - let expr21_0: u32 = 127; - let expr22_0 = RegMemImm::Imm { simm32: expr21_0 }; - let expr23_0 = C::gpr_mem_imm_new(ctx, &expr22_0); - let expr24_0 = constructor_x64_test(ctx, &expr20_0, &expr23_0, pattern1_0)?; - let expr25_0: Type = I64; - let expr26_0 = CC::Z; - let expr27_0: Type = I64; - let expr28_0: u64 = 0; - let expr29_0 = constructor_imm(ctx, expr27_0, expr28_0)?; - let expr30_0 = C::reg_to_gpr_mem(ctx, expr29_0); - let expr31_0 = constructor_cmove(ctx, expr25_0, &expr26_0, &expr30_0, expr19_0)?; - let expr32_0 = constructor_with_flags_reg(ctx, &expr24_0, &expr31_0)?; - let expr33_0 = C::gpr_new(ctx, expr32_0); - let expr34_0: Type = I64; - let expr35_0 = C::gpr_to_gpr_mem_imm(ctx, expr33_0); - let expr36_0 = constructor_x64_or(ctx, expr34_0, expr6_0, &expr35_0)?; - let expr37_0: Type = I64; - let expr38_0: u8 = 63; - let expr39_0 = C::imm8_to_imm8_gpr(ctx, expr38_0); - let expr40_0 = constructor_x64_sar(ctx, expr37_0, expr3_0, &expr39_0)?; - let expr41_0 = OperandSize::Size64; - let expr42_0: u32 = 64; - let expr43_0 = RegMemImm::Imm { simm32: expr42_0 }; - let expr44_0 = C::gpr_mem_imm_new(ctx, &expr43_0); - let expr45_0 = constructor_x64_test(ctx, &expr41_0, &expr44_0, pattern1_0)?; - let expr46_0: Type = I64; - let expr47_0 = CC::Z; - let expr48_0 = C::gpr_to_gpr_mem(ctx, expr36_0); - let expr49_0 = constructor_cmove(ctx, expr46_0, &expr47_0, &expr48_0, expr9_0)?; - let expr50_0: Type = I64; - let expr51_0 = CC::Z; - let expr52_0 = C::gpr_to_gpr_mem(ctx, expr9_0); - let expr53_0 = constructor_cmove(ctx, expr50_0, &expr51_0, &expr52_0, expr40_0)?; - let expr54_0 = constructor_consumes_flags_concat(ctx, &expr49_0, &expr53_0)?; - let expr55_0 = constructor_with_flags(ctx, &expr45_0, &expr54_0)?; - return Some(expr55_0); -} - -// Generated as internal constructor for term sshr_i8x16_bigger_shift. -pub fn constructor_sshr_i8x16_bigger_shift( - ctx: &mut C, - arg0: Type, - arg1: &RegMemImm, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - match pattern1_0 { - &RegMemImm::Imm { simm32: pattern2_0 } => { - // Rule at src/isa/x64/lower.isle line 762. - let expr0_0: u32 = 8; - let expr1_0 = C::u32_add(ctx, pattern2_0, expr0_0); - let expr2_0 = RegMemImm::Imm { simm32: expr1_0 }; - let expr3_0 = C::xmm_mem_imm_new(ctx, &expr2_0); - return Some(expr3_0); - } - &RegMemImm::Reg { reg: pattern2_0 } => { - // Rule at src/isa/x64/lower.isle line 764. - let expr0_0 = C::gpr_new(ctx, pattern2_0); - let expr1_0: u32 = 8; - let expr2_0 = RegMemImm::Imm { simm32: expr1_0 }; - let expr3_0 = C::gpr_mem_imm_new(ctx, &expr2_0); - let expr4_0 = constructor_x64_add(ctx, pattern0_0, expr0_0, &expr3_0)?; - let expr5_0 = C::gpr_to_reg(ctx, expr4_0); - let expr6_0 = RegMemImm::Reg { reg: expr5_0 }; - let expr7_0 = constructor_mov_rmi_to_xmm(ctx, &expr6_0)?; - return Some(expr7_0); - } - &RegMemImm::Mem { - addr: ref pattern2_0, - } => { - // Rule at src/isa/x64/lower.isle line 768. - let expr0_0: u64 = 8; - let expr1_0 = constructor_imm(ctx, pattern0_0, expr0_0)?; - let expr2_0 = C::gpr_new(ctx, expr1_0); - let expr3_0 = C::gpr_mem_imm_new(ctx, pattern1_0); - let expr4_0 = constructor_x64_add(ctx, pattern0_0, expr2_0, &expr3_0)?; - let expr5_0 = C::gpr_to_reg(ctx, expr4_0); - let expr6_0 = RegMemImm::Reg { reg: expr5_0 }; - let expr7_0 = constructor_mov_rmi_to_xmm(ctx, &expr6_0)?; - return Some(expr7_0); - } - _ => {} - } - return None; -} - -// Generated as internal constructor for term sse_and_not. -pub fn constructor_sse_and_not( - ctx: &mut C, - arg0: Type, - arg1: Xmm, - arg2: &XmmMem, -) -> Option { - let pattern0_0 = arg0; - if pattern0_0 == F32X4 { - let pattern2_0 = arg1; - let pattern3_0 = arg2; - // Rule at src/isa/x64/lower.isle line 1194. - let expr0_0 = constructor_x64_andnps(ctx, pattern2_0, pattern3_0)?; - return Some(expr0_0); - } - if pattern0_0 == F64X2 { - let pattern2_0 = arg1; - let pattern3_0 = arg2; - // Rule at src/isa/x64/lower.isle line 1195. - let expr0_0 = constructor_x64_andnpd(ctx, pattern2_0, pattern3_0)?; - return Some(expr0_0); - } - if let Some((pattern1_0, pattern1_1)) = C::multi_lane(ctx, pattern0_0) { - let pattern2_0 = arg1; - let pattern3_0 = arg2; - // Rule at src/isa/x64/lower.isle line 1196. - let expr0_0 = constructor_x64_pandn(ctx, pattern2_0, pattern3_0)?; - return Some(expr0_0); - } - return None; -} - -// Generated as internal constructor for term i128_not. -pub fn constructor_i128_not(ctx: &mut C, arg0: Value) -> Option { - let pattern0_0 = arg0; - // Rule at src/isa/x64/lower.isle line 1259. - let expr0_0 = C::put_in_regs(ctx, pattern0_0); - let expr1_0: usize = 0; - let expr2_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr1_0)?; - let expr3_0: usize = 1; - let expr4_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr3_0)?; - let expr5_0: Type = I64; - let expr6_0 = constructor_x64_not(ctx, expr5_0, expr2_0)?; - let expr7_0: Type = I64; - let expr8_0 = constructor_x64_not(ctx, expr7_0, expr4_0)?; - let expr9_0 = constructor_value_gprs(ctx, expr6_0, expr8_0)?; - return Some(expr9_0); -} - -// Generated as internal constructor for term vec_insert_lane. -pub fn constructor_vec_insert_lane( - ctx: &mut C, - arg0: Type, - arg1: Xmm, - arg2: &RegMem, - arg3: u8, -) -> Option { - let pattern0_0 = arg0; - if pattern0_0 == I8X16 { - let pattern2_0 = arg1; - let pattern3_0 = arg2; - let pattern4_0 = arg3; - // Rule at src/isa/x64/lower.isle line 1313. - let expr0_0 = C::reg_mem_to_gpr_mem(ctx, pattern3_0); - let expr1_0 = constructor_x64_pinsrb(ctx, pattern2_0, &expr0_0, pattern4_0)?; - return Some(expr1_0); - } - if pattern0_0 == I16X8 { - let pattern2_0 = arg1; - let pattern3_0 = arg2; - let pattern4_0 = arg3; - // Rule at src/isa/x64/lower.isle line 1317. - let expr0_0 = C::reg_mem_to_gpr_mem(ctx, pattern3_0); - let expr1_0 = constructor_x64_pinsrw(ctx, pattern2_0, &expr0_0, pattern4_0)?; - return Some(expr1_0); - } - if pattern0_0 == I32X4 { - let pattern2_0 = arg1; - let pattern3_0 = arg2; - let pattern4_0 = arg3; - // Rule at src/isa/x64/lower.isle line 1321. - let expr0_0 = C::reg_mem_to_gpr_mem(ctx, pattern3_0); - let expr1_0 = OperandSize::Size32; - let expr2_0 = constructor_x64_pinsrd(ctx, pattern2_0, &expr0_0, pattern4_0, &expr1_0)?; - return Some(expr2_0); - } - if pattern0_0 == I64X2 { - let pattern2_0 = arg1; - let pattern3_0 = arg2; - let pattern4_0 = arg3; - // Rule at src/isa/x64/lower.isle line 1325. - let expr0_0 = C::reg_mem_to_gpr_mem(ctx, pattern3_0); - let expr1_0 = OperandSize::Size64; - let expr2_0 = constructor_x64_pinsrd(ctx, pattern2_0, &expr0_0, pattern4_0, &expr1_0)?; - return Some(expr2_0); - } - if pattern0_0 == F32X4 { - let pattern2_0 = arg1; - let pattern3_0 = arg2; - let pattern4_0 = arg3; - // Rule at src/isa/x64/lower.isle line 1329. - let expr0_0 = C::reg_mem_to_xmm_mem(ctx, pattern3_0); - let expr1_0 = C::sse_insertps_lane_imm(ctx, pattern4_0); - let expr2_0 = constructor_x64_insertps(ctx, pattern2_0, &expr0_0, expr1_0)?; - return Some(expr2_0); - } - if pattern0_0 == F64X2 { - let pattern2_0 = arg1; - let pattern3_0 = arg2; - if let &RegMem::Reg { reg: pattern4_0 } = pattern3_0 { - let pattern5_0 = arg3; - if pattern5_0 == 0 { - // Rule at src/isa/x64/lower.isle line 1351. - let expr0_0 = constructor_reg_to_xmm_mem(ctx, pattern4_0)?; - let expr1_0 = constructor_x64_movsd_regmove(ctx, pattern2_0, &expr0_0)?; - return Some(expr1_0); - } - } - let pattern4_0 = arg3; - if pattern4_0 == 0 { - // Rule at src/isa/x64/lower.isle line 1353. - let expr0_0 = C::reg_mem_to_xmm_mem(ctx, pattern3_0); - let expr1_0 = constructor_x64_movsd_load(ctx, &expr0_0)?; - let expr2_0 = C::xmm_to_xmm_mem(ctx, expr1_0); - let expr3_0 = constructor_x64_movsd_regmove(ctx, pattern2_0, &expr2_0)?; - return Some(expr3_0); - } - if pattern4_0 == 1 { - // Rule at src/isa/x64/lower.isle line 1361. - let expr0_0 = C::reg_mem_to_xmm_mem(ctx, pattern3_0); - let expr1_0 = constructor_x64_movlhps(ctx, pattern2_0, &expr0_0)?; - return Some(expr1_0); - } - } - return None; -} - -// Generated as internal constructor for term cmp_and_choose. -pub fn constructor_cmp_and_choose( - ctx: &mut C, - arg0: Type, - arg1: &CC, - arg2: Value, - arg3: Value, -) -> Option { - let pattern0_0 = arg0; - if let Some(pattern1_0) = C::fits_in_64(ctx, pattern0_0) { - let pattern2_0 = arg1; - let pattern3_0 = arg2; - let pattern4_0 = arg3; - // Rule at src/isa/x64/lower.isle line 1369. - let expr0_0 = C::raw_operand_size_of_type(ctx, pattern1_0); - let expr1_0 = C::put_in_reg(ctx, pattern3_0); - let expr2_0 = C::put_in_reg(ctx, pattern4_0); - let expr3_0 = constructor_reg_to_gpr_mem_imm(ctx, expr1_0)?; - let expr4_0 = C::gpr_new(ctx, expr2_0); - let expr5_0 = constructor_x64_cmp(ctx, &expr0_0, &expr3_0, expr4_0)?; - let expr6_0 = C::reg_to_gpr_mem(ctx, expr2_0); - let expr7_0 = C::gpr_new(ctx, expr1_0); - let expr8_0 = constructor_cmove(ctx, pattern1_0, pattern2_0, &expr6_0, expr7_0)?; - let expr9_0 = constructor_with_flags_reg(ctx, &expr5_0, &expr8_0)?; - let expr10_0 = C::value_reg(ctx, expr9_0); - return Some(expr10_0); - } - return None; -} - -// Generated as internal constructor for term do_clz. -pub fn constructor_do_clz( - ctx: &mut C, - arg0: Type, - arg1: Type, - arg2: Gpr, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/x64/lower.isle line 1816. - let expr0_0: Type = I64; - let expr1_0: i64 = -1; - let expr2_0 = constructor_imm_i64(ctx, expr0_0, expr1_0)?; - let expr3_0 = C::gpr_new(ctx, expr2_0); - let expr4_0 = constructor_bsr_or_else(ctx, pattern0_0, pattern2_0, expr3_0)?; - let expr5_0 = C::gpr_to_reg(ctx, expr4_0); - let expr6_0 = C::ty_bits_u64(ctx, pattern1_0); - let expr7_0: u64 = 1; - let expr8_0 = C::u64_sub(ctx, expr6_0, expr7_0)?; - let expr9_0 = constructor_imm(ctx, pattern0_0, expr8_0)?; - let expr10_0 = C::gpr_new(ctx, expr9_0); - let expr11_0 = constructor_reg_to_gpr_mem_imm(ctx, expr5_0)?; - let expr12_0 = constructor_x64_sub(ctx, pattern0_0, expr10_0, &expr11_0)?; - return Some(expr12_0); -} - -// Generated as internal constructor for term do_ctz. -pub fn constructor_do_ctz( - ctx: &mut C, - arg0: Type, - arg1: Type, - arg2: Gpr, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - let pattern2_0 = arg2; - // Rule at src/isa/x64/lower.isle line 1857. - let expr0_0: Type = I64; - let expr1_0 = C::ty_bits_u64(ctx, pattern1_0); - let expr2_0 = constructor_imm(ctx, expr0_0, expr1_0)?; - let expr3_0 = C::gpr_new(ctx, expr2_0); - let expr4_0 = constructor_bsf_or_else(ctx, pattern0_0, pattern2_0, expr3_0)?; - return Some(expr4_0); -} - -// Generated as internal constructor for term do_popcnt. -pub fn constructor_do_popcnt(ctx: &mut C, arg0: Type, arg1: Gpr) -> Option { - let pattern0_0 = arg0; - if pattern0_0 == I32 { - let pattern2_0 = arg1; - // Rule at src/isa/x64/lower.isle line 1948. - let expr0_0: Type = I32; - let expr1_0: u8 = 1; - let expr2_0 = Imm8Reg::Imm8 { imm: expr1_0 }; - let expr3_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr2_0); - let expr4_0 = constructor_x64_shr(ctx, expr0_0, pattern2_0, &expr3_0)?; - let expr5_0: Type = I32; - let expr6_0: u64 = 2004318071; - let expr7_0 = constructor_imm(ctx, expr5_0, expr6_0)?; - let expr8_0 = C::gpr_new(ctx, expr7_0); - let expr9_0: Type = I32; - let expr10_0 = C::gpr_to_gpr_mem_imm(ctx, expr8_0); - let expr11_0 = constructor_x64_and(ctx, expr9_0, expr4_0, &expr10_0)?; - let expr12_0: Type = I32; - let expr13_0 = C::gpr_to_gpr_mem_imm(ctx, expr11_0); - let expr14_0 = constructor_x64_sub(ctx, expr12_0, pattern2_0, &expr13_0)?; - let expr15_0: Type = I32; - let expr16_0: u8 = 1; - let expr17_0 = Imm8Reg::Imm8 { imm: expr16_0 }; - let expr18_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr17_0); - let expr19_0 = constructor_x64_shr(ctx, expr15_0, expr11_0, &expr18_0)?; - let expr20_0: Type = I32; - let expr21_0 = C::gpr_to_gpr_mem_imm(ctx, expr8_0); - let expr22_0 = constructor_x64_and(ctx, expr20_0, expr19_0, &expr21_0)?; - let expr23_0: Type = I32; - let expr24_0 = C::gpr_to_gpr_mem_imm(ctx, expr22_0); - let expr25_0 = constructor_x64_sub(ctx, expr23_0, expr14_0, &expr24_0)?; - let expr26_0: Type = I32; - let expr27_0: u8 = 1; - let expr28_0 = Imm8Reg::Imm8 { imm: expr27_0 }; - let expr29_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr28_0); - let expr30_0 = constructor_x64_shr(ctx, expr26_0, expr22_0, &expr29_0)?; - let expr31_0: Type = I32; - let expr32_0 = C::gpr_to_gpr_mem_imm(ctx, expr8_0); - let expr33_0 = constructor_x64_and(ctx, expr31_0, expr30_0, &expr32_0)?; - let expr34_0: Type = I32; - let expr35_0 = C::gpr_to_gpr_mem_imm(ctx, expr33_0); - let expr36_0 = constructor_x64_sub(ctx, expr34_0, expr25_0, &expr35_0)?; - let expr37_0: Type = I32; - let expr38_0: Type = I32; - let expr39_0: u8 = 4; - let expr40_0 = Imm8Reg::Imm8 { imm: expr39_0 }; - let expr41_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr40_0); - let expr42_0 = constructor_x64_shr(ctx, expr38_0, expr36_0, &expr41_0)?; - let expr43_0 = C::gpr_to_gpr_mem_imm(ctx, expr36_0); - let expr44_0 = constructor_x64_add(ctx, expr37_0, expr42_0, &expr43_0)?; - let expr45_0: Type = I32; - let expr46_0: u32 = 252645135; - let expr47_0 = RegMemImm::Imm { simm32: expr46_0 }; - let expr48_0 = C::gpr_mem_imm_new(ctx, &expr47_0); - let expr49_0 = constructor_x64_and(ctx, expr45_0, expr44_0, &expr48_0)?; - let expr50_0: Type = I32; - let expr51_0: u32 = 16843009; - let expr52_0 = RegMemImm::Imm { simm32: expr51_0 }; - let expr53_0 = C::gpr_mem_imm_new(ctx, &expr52_0); - let expr54_0 = constructor_x64_mul(ctx, expr50_0, expr49_0, &expr53_0)?; - let expr55_0: Type = I32; - let expr56_0: u8 = 24; - let expr57_0 = Imm8Reg::Imm8 { imm: expr56_0 }; - let expr58_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr57_0); - let expr59_0 = constructor_x64_shr(ctx, expr55_0, expr54_0, &expr58_0)?; - return Some(expr59_0); - } - if pattern0_0 == I64 { - let pattern2_0 = arg1; - // Rule at src/isa/x64/lower.isle line 1905. - let expr0_0: Type = I64; - let expr1_0: u8 = 1; - let expr2_0 = Imm8Reg::Imm8 { imm: expr1_0 }; - let expr3_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr2_0); - let expr4_0 = constructor_x64_shr(ctx, expr0_0, pattern2_0, &expr3_0)?; - let expr5_0: Type = I64; - let expr6_0: u64 = 8608480567731124087; - let expr7_0 = constructor_imm(ctx, expr5_0, expr6_0)?; - let expr8_0 = C::gpr_new(ctx, expr7_0); - let expr9_0: Type = I64; - let expr10_0 = C::gpr_to_gpr_mem_imm(ctx, expr8_0); - let expr11_0 = constructor_x64_and(ctx, expr9_0, expr4_0, &expr10_0)?; - let expr12_0: Type = I64; - let expr13_0 = C::gpr_to_gpr_mem_imm(ctx, expr11_0); - let expr14_0 = constructor_x64_sub(ctx, expr12_0, pattern2_0, &expr13_0)?; - let expr15_0: Type = I64; - let expr16_0: u8 = 1; - let expr17_0 = Imm8Reg::Imm8 { imm: expr16_0 }; - let expr18_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr17_0); - let expr19_0 = constructor_x64_shr(ctx, expr15_0, expr11_0, &expr18_0)?; - let expr20_0: Type = I64; - let expr21_0 = C::gpr_to_gpr_mem_imm(ctx, expr8_0); - let expr22_0 = constructor_x64_and(ctx, expr20_0, expr19_0, &expr21_0)?; - let expr23_0: Type = I64; - let expr24_0 = C::gpr_to_gpr_mem_imm(ctx, expr22_0); - let expr25_0 = constructor_x64_sub(ctx, expr23_0, expr14_0, &expr24_0)?; - let expr26_0: Type = I64; - let expr27_0: u8 = 1; - let expr28_0 = Imm8Reg::Imm8 { imm: expr27_0 }; - let expr29_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr28_0); - let expr30_0 = constructor_x64_shr(ctx, expr26_0, expr22_0, &expr29_0)?; - let expr31_0: Type = I64; - let expr32_0 = C::gpr_to_gpr_mem_imm(ctx, expr8_0); - let expr33_0 = constructor_x64_and(ctx, expr31_0, expr30_0, &expr32_0)?; - let expr34_0: Type = I64; - let expr35_0 = C::gpr_to_gpr_mem_imm(ctx, expr33_0); - let expr36_0 = constructor_x64_sub(ctx, expr34_0, expr25_0, &expr35_0)?; - let expr37_0: Type = I64; - let expr38_0: Type = I64; - let expr39_0: u8 = 4; - let expr40_0 = Imm8Reg::Imm8 { imm: expr39_0 }; - let expr41_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr40_0); - let expr42_0 = constructor_x64_shr(ctx, expr38_0, expr36_0, &expr41_0)?; - let expr43_0 = C::gpr_to_gpr_mem_imm(ctx, expr36_0); - let expr44_0 = constructor_x64_add(ctx, expr37_0, expr42_0, &expr43_0)?; - let expr45_0: Type = I64; - let expr46_0: u64 = 1085102592571150095; - let expr47_0 = constructor_imm(ctx, expr45_0, expr46_0)?; - let expr48_0 = C::gpr_new(ctx, expr47_0); - let expr49_0: Type = I64; - let expr50_0 = C::gpr_to_gpr_mem_imm(ctx, expr48_0); - let expr51_0 = constructor_x64_and(ctx, expr49_0, expr44_0, &expr50_0)?; - let expr52_0: Type = I64; - let expr53_0: u64 = 72340172838076673; - let expr54_0 = constructor_imm(ctx, expr52_0, expr53_0)?; - let expr55_0 = C::gpr_new(ctx, expr54_0); - let expr56_0: Type = I64; - let expr57_0 = C::gpr_to_gpr_mem_imm(ctx, expr55_0); - let expr58_0 = constructor_x64_mul(ctx, expr56_0, expr51_0, &expr57_0)?; - let expr59_0: Type = I64; - let expr60_0: u8 = 56; - let expr61_0 = Imm8Reg::Imm8 { imm: expr60_0 }; - let expr62_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr61_0); - let expr63_0 = constructor_x64_shr(ctx, expr59_0, expr58_0, &expr62_0)?; - return Some(expr63_0); - } - return None; -} - -// Generated as internal constructor for term do_bitrev8. -pub fn constructor_do_bitrev8(ctx: &mut C, arg0: Type, arg1: Gpr) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/x64/lower.isle line 2037. - let expr0_0 = C::ty_mask(ctx, pattern0_0); - let expr1_0: u64 = 6148914691236517205; - let expr2_0 = C::u64_and(ctx, expr0_0, expr1_0)?; - let expr3_0 = constructor_imm(ctx, pattern0_0, expr2_0)?; - let expr4_0 = C::gpr_new(ctx, expr3_0); - let expr5_0 = C::gpr_to_gpr_mem_imm(ctx, expr4_0); - let expr6_0 = constructor_x64_and(ctx, pattern0_0, pattern1_0, &expr5_0)?; - let expr7_0: u8 = 1; - let expr8_0 = Imm8Reg::Imm8 { imm: expr7_0 }; - let expr9_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr8_0); - let expr10_0 = constructor_x64_shr(ctx, pattern0_0, pattern1_0, &expr9_0)?; - let expr11_0 = C::gpr_to_gpr_mem_imm(ctx, expr4_0); - let expr12_0 = constructor_x64_and(ctx, pattern0_0, expr10_0, &expr11_0)?; - let expr13_0: u8 = 1; - let expr14_0 = Imm8Reg::Imm8 { imm: expr13_0 }; - let expr15_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr14_0); - let expr16_0 = constructor_x64_shl(ctx, pattern0_0, expr6_0, &expr15_0)?; - let expr17_0 = C::gpr_to_gpr_mem_imm(ctx, expr12_0); - let expr18_0 = constructor_x64_or(ctx, pattern0_0, expr16_0, &expr17_0)?; - let expr19_0: u64 = 3689348814741910323; - let expr20_0 = C::u64_and(ctx, expr0_0, expr19_0)?; - let expr21_0 = constructor_imm(ctx, pattern0_0, expr20_0)?; - let expr22_0 = C::gpr_new(ctx, expr21_0); - let expr23_0 = C::gpr_to_gpr_mem_imm(ctx, expr22_0); - let expr24_0 = constructor_x64_and(ctx, pattern0_0, expr18_0, &expr23_0)?; - let expr25_0: u8 = 2; - let expr26_0 = Imm8Reg::Imm8 { imm: expr25_0 }; - let expr27_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr26_0); - let expr28_0 = constructor_x64_shr(ctx, pattern0_0, expr18_0, &expr27_0)?; - let expr29_0 = C::gpr_to_gpr_mem_imm(ctx, expr22_0); - let expr30_0 = constructor_x64_and(ctx, pattern0_0, expr28_0, &expr29_0)?; - let expr31_0: u8 = 2; - let expr32_0 = Imm8Reg::Imm8 { imm: expr31_0 }; - let expr33_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr32_0); - let expr34_0 = constructor_x64_shl(ctx, pattern0_0, expr24_0, &expr33_0)?; - let expr35_0 = C::gpr_to_gpr_mem_imm(ctx, expr30_0); - let expr36_0 = constructor_x64_or(ctx, pattern0_0, expr34_0, &expr35_0)?; - let expr37_0: u64 = 1085102592571150095; - let expr38_0 = C::u64_and(ctx, expr0_0, expr37_0)?; - let expr39_0 = constructor_imm(ctx, pattern0_0, expr38_0)?; - let expr40_0 = C::gpr_new(ctx, expr39_0); - let expr41_0 = C::gpr_to_gpr_mem_imm(ctx, expr40_0); - let expr42_0 = constructor_x64_and(ctx, pattern0_0, expr36_0, &expr41_0)?; - let expr43_0: u8 = 4; - let expr44_0 = Imm8Reg::Imm8 { imm: expr43_0 }; - let expr45_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr44_0); - let expr46_0 = constructor_x64_shr(ctx, pattern0_0, expr36_0, &expr45_0)?; - let expr47_0 = C::gpr_to_gpr_mem_imm(ctx, expr40_0); - let expr48_0 = constructor_x64_and(ctx, pattern0_0, expr46_0, &expr47_0)?; - let expr49_0: u8 = 4; - let expr50_0 = Imm8Reg::Imm8 { imm: expr49_0 }; - let expr51_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr50_0); - let expr52_0 = constructor_x64_shl(ctx, pattern0_0, expr42_0, &expr51_0)?; - let expr53_0 = C::gpr_to_gpr_mem_imm(ctx, expr48_0); - let expr54_0 = constructor_x64_or(ctx, pattern0_0, expr52_0, &expr53_0)?; - return Some(expr54_0); -} - -// Generated as internal constructor for term do_bitrev16. -pub fn constructor_do_bitrev16(ctx: &mut C, arg0: Type, arg1: Gpr) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/x64/lower.isle line 2060. - let expr0_0 = constructor_do_bitrev8(ctx, pattern0_0, pattern1_0)?; - let expr1_0 = C::ty_mask(ctx, pattern0_0); - let expr2_0: u64 = 71777214294589695; - let expr3_0 = C::u64_and(ctx, expr1_0, expr2_0)?; - let expr4_0 = constructor_imm(ctx, pattern0_0, expr3_0)?; - let expr5_0 = C::gpr_new(ctx, expr4_0); - let expr6_0 = C::gpr_to_gpr_mem_imm(ctx, expr5_0); - let expr7_0 = constructor_x64_and(ctx, pattern0_0, expr0_0, &expr6_0)?; - let expr8_0: u8 = 8; - let expr9_0 = Imm8Reg::Imm8 { imm: expr8_0 }; - let expr10_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr9_0); - let expr11_0 = constructor_x64_shr(ctx, pattern0_0, expr0_0, &expr10_0)?; - let expr12_0 = C::gpr_to_gpr_mem_imm(ctx, expr5_0); - let expr13_0 = constructor_x64_and(ctx, pattern0_0, expr11_0, &expr12_0)?; - let expr14_0: u8 = 8; - let expr15_0 = Imm8Reg::Imm8 { imm: expr14_0 }; - let expr16_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr15_0); - let expr17_0 = constructor_x64_shl(ctx, pattern0_0, expr7_0, &expr16_0)?; - let expr18_0 = C::gpr_to_gpr_mem_imm(ctx, expr13_0); - let expr19_0 = constructor_x64_or(ctx, pattern0_0, expr17_0, &expr18_0)?; - return Some(expr19_0); -} - -// Generated as internal constructor for term do_bitrev32. -pub fn constructor_do_bitrev32(ctx: &mut C, arg0: Type, arg1: Gpr) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - // Rule at src/isa/x64/lower.isle line 2072. - let expr0_0 = constructor_do_bitrev16(ctx, pattern0_0, pattern1_0)?; - let expr1_0 = C::ty_mask(ctx, pattern0_0); - let expr2_0: u64 = 281470681808895; - let expr3_0 = C::u64_and(ctx, expr1_0, expr2_0)?; - let expr4_0 = constructor_imm(ctx, pattern0_0, expr3_0)?; - let expr5_0 = C::gpr_new(ctx, expr4_0); - let expr6_0 = C::gpr_to_gpr_mem_imm(ctx, expr5_0); - let expr7_0 = constructor_x64_and(ctx, pattern0_0, expr0_0, &expr6_0)?; - let expr8_0: u8 = 16; - let expr9_0 = Imm8Reg::Imm8 { imm: expr8_0 }; - let expr10_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr9_0); - let expr11_0 = constructor_x64_shr(ctx, pattern0_0, expr0_0, &expr10_0)?; - let expr12_0 = C::gpr_to_gpr_mem_imm(ctx, expr5_0); - let expr13_0 = constructor_x64_and(ctx, pattern0_0, expr11_0, &expr12_0)?; - let expr14_0: u8 = 16; - let expr15_0 = Imm8Reg::Imm8 { imm: expr14_0 }; - let expr16_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr15_0); - let expr17_0 = constructor_x64_shl(ctx, pattern0_0, expr7_0, &expr16_0)?; - let expr18_0 = C::gpr_to_gpr_mem_imm(ctx, expr13_0); - let expr19_0 = constructor_x64_or(ctx, pattern0_0, expr17_0, &expr18_0)?; - return Some(expr19_0); -} - -// Generated as internal constructor for term do_bitrev64. -pub fn constructor_do_bitrev64(ctx: &mut C, arg0: Type, arg1: Gpr) -> Option { - let pattern0_0 = arg0; - if pattern0_0 == I64 { - let pattern2_0 = arg1; - // Rule at src/isa/x64/lower.isle line 2084. - let expr0_0 = constructor_do_bitrev32(ctx, pattern0_0, pattern2_0)?; - let expr1_0: u64 = 4294967295; - let expr2_0 = constructor_imm(ctx, pattern0_0, expr1_0)?; - let expr3_0 = C::gpr_new(ctx, expr2_0); - let expr4_0 = C::gpr_to_gpr_mem_imm(ctx, expr3_0); - let expr5_0 = constructor_x64_and(ctx, pattern0_0, expr0_0, &expr4_0)?; - let expr6_0: u8 = 32; - let expr7_0 = Imm8Reg::Imm8 { imm: expr6_0 }; - let expr8_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr7_0); - let expr9_0 = constructor_x64_shr(ctx, pattern0_0, expr0_0, &expr8_0)?; - let expr10_0: u8 = 32; - let expr11_0 = Imm8Reg::Imm8 { imm: expr10_0 }; - let expr12_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr11_0); - let expr13_0 = constructor_x64_shl(ctx, pattern0_0, expr5_0, &expr12_0)?; - let expr14_0 = C::gpr_to_gpr_mem_imm(ctx, expr9_0); - let expr15_0 = constructor_x64_or(ctx, pattern0_0, expr13_0, &expr14_0)?; - return Some(expr15_0); - } - return None; -} - -// Generated as internal constructor for term generic_sextend. -pub fn constructor_generic_sextend( - ctx: &mut C, - arg0: Value, - arg1: Type, - arg2: Type, -) -> Option { - let pattern0_0 = arg0; - let pattern1_0 = arg1; - if let Some(pattern2_0) = C::fits_in_32(ctx, pattern1_0) { - let pattern3_0 = arg2; - if let Some(pattern4_0) = C::fits_in_32(ctx, pattern3_0) { - // Rule at src/isa/x64/lower.isle line 2204. - let expr0_0: Type = I32; - let expr1_0 = ExtendKind::Sign; - let expr2_0 = constructor_extend_to_gpr(ctx, pattern0_0, expr0_0, &expr1_0)?; - let expr3_0 = constructor_output_gpr(ctx, expr2_0)?; - return Some(expr3_0); - } - if let Some(pattern4_0) = C::ty_int_bool_64(ctx, pattern3_0) { - // Rule at src/isa/x64/lower.isle line 2200. - let expr0_0: Type = I64; - let expr1_0 = ExtendKind::Sign; - let expr2_0 = constructor_extend_to_gpr(ctx, pattern0_0, expr0_0, &expr1_0)?; - let expr3_0 = constructor_output_gpr(ctx, expr2_0)?; - return Some(expr3_0); - } - if let Some(pattern4_0) = C::ty_int_bool_128(ctx, pattern3_0) { - // Rule at src/isa/x64/lower.isle line 2194. - let expr0_0: Type = I64; - let expr1_0 = ExtendKind::Sign; - let expr2_0 = constructor_extend_to_gpr(ctx, pattern0_0, expr0_0, &expr1_0)?; - let expr3_0 = constructor_spread_sign_bit(ctx, expr2_0)?; - let expr4_0 = C::gpr_to_reg(ctx, expr2_0); - let expr5_0 = C::gpr_to_reg(ctx, expr3_0); - let expr6_0 = C::value_regs(ctx, expr4_0, expr5_0); - let expr7_0 = C::output(ctx, expr6_0); - return Some(expr7_0); - } - } - if let Some(pattern2_0) = C::ty_int_bool_64(ctx, pattern1_0) { - let pattern3_0 = arg2; - if let Some(pattern4_0) = C::ty_int_bool_128(ctx, pattern3_0) { - // Rule at src/isa/x64/lower.isle line 2190. - let expr0_0 = C::put_in_reg(ctx, pattern0_0); - let expr1_0 = constructor_put_in_gpr(ctx, pattern0_0)?; - let expr2_0 = constructor_spread_sign_bit(ctx, expr1_0)?; - let expr3_0 = C::gpr_to_reg(ctx, expr2_0); - let expr4_0 = C::value_regs(ctx, expr0_0, expr3_0); - let expr5_0 = C::output(ctx, expr4_0); - return Some(expr5_0); - } - } - let pattern2_0 = arg2; - if pattern2_0 == pattern1_0 { - // Rule at src/isa/x64/lower.isle line 2180. - let expr0_0 = constructor_output_value(ctx, pattern0_0)?; - return Some(expr0_0); - } - return None; -} - -// Generated as internal constructor for term spread_sign_bit. -pub fn constructor_spread_sign_bit(ctx: &mut C, arg0: Gpr) -> Option { - let pattern0_0 = arg0; - // Rule at src/isa/x64/lower.isle line 2186. - let expr0_0: Type = I64; - let expr1_0: u8 = 63; - let expr2_0 = Imm8Reg::Imm8 { imm: expr1_0 }; - let expr3_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr2_0); - let expr4_0 = constructor_x64_sar(ctx, expr0_0, pattern0_0, &expr3_0)?; - return Some(expr4_0); -} +include!(concat!(env!("ISLE_DIR"), "/isle_x64.rs")); diff --git a/cranelift/isle/fuzz/fuzz_targets/compile.rs b/cranelift/isle/fuzz/fuzz_targets/compile.rs index 2a21361b52..b98a5a37b5 100644 --- a/cranelift/isle/fuzz/fuzz_targets/compile.rs +++ b/cranelift/isle/fuzz/fuzz_targets/compile.rs @@ -1,6 +1,7 @@ #![no_main] use libfuzzer_sys::fuzz_target; +use std::default::Default; fuzz_target!(|s: &str| { let _ = env_logger::try_init(); @@ -19,7 +20,7 @@ fuzz_target!(|s: &str| { Err(_) => return, }; - let code = cranelift_isle::compile::compile(&defs); + let code = cranelift_isle::compile::compile(&defs, &Default::default()); log::debug!("code = {:?}", code); let code = match code { Ok(c) => c, diff --git a/cranelift/isle/isle/Cargo.toml b/cranelift/isle/isle/Cargo.toml index 4c4d0b6121..beb2d41586 100644 --- a/cranelift/isle/isle/Cargo.toml +++ b/cranelift/isle/isle/Cargo.toml @@ -9,9 +9,14 @@ repository = "https://github.com/bytecodealliance/wasmtime/tree/main/cranelift/i version = "0.85.0" [dependencies] -log = "0.4" -miette = "3.0.0" -thiserror = "1.0.29" +log = { version = "0.4", optional = true } +miette = { version = "4.7.0", optional = true } [dev-dependencies] tempfile = "3" + +[features] +default = [] + +logging = ["log"] +miette-errors = ["miette"] diff --git a/cranelift/isle/isle/src/ast.rs b/cranelift/isle/isle/src/ast.rs index fcf8f8fcc1..51ebdf23c7 100644 --- a/cranelift/isle/isle/src/ast.rs +++ b/cranelift/isle/isle/src/ast.rs @@ -3,6 +3,7 @@ #![allow(missing_docs)] use crate::lexer::Pos; +use crate::log; use std::sync::Arc; /// The parsed form of an ISLE file. @@ -172,7 +173,7 @@ impl Pattern { } pub fn make_macro_template(&self, macro_args: &[Ident]) -> Pattern { - log::trace!("make_macro_template: {:?} with {:?}", self, macro_args); + log!("make_macro_template: {:?} with {:?}", self, macro_args); match self { &Pattern::BindPattern { ref var, @@ -233,7 +234,7 @@ impl Pattern { } pub fn subst_macro_args(&self, macro_args: &[Pattern]) -> Option { - log::trace!("subst_macro_args: {:?} with {:?}", self, macro_args); + log!("subst_macro_args: {:?} with {:?}", self, macro_args); match self { &Pattern::BindPattern { ref var, diff --git a/cranelift/isle/isle/src/codegen.rs b/cranelift/isle/isle/src/codegen.rs index b280d3a8f2..c157b1dd15 100644 --- a/cranelift/isle/isle/src/codegen.rs +++ b/cranelift/isle/isle/src/codegen.rs @@ -1,15 +1,29 @@ //! Generate Rust code from a series of Sequences. use crate::ir::{ExprInst, InstId, PatternInst, Value}; +use crate::log; use crate::sema::ExternalSig; use crate::sema::{TermEnv, TermId, Type, TypeEnv, TypeId, Variant}; use crate::trie::{TrieEdge, TrieNode, TrieSymbol}; use std::collections::{BTreeMap, BTreeSet}; use std::fmt::Write; +/// Options for code generation. +#[derive(Clone, Debug, Default)] +pub struct CodegenOptions { + /// Do not include the `#![allow(...)]` pragmas in the generated + /// source. Useful if it must be include!()'d elsewhere. + pub exclude_global_allow_pragmas: bool, +} + /// Emit Rust source code for the given type and term environments. -pub fn codegen(typeenv: &TypeEnv, termenv: &TermEnv, tries: &BTreeMap) -> String { - Codegen::compile(typeenv, termenv, tries).generate_rust() +pub fn codegen( + typeenv: &TypeEnv, + termenv: &TermEnv, + tries: &BTreeMap, + options: &CodegenOptions, +) -> String { + Codegen::compile(typeenv, termenv, tries).generate_rust(options) } #[derive(Clone, Debug)] @@ -38,10 +52,10 @@ impl<'a> Codegen<'a> { } } - fn generate_rust(&self) -> String { + fn generate_rust(&self, options: &CodegenOptions) -> String { let mut code = String::new(); - self.generate_header(&mut code); + self.generate_header(&mut code, options); self.generate_ctx_trait(&mut code); self.generate_internal_types(&mut code); self.generate_internal_term_constructors(&mut code); @@ -49,7 +63,7 @@ impl<'a> Codegen<'a> { code } - fn generate_header(&self, code: &mut String) { + fn generate_header(&self, code: &mut String, options: &CodegenOptions) { writeln!(code, "// GENERATED BY ISLE. DO NOT EDIT!").unwrap(); writeln!(code, "//").unwrap(); writeln!( @@ -61,17 +75,19 @@ impl<'a> Codegen<'a> { writeln!(code, "// - {}", file).unwrap(); } - writeln!( - code, - "\n#![allow(dead_code, unreachable_code, unreachable_patterns)]" - ) - .unwrap(); - writeln!( - code, - "#![allow(unused_imports, unused_variables, non_snake_case, unused_mut)]" - ) - .unwrap(); - writeln!(code, "#![allow(irrefutable_let_patterns)]").unwrap(); + if !options.exclude_global_allow_pragmas { + writeln!( + code, + "\n#![allow(dead_code, unreachable_code, unreachable_patterns)]" + ) + .unwrap(); + writeln!( + code, + "#![allow(unused_imports, unused_variables, non_snake_case, unused_mut)]" + ) + .unwrap(); + writeln!(code, "#![allow(irrefutable_let_patterns)]").unwrap(); + } writeln!(code, "\nuse super::*; // Pulls in all external types.").unwrap(); } @@ -311,7 +327,7 @@ impl<'a> Codegen<'a> { ctx: &mut BodyContext, returns: &mut Vec<(usize, String)>, ) { - log::trace!("generate_expr_inst: {:?}", inst); + log!("generate_expr_inst: {:?}", inst); match inst { &ExprInst::ConstInt { ty, val } => { let value = Value::Expr { @@ -665,7 +681,7 @@ impl<'a> Codegen<'a> { indent: &str, ctx: &mut BodyContext, ) -> bool { - log::trace!("generate_body:\n{}", trie.pretty()); + log!("generate_body:\n{}", trie.pretty()); let mut returned = false; match trie { &TrieNode::Empty => {} @@ -706,7 +722,7 @@ impl<'a> Codegen<'a> { let mut last = i; let mut adjacent_variants = BTreeSet::new(); let mut adjacent_variant_input = None; - log::trace!( + log!( "edge: prio = {:?}, symbol = {:?}", edges[i].prio, edges[i].symbol diff --git a/cranelift/isle/isle/src/compile.rs b/cranelift/isle/isle/src/compile.rs index 8d9a1bb754..877b8a5cec 100644 --- a/cranelift/isle/isle/src/compile.rs +++ b/cranelift/isle/isle/src/compile.rs @@ -4,9 +4,9 @@ use crate::error::Result; use crate::{ast, codegen, sema, trie}; /// Compile the given AST definitions into Rust source code. -pub fn compile(defs: &ast::Defs) -> Result { +pub fn compile(defs: &ast::Defs, options: &codegen::CodegenOptions) -> Result { let mut typeenv = sema::TypeEnv::from_ast(defs)?; let termenv = sema::TermEnv::from_ast(&mut typeenv, defs)?; let tries = trie::build_tries(&typeenv, &termenv); - Ok(codegen::codegen(&typeenv, &termenv, &tries)) + Ok(codegen::codegen(&typeenv, &termenv, &tries, options)) } diff --git a/cranelift/isle/isle/src/error.rs b/cranelift/isle/isle/src/error.rs index 4aee4c0e2e..89c0ae4341 100644 --- a/cranelift/isle/isle/src/error.rs +++ b/cranelift/isle/isle/src/error.rs @@ -1,62 +1,47 @@ //! Error types. -use miette::{Diagnostic, SourceCode, SourceSpan}; use std::sync::Arc; /// Either `Ok(T)` or `Err(isle::Error)`. pub type Result = std::result::Result; /// Errors produced by ISLE. -#[derive(thiserror::Error, Diagnostic, Clone, Debug)] +#[derive(Clone, Debug)] pub enum Error { /// An I/O error. - #[error("{context}")] IoError { /// The underlying I/O error. - #[source] error: Arc, /// The context explaining what caused the I/O error. context: String, }, /// The input ISLE source has a parse error. - #[error("parse error: {msg}")] - #[diagnostic()] ParseError { /// The error message. msg: String, /// The input ISLE source. - #[source_code] src: Source, /// The location of the parse error. - #[label("{msg}")] - span: SourceSpan, + span: Span, }, /// The input ISLE source has a type error. - #[error("type error: {msg}")] - #[diagnostic()] TypeError { /// The error message. msg: String, /// The input ISLE source. - #[source_code] src: Source, /// The location of the type error. - #[label("{msg}")] - span: SourceSpan, + span: Span, }, /// Multiple errors. - #[error("Found {} errors:\n\n{}", - self.unwrap_errors().len(), - DisplayErrors(self.unwrap_errors()))] - #[diagnostic()] - Errors(#[related] Vec), + Errors(Vec), } impl Error { @@ -84,6 +69,31 @@ impl Error { } } +impl std::error::Error for Error { + fn source(&self) -> Option<&(dyn std::error::Error + 'static)> { + match self { + Error::IoError { error, .. } => Some(&*error as &dyn std::error::Error), + _ => None, + } + } +} + +impl std::fmt::Display for Error { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + match self { + Error::IoError { context, .. } => write!(f, "{}", context), + Error::ParseError { msg, .. } => write!(f, "parse error: {}", msg), + Error::TypeError { msg, .. } => write!(f, "type error: {}", msg), + Error::Errors(_) => write!( + f, + "found {} errors:\n\n{}", + self.unwrap_errors().len(), + DisplayErrors(self.unwrap_errors()) + ), + } + } +} + struct DisplayErrors<'a>(&'a [Error]); impl std::fmt::Display for DisplayErrors<'_> { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { @@ -97,8 +107,11 @@ impl std::fmt::Display for DisplayErrors<'_> { /// A source file and its contents. #[derive(Clone)] pub struct Source { - name: Arc, - text: Arc, + /// The name of this source file. + pub name: Arc, + /// The text of this source file. + #[allow(unused)] // Used only when miette is enabled. + pub text: Arc, } impl std::fmt::Debug for Source { @@ -126,23 +139,21 @@ impl Source { } } -impl SourceCode for Source { - fn read_span<'a>( - &'a self, - span: &SourceSpan, - context_lines_before: usize, - context_lines_after: usize, - ) -> std::result::Result + 'a>, miette::MietteError> { - let contents = self - .text - .read_span(span, context_lines_before, context_lines_after)?; - Ok(Box::new(miette::MietteSpanContents::new_named( - self.name.to_string(), - contents.data(), - contents.span().clone(), - contents.line(), - contents.column(), - contents.line_count(), - ))) +/// A span in a given source. +#[derive(Clone, Debug)] +pub struct Span { + /// The byte offset of the start of the span. + pub from: usize, + /// The byte offset of the end of the span. + pub to: usize, +} + +impl Span { + /// Create a new span that covers one character at the given offset. + pub fn new_single(offset: usize) -> Span { + Span { + from: offset, + to: offset + 1, + } } } diff --git a/cranelift/isle/isle/src/error_miette.rs b/cranelift/isle/isle/src/error_miette.rs new file mode 100644 index 0000000000..4050b065ad --- /dev/null +++ b/cranelift/isle/isle/src/error_miette.rs @@ -0,0 +1,65 @@ +//! miette-specific trait implementations. This is kept separate so +//! that we can have a very lightweight build of the ISLE compiler as +//! part of the Cranelift build process without pulling in any +//! dependencies. + +use crate::error::{Error, Source, Span}; +use miette::{SourceCode, SourceSpan}; + +impl From for SourceSpan { + fn from(span: Span) -> Self { + SourceSpan::new(span.from.into(), span.to.into()) + } +} + +impl SourceCode for Source { + fn read_span<'a>( + &'a self, + span: &SourceSpan, + context_lines_before: usize, + context_lines_after: usize, + ) -> std::result::Result + 'a>, miette::MietteError> { + let contents = self + .text + .read_span(span, context_lines_before, context_lines_after)?; + Ok(Box::new(miette::MietteSpanContents::new_named( + self.name.to_string(), + contents.data(), + contents.span().clone(), + contents.line(), + contents.column(), + contents.line_count(), + ))) + } +} + +impl miette::Diagnostic for Error { + fn labels(&self) -> Option + '_>> { + match self { + Self::ParseError { msg, span, .. } | Self::TypeError { msg, span, .. } => { + Some(Box::new( + vec![miette::LabeledSpan::new_with_span( + Some(msg.clone()), + span.clone(), + )] + .into_iter(), + )) + } + _ => None, + } + } + fn source_code(&self) -> std::option::Option<&dyn miette::SourceCode> { + match self { + Self::ParseError { src, .. } | Self::TypeError { src, .. } => Some(src), + _ => None, + } + } + fn related(&self) -> Option + '_>> { + match self { + Self::Errors(errors) => Some(Box::new( + errors.iter().map(|x| x as &dyn miette::Diagnostic), + )), + _ => None, + } + } +} diff --git a/cranelift/isle/isle/src/ir.rs b/cranelift/isle/isle/src/ir.rs index e7f7a86e77..58c7d410a1 100644 --- a/cranelift/isle/isle/src/ir.rs +++ b/cranelift/isle/isle/src/ir.rs @@ -1,6 +1,7 @@ //! Lowered matching IR. use crate::lexer::Pos; +use crate::log; use crate::sema::*; use std::collections::BTreeMap; @@ -549,7 +550,7 @@ impl ExprSequence { expr: &Expr, vars: &BTreeMap, ) -> Value { - log::trace!("gen_expr: expr {:?}", expr); + log!("gen_expr: expr {:?}", expr); match expr { &Expr::ConstInt(ty, val) => self.add_const_int(ty, val), &Expr::ConstPrim(ty, val) => self.add_const_prim(ty, val), @@ -627,7 +628,7 @@ pub fn lower_rule( .root_term() .expect("Pattern must have a term at the root"); - log::trace!("lower_rule: ruledata {:?}", ruledata,); + log!("lower_rule: ruledata {:?}", ruledata,); // Lower the pattern, starting from the root input value. pattern_seq.gen_pattern( diff --git a/cranelift/isle/isle/src/lexer.rs b/cranelift/isle/isle/src/lexer.rs index b898fd4074..996356c568 100644 --- a/cranelift/isle/isle/src/lexer.rs +++ b/cranelift/isle/isle/src/lexer.rs @@ -1,6 +1,6 @@ //! Lexer for the ISLE language. -use crate::error::{Error, Result, Source}; +use crate::error::{Error, Result, Source, Span}; use std::borrow::Cow; use std::path::Path; use std::sync::Arc; @@ -167,7 +167,7 @@ impl<'a> Lexer<'a> { self.filenames[pos.file].clone(), self.file_texts[pos.file].clone(), ), - span: miette::SourceSpan::from((self.pos().offset, 1)), + span: Span::new_single(self.pos().offset), } } diff --git a/cranelift/isle/isle/src/lib.rs b/cranelift/isle/isle/src/lib.rs index c516a78d9e..38d8f81a31 100644 --- a/cranelift/isle/isle/src/lib.rs +++ b/cranelift/isle/isle/src/lib.rs @@ -24,6 +24,10 @@ pub mod compile; pub mod error; pub mod ir; pub mod lexer; +mod log; pub mod parser; pub mod sema; pub mod trie; + +#[cfg(feature = "miette-errors")] +mod error_miette; diff --git a/cranelift/isle/isle/src/log.rs b/cranelift/isle/isle/src/log.rs new file mode 100644 index 0000000000..9cf02ef8b5 --- /dev/null +++ b/cranelift/isle/isle/src/log.rs @@ -0,0 +1,17 @@ +//! Debug logging from the ISLE compiler itself. + +/// Log a compiler-internal message for debugging purposes. +#[cfg(feature = "logging")] +#[macro_export] +macro_rules! log { + ($($msg:tt)*) => { + ::log::trace!($($msg)*) + }; +} + +/// Log a compiler-internal message for debugging purposes. +#[cfg(not(feature = "logging"))] +#[macro_export] +macro_rules! log { + ($($msg:tt)*) => {}; +} diff --git a/cranelift/isle/isle/src/parser.rs b/cranelift/isle/isle/src/parser.rs index 09c91946da..1427cdb2c4 100644 --- a/cranelift/isle/isle/src/parser.rs +++ b/cranelift/isle/isle/src/parser.rs @@ -39,7 +39,7 @@ impl<'a> Parser<'a> { self.lexer.filenames[pos.file].clone(), self.lexer.file_texts[pos.file].clone(), ), - span: miette::SourceSpan::from((pos.offset, 1)), + span: Span::new_single(pos.offset), } } diff --git a/cranelift/isle/isle/src/sema.rs b/cranelift/isle/isle/src/sema.rs index 1a626ce67a..784fbb5bdd 100644 --- a/cranelift/isle/isle/src/sema.rs +++ b/cranelift/isle/isle/src/sema.rs @@ -17,6 +17,7 @@ use crate::ast; use crate::ast::Ident; use crate::error::*; use crate::lexer::Pos; +use crate::log; use std::collections::btree_map::Entry; use std::collections::BTreeMap; use std::collections::BTreeSet; @@ -725,9 +726,9 @@ impl TypeEnv { self.filenames[pos.file].clone(), self.file_texts[pos.file].clone(), ), - span: miette::SourceSpan::from((pos.offset, 1)), + span: Span::new_single(pos.offset), }; - log::trace!("{}", e); + log!("{}", e); e } @@ -902,7 +903,7 @@ impl TermEnv { fn collect_constructors(&mut self, tyenv: &mut TypeEnv, defs: &ast::Defs) { for def in &defs.defs { - log::debug!("collect_constructors from def: {:?}", def); + log!("collect_constructors from def: {:?}", def); match def { &ast::Def::Rule(ref rule) => { let pos = rule.pos; @@ -982,7 +983,7 @@ impl TermEnv { }; let template = ext.template.make_macro_template(&ext.args[..]); - log::trace!("extractor def: {:?} becomes template {:?}", def, template); + log!("extractor def: {:?} becomes template {:?}", def, template); let mut callees = BTreeSet::new(); template.terms(&mut |pos, t| { @@ -1451,8 +1452,8 @@ impl TermEnv { bindings: &mut Bindings, is_root: bool, ) -> Option<(Pattern, TypeId)> { - log::trace!("translate_pattern: {:?}", pat); - log::trace!("translate_pattern: bindings = {:?}", bindings); + log!("translate_pattern: {:?}", pat); + log!("translate_pattern: bindings = {:?}", bindings); match pat { // TODO: flag on primitive type decl indicating it's an integer type? &ast::Pattern::ConstInt { val, pos } => { @@ -1546,7 +1547,7 @@ impl TermEnv { } let id = VarId(bindings.next_var); bindings.next_var += 1; - log::trace!("binding var {:?}", var.0); + log!("binding var {:?}", var.0); bindings.vars.push(BoundVar { name, id, ty }); Some((Pattern::BindPattern(ty, id, Box::new(subpat)), ty)) @@ -1572,7 +1573,7 @@ impl TermEnv { }; let id = VarId(bindings.next_var); bindings.next_var += 1; - log::trace!("binding var {:?}", var.0); + log!("binding var {:?}", var.0); bindings.vars.push(BoundVar { name, id, ty }); Some(( Pattern::BindPattern(ty, id, Box::new(Pattern::Wildcard(ty))), @@ -1687,7 +1688,7 @@ impl TermEnv { for template_arg in args { macro_args.push(template_arg.clone()); } - log::trace!("internal extractor macro args = {:?}", args); + log!("internal extractor macro args = {:?}", args); let pat = template.subst_macro_args(¯o_args[..])?; return self.translate_pattern( tyenv, @@ -1767,7 +1768,7 @@ impl TermEnv { bindings: &mut Bindings, pure: bool, ) -> Option { - log::trace!("translate_expr: {:?}", expr); + log!("translate_expr: {:?}", expr); match expr { &ast::Expr::Term { ref sym, diff --git a/cranelift/isle/isle/src/trie.rs b/cranelift/isle/isle/src/trie.rs index 686d0afd98..02a183816e 100644 --- a/cranelift/isle/isle/src/trie.rs +++ b/cranelift/isle/isle/src/trie.rs @@ -1,6 +1,7 @@ //! Trie construction. use crate::ir::{lower_rule, ExprSequence, PatternInst, PatternSequence}; +use crate::log; use crate::sema::{RuleId, TermEnv, TermId, TypeEnv}; use std::collections::BTreeMap; @@ -8,7 +9,7 @@ use std::collections::BTreeMap; pub fn build_tries(typeenv: &TypeEnv, termenv: &TermEnv) -> BTreeMap { let mut builder = TermFunctionsBuilder::new(typeenv, termenv); builder.build(); - log::trace!("builder: {:?}", builder); + log!("builder: {:?}", builder); builder.finalize() } @@ -324,8 +325,8 @@ struct TermFunctionsBuilder<'a> { impl<'a> TermFunctionsBuilder<'a> { fn new(typeenv: &'a TypeEnv, termenv: &'a TermEnv) -> Self { - log::trace!("typeenv: {:?}", typeenv); - log::trace!("termenv: {:?}", termenv); + log!("typeenv: {:?}", typeenv); + log!("termenv: {:?}", termenv); Self { builders_by_term: BTreeMap::new(), typeenv, @@ -341,7 +342,7 @@ impl<'a> TermFunctionsBuilder<'a> { let (pattern, expr) = lower_rule(self.typeenv, self.termenv, rule); let root_term = self.termenv.rules[rule.index()].lhs.root_term().unwrap(); - log::trace!( + log!( "build:\n- rule {:?}\n- pattern {:?}\n- expr {:?}", self.termenv.rules[rule.index()], pattern, diff --git a/cranelift/isle/isle/tests/run_tests.rs b/cranelift/isle/isle/tests/run_tests.rs index b328597bd3..2447b45117 100644 --- a/cranelift/isle/isle/tests/run_tests.rs +++ b/cranelift/isle/isle/tests/run_tests.rs @@ -2,11 +2,12 @@ use cranelift_isle::error::Result; use cranelift_isle::{compile, lexer, parser}; +use std::default::Default; fn build(filename: &str) -> Result { let lexer = lexer::Lexer::from_files(vec![filename])?; let defs = parser::parse(lexer)?; - compile::compile(&defs) + compile::compile(&defs, &Default::default()) } pub fn run_pass(filename: &str) { diff --git a/cranelift/isle/islec/Cargo.toml b/cranelift/isle/islec/Cargo.toml index f65970c310..ce35735b4c 100644 --- a/cranelift/isle/islec/Cargo.toml +++ b/cranelift/isle/islec/Cargo.toml @@ -7,7 +7,7 @@ license = "Apache-2.0 WITH LLVM-exception" publish = false [dependencies] -cranelift-isle = { version = "*", path = "../isle/" } +cranelift-isle = { version = "*", path = "../isle/", features = ["miette-errors", "logging"] } env_logger = { version = "0.9", default-features = false } -miette = { version = "3.0.0", features = ["fancy"] } +miette = { version = "4.7.0", features = ["fancy"] } clap = { version = "3.1.12", features = ["derive"] } diff --git a/cranelift/isle/islec/src/main.rs b/cranelift/isle/islec/src/main.rs index 2f5ab17c0e..20c235d929 100644 --- a/cranelift/isle/islec/src/main.rs +++ b/cranelift/isle/islec/src/main.rs @@ -2,6 +2,7 @@ use clap::Parser; use cranelift_isle::{compile, lexer, parser}; use miette::{Context, IntoDiagnostic, Result}; use std::{ + default::Default, fs, io::{self, Write}, path::PathBuf, @@ -36,7 +37,7 @@ fn main() -> Result<()> { let lexer = lexer::Lexer::from_files(opts.inputs)?; let defs = parser::parse(lexer)?; - let code = compile::compile(&defs)?; + let code = compile::compile(&defs, &Default::default())?; let stdout = io::stdout(); let (mut output, output_name): (Box, _) = match &opts.output { diff --git a/scripts/force-rebuild-isle.sh b/scripts/force-rebuild-isle.sh deleted file mode 100755 index 1137341c34..0000000000 --- a/scripts/force-rebuild-isle.sh +++ /dev/null @@ -1,19 +0,0 @@ -#!/bin/sh -# -# This script rebuilds all ISLE generated source that is checked in, even if -# the source has not changed relative to the manifests. -# -# This is useful when one is developing the ISLE compiler itself; otherwise, -# changing the compiler does not automatically change the generated code, even -# if the `rebuild-isle` feature is specified. - -set -e - -# Remove the manifests (which contain hashes of ISLE source) to force the build -# script to regenerate all backends. -rm -f cranelift/codegen/src/isa/*/lower/isle/generated_code.manifest - -# `cargo check` will both invoke the build script to rebuild the backends, and -# check that the output is valid Rust. We specify `all-arch` here to include -# all backends. -cargo check -p cranelift-codegen --features rebuild-isle,all-arch