commit 9ed1b679c08ff3fa1569e65cb50499e9d7cfdb5a
Author: Jacob Lifshay <programmerjake@gmail.com>
Date:   Mon Mar 30 19:41:36 2026 -0700

    initial commit

diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..6623e2b
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,6 @@
+# SPDX-License-Identifier: LGPL-3.0-or-later
+# See Notices.txt for copyright information
+/downloads
+/qemu-10.2.2*
+/libqemu-ppc64-softmmu.*
+/target
diff --git a/Cargo.lock b/Cargo.lock
new file mode 100644
index 0000000..1f630ab
--- /dev/null
+++ b/Cargo.lock
@@ -0,0 +1,178 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "anyhow"
+version = "1.0.102"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7f202df86484c868dbad7eaa557ef785d5c66295e41b460ef922eca0723b842c"
+
+[[package]]
+name = "cc"
+version = "1.2.58"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e1e928d4b69e3077709075a938a05ffbedfa53a84c8f766efbf8220bb1ff60e1"
+dependencies = [
+ "find-msvc-tools",
+ "shlex",
+]
+
+[[package]]
+name = "compile-qemu-for-decoder"
+version = "0.1.0"
+dependencies = [
+ "eyre",
+ "inkwell",
+]
+
+[[package]]
+name = "eyre"
+version = "0.6.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7cd915d99f24784cdc19fd37ef22b97e3ff0ae756c7e492e9fbfe897d61e2aec"
+dependencies = [
+ "indenter",
+ "once_cell",
+]
+
+[[package]]
+name = "find-msvc-tools"
+version = "0.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5baebc0774151f905a1a2cc41989300b1e6fbb29aff0ceffa1064fdd3088d582"
+
+[[package]]
+name = "indenter"
+version = "0.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "964de6e86d545b246d84badc0fef527924ace5134f30641c203ef52ba83f58d5"
+
+[[package]]
+name = "inkwell"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1def4112dfb2ce2993db7027f7acdb43c1f4ee1c70a082a2eef306ed5d0df365"
+dependencies = [
+ "inkwell_internals",
+ "libc",
+ "llvm-sys",
+ "once_cell",
+ "thiserror",
+]
+
+[[package]]
+name = "inkwell_internals"
+version = "0.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "63736175c9a30ea123f7018de9f26163e0b39cd6978990ae486b510c4f3bad69"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "lazy_static"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
+
+[[package]]
+name = "libc"
+version = "0.2.183"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b5b646652bf6661599e1da8901b3b9522896f01e736bad5f723fe7a3a27f899d"
+
+[[package]]
+name = "llvm-sys"
+version = "201.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9bb947e8b79254ca10d496d0798a9ba1287dcf68e50a92b016fec1cc45bef447"
+dependencies = [
+ "anyhow",
+ "cc",
+ "lazy_static",
+ "libc",
+ "regex-lite",
+ "semver",
+]
+
+[[package]]
+name = "once_cell"
+version = "1.21.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50"
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.106"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8fd00f0bb2e90d81d1044c2b32617f68fcb9fa3bb7640c23e9c748e53fb30934"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.45"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41f2619966050689382d2b44f664f4bc593e129785a36d6ee376ddf37259b924"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "regex-lite"
+version = "0.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cab834c73d247e67f4fae452806d17d3c7501756d98c8808d7c9c7aa7d18f973"
+
+[[package]]
+name = "semver"
+version = "1.0.27"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d767eb0aabc880b29956c35734170f26ed551a859dbd361d140cdbeca61ab1e2"
+
+[[package]]
+name = "shlex"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
+
+[[package]]
+name = "syn"
+version = "2.0.117"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e665b8803e7b1d2a727f4023456bbbbe74da67099c585258af0ad9c5013b9b99"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "thiserror"
+version = "2.0.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4288b5bcbc7920c07a1149a35cf9590a2aa808e0bc1eafaade0b80947865fbc4"
+dependencies = [
+ "thiserror-impl",
+]
+
+[[package]]
+name = "thiserror-impl"
+version = "2.0.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ebc4ee7f67670e9b64d05fa4253e753e016c6c95ff35b89b7941d6b856dec1d5"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.24"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75"
diff --git a/Cargo.toml b/Cargo.toml
new file mode 100644
index 0000000..9e06087
--- /dev/null
+++ b/Cargo.toml
@@ -0,0 +1,10 @@
+# SPDX-License-Identifier: LGPL-3.0-or-later
+# See Notices.txt for copyright information
+[package]
+name = "compile-qemu-for-decoder"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+eyre = "0.6.12"
+inkwell = { version = "0.8.0", features = ["no-libffi-linking", "llvm20-1", "target-powerpc", "llvm20-1-prefer-dynamic"], default-features = false }
diff --git a/LICENSE.md b/LICENSE.md
new file mode 100644
index 0000000..0927556
--- /dev/null
+++ b/LICENSE.md
@@ -0,0 +1,157 @@
+### GNU LESSER GENERAL PUBLIC LICENSE
+
+Version 3, 29 June 2007
+
+Copyright (C) 2007 Free Software Foundation, Inc.
+<https://fsf.org/>
+
+Everyone is permitted to copy and distribute verbatim copies of this
+license document, but changing it is not allowed.
+
+This version of the GNU Lesser General Public License incorporates the
+terms and conditions of version 3 of the GNU General Public License,
+supplemented by the additional permissions listed below.
+
+#### 0. Additional Definitions.
+
+As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the
+GNU General Public License.
+
+"The Library" refers to a covered work governed by this License, other
+than an Application or a Combined Work as defined below.
+
+An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+A "Combined Work" is a work produced by combining or linking an
+Application with the Library. The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+#### 1. Exception to Section 3 of the GNU GPL.
+
+You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+#### 2. Conveying Modified Versions.
+
+If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+-   a) under this License, provided that you make a good faith effort
+    to ensure that, in the event an Application does not supply the
+    function or data, the facility still operates, and performs
+    whatever part of its purpose remains meaningful, or
+-   b) under the GNU GPL, with none of the additional permissions of
+    this License applicable to that copy.
+
+#### 3. Object Code Incorporating Material from Library Header Files.
+
+The object code form of an Application may incorporate material from a
+header file that is part of the Library. You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+-   a) Give prominent notice with each copy of the object code that
+    the Library is used in it and that the Library and its use are
+    covered by this License.
+-   b) Accompany the object code with a copy of the GNU GPL and this
+    license document.
+
+#### 4. Combined Works.
+
+You may convey a Combined Work under terms of your choice that, taken
+together, effectively do not restrict modification of the portions of
+the Library contained in the Combined Work and reverse engineering for
+debugging such modifications, if you also do each of the following:
+
+-   a) Give prominent notice with each copy of the Combined Work that
+    the Library is used in it and that the Library and its use are
+    covered by this License.
+-   b) Accompany the Combined Work with a copy of the GNU GPL and this
+    license document.
+-   c) For a Combined Work that displays copyright notices during
+    execution, include the copyright notice for the Library among
+    these notices, as well as a reference directing the user to the
+    copies of the GNU GPL and this license document.
+-   d) Do one of the following:
+    -   0) Convey the Minimal Corresponding Source under the terms of
+        this License, and the Corresponding Application Code in a form
+        suitable for, and under terms that permit, the user to
+        recombine or relink the Application with a modified version of
+        the Linked Version to produce a modified Combined Work, in the
+        manner specified by section 6 of the GNU GPL for conveying
+        Corresponding Source.
+    -   1) Use a suitable shared library mechanism for linking with
+        the Library. A suitable mechanism is one that (a) uses at run
+        time a copy of the Library already present on the user's
+        computer system, and (b) will operate properly with a modified
+        version of the Library that is interface-compatible with the
+        Linked Version.
+-   e) Provide Installation Information, but only if you would
+    otherwise be required to provide such information under section 6
+    of the GNU GPL, and only to the extent that such information is
+    necessary to install and execute a modified version of the
+    Combined Work produced by recombining or relinking the Application
+    with a modified version of the Linked Version. (If you use option
+    4d0, the Installation Information must accompany the Minimal
+    Corresponding Source and Corresponding Application Code. If you
+    use option 4d1, you must provide the Installation Information in
+    the manner specified by section 6 of the GNU GPL for conveying
+    Corresponding Source.)
+
+#### 5. Combined Libraries.
+
+You may place library facilities that are a work based on the Library
+side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+-   a) Accompany the combined library with a copy of the same work
+    based on the Library, uncombined with any other library
+    facilities, conveyed under the terms of this License.
+-   b) Give prominent notice with the combined library that part of it
+    is a work based on the Library, and explaining where to find the
+    accompanying uncombined form of the same work.
+
+#### 6. Revised Versions of the GNU Lesser General Public License.
+
+The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser General Public License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.
+
+Each version is given a distinguishing version number. If the Library
+as you received it specifies that a certain numbered version of the
+GNU Lesser General Public License "or any later version" applies to
+it, you have the option of following the terms and conditions either
+of that published version or of any later version published by the
+Free Software Foundation. If the Library as you received it does not
+specify a version number of the GNU Lesser General Public License, you
+may choose any version of the GNU Lesser General Public License ever
+published by the Free Software Foundation.
+
+If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.
diff --git a/Notices.txt b/Notices.txt
new file mode 100644
index 0000000..9dcca8d
--- /dev/null
+++ b/Notices.txt
@@ -0,0 +1,16 @@
+Copyright 2026 Jacob Lifshay
+
+This file is part of Compile-QEMU-for-decoder.
+
+Compile-QEMU-for-decoder is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+Compile-QEMU-for-decoder is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with Compile-QEMU-for-decoder.  If not, see <https://www.gnu.org/licenses/>.
diff --git a/compile-qemu-for-decoder.sh b/compile-qemu-for-decoder.sh
new file mode 100755
index 0000000..a3e56ba
--- /dev/null
+++ b/compile-qemu-for-decoder.sh
@@ -0,0 +1,46 @@
+#!/bin/bash
+# SPDX-License-Identifier: LGPL-3.0-or-later
+# See Notices.txt for copyright information
+
+set -e
+
+function download_if_needed() {
+    local dest="$1" hash="$2" url="$3"
+    if [[ ! -f "$1" ]]; then
+        wget -O "$dest" "$url"
+    fi
+    sha256sum -c <<<"$hash *$dest"
+}
+
+function build-qemu() (
+    [[ -x "$QEMU_SOURCE/configure" ]] || tar -xJf "downloads/$QEMU_SOURCE.tar.xz"
+
+    rm -rf "$QEMU_BUILD"
+    mkdir -p "$QEMU_BUILD"
+    cd "$QEMU_BUILD"
+    export CC="clang-20 --target=powerpc64le-linux-gnu"
+    export CXX="clang++-20 --target=powerpc64le-linux-gnu"
+    export LD="clang++-20 --target=powerpc64le-linux-gnu"
+    export AR="llvm-ar-20"
+    "../$QEMU_SOURCE/configure" \
+        --target-list=ppc64-softmmu \
+        --enable-lto \
+        --enable-tcg-interpreter \
+        --without-default-features \
+        --cross-prefix=powerpc64le-linux-gnu-
+    QEMU_LIBRARIES_WE_USE=(libqemu-ppc64-softmmu.a libqom.a)
+    make -j"$(nproc)" "${QEMU_LIBRARIES_WE_USE[@]}"
+    llvm-link-20 -o ../libqemu-ppc64-softmmu.bc "${QEMU_LIBRARIES_WE_USE[@]}"
+)
+
+mkdir -p downloads
+
+QEMU_SOURCE=qemu-10.2.2
+QEMU_SOURCE_HASH=784b296ff29c1417aa72323abcb2d2ea9ab9771724f577dcd785c3b04f21e176
+QEMU_BUILD="$QEMU_SOURCE-build"
+
+download_if_needed "downloads/$QEMU_SOURCE.tar.xz" "$QEMU_SOURCE_HASH" \
+    "https://download.qemu.org/$QEMU_SOURCE.tar.xz"
+
+build-qemu
+llvm-dis-20 -o libqemu-ppc64-softmmu.ll libqemu-ppc64-softmmu.bc
diff --git a/scripts/check-copyright.sh b/scripts/check-copyright.sh
new file mode 100755
index 0000000..05b399d
--- /dev/null
+++ b/scripts/check-copyright.sh
@@ -0,0 +1,75 @@
+#!/bin/bash
+# SPDX-License-Identifier: LGPL-3.0-or-later
+# See Notices.txt for copyright information
+set -e
+
+function fail()
+{
+    local error="$1"
+    echo "error: $error" >&2
+    exit 1
+}
+
+function fail_file()
+{
+    local file="$1" line="$2" error="$3"
+    fail "$file:$((line + 1)): $error"
+}
+
+function check_file()
+{
+    local file="$1" regexes=("${@:2}")
+    local lines
+    mapfile -t lines < "$file"
+    local line
+    for line in "${!regexes[@]}"; do
+        eval '[[ "${lines[i]}" =~ '"${regexes[i]}"' ]]' ||
+            fail_file "$file" "$line" "doesn't match regex: ${regexes[i]}"
+    done
+}
+
+POUND_HEADER=('^"# SPDX-License-Identifier: LGPL-3.0-or-later"$' '^"# See Notices.txt for copyright information"$')
+SLASH_HEADER=('^"// SPDX-License-Identifier: LGPL-3.0-or-later"$' '^"// See Notices.txt for copyright information"$')
+MD_HEADER=('^"<!--"$' '^"SPDX-License-Identifier: LGPL-3.0-or-later"$' '^"See Notices.txt for copyright information"$')
+JSON_HEADER=('^"{"$' '^"    \"license_header\": ["$' '^"        \"SPDX-License-Identifier: LGPL-3.0-or-later\","$' '^"        \"See Notices.txt for copyright information\""')
+ROCQ_HEADER=('^"(*  SPDX-License-Identifier: LGPL-3.0-or-later"$' '^"   See Notices.txt for copyright information *)"$')
+
+function main()
+{
+    local IFS=$'\n'
+    [[ -z "$(git status --porcelain)" ]] || fail "git repo is dirty"
+    local file
+    for file in $(git ls-tree --name-only --full-tree -r HEAD); do
+        case "/$file" in
+        /Cargo.lock)
+            # generated file
+            ;;
+        */LICENSE.md|*/Notices.txt)
+            # copyright file
+            ;;
+        /.forgejo/workflows/*.yml|*/.gitignore|*.toml)
+            check_file "$file" "${POUND_HEADER[@]}"
+            ;;
+        *.md)
+            check_file "$file" "${MD_HEADER[@]}"
+            ;;
+        *.sh)
+            check_file "$file" '^'\''#!'\' "${POUND_HEADER[@]}"
+            ;;
+        *.rs)
+            check_file "$file" "${SLASH_HEADER[@]}"
+            ;;
+        *.json)
+            check_file "$file" "${JSON_HEADER[@]}"
+            ;;
+        *.v)
+            check_file "$file" "${ROCQ_HEADER[@]}"
+            ;;
+        *)
+            fail_file "$file" 0 "unimplemented file kind -- you need to add it to $0"
+            ;;
+        esac
+    done
+}
+
+main
\ No newline at end of file
diff --git a/src/lib.rs b/src/lib.rs
new file mode 100644
index 0000000..c65b7cf
--- /dev/null
+++ b/src/lib.rs
@@ -0,0 +1,1542 @@
+// SPDX-License-Identifier: LGPL-3.0-or-later
+// See Notices.txt for copyright information
+
+use eyre::{OptionExt, Result, bail, ensure, eyre};
+use inkwell::{
+    AddressSpace,
+    context::Context,
+    llvm_sys::{
+        LLVMValueKind,
+        core::{
+            LLVMGetAggregateElement, LLVMGetCalledValue, LLVMGetNumArgOperands, LLVMGetValueKind,
+            LLVMLookupIntrinsicID,
+        },
+    },
+    module::Module,
+    support::LLVMString,
+    targets::TargetData,
+    types::{AnyType, AnyTypeEnum, BasicType, BasicTypeEnum, FunctionType},
+    values::{
+        AnyValue, AnyValueEnum, ArrayValue, AsValueRef, BasicValueEnum, FunctionValue, GlobalValue,
+        InstructionOpcode, InstructionValue, Operand, PointerValue,
+    },
+};
+use std::{
+    collections::{BTreeMap, HashMap},
+    ffi::{CStr, CString},
+    fmt,
+    marker::PhantomData,
+    mem,
+    num::NonZeroU32,
+    ops::{ControlFlow, IndexMut},
+    path::Path,
+    rc::Rc,
+    sync::OnceLock,
+};
+
+fn map_llvm_err(v: LLVMString) -> eyre::Report {
+    eyre::eyre!("LLVM Error: {}", v.to_string_lossy())
+}
+
+macro_rules! declare_intrinsics {
+    (
+        $(#[name = $name:literal]
+        $Variant:ident,)+
+    ) => {
+        #[derive(Clone, Copy, Debug, PartialEq, Eq, Ord, PartialOrd)]
+        enum Intrinsic {
+            $($Variant,)+
+            Unknown(NonZeroU32),
+        }
+
+        #[derive(Debug)]
+        #[expect(non_snake_case)]
+        struct KnownIntrinsicIds {
+            $($Variant: NonZeroU32,)+
+        }
+
+        impl KnownIntrinsicIds {
+            fn get() -> &'static KnownIntrinsicIds {
+                static RETVAL: OnceLock<KnownIntrinsicIds> = OnceLock::new();
+                fn find(name: &'static str) -> NonZeroU32 {
+                    let Some(retval) = NonZeroU32::new(unsafe { LLVMLookupIntrinsicID(name.as_ptr().cast(), name.len()) }) else {
+                        panic!("LLVM intrinsic is known to exist: {name}");
+                    };
+                    retval
+                }
+                RETVAL.get_or_init(|| KnownIntrinsicIds {
+                    $($Variant: find($name),)+
+                })
+            }
+        }
+
+        impl Intrinsic {
+            fn new(intrinsic_id: NonZeroU32) -> Self {
+                let known_intrinsic_ids = KnownIntrinsicIds::get();
+                $(if intrinsic_id == known_intrinsic_ids.$Variant {
+                    Self::$Variant
+                } else)+ {
+                    Self::Unknown(intrinsic_id)
+                }
+            }
+            fn id(self) -> NonZeroU32 {
+                match self {
+                    $(Self::$Variant => KnownIntrinsicIds::get().$Variant,)+
+                    Self::Unknown(id) => id,
+                }
+            }
+        }
+
+        #[cfg(test)]
+        #[test]
+        fn test_intrinsics() {
+            for id in 1..10000 {
+                let id = NonZeroU32::new(id).unwrap();
+                let intrinsic = Intrinsic::new(id);
+                assert_eq!(intrinsic.id(), id, "{intrinsic:?}");
+            }
+        }
+    };
+}
+
+declare_intrinsics! {
+    #[name = "llvm.lifetime.start"]
+    LifetimeStart,
+    #[name = "llvm.memset"]
+    Memset,
+}
+
+macro_rules! declare_known_functions {
+    (
+        $(#[name = $name:literal]
+        $Variant:ident,)+
+    ) => {
+        #[derive(Copy, Clone, PartialEq, Eq, Ord, PartialOrd, Hash, Debug)]
+        enum KnownFunction {
+            $($Variant,)+
+        }
+
+        impl KnownFunction {
+            fn name(self) -> &'static CStr {
+                match self {
+                    $(Self::$Variant => $name,)+
+                }
+            }
+            fn new(name: &CStr) -> Option<Self> {
+                $(if name == $name {
+                    Some(Self::$Variant)
+                } else)+ {
+                    None
+                }
+            }
+        }
+    };
+}
+
+declare_known_functions! {
+    #[name = c"type_register_static"]
+    TypeRegisterStatic,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+struct TargetLayout {
+    size: u64,
+    align: NonZeroU32,
+}
+
+impl TargetLayout {
+    fn abi_layout<'ctx>(parser: &Parser<'ctx>, ty: impl AnyType<'ctx>) -> Self {
+        Self {
+            size: parser.target_data.get_abi_size(&ty),
+            align: NonZeroU32::new(parser.target_data.get_abi_alignment(&ty))
+                .expect("alignments are known to be non-zero"),
+        }
+    }
+    const EMPTY: TargetLayout = Self {
+        size: 0,
+        align: NonZeroU32::new(1).unwrap(),
+    };
+    const fn array_layout(self, len: u32) -> Self {
+        let Some(size) = self.size.checked_mul(len as u64) else {
+            panic!("size overflowed");
+        };
+        Self {
+            size,
+            align: self.align,
+        }
+    }
+    #[track_caller]
+    const fn struct_layout(fields: &[TargetLayout], offsets: &mut [u64]) -> Self {
+        let mut retval = Self::EMPTY;
+        let mut i = 0;
+        while i < fields.len() {
+            let TargetLayout { size, align } = fields[i];
+            let Some(offset) = retval.size.checked_next_multiple_of(align.get() as u64) else {
+                panic!("struct too big");
+            };
+            if i < offsets.len() {
+                offsets[i] = offset;
+            }
+            let Some(cur_size) = offset.checked_add(size) else {
+                panic!("struct too big");
+            };
+            retval.size = cur_size;
+            if retval.align.get() < align.get() {
+                retval.align = align;
+            }
+            i += 1;
+        }
+        let Some(size) = retval
+            .size
+            .checked_next_multiple_of(retval.align.get() as u64)
+        else {
+            panic!("struct too big");
+        };
+        retval.size = size;
+        retval
+    }
+}
+
+trait TargetType {
+    const LAYOUT: TargetLayout;
+    type Value;
+    fn llvm_type<'ctx>(parser: &Parser<'ctx>) -> AnyTypeEnum<'ctx>;
+    fn llvm_basic_type<'ctx>(parser: &Parser<'ctx>) -> Option<BasicTypeEnum<'ctx>> {
+        BasicTypeEnum::try_from(Self::llvm_type(parser)).ok()
+    }
+    fn load<'ctx>(state: &State<'ctx>, ptr: Pointer) -> Result<Self::Value>;
+}
+
+trait TargetIntType: TargetType<Value = Self> + Copy + Ord + fmt::Debug + std::hash::Hash {
+    type Bytes: Copy
+        + Default
+        + IndexMut<usize, Output = u8>
+        + IndexMut<std::ops::RangeFull, Output = [u8]>
+        + AsRef<[u8]>
+        + AsMut<[u8]>;
+    fn from_bytes(bytes: Self::Bytes) -> Self;
+    fn to_bytes(self) -> Self::Bytes;
+}
+
+macro_rules! impl_target_type_for_int {
+    ($ty:ident, $size:literal, $align:literal) => {
+        impl TargetType for $ty {
+            const LAYOUT: TargetLayout = TargetLayout {
+                size: $size,
+                align: NonZeroU32::new($align).unwrap(),
+            };
+            type Value = $ty;
+            fn llvm_type<'ctx>(parser: &Parser<'ctx>) -> AnyTypeEnum<'ctx> {
+                let retval = parser.context.custom_width_int_type($size * u8::BITS);
+                assert_eq!(TargetLayout::abi_layout(parser, retval), Self::LAYOUT);
+                retval.into()
+            }
+            fn load<'ctx>(state: &State<'ctx>, ptr: Pointer) -> Result<Self::Value> {
+                state.load_int(ptr)
+            }
+        }
+        impl TargetIntType for $ty {
+            type Bytes = [u8; $size];
+            fn from_bytes(bytes: Self::Bytes) -> Self {
+                Self::from_le_bytes(bytes)
+            }
+            fn to_bytes(self) -> Self::Bytes {
+                self.to_le_bytes()
+            }
+        }
+    };
+}
+
+#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+struct TargetCChar(u8);
+
+impl TargetCChar {
+    const fn from_le_bytes(bytes: [u8; 1]) -> Self {
+        Self(bytes[0])
+    }
+    const fn to_le_bytes(self) -> [u8; 1] {
+        [self.0]
+    }
+}
+
+impl fmt::Debug for TargetCChar {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "b'{}'", [self.0].escape_ascii())
+    }
+}
+
+#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+struct TargetMemBool(bool);
+
+impl TargetMemBool {
+    const fn from_le_bytes(bytes: [u8; 1]) -> Self {
+        assert!(bytes[0] <= 1, "invalid bool value");
+        Self(bytes[0] != 0)
+    }
+    const fn to_le_bytes(self) -> [u8; 1] {
+        [self.0 as u8]
+    }
+}
+
+impl fmt::Debug for TargetMemBool {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{:?}", self.0)
+    }
+}
+
+#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+struct TargetUsize(u64);
+
+impl TargetUsize {
+    const fn from_le_bytes(bytes: [u8; 8]) -> Self {
+        Self(u64::from_le_bytes(bytes))
+    }
+    const fn to_le_bytes(self) -> [u8; 8] {
+        self.0.to_le_bytes()
+    }
+}
+
+impl fmt::Debug for TargetUsize {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{:?}", self.0)
+    }
+}
+
+#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+struct TargetIsize(i64);
+
+impl TargetIsize {
+    const fn from_le_bytes(bytes: [u8; 8]) -> Self {
+        Self(i64::from_le_bytes(bytes))
+    }
+    const fn to_le_bytes(self) -> [u8; 8] {
+        self.0.to_le_bytes()
+    }
+}
+
+impl fmt::Debug for TargetIsize {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{:?}", self.0)
+    }
+}
+
+impl_target_type_for_int!(TargetCChar, 1, 1);
+impl_target_type_for_int!(TargetMemBool, 1, 1);
+impl_target_type_for_int!(u8, 1, 1);
+impl_target_type_for_int!(i8, 1, 1);
+impl_target_type_for_int!(u16, 2, 2);
+impl_target_type_for_int!(i16, 2, 2);
+impl_target_type_for_int!(u32, 4, 4);
+impl_target_type_for_int!(i32, 4, 4);
+impl_target_type_for_int!(u64, 8, 8);
+impl_target_type_for_int!(i64, 8, 8);
+impl_target_type_for_int!(TargetUsize, 8, 8);
+impl_target_type_for_int!(TargetIsize, 8, 8);
+
+trait TargetPointerType: TargetType {
+    type Pointee;
+}
+
+impl<T> TargetType for *const T {
+    const LAYOUT: TargetLayout = <TargetUsize as TargetType>::LAYOUT;
+    type Value = Pointer;
+    fn llvm_type<'ctx>(parser: &Parser<'ctx>) -> AnyTypeEnum<'ctx> {
+        let retval = parser.context.ptr_type(AddressSpace::from(0u16));
+        assert_eq!(TargetLayout::abi_layout(parser, retval), Self::LAYOUT);
+        retval.into()
+    }
+    fn load<'ctx>(state: &State<'ctx>, ptr: Pointer) -> Result<Self::Value> {
+        state.load_ptr(ptr)
+    }
+}
+
+impl<T> TargetPointerType for *const T {
+    type Pointee = T;
+}
+
+impl<T> TargetType for *mut T {
+    const LAYOUT: TargetLayout = <*const T as TargetType>::LAYOUT;
+    type Value = Pointer;
+    fn llvm_type<'ctx>(parser: &Parser<'ctx>) -> AnyTypeEnum<'ctx> {
+        <*const T as TargetType>::llvm_type(parser)
+    }
+    fn load<'ctx>(state: &State<'ctx>, ptr: Pointer) -> Result<Self::Value> {
+        state.load_ptr(ptr)
+    }
+}
+
+impl<T> TargetPointerType for *mut T {
+    type Pointee = T;
+}
+
+struct TargetFunctionType<Args, R> {
+    args: Args,
+    ret: R,
+}
+
+macro_rules! impl_target_type_for_fn_ptr {
+    ($($T:ident),* $(,)?) => {
+        impl<R: TargetType, $($T: TargetType),*> TargetType for TargetFunctionType<($($T,)*), R> {
+            const LAYOUT: TargetLayout = TargetLayout::EMPTY;
+            type Value = ();
+            fn llvm_type<'ctx>(parser: &Parser<'ctx>) -> AnyTypeEnum<'ctx> {
+                R::llvm_basic_type(parser).expect("invalid return type").fn_type(&[$($T::llvm_basic_type(parser).expect("invalid argument type").into()),*], false).into()
+            }
+            fn load<'ctx>(_state: &State<'ctx>, _ptr: Pointer) -> Result<Self::Value> {
+                panic!("can't load a value of function type. try using function pointers?")
+            }
+        }
+        impl<R: TargetType, $($T: TargetType),*> TargetType for Option<unsafe extern "C" fn($($T),*) -> R> {
+            const LAYOUT: TargetLayout = <*const () as TargetType>::LAYOUT;
+            type Value = Pointer;
+            fn llvm_type<'ctx>(parser: &Parser<'ctx>) -> AnyTypeEnum<'ctx> {
+                <*const () as TargetType>::llvm_type(parser)
+            }
+            fn load<'ctx>(state: &State<'ctx>, ptr: Pointer) -> Result<Self::Value> {
+                state.load_ptr(ptr)
+            }
+        }
+        impl<R: TargetType, $($T: TargetType),*> TargetPointerType for Option<unsafe extern "C" fn($($T),*) -> R> {
+            type Pointee = TargetFunctionType<($($T,)*), R>;
+        }
+        impl<$($T: TargetType),*> TargetType for TargetFunctionType<($($T,)*), ()> {
+            const LAYOUT: TargetLayout = TargetLayout::EMPTY;
+            type Value = ();
+            fn llvm_type<'ctx>(parser: &Parser<'ctx>) -> AnyTypeEnum<'ctx> {
+                parser.context.void_type().fn_type(&[$($T::llvm_basic_type(parser).expect("invalid argument type").into()),*], false).into()
+            }
+            fn load<'ctx>(_state: &State<'ctx>, _ptr: Pointer) -> Result<Self::Value> {
+                panic!("can't load a value of function type. try using function pointers?")
+            }
+        }
+        impl<$($T: TargetType),*> TargetType for Option<unsafe extern "C" fn($($T),*)> {
+            const LAYOUT: TargetLayout = <*const () as TargetType>::LAYOUT;
+            type Value = Pointer;
+            fn llvm_type<'ctx>(parser: &Parser<'ctx>) -> AnyTypeEnum<'ctx> {
+                <*const () as TargetType>::llvm_type(parser)
+            }
+            fn load<'ctx>(state: &State<'ctx>, ptr: Pointer) -> Result<Self::Value> {
+                state.load_ptr(ptr)
+            }
+        }
+        impl<$($T: TargetType),*> TargetPointerType for Option<unsafe extern "C" fn($($T),*)> {
+            type Pointee = TargetFunctionType<($($T,)*), ()>;
+        }
+    };
+}
+
+impl_target_type_for_fn_ptr!();
+impl_target_type_for_fn_ptr!(A0);
+impl_target_type_for_fn_ptr!(A0, A1);
+impl_target_type_for_fn_ptr!(A0, A1, A2);
+impl_target_type_for_fn_ptr!(A0, A1, A2, A3);
+impl_target_type_for_fn_ptr!(A0, A1, A2, A3, A4);
+impl_target_type_for_fn_ptr!(A0, A1, A2, A3, A4, A5);
+impl_target_type_for_fn_ptr!(A0, A1, A2, A3, A4, A5, A6);
+impl_target_type_for_fn_ptr!(A0, A1, A2, A3, A4, A5, A6, A7);
+impl_target_type_for_fn_ptr!(A0, A1, A2, A3, A4, A5, A6, A7, A8);
+impl_target_type_for_fn_ptr!(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9);
+impl_target_type_for_fn_ptr!(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10);
+impl_target_type_for_fn_ptr!(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11);
+
+struct TargetField<Struct: TargetStruct, Field: TargetType, const INDEX: usize, const OFFSET: u64> {
+    field: Field,
+    _struct: PhantomData<Struct>,
+}
+
+impl<Struct: TargetStruct, Field: TargetType, const INDEX: usize, const OFFSET: u64>
+    TargetField<Struct, Field, INDEX, OFFSET>
+{
+    const INDEX: usize = INDEX;
+    const OFFSET: usize = INDEX;
+    const LAYOUT: TargetLayout = Field::LAYOUT;
+    fn llvm_type<'ctx>(parser: &Parser<'ctx>) -> AnyTypeEnum<'ctx> {
+        Field::llvm_type(parser)
+    }
+}
+
+trait TargetStruct: TargetType {
+    const FIELD_LAYOUTS: &[TargetLayout];
+    const FIELD_OFFSETS: &[u64];
+}
+
+macro_rules! declare_target_struct {
+    (
+        #[field_ints = $FieldInts:ident, value = $Value:ident]
+        #[repr(C)]
+        struct $Struct:ident {
+            $($field:ident: $field_ty:ty,)*
+        }
+    ) => {
+        struct $FieldInts {
+            $($field: u64,)*
+        }
+        struct $Struct {
+            $(#[allow(dead_code)]
+            $field: TargetField<Self, $field_ty, { Self::FIELD_INDEXES.$field as usize }, { Self::OFFSETS.$field }>,)*
+        }
+        #[derive(Clone, Debug)]
+        struct $Value {
+            $($field: <$field_ty as TargetType>::Value,)*
+        }
+        impl $Struct {
+            #[expect(unused_assignments)]
+            const FIELD_INDEXES: $FieldInts = {
+                let mut index = 0;
+                $FieldInts {
+                    $($field: {
+                        let v = index;
+                        index += 1;
+                        v
+                    },)*
+                }
+            };
+            const OFFSETS: $FieldInts = {
+                $FieldInts {
+                    $($field: <Self as TargetStruct>::FIELD_OFFSETS[Self::FIELD_INDEXES.$field as usize],)*
+                }
+            };
+        }
+        impl TargetStruct for $Struct {
+            const FIELD_LAYOUTS: &[TargetLayout] = &[$(<$field_ty as TargetType>::LAYOUT),*];
+            const FIELD_OFFSETS: &[u64] = &{
+                let mut offsets = [0u64; Self::FIELD_LAYOUTS.len()];
+                TargetLayout::struct_layout(Self::FIELD_LAYOUTS, &mut offsets);
+                offsets
+            };
+        }
+        impl TargetType for $Struct {
+            const LAYOUT: TargetLayout = TargetLayout::struct_layout(Self::FIELD_LAYOUTS, &mut []);
+            type Value = $Value;
+            fn llvm_type<'ctx>(parser: &Parser<'ctx>) -> AnyTypeEnum<'ctx> {
+                parser.context.struct_type(&[$(<$field_ty as TargetType>::llvm_basic_type(parser).expect("invalid field type")),*], false).into()
+            }
+            fn load<'ctx>(state: &State<'ctx>, ptr: Pointer) -> Result<Self::Value> {
+                Ok($Value {
+                    $($field: <$field_ty as TargetType>::load(state, ptr.add($Struct::OFFSETS.$field))?,)*
+                })
+            }
+        }
+    };
+}
+
+macro_rules! declare_opaque_target_struct {
+    (struct $Struct:ident;) => {
+        struct $Struct;
+        impl TargetType for $Struct {
+            const LAYOUT: TargetLayout = TargetLayout::EMPTY;
+            type Value = ();
+            fn llvm_type<'ctx>(parser: &Parser<'ctx>) -> AnyTypeEnum<'ctx> {
+                parser.context.void_type().into()
+            }
+            fn load<'ctx>(_state: &State<'ctx>, _ptr: Pointer) -> Result<Self::Value> {
+                panic!("can't load a value of opaque struct type")
+            }
+        }
+    };
+}
+
+declare_opaque_target_struct! {
+    struct TargetObject;
+}
+
+declare_opaque_target_struct! {
+    struct TargetObjectClass;
+}
+
+declare_opaque_target_struct! {
+    struct TargetInterfaceInfo;
+}
+
+declare_target_struct! {
+    #[field_ints = TargetTypeInfoFieldInts, value = TargetTypeInfoValue]
+    #[repr(C)]
+    struct TargetTypeInfo
+    {
+        name: *const TargetCChar,
+        parent: *const TargetCChar,
+        instance_size: TargetUsize,
+        instance_align: TargetUsize,
+        instance_init: Option<unsafe extern "C" fn(*mut TargetObject)>,
+        instance_post_init: Option<unsafe extern "C" fn(*mut TargetObject)>,
+        instance_finalize: Option<unsafe extern "C" fn(*mut TargetObject)>,
+        r#abstract: TargetMemBool,
+        class_size: TargetUsize,
+        class_init: Option<unsafe extern "C" fn(*mut TargetObjectClass, *const ())>,
+        class_base_init: Option<unsafe extern "C" fn(*mut TargetObjectClass, *const ())>,
+        class_data: *const (),
+        interfaces: *const TargetInterfaceInfo,
+    }
+}
+
+fn get_called_value<'ctx>(instruction: InstructionValue<'ctx>) -> AnyValueEnum<'ctx> {
+    match instruction.get_opcode() {
+        InstructionOpcode::Call | InstructionOpcode::Invoke => {}
+        _ => panic!("can't get called value of a non-call/invoke instruction"),
+    }
+    unsafe { AnyValueEnum::new(LLVMGetCalledValue(instruction.as_value_ref())) }
+}
+
+fn get_num_arg_operands(instruction: InstructionValue<'_>) -> u32 {
+    match instruction.get_opcode() {
+        InstructionOpcode::Call | InstructionOpcode::Invoke => {}
+        _ => panic!("can't get argument operand count of a non-call/invoke instruction"),
+    }
+    unsafe { LLVMGetNumArgOperands(instruction.as_value_ref()) }
+}
+
+fn global_variable_from_pointer<'ctx>(v: PointerValue<'ctx>) -> Option<GlobalValue<'ctx>> {
+    unsafe {
+        match LLVMGetValueKind(v.as_value_ref()) {
+            LLVMValueKind::LLVMGlobalVariableValueKind => Some(GlobalValue::new(v.as_value_ref())),
+            _ => None,
+        }
+    }
+}
+
+fn get_array_element<'ctx>(v: ArrayValue<'ctx>, index: u32) -> BasicValueEnum<'ctx> {
+    assert!(index < v.get_type().len());
+    unsafe { BasicValueEnum::new(LLVMGetAggregateElement(v.as_value_ref(), index)) }
+}
+
+fn array_try_from_fn<T, const N: usize, E, F: FnMut(usize) -> Result<T, E>>(
+    mut f: F,
+) -> Result<[T; N], E> {
+    let mut error = Ok(());
+    let mut values: [Option<T>; N] = std::array::from_fn(|i| {
+        if error.is_ok() {
+            f(i).map_err(|e| error = Err(e)).ok()
+        } else {
+            None
+        }
+    });
+    error?;
+    Ok(std::array::from_fn(|i| {
+        values[i].take().expect("known to be some")
+    }))
+}
+
+#[derive(PartialEq, Eq, PartialOrd, Ord, Debug)]
+enum PointerBase {
+    Null,
+    Local { id: u64, align: u32 },
+    CpuState,
+    EmulatedPC,
+    Global { name: CString, is_constant: bool },
+    Function { name: CString },
+    TranslationBlock,
+    MaxInstructions,
+    HostPC,
+}
+
+impl PointerBase {
+    fn address(&self) -> Option<u64> {
+        match self {
+            PointerBase::Null => Some(0),
+            PointerBase::Local { .. } => None,
+            PointerBase::CpuState => None,
+            PointerBase::EmulatedPC => Some(0),
+            PointerBase::Global { .. } => None,
+            PointerBase::Function { .. } => None,
+            PointerBase::TranslationBlock => None,
+            PointerBase::MaxInstructions => None,
+            PointerBase::HostPC => todo!(),
+        }
+    }
+}
+
+#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Debug)]
+struct Pointer {
+    base: Rc<PointerBase>,
+    offset: u64,
+}
+
+impl Pointer {
+    fn add(&self, additional: u64) -> Self {
+        Self {
+            base: self.base.clone(),
+            offset: self.offset.wrapping_add(additional),
+        }
+    }
+}
+
+#[derive(Clone, PartialEq, Eq, PartialOrd, Ord)]
+enum Byte {
+    Constant(u8),
+    PointerBits { ptr: Pointer, offset: u8 },
+    Undefined,
+}
+
+impl Byte {
+    fn as_u8(&self) -> Option<u8> {
+        match *self {
+            Byte::Constant(v) => Some(v),
+            Byte::PointerBits { ref ptr, offset } => {
+                if let Some(address) = ptr.base.address() {
+                    address
+                        .wrapping_add(ptr.offset)
+                        .to_le_bytes()
+                        .get(offset as usize)
+                        .copied()
+                } else {
+                    None
+                }
+            }
+            Byte::Undefined => None,
+        }
+    }
+}
+
+impl fmt::Debug for Byte {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::Constant(byte) => write!(f, "{byte:#x}u8"),
+            Self::PointerBits { ptr, offset } => f
+                .debug_struct("PointerBits")
+                .field("ptr", ptr)
+                .field("offset", offset)
+                .finish(),
+            Self::Undefined => write!(f, "Undefined"),
+        }
+    }
+}
+
+#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Debug)]
+enum Value {
+    Pointer(Pointer),
+    ConstantInt(u128),
+    Aggregate(Rc<[Byte]>),
+}
+
+impl Value {
+    fn get_byte(&self, offset: usize) -> Byte {
+        match self {
+            Value::Pointer(ptr) => Byte::PointerBits {
+                ptr: ptr.clone(),
+                offset: offset as u8,
+            },
+            Value::ConstantInt(v) => Byte::Constant(v.to_le_bytes()[offset]),
+            Value::Aggregate(v) => v[offset].clone(),
+        }
+    }
+    fn get_bytes(&self, range: std::ops::Range<usize>) -> Rc<[Byte]> {
+        match self {
+            Value::Aggregate(bytes) if range == (0..bytes.len()) => bytes.clone(),
+            Value::Pointer(_) | Value::ConstantInt(_) | Value::Aggregate(_) => {
+                Rc::from_iter(range.map(|offset| self.get_byte(offset)))
+            }
+        }
+    }
+}
+
+struct Parser<'ctx> {
+    context: &'ctx Context,
+    module: Rc<Module<'ctx>>,
+    target_data: TargetData,
+}
+
+impl<'ctx> fmt::Debug for Parser<'ctx> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("Parser")
+            .field("target_data", &self.target_data)
+            .finish_non_exhaustive()
+    }
+}
+
+impl<'ctx> Parser<'ctx> {
+    fn new(context: &'ctx Context, module: Rc<Module<'ctx>>) -> Result<Self> {
+        let data_layout_ref = module.get_data_layout();
+        let data_layout = data_layout_ref
+            .as_str()
+            .to_str()
+            .ok()
+            .ok_or_eyre("data layout string should be UTF-8")?;
+        let target_data = TargetData::create(data_layout);
+        drop(data_layout_ref);
+        Ok(Self {
+            context,
+            module,
+            target_data,
+        })
+    }
+}
+
+#[derive(Clone, Debug)]
+struct ParsedTypeInfo {
+    type_info_ptr: Pointer,
+    name: CString,
+    parent: CString,
+    value: TargetTypeInfoValue,
+}
+
+#[derive(Clone, Debug)]
+struct GlobalState<'ctx> {
+    memory: BTreeMap<Rc<PointerBase>, Rc<[Byte]>>,
+    null_ptr_base: Rc<PointerBase>,
+    next_id: u64,
+    parser: Rc<Parser<'ctx>>,
+    registered_type_infos: Vec<ParsedTypeInfo>,
+    global_values: HashMap<AnyValueEnum<'ctx>, Value>,
+}
+
+impl<'ctx> GlobalState<'ctx> {
+    fn new(parser: Rc<Parser<'ctx>>) -> Self {
+        let mut retval = Self {
+            memory: BTreeMap::new(),
+            null_ptr_base: Rc::new(PointerBase::Null),
+            next_id: 0,
+            parser,
+            registered_type_infos: vec![],
+            global_values: HashMap::new(),
+        };
+        let null_ptr = retval.add_memory(retval.null_ptr_base.clone(), Rc::new([]));
+        retval.global_values.insert(
+            retval
+                .parser
+                .context
+                .ptr_type(AddressSpace::from(0u16))
+                .const_null()
+                .as_any_value_enum(),
+            Value::Pointer(null_ptr),
+        );
+        retval
+    }
+    fn take(&mut self) -> Self {
+        let Self {
+            memory,
+            null_ptr_base,
+            next_id,
+            parser,
+            registered_type_infos,
+            global_values,
+        } = self;
+        Self {
+            memory: mem::take(memory),
+            null_ptr_base: null_ptr_base.clone(),
+            next_id: *next_id,
+            parser: parser.clone(),
+            registered_type_infos: mem::take(registered_type_infos),
+            global_values: mem::take(global_values),
+        }
+    }
+    fn add_memory(&mut self, ptr_base: Rc<PointerBase>, value: Rc<[Byte]>) -> Pointer {
+        self.memory.insert(ptr_base.clone(), value);
+        Pointer {
+            base: ptr_base,
+            offset: 0,
+        }
+    }
+}
+
+#[derive(Clone, Debug)]
+struct State<'ctx> {
+    global: GlobalState<'ctx>,
+    return_target: Option<Rc<State<'ctx>>>,
+    stack_variables: Vec<Rc<PointerBase>>,
+    local_values: HashMap<AnyValueEnum<'ctx>, Value>,
+    next_instruction: InstructionValue<'ctx>,
+}
+
+impl<'ctx> State<'ctx> {
+    #[track_caller]
+    fn new(
+        global: GlobalState<'ctx>,
+        start_fn_name: impl AsRef<str>,
+        expected_function_type: FunctionType<'ctx>,
+        arguments: impl FnOnce(&mut State<'ctx>) -> Result<Vec<Value>>,
+    ) -> Result<Self> {
+        let start_fn_name = start_fn_name.as_ref();
+        let function = global
+            .parser
+            .module
+            .get_function(start_fn_name)
+            .ok_or_else(|| eyre!("function not found: {start_fn_name}"))?;
+        let function_type = function.get_type();
+        if function_type != expected_function_type {
+            bail!(
+                "entry function {start_fn_name} has wrong type: {function_type}\nexpected: {expected_function_type}"
+            );
+        }
+        let basic_block = function
+            .get_first_basic_block()
+            .ok_or_else(|| eyre!("function missing start block: {start_fn_name}"))?;
+        let next_instruction = basic_block.get_first_instruction().ok_or_else(|| {
+            eyre!("function start block missing first instruction: {start_fn_name}")
+        })?;
+        let mut retval = Self {
+            global,
+            return_target: None,
+            stack_variables: vec![],
+            local_values: HashMap::new(),
+            next_instruction,
+        };
+        let arguments = arguments(&mut retval)?;
+        assert_eq!(function.count_params() as usize, arguments.len());
+        for (param, value) in function.get_param_iter().zip(arguments) {
+            retval.local_values.insert(param.as_any_value_enum(), value);
+        }
+        Ok(retval)
+    }
+    fn gen_id(&mut self) -> u64 {
+        let id = self.global.next_id;
+        self.global.next_id += 1;
+        id
+    }
+    fn get_value(&mut self, value: impl AnyValue<'ctx>) -> Result<Value> {
+        let value = value.as_any_value_enum();
+        if let Some(retval) = self.local_values.get(&value) {
+            Ok(retval.clone())
+        } else if let Some(retval) = self.global.global_values.get(&value) {
+            Ok(retval.clone())
+        } else {
+            match value {
+                AnyValueEnum::ArrayValue(value) => {
+                    let ty = value.get_type();
+                    let size = self.global.parser.target_data.get_abi_size(&ty);
+                    let element_size =
+                        self.global
+                            .parser
+                            .target_data
+                            .get_abi_size(&ty.get_element_type()) as usize;
+                    let element_store_size = self
+                        .global
+                        .parser
+                        .target_data
+                        .get_store_size(&ty.get_element_type())
+                        as usize;
+                    let mut retval = Rc::from_iter((0..size).map(|_| Byte::Undefined));
+                    let bytes = Rc::make_mut(&mut retval);
+                    for i in 0..ty.len() {
+                        let start = i as usize * element_size;
+                        let element_value = self.get_value(get_array_element(value, i))?;
+                        for j in 0..element_store_size {
+                            bytes[j + start] = element_value.get_byte(j);
+                        }
+                    }
+                    let retval = Value::Aggregate(retval);
+                    self.global
+                        .global_values
+                        .insert(value.as_any_value_enum(), retval.clone());
+                    Ok(retval)
+                }
+                AnyValueEnum::IntValue(value) => {
+                    if let Some(v) = value.get_zero_extended_constant() {
+                        Ok(Value::ConstantInt(v as u128))
+                    } else {
+                        todo!("{value}")
+                    }
+                }
+                AnyValueEnum::FloatValue(value) => todo!("{value}"),
+                AnyValueEnum::PhiValue(value) => todo!("{value}"),
+                AnyValueEnum::FunctionValue(value) => {
+                    let ptr_base = Rc::new(PointerBase::Function {
+                        name: value.get_name().into(),
+                    });
+                    self.global.memory.insert(ptr_base.clone(), Rc::new([]));
+                    let retval = Value::Pointer(Pointer {
+                        base: ptr_base,
+                        offset: 0,
+                    });
+                    self.global
+                        .global_values
+                        .insert(value.as_any_value_enum(), retval.clone());
+                    Ok(retval)
+                }
+                AnyValueEnum::PointerValue(value) => {
+                    if let Some(value) = global_variable_from_pointer(value) {
+                        if let Some(initializer) = value.get_initializer() {
+                            let initializer = self.get_value(initializer)?;
+                            let ty = value.get_value_type();
+                            let size = self.global.parser.target_data.get_abi_size(&ty);
+                            let ptr_base = Rc::new(PointerBase::Global {
+                                name: value.get_name().into(),
+                                is_constant: value.is_constant(),
+                            });
+                            self.global
+                                .memory
+                                .insert(ptr_base.clone(), initializer.get_bytes(0..size as usize));
+                            let retval = Value::Pointer(Pointer {
+                                base: ptr_base,
+                                offset: 0,
+                            });
+                            self.global
+                                .global_values
+                                .insert(value.as_any_value_enum(), retval.clone());
+                            Ok(retval)
+                        } else {
+                            todo!("{value}");
+                        }
+                    } else if value.is_null() {
+                        Ok(Value::Pointer(Pointer {
+                            base: self.global.null_ptr_base.clone(),
+                            offset: 0,
+                        }))
+                    } else {
+                        todo!("{value}");
+                    }
+                }
+                AnyValueEnum::StructValue(value) => {
+                    let ty = value.get_type();
+                    let size = self.global.parser.target_data.get_abi_size(&ty);
+                    let mut retval = Rc::from_iter((0..size).map(|_| Byte::Undefined));
+                    let bytes = Rc::make_mut(&mut retval);
+                    for (i, field) in value.get_fields().enumerate() {
+                        let start = self
+                            .global
+                            .parser
+                            .target_data
+                            .offset_of_element(&ty, i as u32)
+                            .expect("index known to be in bounds")
+                            as usize;
+                        let field_value = self.get_value(field)?;
+                        let field_store_size = self
+                            .global
+                            .parser
+                            .target_data
+                            .get_store_size(&field.get_type())
+                            as usize;
+                        for j in 0..field_store_size {
+                            bytes[j + start] = field_value.get_byte(j);
+                        }
+                    }
+                    let retval = Value::Aggregate(retval);
+                    self.global
+                        .global_values
+                        .insert(value.as_any_value_enum(), retval.clone());
+                    Ok(retval)
+                }
+                AnyValueEnum::VectorValue(value) => todo!("{value}"),
+                AnyValueEnum::ScalableVectorValue(value) => todo!("{value}"),
+                AnyValueEnum::InstructionValue(value) => todo!("{value}"),
+                AnyValueEnum::MetadataValue(value) => todo!("{value}"),
+            }
+        }
+    }
+    fn get_call_arg_operands<const N: usize>(&self) -> Result<[Operand<'ctx>; N]> {
+        ensure!(
+            get_num_arg_operands(self.next_instruction) == N as u32,
+            "unexpected argument operand count: {}",
+            self.next_instruction,
+        );
+        Ok(std::array::from_fn(|i| {
+            self.next_instruction
+                .get_operand(i as u32)
+                .expect("just checked number of argument operands")
+        }))
+    }
+    fn get_call_arg_values<const N: usize>(&mut self) -> Result<[Value; N]> {
+        let operands = self.get_call_arg_operands::<N>()?;
+        array_try_from_fn(|i| {
+            self.get_value(
+                operands[i]
+                    .value()
+                    .ok_or_eyre("call argument operand should be a value")?,
+            )
+        })
+    }
+    fn do_store(&mut self, ptr: &Pointer, value: Byte) -> Result<()> {
+        let Some(memory) = self.global.memory.get_mut(&ptr.base) else {
+            bail!("target memory not found: {ptr:?}");
+        };
+        let memory = Rc::make_mut(memory);
+        if let Ok(offset) = usize::try_from(ptr.offset)
+            && let Some(dest) = memory.get_mut(offset)
+        {
+            *dest = value;
+            Ok(())
+        } else {
+            bail!(
+                "pointer out of bounds: {ptr:?}, memory len: {}",
+                memory.len()
+            );
+        }
+    }
+    fn do_load(&self, ptr: &Pointer) -> Result<Byte> {
+        let Some(memory) = self.global.memory.get(&ptr.base) else {
+            bail!("target memory not found: {ptr:?}");
+        };
+        if let Ok(offset) = usize::try_from(ptr.offset)
+            && let Some(dest) = memory.get(offset)
+        {
+            Ok(dest.clone())
+        } else {
+            bail!(
+                "pointer out of bounds: {ptr:?}, memory len: {}",
+                memory.len()
+            );
+        }
+    }
+    fn load_c_str(&self, mut ptr: Pointer) -> Result<CString> {
+        let mut bytes = Vec::new();
+        loop {
+            let byte = self
+                .do_load(&ptr)?
+                .as_u8()
+                .ok_or_eyre("byte's value isn't known")?;
+            bytes.push(byte);
+            if byte == 0 {
+                break;
+            }
+            ptr.offset += 1;
+        }
+        Ok(CString::from_vec_with_nul(bytes).expect("already checked"))
+    }
+    fn load_ptr(&self, mut ptr: Pointer) -> Result<Pointer> {
+        match self.do_load(&ptr)? {
+            Byte::Constant(v) => todo!(),
+            Byte::PointerBits {
+                ptr: loaded_ptr,
+                offset,
+            } => {
+                if offset != 0 {
+                    todo!();
+                }
+                for i in 1..<*const () as TargetType>::LAYOUT.size as u8 {
+                    ptr.offset += 1;
+                    match self.do_load(&ptr)? {
+                        Byte::Constant(_) => todo!(),
+                        Byte::PointerBits {
+                            ptr: cur_ptr,
+                            offset,
+                        } => {
+                            if cur_ptr != loaded_ptr || offset != i {
+                                todo!();
+                            }
+                        }
+                        Byte::Undefined => todo!(),
+                    }
+                }
+                Ok(loaded_ptr)
+            }
+            Byte::Undefined => todo!(),
+        }
+    }
+    fn load_int<T: TargetIntType>(&self, mut ptr: Pointer) -> Result<T> {
+        let mut bytes = T::Bytes::default();
+        for b in &mut bytes[..] {
+            *b = match self.do_load(&ptr)?.as_u8() {
+                Some(v) => v,
+                None => todo!(),
+            };
+            ptr.offset += 1;
+        }
+        Ok(T::from_bytes(bytes))
+    }
+    fn load(&self, ptr: &Pointer, ty: BasicTypeEnum<'ctx>) -> Result<Value> {
+        match ty {
+            BasicTypeEnum::ArrayType(_) | BasicTypeEnum::StructType(_) => todo!("{ty}"),
+            BasicTypeEnum::FloatType(ty) => todo!("{ty}"),
+            BasicTypeEnum::IntType(ty) => {
+                let size = self.global.parser.target_data.get_store_size(&ty);
+                let mut target_bytes = 0u128.to_le_bytes();
+                assert!(size <= target_bytes.len() as u64);
+                let mut ptr = ptr.clone();
+                for i in 0..size as usize {
+                    target_bytes[i] = match self.do_load(&ptr)?.as_u8() {
+                        Some(v) => v,
+                        None => todo!(),
+                    };
+                    ptr.offset += 1;
+                }
+                Ok(Value::ConstantInt(u128::from_le_bytes(target_bytes)))
+            }
+            BasicTypeEnum::PointerType(_) => self.load_ptr(ptr.clone()).map(Value::Pointer),
+            BasicTypeEnum::VectorType(ty) => todo!("{ty}"),
+            BasicTypeEnum::ScalableVectorType(ty) => todo!("{ty}"),
+        }
+    }
+    fn run_call_intrinsic(
+        &mut self,
+        function_value: FunctionValue<'ctx>,
+        intrinsic: Intrinsic,
+    ) -> Result<()> {
+        match intrinsic {
+            Intrinsic::LifetimeStart => Ok(()),
+            Intrinsic::Memset => {
+                let [dest, val, len, _is_volatile] = self.get_call_arg_values()?;
+                let Value::Pointer(mut dest) = dest else {
+                    bail!("expected pointer, got: {dest:?}");
+                };
+                let val = val.get_byte(0);
+                let Value::ConstantInt(len) = len else {
+                    bail!("expected integer length, got: {len:?}");
+                };
+                for _ in 0..len {
+                    self.do_store(&dest, val.clone())?;
+                    dest.offset += 1;
+                }
+                Ok(())
+            }
+            Intrinsic::Unknown(_) => todo!("{function_value}"),
+        }
+    }
+    fn run_call_type_register_static(&mut self) -> Result<()> {
+        let [type_info_ptr] = self.get_call_arg_values()?;
+        let Value::Pointer(type_info_ptr) = type_info_ptr else {
+            bail!("type_register_static argument must be a pointer");
+        };
+        let value = TargetTypeInfo::load(self, type_info_ptr.clone())?;
+        let name = self.load_c_str(value.name.clone())?;
+        let parent = self.load_c_str(value.parent.clone())?;
+        let parsed_type_info = ParsedTypeInfo {
+            type_info_ptr,
+            name,
+            parent,
+            value,
+        };
+        self.global.registered_type_infos.push(parsed_type_info);
+        Ok(())
+    }
+    fn run_call_known_function(
+        &mut self,
+        function_value: FunctionValue<'ctx>,
+        known_function: KnownFunction,
+    ) -> Result<()> {
+        match known_function {
+            KnownFunction::TypeRegisterStatic => self.run_call_type_register_static(),
+        }
+    }
+    fn run_normal_call(mut self: Rc<Self>, function: FunctionValue<'ctx>) -> Result<Rc<Self>> {
+        let this = Rc::make_mut(&mut self);
+        let global = this.global.take();
+        let call_instruction = this.next_instruction;
+        let basic_block = function.get_first_basic_block().ok_or_else(|| {
+            eyre!(
+                "function missing start block: {}",
+                function.get_name().to_string_lossy(),
+            )
+        })?;
+        let next_instruction = basic_block.get_first_instruction().ok_or_else(|| {
+            eyre!(
+                "function start block missing first instruction: {}",
+                function.get_name().to_string_lossy(),
+            )
+        })?;
+        let mut local_values = HashMap::new();
+        for i in 0..get_num_arg_operands(call_instruction) {
+            local_values.insert(
+                function
+                    .get_nth_param(i)
+                    .expect("argument count doesn't match function parameter count")
+                    .as_any_value_enum(),
+                this.get_value(
+                    call_instruction
+                        .get_operand(i)
+                        .expect("known to be in-bounds")
+                        .value()
+                        .ok_or_eyre("call argument operand should be a value")?,
+                )?,
+            );
+        }
+        Ok(Rc::new(Self {
+            global,
+            return_target: Some(self),
+            stack_variables: vec![],
+            local_values,
+            next_instruction,
+        }))
+    }
+    fn get_next_states(
+        mut self: Rc<Self>,
+        new_states: &mut Vec<Rc<Self>>,
+    ) -> Result<ControlFlow<Rc<Self>>> {
+        let this = Rc::make_mut(&mut self);
+        macro_rules! return_after_non_term {
+            () => {{
+                this.next_instruction = this
+                    .next_instruction
+                    .get_next_instruction()
+                    .expect("not a block terminator");
+                new_states.push(self);
+                return Ok(ControlFlow::Continue(()));
+            }};
+        }
+        println!(
+            "get_next_states: {}",
+            this.next_instruction.print_to_string().to_string_lossy(),
+        );
+        match this.next_instruction.get_opcode() {
+            InstructionOpcode::Add => todo!("{}", this.next_instruction),
+            InstructionOpcode::AddrSpaceCast => todo!("{}", this.next_instruction),
+            InstructionOpcode::Alloca => {
+                let allocated_type = this
+                    .next_instruction
+                    .get_allocated_type()
+                    .expect("just checked that it's an alloca");
+                let size = this.global.parser.target_data.get_abi_size(&allocated_type);
+                let mut align = this
+                    .next_instruction
+                    .get_alignment()
+                    .expect("just checked that it's an alloca");
+                if align == 0 {
+                    align = this
+                        .global
+                        .parser
+                        .target_data
+                        .get_abi_alignment(&allocated_type);
+                }
+                let pointer_base = Rc::new(PointerBase::Local {
+                    id: this.gen_id(),
+                    align,
+                });
+                this.stack_variables.push(pointer_base.clone());
+                this.global.memory.insert(
+                    pointer_base.clone(),
+                    Rc::from_iter((0..size).map(|_| Byte::Undefined)),
+                );
+                let value = this.next_instruction.as_any_value_enum();
+                this.local_values.insert(
+                    value,
+                    Value::Pointer(Pointer {
+                        base: pointer_base,
+                        offset: 0,
+                    }),
+                );
+                return_after_non_term!();
+            }
+            InstructionOpcode::And => todo!("{}", this.next_instruction),
+            InstructionOpcode::AShr => todo!("{}", this.next_instruction),
+            InstructionOpcode::AtomicCmpXchg => todo!("{}", this.next_instruction),
+            InstructionOpcode::AtomicRMW => todo!("{}", this.next_instruction),
+            InstructionOpcode::BitCast => todo!("{}", this.next_instruction),
+            InstructionOpcode::Br => todo!("{}", this.next_instruction),
+            InstructionOpcode::Call => {
+                let called_value = get_called_value(this.next_instruction);
+                match called_value {
+                    AnyValueEnum::ArrayValue(_)
+                    | AnyValueEnum::IntValue(_)
+                    | AnyValueEnum::FloatValue(_)
+                    | AnyValueEnum::StructValue(_)
+                    | AnyValueEnum::VectorValue(_)
+                    | AnyValueEnum::ScalableVectorValue(_)
+                    | AnyValueEnum::InstructionValue(_)
+                    | AnyValueEnum::MetadataValue(_) => unreachable!(),
+                    AnyValueEnum::PhiValue(phi_value) => todo!(),
+                    AnyValueEnum::FunctionValue(function_value) => {
+                        if let Some(intrinsic_id) =
+                            NonZeroU32::new(function_value.get_intrinsic_id())
+                        {
+                            this.run_call_intrinsic(function_value, Intrinsic::new(intrinsic_id))?;
+                            return_after_non_term!();
+                        } else if let Some(known_function) =
+                            KnownFunction::new(function_value.get_name())
+                        {
+                            this.run_call_known_function(function_value, known_function)?;
+                            return_after_non_term!();
+                        } else if function_value.get_first_basic_block().is_some() {
+                            new_states.push(self.run_normal_call(function_value)?);
+                            return Ok(ControlFlow::Continue(()));
+                        } else {
+                            todo!("{}", function_value.get_name().to_string_lossy());
+                        }
+                    }
+                    AnyValueEnum::PointerValue(pointer_value) => todo!(),
+                }
+            }
+            InstructionOpcode::CallBr => todo!("{}", this.next_instruction),
+            InstructionOpcode::CatchPad => todo!("{}", this.next_instruction),
+            InstructionOpcode::CatchRet => todo!("{}", this.next_instruction),
+            InstructionOpcode::CatchSwitch => todo!("{}", this.next_instruction),
+            InstructionOpcode::CleanupPad => todo!("{}", this.next_instruction),
+            InstructionOpcode::CleanupRet => todo!("{}", this.next_instruction),
+            InstructionOpcode::ExtractElement => todo!("{}", this.next_instruction),
+            InstructionOpcode::ExtractValue => todo!("{}", this.next_instruction),
+            InstructionOpcode::FNeg => todo!("{}", this.next_instruction),
+            InstructionOpcode::FAdd => todo!("{}", this.next_instruction),
+            InstructionOpcode::FCmp => todo!("{}", this.next_instruction),
+            InstructionOpcode::FDiv => todo!("{}", this.next_instruction),
+            InstructionOpcode::Fence => todo!("{}", this.next_instruction),
+            InstructionOpcode::FMul => todo!("{}", this.next_instruction),
+            InstructionOpcode::FPExt => todo!("{}", this.next_instruction),
+            InstructionOpcode::FPToSI => todo!("{}", this.next_instruction),
+            InstructionOpcode::FPToUI => todo!("{}", this.next_instruction),
+            InstructionOpcode::FPTrunc => todo!("{}", this.next_instruction),
+            InstructionOpcode::Freeze => todo!("{}", this.next_instruction),
+            InstructionOpcode::FRem => todo!("{}", this.next_instruction),
+            InstructionOpcode::FSub => todo!("{}", this.next_instruction),
+            InstructionOpcode::GetElementPtr => todo!("{}", this.next_instruction),
+            InstructionOpcode::ICmp => todo!("{}", this.next_instruction),
+            InstructionOpcode::IndirectBr => todo!("{}", this.next_instruction),
+            InstructionOpcode::InsertElement => todo!("{}", this.next_instruction),
+            InstructionOpcode::InsertValue => todo!("{}", this.next_instruction),
+            InstructionOpcode::IntToPtr => todo!("{}", this.next_instruction),
+            InstructionOpcode::Invoke => todo!("{}", this.next_instruction),
+            InstructionOpcode::LandingPad => todo!("{}", this.next_instruction),
+            InstructionOpcode::Load => todo!("{}", this.next_instruction),
+            InstructionOpcode::LShr => todo!("{}", this.next_instruction),
+            InstructionOpcode::Mul => todo!("{}", this.next_instruction),
+            InstructionOpcode::Or => todo!("{}", this.next_instruction),
+            InstructionOpcode::Phi => todo!("{}", this.next_instruction),
+            InstructionOpcode::PtrToInt => todo!("{}", this.next_instruction),
+            InstructionOpcode::Resume => todo!("{}", this.next_instruction),
+            InstructionOpcode::Return => {
+                if let Some(mut return_target) = this.return_target.take() {
+                    let this = Rc::unwrap_or_clone(self);
+                    let return_target_mut = Rc::make_mut(&mut return_target);
+                    return_target_mut.global = this.global;
+                    if this.next_instruction.get_num_operands() > 0 {
+                        todo!("{}", this.next_instruction);
+                    }
+                    for stack_variable in this.stack_variables {
+                        return_target_mut.global.memory.remove(&stack_variable);
+                    }
+                    match return_target_mut.next_instruction.get_opcode() {
+                        InstructionOpcode::Call => {
+                            return_target_mut.next_instruction = return_target_mut
+                                .next_instruction
+                                .get_next_instruction()
+                                .expect("not a block terminator");
+                        }
+                        InstructionOpcode::Invoke => {
+                            todo!("return to: {}", return_target_mut.next_instruction);
+                        }
+                        _ => unreachable!(),
+                    }
+                    new_states.push(return_target);
+                    return Ok(ControlFlow::Continue(()));
+                } else {
+                    return Ok(ControlFlow::Break(self));
+                }
+            }
+            InstructionOpcode::SDiv => todo!("{}", this.next_instruction),
+            InstructionOpcode::Select => todo!("{}", this.next_instruction),
+            InstructionOpcode::SExt => todo!("{}", this.next_instruction),
+            InstructionOpcode::Shl => todo!("{}", this.next_instruction),
+            InstructionOpcode::ShuffleVector => todo!("{}", this.next_instruction),
+            InstructionOpcode::SIToFP => todo!("{}", this.next_instruction),
+            InstructionOpcode::SRem => todo!("{}", this.next_instruction),
+            InstructionOpcode::Store => todo!("{}", this.next_instruction),
+            InstructionOpcode::Sub => todo!("{}", this.next_instruction),
+            InstructionOpcode::Switch => todo!("{}", this.next_instruction),
+            InstructionOpcode::Trunc => todo!("{}", this.next_instruction),
+            InstructionOpcode::UDiv => todo!("{}", this.next_instruction),
+            InstructionOpcode::UIToFP => todo!("{}", this.next_instruction),
+            InstructionOpcode::Unreachable => todo!("{}", this.next_instruction),
+            InstructionOpcode::URem => todo!("{}", this.next_instruction),
+            InstructionOpcode::UserOp1 => todo!("{}", this.next_instruction),
+            InstructionOpcode::UserOp2 => todo!("{}", this.next_instruction),
+            InstructionOpcode::VAArg => todo!("{}", this.next_instruction),
+            InstructionOpcode::Xor => todo!("{}", this.next_instruction),
+            InstructionOpcode::ZExt => todo!("{}", this.next_instruction),
+        }
+    }
+    fn run_states(
+        mut states: Vec<Rc<Self>>,
+        max_step_count: u64,
+        max_state_count: usize,
+    ) -> Result<Vec<Rc<Self>>> {
+        let mut next_states = Vec::new();
+        let mut finished_states = Vec::new();
+        for step in 0..max_step_count {
+            next_states.clear();
+            let mut last_states = mem::replace(&mut states, next_states);
+            for last_state in last_states.drain(..) {
+                match last_state.get_next_states(&mut states)? {
+                    ControlFlow::Continue(()) => {}
+                    ControlFlow::Break(state) => finished_states.push(state),
+                }
+            }
+            next_states = last_states;
+            if states
+                .len()
+                .checked_add(finished_states.len())
+                .is_none_or(|v| v > max_state_count)
+            {
+                bail!(
+                    "at step {step}: too many states {}, finished {}",
+                    states.len(),
+                    finished_states.len()
+                );
+            }
+            if states.is_empty() {
+                return Ok(finished_states);
+            }
+        }
+        bail!("too many steps");
+    }
+    fn run(self: Rc<Self>, max_step_count: u64, max_state_count: usize) -> Result<Vec<Rc<Self>>> {
+        Self::run_states(vec![self], max_step_count, max_state_count)
+    }
+    fn run_single(self: Rc<Self>, max_step_count: u64) -> Result<Rc<Self>> {
+        self.run(max_step_count, 1)?.pop().ok_or_eyre("no states")
+    }
+}
+
+pub fn parse_qemu_ppc64_softmmu(
+    path: impl AsRef<Path>,
+    max_step_count: u64,
+    max_state_count: usize,
+) -> Result<()> {
+    let context = Context::create();
+    let context = &context;
+    let module = Rc::new(Module::parse_bitcode_from_path(path, context).map_err(map_llvm_err)?);
+    let parser = Rc::new(Parser::new(context, module)?);
+    let ptr_ty = context.ptr_type(AddressSpace::from(0u16));
+    let state = Rc::new(State::new(
+        GlobalState::new(parser),
+        "ppc_cpu_register_types",
+        context.void_type().fn_type(&[], false),
+        |_| Ok(vec![]),
+    )?)
+    .run_single(max_step_count)?;
+    let powerpc64_cpu_type_info = state
+        .global
+        .registered_type_infos
+        .iter()
+        .find(|v| &*v.name == c"powerpc64-cpu")
+        .ok_or_eyre("can't find `powerpc64-cpu` type info")?
+        .clone();
+    dbg!(&powerpc64_cpu_type_info);
+    // should be: void ppc_translate_code(CPUState *cs, TranslationBlock *tb, int *max_insns, vaddr pc, void *host_pc)
+    let states = Rc::new(State::new(
+        Rc::unwrap_or_clone(state).global,
+        "ppc_translate_code",
+        context.void_type().fn_type(
+            &[
+                ptr_ty.into(),
+                ptr_ty.into(),
+                ptr_ty.into(),
+                context.i64_type().into(),
+                ptr_ty.into(),
+            ],
+            false,
+        ),
+        |state: &mut State<'_>| {
+            Ok(vec![
+                Value::Pointer(state.global.add_memory(
+                    Rc::new(PointerBase::CpuState),
+                    // TODO: correctly initialize
+                    Rc::from_iter(
+                        (0..powerpc64_cpu_type_info.value.instance_size.0).map(|_| Byte::Undefined),
+                    ),
+                )),
+                Value::Pointer(
+                    // TODO: use correct size
+                    state
+                        .global
+                        .add_memory(Rc::new(PointerBase::TranslationBlock), Rc::new([])),
+                ),
+                Value::Pointer(
+                    // TODO: use correct size
+                    state
+                        .global
+                        .add_memory(Rc::new(PointerBase::MaxInstructions), Rc::new([])),
+                ),
+                Value::Pointer(
+                    // TODO: use correct size
+                    state
+                        .global
+                        .add_memory(Rc::new(PointerBase::EmulatedPC), Rc::new([])),
+                ),
+                Value::Pointer(
+                    // TODO: use correct size
+                    state
+                        .global
+                        .add_memory(Rc::new(PointerBase::HostPC), Rc::new([])),
+                ),
+            ])
+        },
+    )?)
+    .run(max_step_count, max_state_count)?;
+    todo!();
+}
diff --git a/src/main.rs b/src/main.rs
new file mode 100644
index 0000000..48f1f30
--- /dev/null
+++ b/src/main.rs
@@ -0,0 +1,10 @@
+// SPDX-License-Identifier: LGPL-3.0-or-later
+// See Notices.txt for copyright information
+
+use compile_qemu_for_decoder::parse_qemu_ppc64_softmmu;
+use inkwell::targets::{InitializationConfig, Target};
+
+fn main() -> eyre::Result<()> {
+    Target::initialize_power_pc(&InitializationConfig::default());
+    parse_qemu_ppc64_softmmu("libqemu-ppc64-softmmu.bc", 10, 10)
+}