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