diff --git a/.cargo/config.toml b/.cargo/config.toml
index 23b1247..c4c8f48 100644
--- a/.cargo/config.toml
+++ b/.cargo/config.toml
@@ -61,7 +61,6 @@ rustflags = [
     "-Wclippy::string_add_assign",
     "-Wclippy::string_add",
     "-Wclippy::string_lit_as_bytes",
-    "-Wclippy::string_to_string",
     "-Wclippy::todo",
     "-Wclippy::trait_duplication_in_bounds",
     "-Wclippy::unimplemented",
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 99ec64e..34a2cdd 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -9,6 +9,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 <!-- next-header -->
 ## [Unreleased] - ReleaseDate
+### Changed
+- [PR#83](https://github.com/EmbarkStudios/cfg-expr/pull/83) updated the builtin target list to 1.91.0.
+
 ## [0.20.3] - 2025-09-18
 ### Changed
 - [PR#82](https://github.com/EmbarkStudios/cfg-expr/pull/82) updated the builtin target list to 1.90.0.
diff --git a/Cargo.lock b/Cargo.lock
index 44a942d..602cd09 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -124,9 +124,9 @@ dependencies = [
 
 [[package]]
 name = "smallvec"
-version = "1.14.0"
+version = "1.15.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7fcf8323ef1faaee30a44a340193b1ac6814fd9b7b4e88e9d4519a3e4abe1cfd"
+checksum = "67b1b7a3b5fe4f1376887184045fcf45c69e92af734b7aaddc05fb777b6fbd03"
 
 [[package]]
 name = "syn"
@@ -141,9 +141,9 @@ dependencies = [
 
 [[package]]
 name = "target-lexicon"
-version = "0.13.2"
+version = "0.13.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e502f78cdbb8ba4718f566c418c52bc729126ffd16baee5baa718cf25dd5a69a"
+checksum = "df7f62577c25e07834649fc3b39fafdc597c0a3527dc1c60129201ccfcbaa50c"
 
 [[package]]
 name = "unicode-ident"
diff --git a/Cargo.toml b/Cargo.toml
index f865b33..ec746fe 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -23,8 +23,8 @@ default = []
 targets = ["target-lexicon"]
 
 [dependencies]
-smallvec = "1.14"
-target-lexicon = { version = "=0.13.2", optional = true }
+smallvec = "1.15"
+target-lexicon = { version = "=0.13.3", optional = true }
 
 [dev-dependencies]
 similar-asserts = "1.7"
diff --git a/README.md b/README.md
index 96b589f..503703b 100644
--- a/README.md
+++ b/README.md
@@ -4,13 +4,13 @@
 
 # `⚙️ cfg-expr`
 
-**A parser and evaluator for Rust `cfg()` expressions. Builtin targets as of [1.90.0] are supported.**
+**A parser and evaluator for Rust `cfg()` expressions. Builtin targets as of [1.91.0] are supported.**
 
 [![Build Status](https://github.com/EmbarkStudios/cfg-expr/workflows/CI/badge.svg)](https://github.com/EmbarkStudios/cfg-expr/actions?workflow=CI)
 [![Crates.io](https://img.shields.io/crates/v/cfg-expr.svg)](https://crates.io/crates/cfg-expr)
 [![Docs](https://docs.rs/cfg-expr/badge.svg)](https://docs.rs/cfg-expr)
 [![Minimum Stable Rust Version](https://img.shields.io/badge/Rust%20MSRV-1.70.0-blue?color=fc8d62&logo=rust)](https://blog.rust-lang.org/2023/06/01/Rust-1.70.0.html)
-[![Rust Targets](https://img.shields.io/badge/Rust%20Targets-1.90.0-blue.svg)](https://forge.rust-lang.org/release/platform-support.html)
+[![Rust Targets](https://img.shields.io/badge/Rust%20Targets-1.91.0-blue.svg)](https://forge.rust-lang.org/release/platform-support.html)
 [![Contributor Covenant](https://img.shields.io/badge/contributor%20covenant-v2.0%20adopted-ff69b4.svg)](CODE_OF_CONDUCT.md)
 [![Embark](https://img.shields.io/badge/embark-open%20source-blueviolet.svg)](https://embark.dev)
 </div>
@@ -24,7 +24,7 @@
 
 `cfg-expr` is a crate that can be used to parse and evaluate Rust `cfg()` expressions, both as declarable in Rust code itself, as well in cargo manifests' `[target.'cfg()'.dependencies]` sections.
 
-It contains a list of all builtin targets known to rustc as of [1.90.0] that can be used to determine if a particular cfg expression is satisfiable.
+It contains a list of all builtin targets known to rustc as of [1.91.0] that can be used to determine if a particular cfg expression is satisfiable.
 
 ```rust
 use cfg_expr::{targets::get_builtin_target_by_triple, Expression, Predicate};
@@ -100,4 +100,4 @@ at your option.
 
 Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in the work by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions.
 
-[1.90.0]: (https://forge.rust-lang.org/release/platform-support.html)
+[1.91.0]: (https://forge.rust-lang.org/release/platform-support.html)
diff --git a/src/expr.rs b/src/expr.rs
index e849e1e..11dbc6c 100644
--- a/src/expr.rs
+++ b/src/expr.rs
@@ -103,14 +103,15 @@ impl TargetMatcher for target_lexicon::Triple {
         use TargetPredicate::{
             Abi, Arch, Endian, Env, Family, HasAtomic, Os, Panic, PointerWidth, Vendor,
         };
-        use target_lexicon::*;
+        use target_lexicon::{
+            self as tl, Architecture as arch, ArmArchitecture, Endianness as endian,
+            Environment as env, Mips32Architecture as mips32, Mips64Architecture as mips64,
+            OperatingSystem as os,
+        };
 
-        const NUTTX: target_lexicon::Vendor =
-            target_lexicon::Vendor::Custom(target_lexicon::CustomVendor::Static("nuttx"));
-        const RTEMS: target_lexicon::Vendor =
-            target_lexicon::Vendor::Custom(target_lexicon::CustomVendor::Static("rtems"));
-        const WALI: target_lexicon::Vendor =
-            target_lexicon::Vendor::Custom(target_lexicon::CustomVendor::Static("wali"));
+        const NUTTX: tl::Vendor = tl::Vendor::Custom(tl::CustomVendor::Static("nuttx"));
+        const RTEMS: tl::Vendor = tl::Vendor::Custom(tl::CustomVendor::Static("rtems"));
+        const WALI: tl::Vendor = tl::Vendor::Custom(tl::CustomVendor::Static("wali"));
 
         match tp {
             Abi(_) => {
@@ -119,44 +120,37 @@ impl TargetMatcher for target_lexicon::Triple {
             }
             Arch(arch) => {
                 if arch == &targ::Arch::x86 {
-                    matches!(self.architecture, Architecture::X86_32(_))
+                    matches!(self.architecture, arch::X86_32(_))
                 } else if arch == &targ::Arch::wasm32 {
-                    self.architecture == Architecture::Wasm32
-                        || self.architecture == Architecture::Asmjs
+                    self.architecture == arch::Wasm32 || self.architecture == arch::Asmjs
                 } else if arch == &targ::Arch::arm {
-                    matches!(self.architecture, Architecture::Arm(_))
+                    matches!(self.architecture, arch::Arm(_))
                 } else if arch == &targ::Arch::bpf {
-                    self.architecture == Architecture::Bpfeb
-                        || self.architecture == Architecture::Bpfel
+                    self.architecture == arch::Bpfeb || self.architecture == arch::Bpfel
                 } else if arch == &targ::Arch::x86_64 {
-                    self.architecture == Architecture::X86_64
-                        || self.architecture == Architecture::X86_64h
+                    self.architecture == arch::X86_64 || self.architecture == arch::X86_64h
                 } else if arch == &targ::Arch::mips32r6 {
                     matches!(
                         self.architecture,
-                        Architecture::Mips32(
-                            Mips32Architecture::Mipsisa32r6 | Mips32Architecture::Mipsisa32r6el
-                        )
+                        arch::Mips32(mips32::Mipsisa32r6 | mips32::Mipsisa32r6el)
                     )
                 } else if arch == &targ::Arch::mips64r6 {
                     matches!(
                         self.architecture,
-                        Architecture::Mips64(
-                            Mips64Architecture::Mipsisa64r6 | Mips64Architecture::Mipsisa64r6el
-                        )
+                        arch::Mips64(mips64::Mipsisa64r6 | mips64::Mipsisa64r6el)
                     )
                 } else if arch == &targ::Arch::amdgpu {
-                    self.architecture == Architecture::AmdGcn
+                    self.architecture == arch::AmdGcn
                 } else {
-                    match arch.0.parse::<Architecture>() {
+                    match arch.0.parse::<arch>() {
                         Ok(a) => match (self.architecture, a) {
-                            (Architecture::Aarch64(_), Architecture::Aarch64(_))
-                            | (Architecture::Mips32(_), Architecture::Mips32(_))
-                            | (Architecture::Mips64(_), Architecture::Mips64(_))
-                            | (Architecture::Powerpc64le, Architecture::Powerpc64)
-                            | (Architecture::Riscv32(_), Architecture::Riscv32(_))
-                            | (Architecture::Riscv64(_), Architecture::Riscv64(_))
-                            | (Architecture::Sparcv9, Architecture::Sparc64) => true,
+                            (arch::Aarch64(_), arch::Aarch64(_))
+                            | (arch::Mips32(_), arch::Mips32(_))
+                            | (arch::Mips64(_), arch::Mips64(_))
+                            | (arch::Powerpc64le, arch::Powerpc64)
+                            | (arch::Riscv32(_), arch::Riscv32(_))
+                            | (arch::Riscv64(_), arch::Riscv64(_))
+                            | (arch::Sparcv9, arch::Sparc64) => true,
                             (a, b) => a == b,
                         },
                         Err(_) => false,
@@ -166,8 +160,8 @@ impl TargetMatcher for target_lexicon::Triple {
             Endian(end) => match self.architecture.endianness() {
                 Ok(endian) => matches!(
                     (end, endian),
-                    (crate::targets::Endian::little, Endianness::Little)
-                        | (crate::targets::Endian::big, Endianness::Big)
+                    (crate::targets::Endian::little, endian::Little)
+                        | (crate::targets::Endian::big, endian::Big)
                 ),
 
                 Err(_) => false,
@@ -175,85 +169,82 @@ impl TargetMatcher for target_lexicon::Triple {
             Env(env) => {
                 // The environment is implied by some operating systems
                 match self.operating_system {
-                    OperatingSystem::Redox => env == &targ::Env::relibc,
-                    OperatingSystem::VxWorks => env == &targ::Env::gnu,
-                    OperatingSystem::Freebsd => env.0.is_empty(),
-                    OperatingSystem::Netbsd => match self.architecture {
-                        Architecture::Arm(ArmArchitecture::Armv6 | ArmArchitecture::Armv7) => {
+                    os::Redox => env == &targ::Env::relibc,
+                    os::VxWorks => env == &targ::Env::gnu,
+                    os::Freebsd => env.0.is_empty(),
+                    os::Netbsd => match self.architecture {
+                        arch::Arm(ArmArchitecture::Armv6 | ArmArchitecture::Armv7) => {
                             env.0.is_empty()
                         }
                         _ => env.0.is_empty(),
                     },
-                    OperatingSystem::None_
-                    | OperatingSystem::Cloudabi
-                    | OperatingSystem::Hermit
-                    | OperatingSystem::IOS(_) => match self.environment {
-                        Environment::LinuxKernel => env == &targ::Env::gnu,
+                    os::None_ | os::Cloudabi | os::Hermit => match self.environment {
+                        env::LinuxKernel => env == &targ::Env::gnu,
+                        _ => env.0.is_empty(),
+                    },
+                    os::IOS(_) | os::TvOS(_) => match self.environment {
+                        env::LinuxKernel => env == &targ::Env::gnu,
+                        env::Macabi => env == &targ::Env::macabi,
+                        env::Sim => env == &targ::Env::sim,
+                        env::Unknown => env.0.is_empty() || env == &targ::Env::sim,
                         _ => env.0.is_empty(),
                     },
-                    OperatingSystem::WasiP1 => env == &targ::Env::p1,
-                    OperatingSystem::WasiP2 => env == &targ::Env::p2,
-                    OperatingSystem::Wasi => env.0.is_empty() || env == &targ::Env::p1,
+                    os::WasiP1 => env == &targ::Env::p1,
+                    os::WasiP2 => env == &targ::Env::p2,
+                    os::Wasi => env.0.is_empty() || env == &targ::Env::p1,
                     _ => {
                         if env.0.is_empty() {
                             matches!(
                                 self.environment,
-                                Environment::Unknown
-                                    | Environment::Android
-                                    | Environment::Softfloat
-                                    | Environment::Androideabi
-                                    | Environment::Eabi
-                                    | Environment::Eabihf
-                                    | Environment::Sim
-                                    | Environment::None
+                                env::Unknown
+                                    | env::Android
+                                    | env::Softfloat
+                                    | env::Androideabi
+                                    | env::Eabi
+                                    | env::Eabihf
+                                    | env::Sim
+                                    | env::None
                             )
                         } else {
-                            match env.0.parse::<Environment>() {
+                            match env.0.parse::<env>() {
                                 Ok(e) => {
                                     // Rustc shortens multiple "gnu*" environments to just "gnu"
                                     if env == &targ::Env::gnu {
                                         match self.environment {
-                                            Environment::Gnu
-                                            | Environment::Gnuabi64
-                                            | Environment::Gnueabi
-                                            | Environment::Gnuspe
-                                            | Environment::Gnux32
-                                            | Environment::GnuIlp32
-                                            | Environment::Gnueabihf
-                                            | Environment::GnuLlvm => true,
+                                            env::Gnu
+                                            | env::Gnuabi64
+                                            | env::Gnueabi
+                                            | env::Gnuspe
+                                            | env::Gnux32
+                                            | env::GnuIlp32
+                                            | env::Gnueabihf
+                                            | env::GnuLlvm => true,
                                             // Rust 1.49.0 changed all android targets to have the
                                             // gnu environment
-                                            Environment::Android | Environment::Androideabi
-                                                if self.operating_system
-                                                    == OperatingSystem::Linux =>
+                                            env::Android | env::Androideabi
+                                                if self.operating_system == os::Linux =>
                                             {
                                                 true
                                             }
-                                            Environment::Kernel => {
-                                                self.operating_system == OperatingSystem::Linux
-                                            }
-                                            _ => self.architecture == Architecture::Avr,
+                                            env::Kernel => self.operating_system == os::Linux,
+                                            _ => self.architecture == arch::Avr,
                                         }
                                     } else if env == &targ::Env::musl {
                                         matches!(
                                             self.environment,
-                                            Environment::Musl
-                                                | Environment::Musleabi
-                                                | Environment::Musleabihf
-                                                | Environment::Muslabi64
+                                            env::Musl
+                                                | env::Musleabi
+                                                | env::Musleabihf
+                                                | env::Muslabi64
                                         )
                                     } else if env == &targ::Env::uclibc {
                                         matches!(
                                             self.environment,
-                                            Environment::Uclibc
-                                                | Environment::Uclibceabi
-                                                | Environment::Uclibceabihf
+                                            env::Uclibc | env::Uclibceabi | env::Uclibceabihf
                                         )
                                     } else if env == &targ::Env::newlib {
-                                        matches!(
-                                            self.operating_system,
-                                            OperatingSystem::Horizon | OperatingSystem::Espidf
-                                        ) || self.vendor == RTEMS
+                                        matches!(self.operating_system, os::Horizon | os::Espidf)
+                                            || self.vendor == RTEMS
                                     } else {
                                         self.environment == e
                                     }
@@ -265,71 +256,72 @@ impl TargetMatcher for target_lexicon::Triple {
                 }
             }
             Family(fam) => {
-                use OperatingSystem::{
-                    Aix, AmdHsa, Bitrig, Cloudabi, Cuda, Darwin, Dragonfly, Emscripten, Espidf,
-                    Freebsd, Fuchsia, Haiku, Hermit, Horizon, Hurd, IOS, Illumos, L4re, Linux,
-                    MacOSX, Nebulet, Netbsd, None_, Openbsd, Redox, Solaris, TvOS, Uefi, Unknown,
-                    VisionOS, VxWorks, Wasi, WasiP1, WasiP2, WatchOS, Windows,
-                };
-
                 match self.operating_system {
-                    AmdHsa | Bitrig | Cloudabi | Cuda | Hermit | Nebulet | None_ | Uefi => false,
-                    Aix
-                    | Darwin(_)
-                    | Dragonfly
-                    | Espidf
-                    | Freebsd
-                    | Fuchsia
-                    | Haiku
-                    | Hurd
-                    | Illumos
-                    | IOS(_)
-                    | L4re
-                    | MacOSX { .. }
-                    | Horizon
-                    | Netbsd
-                    | Openbsd
-                    | Redox
-                    | Solaris
-                    | TvOS(_)
-                    | VisionOS(_)
-                    | VxWorks
-                    | WatchOS(_) => fam == &crate::targets::Family::unix,
-                    Emscripten => {
+                    os::AmdHsa
+                    | os::Bitrig
+                    | os::Cloudabi
+                    | os::Cuda
+                    | os::Hermit
+                    | os::Nebulet
+                    | os::None_
+                    | os::Uefi => false,
+                    os::Aix
+                    | os::Darwin(_)
+                    | os::Dragonfly
+                    | os::Espidf
+                    | os::Freebsd
+                    | os::Fuchsia
+                    | os::Haiku
+                    | os::Hurd
+                    | os::Illumos
+                    | os::IOS(_)
+                    | os::L4re
+                    | os::MacOSX { .. }
+                    | os::Horizon
+                    | os::Netbsd
+                    | os::Openbsd
+                    | os::Redox
+                    | os::Solaris
+                    | os::TvOS(_)
+                    | os::VisionOS(_)
+                    | os::VxWorks
+                    | os::WatchOS(_) => fam == &crate::targets::Family::unix,
+                    os::Emscripten => {
                         match self.architecture {
                             // asmjs, wasm32 and wasm64 are part of both the wasm and unix families
-                            Architecture::Asmjs | Architecture::Wasm32 => {
+                            arch::Asmjs | arch::Wasm32 => {
                                 fam == &crate::targets::Family::wasm
                                     || fam == &crate::targets::Family::unix
                             }
                             _ => false,
                         }
                     }
-                    Unknown if self.vendor == NUTTX || self.vendor == RTEMS => {
+                    os::Unknown if self.vendor == NUTTX || self.vendor == RTEMS => {
                         fam == &crate::targets::Family::unix
                     }
-                    Unknown => {
+                    os::Unknown => {
                         // asmjs, wasm32 and wasm64 are part of the wasm family.
                         match self.architecture {
-                            Architecture::Asmjs | Architecture::Wasm32 | Architecture::Wasm64 => {
+                            arch::Asmjs | arch::Wasm32 | arch::Wasm64 => {
                                 fam == &crate::targets::Family::wasm
                             }
                             _ => false,
                         }
                     }
-                    Linux if self.vendor == WALI => {
+                    os::Linux if self.vendor == WALI => {
                         fam == &crate::targets::Family::wasm || fam == &crate::targets::Family::unix
                     }
-                    Linux => {
+                    os::Linux => {
                         // The 'kernel' environment is treated specially as not-unix
-                        if self.environment != Environment::Kernel {
+                        if self.environment != env::Kernel {
                             fam == &crate::targets::Family::unix
                         } else {
                             false
                         }
                     }
-                    Wasi | WasiP1 | WasiP2 => fam == &crate::targets::Family::wasm,
-                    Windows => fam == &crate::targets::Family::windows,
+                    os::Wasi | os::WasiP1 | os::WasiP2 => fam == &crate::targets::Family::wasm,
+                    os::Windows => fam == &crate::targets::Family::windows,
+                    os::Cygwin => fam == &crate::targets::Family::unix,
                     // I really dislike non-exhaustive :(
                     _ => false,
                 }
@@ -340,35 +332,30 @@ impl TargetMatcher for target_lexicon::Triple {
                 false
             }
             Os(os) => {
-                if os == &targ::Os::wasi
-                    && matches!(
-                        self.operating_system,
-                        OperatingSystem::WasiP1 | OperatingSystem::WasiP2
-                    )
+                if os == &targ::Os::wasi && matches!(self.operating_system, os::WasiP1 | os::WasiP2)
                     || (os == &targ::Os::nuttx && self.vendor == NUTTX)
                     || (os == &targ::Os::rtems && self.vendor == RTEMS)
                 {
                     return true;
                 }
 
-                match os.0.parse::<OperatingSystem>() {
+                match os.0.parse::<os>() {
                     Ok(o) => match self.environment {
-                        Environment::HermitKernel => os == &targ::Os::hermit,
+                        env::HermitKernel => os == &targ::Os::hermit,
                         _ => self.operating_system == o,
                     },
                     Err(_) => {
                         // Handle special case for darwin/macos, where the triple is
                         // "darwin", but rustc identifies the OS as "macos"
-                        if os == &targ::Os::macos
-                            && matches!(self.operating_system, OperatingSystem::Darwin(_))
+                        if os == &targ::Os::macos && matches!(self.operating_system, os::Darwin(_))
                         {
                             true
                         } else {
                             // For android, the os is still linux, but the environment is android
                             os == &targ::Os::android
-                                && self.operating_system == OperatingSystem::Linux
-                                && (self.environment == Environment::Android
-                                    || self.environment == Environment::Androideabi)
+                                && self.operating_system == os::Linux
+                                && (self.environment == env::Android
+                                    || self.environment == env::Androideabi)
                         }
                     }
                 }
@@ -384,10 +371,9 @@ impl TargetMatcher for target_lexicon::Triple {
                             && ven == &targ::Vendor::unknown)
                     {
                         true
-                    } else if let target_lexicon::Vendor::Custom(custom) = &self.vendor {
+                    } else if let tl::Vendor::Custom(custom) = &self.vendor {
                         matches!(custom.as_str(), "esp" | "esp32" | "esp32s2" | "esp32s3")
-                            && (v == target_lexicon::Vendor::Espressif
-                                || v == target_lexicon::Vendor::Unknown)
+                            && (v == tl::Vendor::Espressif || v == tl::Vendor::Unknown)
                     } else {
                         false
                     }
@@ -397,10 +383,7 @@ impl TargetMatcher for target_lexicon::Triple {
             PointerWidth(pw) => {
                 // The gnux32 environment is a special case, where it has an
                 // x86_64 architecture, but a 32-bit pointer width
-                if !matches!(
-                    self.environment,
-                    Environment::Gnux32 | Environment::GnuIlp32
-                ) {
+                if !matches!(self.environment, env::Gnux32 | env::GnuIlp32) {
                     *pw == match self.pointer_width() {
                         Ok(pw) => pw.bits(),
                         Err(_) => return false,
diff --git a/src/targets/builtins.rs b/src/targets/builtins.rs
index 6f37123..ec3b792 100644
--- a/src/targets/builtins.rs
+++ b/src/targets/builtins.rs
@@ -10,7 +10,7 @@
 
 use super::*;
 
-pub(crate) const RUSTC_VERSION: &str = "1.90.0";
+pub(crate) const RUSTC_VERSION: &str = "1.91.0";
 
 pub const ALL_BUILTINS: &[TargetInfo] = &[
     TargetInfo {
@@ -44,7 +44,7 @@ pub const ALL_BUILTINS: &[TargetInfo] = &[
         os: Some(Os::ios),
         abi: Some(Abi::macabi),
         arch: Arch::aarch64,
-        env: None,
+        env: Some(Env::macabi),
         vendor: Some(Vendor::apple),
         families: Families::unix,
         pointer_width: 64,
@@ -57,7 +57,7 @@ pub const ALL_BUILTINS: &[TargetInfo] = &[
         os: Some(Os::ios),
         abi: Some(Abi::sim),
         arch: Arch::aarch64,
-        env: None,
+        env: Some(Env::sim),
         vendor: Some(Vendor::apple),
         families: Families::unix,
         pointer_width: 64,
@@ -83,7 +83,7 @@ pub const ALL_BUILTINS: &[TargetInfo] = &[
         os: Some(Os::tvos),
         abi: Some(Abi::sim),
         arch: Arch::aarch64,
-        env: None,
+        env: Some(Env::sim),
         vendor: Some(Vendor::apple),
         families: Families::unix,
         pointer_width: 64,
@@ -109,7 +109,7 @@ pub const ALL_BUILTINS: &[TargetInfo] = &[
         os: Some(Os::visionos),
         abi: Some(Abi::sim),
         arch: Arch::aarch64,
-        env: None,
+        env: Some(Env::sim),
         vendor: Some(Vendor::apple),
         families: Families::unix,
         pointer_width: 64,
@@ -135,7 +135,7 @@ pub const ALL_BUILTINS: &[TargetInfo] = &[
         os: Some(Os::watchos),
         abi: Some(Abi::sim),
         arch: Arch::aarch64,
-        env: None,
+        env: Some(Env::sim),
         vendor: Some(Vendor::apple),
         families: Families::unix,
         pointer_width: 64,
@@ -312,6 +312,19 @@ pub const ALL_BUILTINS: &[TargetInfo] = &[
         has_atomics: HasAtomics::atomic_8_16_32_64_128_ptr,
         panic: Panic::unwind,
     },
+    TargetInfo {
+        triple: Triple::new_const("aarch64-unknown-managarm-mlibc"),
+        os: Some(Os::managarm),
+        abi: None,
+        arch: Arch::aarch64,
+        env: Some(Env::mlibc),
+        vendor: Some(Vendor::unknown),
+        families: Families::unix,
+        pointer_width: 64,
+        endian: Endian::little,
+        has_atomics: HasAtomics::atomic_8_16_32_64_128_ptr,
+        panic: Panic::unwind,
+    },
     TargetInfo {
         triple: Triple::new_const("aarch64-unknown-netbsd"),
         os: Some(Os::netbsd),
@@ -507,6 +520,19 @@ pub const ALL_BUILTINS: &[TargetInfo] = &[
         has_atomics: HasAtomics::atomic_8_16_32_64_128_ptr,
         panic: Panic::unwind,
     },
+    TargetInfo {
+        triple: Triple::new_const("aarch64_be-unknown-hermit"),
+        os: Some(Os::hermit),
+        abi: None,
+        arch: Arch::aarch64,
+        env: None,
+        vendor: Some(Vendor::unknown),
+        families: Families::new_const(&[]),
+        pointer_width: 64,
+        endian: Endian::big,
+        has_atomics: HasAtomics::atomic_8_16_32_64_128_ptr,
+        panic: Panic::abort,
+    },
     TargetInfo {
         triple: Triple::new_const("aarch64_be-unknown-linux-gnu"),
         os: Some(Os::linux),
@@ -533,6 +559,19 @@ pub const ALL_BUILTINS: &[TargetInfo] = &[
         has_atomics: HasAtomics::atomic_8_16_32_64_128_ptr,
         panic: Panic::unwind,
     },
+    TargetInfo {
+        triple: Triple::new_const("aarch64_be-unknown-linux-musl"),
+        os: Some(Os::linux),
+        abi: None,
+        arch: Arch::aarch64,
+        env: Some(Env::musl),
+        vendor: Some(Vendor::unknown),
+        families: Families::unix,
+        pointer_width: 64,
+        endian: Endian::big,
+        has_atomics: HasAtomics::atomic_8_16_32_64_128_ptr,
+        panic: Panic::unwind,
+    },
     TargetInfo {
         triple: Triple::new_const("aarch64_be-unknown-netbsd"),
         os: Some(Os::netbsd),
@@ -546,6 +585,19 @@ pub const ALL_BUILTINS: &[TargetInfo] = &[
         has_atomics: HasAtomics::atomic_8_16_32_64_128_ptr,
         panic: Panic::unwind,
     },
+    TargetInfo {
+        triple: Triple::new_const("aarch64_be-unknown-none-softfloat"),
+        os: None,
+        abi: Some(Abi::softfloat),
+        arch: Arch::aarch64,
+        env: None,
+        vendor: Some(Vendor::unknown),
+        families: Families::new_const(&[]),
+        pointer_width: 64,
+        endian: Endian::big,
+        has_atomics: HasAtomics::atomic_8_16_32_64_128_ptr,
+        panic: Panic::abort,
+    },
     TargetInfo {
         triple: Triple::new_const("amdgcn-amd-amdhsa"),
         os: Some(Os::amdhsa),
@@ -1105,6 +1157,19 @@ pub const ALL_BUILTINS: &[TargetInfo] = &[
         has_atomics: HasAtomics::atomic_8_16_32_64_ptr,
         panic: Panic::abort,
     },
+    TargetInfo {
+        triple: Triple::new_const("armv7a-vex-v5"),
+        os: Some(Os::vexos),
+        abi: Some(Abi::eabihf),
+        arch: Arch::arm,
+        env: Some(Env::v5),
+        vendor: Some(Vendor::vex),
+        families: Families::new_const(&[]),
+        pointer_width: 32,
+        endian: Endian::little,
+        has_atomics: HasAtomics::atomic_8_16_32_64_ptr,
+        panic: Panic::abort,
+    },
     TargetInfo {
         triple: Triple::new_const("armv7k-apple-watchos"),
         os: Some(Os::watchos),
@@ -1266,7 +1331,7 @@ pub const ALL_BUILTINS: &[TargetInfo] = &[
         os: Some(Os::ios),
         abi: Some(Abi::sim),
         arch: Arch::x86,
-        env: None,
+        env: Some(Env::sim),
         vendor: Some(Vendor::apple),
         families: Families::unix,
         pointer_width: 32,
@@ -2509,6 +2574,19 @@ pub const ALL_BUILTINS: &[TargetInfo] = &[
         has_atomics: HasAtomics::atomic_8_16_32_64_ptr,
         panic: Panic::unwind,
     },
+    TargetInfo {
+        triple: Triple::new_const("riscv64a23-unknown-linux-gnu"),
+        os: Some(Os::linux),
+        abi: None,
+        arch: Arch::riscv64,
+        env: Some(Env::gnu),
+        vendor: Some(Vendor::unknown),
+        families: Families::unix,
+        pointer_width: 64,
+        endian: Endian::little,
+        has_atomics: HasAtomics::atomic_8_16_32_64_ptr,
+        panic: Panic::unwind,
+    },
     TargetInfo {
         triple: Triple::new_const("riscv64gc-unknown-freebsd"),
         os: Some(Os::freebsd),
@@ -2574,6 +2652,19 @@ pub const ALL_BUILTINS: &[TargetInfo] = &[
         has_atomics: HasAtomics::atomic_8_16_32_64_ptr,
         panic: Panic::unwind,
     },
+    TargetInfo {
+        triple: Triple::new_const("riscv64gc-unknown-managarm-mlibc"),
+        os: Some(Os::managarm),
+        abi: None,
+        arch: Arch::riscv64,
+        env: Some(Env::mlibc),
+        vendor: Some(Vendor::unknown),
+        families: Families::unix,
+        pointer_width: 64,
+        endian: Endian::little,
+        has_atomics: HasAtomics::atomic_8_16_32_64_ptr,
+        panic: Panic::unwind,
+    },
     TargetInfo {
         triple: Triple::new_const("riscv64gc-unknown-netbsd"),
         os: Some(Os::netbsd),
@@ -3177,7 +3268,7 @@ pub const ALL_BUILTINS: &[TargetInfo] = &[
         os: Some(Os::ios),
         abi: Some(Abi::sim),
         arch: Arch::x86_64,
-        env: None,
+        env: Some(Env::sim),
         vendor: Some(Vendor::apple),
         families: Families::unix,
         pointer_width: 64,
@@ -3190,7 +3281,7 @@ pub const ALL_BUILTINS: &[TargetInfo] = &[
         os: Some(Os::ios),
         abi: Some(Abi::macabi),
         arch: Arch::x86_64,
-        env: None,
+        env: Some(Env::macabi),
         vendor: Some(Vendor::apple),
         families: Families::unix,
         pointer_width: 64,
@@ -3203,7 +3294,7 @@ pub const ALL_BUILTINS: &[TargetInfo] = &[
         os: Some(Os::tvos),
         abi: Some(Abi::sim),
         arch: Arch::x86_64,
-        env: None,
+        env: Some(Env::sim),
         vendor: Some(Vendor::apple),
         families: Families::unix,
         pointer_width: 64,
@@ -3216,7 +3307,7 @@ pub const ALL_BUILTINS: &[TargetInfo] = &[
         os: Some(Os::watchos),
         abi: Some(Abi::sim),
         arch: Arch::x86_64,
-        env: None,
+        env: Some(Env::sim),
         vendor: Some(Vendor::apple),
         families: Families::unix,
         pointer_width: 64,
@@ -3549,6 +3640,19 @@ pub const ALL_BUILTINS: &[TargetInfo] = &[
         has_atomics: HasAtomics::atomic_8_16_32_64_ptr,
         panic: Panic::unwind,
     },
+    TargetInfo {
+        triple: Triple::new_const("x86_64-unknown-managarm-mlibc"),
+        os: Some(Os::managarm),
+        abi: None,
+        arch: Arch::x86_64,
+        env: Some(Env::mlibc),
+        vendor: Some(Vendor::unknown),
+        families: Families::unix,
+        pointer_width: 64,
+        endian: Endian::little,
+        has_atomics: HasAtomics::atomic_8_16_32_64_ptr,
+        panic: Panic::unwind,
+    },
     TargetInfo {
         triple: Triple::new_const("x86_64-unknown-netbsd"),
         os: Some(Os::netbsd),
@@ -3856,6 +3960,7 @@ impl super::Vendor {
     pub const unikraft: Vendor = Vendor::new_const("unikraft");
     pub const unknown: Vendor = Vendor::new_const("unknown");
     pub const uwp: Vendor = Vendor::new_const("uwp");
+    pub const vex: Vendor = Vendor::new_const("vex");
     pub const win7: Vendor = Vendor::new_const("win7");
     pub const wrs: Vendor = Vendor::new_const("wrs");
 }
@@ -3881,6 +3986,7 @@ impl super::Os {
     pub const linux: Os = Os::new_const("linux");
     pub const lynxos178: Os = Os::new_const("lynxos178");
     pub const macos: Os = Os::new_const("macos");
+    pub const managarm: Os = Os::new_const("managarm");
     pub const netbsd: Os = Os::new_const("netbsd");
     pub const nto: Os = Os::new_const("nto");
     pub const nuttx: Os = Os::new_const("nuttx");
@@ -3896,6 +4002,7 @@ impl super::Os {
     pub const tvos: Os = Os::new_const("tvos");
     pub const uefi: Os = Os::new_const("uefi");
     pub const unknown: Os = Os::new_const("unknown");
+    pub const vexos: Os = Os::new_const("vexos");
     pub const visionos: Os = Os::new_const("visionos");
     pub const vita: Os = Os::new_const("vita");
     pub const vxworks: Os = Os::new_const("vxworks");
@@ -3926,6 +4033,8 @@ impl super::Families {
 
 impl super::Env {
     pub const gnu: Env = Env::new_const("gnu");
+    pub const macabi: Env = Env::new_const("macabi");
+    pub const mlibc: Env = Env::new_const("mlibc");
     pub const msvc: Env = Env::new_const("msvc");
     pub const musl: Env = Env::new_const("musl");
     pub const newlib: Env = Env::new_const("newlib");
@@ -3938,7 +4047,9 @@ impl super::Env {
     pub const p2: Env = Env::new_const("p2");
     pub const relibc: Env = Env::new_const("relibc");
     pub const sgx: Env = Env::new_const("sgx");
+    pub const sim: Env = Env::new_const("sim");
     pub const uclibc: Env = Env::new_const("uclibc");
+    pub const v5: Env = Env::new_const("v5");
 }
 
 const __has_atomics_8_16_32_64_128_ptr: &[HasAtomic] = &[