rust/compiler/rustc_target/src/spec/tests/tests_impl.rs

use std::assert_matches::assert_matches;

use super::super::*;

// Test target self-consistency and JSON encoding/decoding roundtrip.
pub(super) fn test_target(mut target: Target) {
    let recycled_target = Target::from_json(target.to_json()).map(|(j, _)| j);
    target.update_to_cli();
    target.check_consistency();
    assert_eq!(recycled_target, Ok(target));
}

impl Target {
    fn check_consistency(&self) {
        assert_eq!(self.is_like_osx, self.vendor == "apple");
        assert_eq!(self.is_like_solaris, self.os == "solaris" || self.os == "illumos");
        assert_eq!(self.is_like_windows, self.os == "windows" || self.os == "uefi");
        assert_eq!(self.is_like_wasm, self.arch == "wasm32" || self.arch == "wasm64");
        if self.is_like_msvc {
            assert!(self.is_like_windows);
        }

        // Check that default linker flavor is compatible with some other key properties.
        assert_eq!(self.is_like_osx, matches!(self.linker_flavor, LinkerFlavor::Darwin(..)));
        assert_eq!(self.is_like_msvc, matches!(self.linker_flavor, LinkerFlavor::Msvc(..)));
        assert_eq!(
            self.is_like_wasm && self.os != "emscripten",
            matches!(self.linker_flavor, LinkerFlavor::WasmLld(..))
        );
        assert_eq!(self.os == "emscripten", matches!(self.linker_flavor, LinkerFlavor::EmCc));
        assert_eq!(self.arch == "bpf", matches!(self.linker_flavor, LinkerFlavor::Bpf));
        assert_eq!(self.arch == "nvptx64", matches!(self.linker_flavor, LinkerFlavor::Ptx));

        for args in [
            &self.pre_link_args,
            &self.late_link_args,
            &self.late_link_args_dynamic,
            &self.late_link_args_static,
            &self.post_link_args,
        ] {
            for (&flavor, flavor_args) in args {
                assert!(!flavor_args.is_empty());
                // Check that flavors mentioned in link args are compatible with the default flavor.
                match self.linker_flavor {
                    LinkerFlavor::Gnu(..) => {
                        assert_matches!(flavor, LinkerFlavor::Gnu(..));
                    }
                    LinkerFlavor::Darwin(..) => {
                        assert_matches!(flavor, LinkerFlavor::Darwin(..))
                    }
                    LinkerFlavor::WasmLld(..) => {
                        assert_matches!(flavor, LinkerFlavor::WasmLld(..))
                    }
                    LinkerFlavor::Unix(..) => {
                        assert_matches!(flavor, LinkerFlavor::Unix(..));
                    }
                    LinkerFlavor::Msvc(..) => {
                        assert_matches!(flavor, LinkerFlavor::Msvc(..))
                    }
                    LinkerFlavor::EmCc
                    | LinkerFlavor::Bpf
                    | LinkerFlavor::Ptx
                    | LinkerFlavor::Llbc => {
                        assert_eq!(flavor, self.linker_flavor)
                    }
                }

                // Check that link args for cc and non-cc versions of flavors are consistent.
                let check_noncc = |noncc_flavor| {
                    if let Some(noncc_args) = args.get(&noncc_flavor) {
                        for arg in flavor_args {
                            if let Some(suffix) = arg.strip_prefix("-Wl,") {
                                assert!(noncc_args.iter().any(|a| a == suffix));
                            }
                        }
                    }
                };

                match self.linker_flavor {
                    LinkerFlavor::Gnu(Cc::Yes, lld) => check_noncc(LinkerFlavor::Gnu(Cc::No, lld)),
                    LinkerFlavor::WasmLld(Cc::Yes) => check_noncc(LinkerFlavor::WasmLld(Cc::No)),
                    LinkerFlavor::Unix(Cc::Yes) => check_noncc(LinkerFlavor::Unix(Cc::No)),
                    _ => {}
                }
            }

            // Check that link args for lld and non-lld versions of flavors are consistent.
            for cc in [Cc::No, Cc::Yes] {
                assert_eq!(
                    args.get(&LinkerFlavor::Gnu(cc, Lld::No)),
                    args.get(&LinkerFlavor::Gnu(cc, Lld::Yes)),
                );
                assert_eq!(
                    args.get(&LinkerFlavor::Darwin(cc, Lld::No)),
                    args.get(&LinkerFlavor::Darwin(cc, Lld::Yes)),
                );
            }
            assert_eq!(
                args.get(&LinkerFlavor::Msvc(Lld::No)),
                args.get(&LinkerFlavor::Msvc(Lld::Yes)),
            );
        }

        if self.link_self_contained.is_disabled() {
            assert!(
                self.pre_link_objects_self_contained.is_empty()
                    && self.post_link_objects_self_contained.is_empty()
            );
        }

        // If your target really needs to deviate from the rules below,
        // except it and document the reasons.
        // Keep the default "unknown" vendor instead.
        assert_ne!(self.vendor, "");
        assert_ne!(self.os, "");
        if !self.can_use_os_unknown() {
            // Keep the default "none" for bare metal targets instead.
            assert_ne!(self.os, "unknown");
        }

        // Check dynamic linking stuff
        // BPF: when targeting user space vms (like rbpf), those can load dynamic libraries.
        // hexagon: when targeting QuRT, that OS can load dynamic libraries.
        // wasm{32,64}: dynamic linking is inherent in the definition of the VM.
        if self.os == "none"
            && (self.arch != "bpf"
                && self.arch != "hexagon"
                && self.arch != "wasm32"
                && self.arch != "wasm64")
        {
            assert!(!self.dynamic_linking);
        }
        if self.only_cdylib
            || self.crt_static_allows_dylibs
            || !self.late_link_args_dynamic.is_empty()
        {
            assert!(self.dynamic_linking);
        }
        // Apparently PIC was slow on wasm at some point, see comments in wasm_base.rs
        if self.dynamic_linking && !(self.is_like_wasm && self.os != "emscripten") {
            assert_eq!(self.relocation_model, RelocModel::Pic);
        }
        if self.position_independent_executables {
            assert_eq!(self.relocation_model, RelocModel::Pic);
        }
        // The UEFI targets do not support dynamic linking but still require PIC (#101377).
        if self.relocation_model == RelocModel::Pic && self.os != "uefi" {
            assert!(self.dynamic_linking || self.position_independent_executables);
        }
        if self.static_position_independent_executables {
            assert!(self.position_independent_executables);
        }
        if self.position_independent_executables {
            assert!(self.executables);
        }

        // Check crt static stuff
        if self.crt_static_default || self.crt_static_allows_dylibs {
            assert!(self.crt_static_respected);
        }

        // Check that RISC-V targets always specify which ABI they use.
        match &*self.arch {
            "riscv32" => {
                assert_matches!(&*self.llvm_abiname, "ilp32" | "ilp32f" | "ilp32d" | "ilp32e")
            }
            "riscv64" => {
                // Note that the `lp64e` is still unstable as it's not (yet) part of the ELF psABI.
                assert_matches!(&*self.llvm_abiname, "lp64" | "lp64f" | "lp64d" | "lp64q" | "lp64e")
            }
            _ => {}
        }
    }

    // Add your target to the whitelist if it has `std` library
    // and you certainly want "unknown" for the OS name.
    fn can_use_os_unknown(&self) -> bool {
        self.llvm_target == "wasm32-unknown-unknown"
            || self.llvm_target == "wasm64-unknown-unknown"
            || (self.env == "sgx" && self.vendor == "fortanix")
    }
}