rucc_pp/

predef.rs

//! The predefined macro set, generated from the target description.
//!
//! Design: `spec/04-driver-and-cli.md` section 4.5.
//!
//! The set is built as text and then read by the directive engine, which is what GCC does and
//! is not laziness. Constructing a few hundred `MacroDef` values by hand would need its own
//! parser for macro bodies, would not exercise the one that already exists, and could not be
//! read by a person checking a limit against the psABI. A file of `#define` lines can be
//! printed by `-dM`, diffed against GCC's output, and understood at a glance.
//!
//! Two synthetic files come out of this, and they are the two GCC names in a diagnostic:
//! `<built-in>` for the generated set and `<command-line>` for `-D` and `-U`. Keeping them
//! apart is what lets "`FOO` redefined" point at the command line rather than at a line
//! nobody wrote.
//!
//! The decision that everything else follows from is in section 4.5: we define `__GNUC__`,
//! which means glibc's headers, the kernel's headers and every autoconf probe take the GNU
//! path. The version claimed is deliberately conservative and is a knob, because claiming too
//! high a version means headers use extensions we do not have, and the matrix in `rucc-gnu`
//! is the list of promises the claim makes.

use rucc_base::float::Format;
use rucc_session::{GnucVersion, Math, OptLevel, Options, Pic, Std};
use rucc_target::{Arch, Env, Isa, Os, TargetInfo, Triple};
use rucc_tuple::{self as tuple};

/// The name a diagnostic about the generated set points at.
pub const BUILT_IN: &str = "<built-in>";

/// The name a diagnostic about `-D` or `-U` points at.
pub const COMMAND_LINE: &str = "<command-line>";

/// The translation date, as `__DATE__` and `__TIME__` spell it.
///
/// Fixed for the whole translation unit, which is what the standard requires and what makes
/// the two macros ordinary object-like macros rather than something the expander has to know
/// about.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Timestamp {
    /// `Mmm dd yyyy`, with the day space padded, which is the format the standard fixes.
    pub date: String,
    /// `hh:mm:ss`.
    pub time: String,
}

impl Timestamp {
    /// The current time, or `SOURCE_DATE_EPOCH` when the build asked for a reproducible one.
    ///
    /// Reading the environment here rather than in the driver is what GCC does, and it keeps
    /// the variable working for an embedder who never goes through a command line.
    pub fn now() -> Timestamp {
        let seconds = match std::env::var("SOURCE_DATE_EPOCH").ok().and_then(|v| v.parse().ok()) {
            Some(fixed) => fixed,
            None => std::time::SystemTime::now()
                .duration_since(std::time::UNIX_EPOCH)
                .map_or(0, |d| d.as_secs() as i64),
        };
        Timestamp::from_unix(seconds)
    }

    /// The time `seconds` after the epoch, in UTC.
    ///
    /// UTC rather than local time, because a compiler whose output depends on the machine's
    /// time zone is a compiler whose output is not reproducible.
    pub fn from_unix(seconds: i64) -> Timestamp {
        let days = seconds.div_euclid(86_400);
        let rest = seconds.rem_euclid(86_400);
        let (year, month, day) = civil_from_days(days);
        const MONTHS: [&str; 12] =
            ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
        let name = MONTHS[(month - 1) as usize];
        Timestamp {
            date: format!("{name} {day:2} {year}"),
            time: format!("{:02}:{:02}:{:02}", rest / 3600, (rest / 60) % 60, rest % 60),
        }
    }
}

/// The year, month and day `days` after 1970-01-01.
///
/// Howard Hinnant's civil calendar algorithm, which is a handful of divisions and no table.
/// It is here rather than in a dependency because the whole workspace has no dependencies,
/// and a date conversion is not a good reason to acquire the first one.
fn civil_from_days(days: i64) -> (i64, u32, u32) {
    // Shift the epoch to 0000-03-01, so that a leap day is the last day of the year and the
    // month lengths become a repeating pattern that one division can invert.
    let shifted = days + 719_468;
    let era = shifted.div_euclid(146_097);
    let day_of_era = shifted.rem_euclid(146_097);
    let year_of_era =
        (day_of_era - day_of_era / 1460 + day_of_era / 36_524 - day_of_era / 146_096) / 365;
    let year = year_of_era + era * 400;
    let day_of_year = day_of_era - (365 * year_of_era + year_of_era / 4 - year_of_era / 100);
    let marched = (5 * day_of_year + 2) / 153;
    let day = (day_of_year - (153 * marched + 2) / 5 + 1) as u32;
    let month = if marched < 10 { marched + 3 } else { marched - 9 } as u32;
    (year + i64::from(month <= 2), month, day)
}

/// Everything the predefined set is built from that is not the target.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Predef {
    /// The dialect, which decides `__STDC_VERSION__`.
    pub std: Std,
    /// Whether the GNU extensions are on, which is `-std=gnu23` rather than `-std=c23`. It
    /// decides `__STRICT_ANSI__` and the unarmoured `linux` and `unix` macros.
    pub gnu_extensions: bool,
    /// Whether the unit is under GNU's reading of `inline`, which is `-fgnu89-inline`. It decides
    /// which of `__GNUC_GNU_INLINE__` and `__GNUC_STDC_INLINE__` is defined, and the C89 dialects
    /// are under that reading whatever it says.
    pub gnu89_inline: bool,
    /// The GCC release claimed.
    pub gnuc: GnucVersion,
    /// Decides `__OPTIMIZE__`, `__OPTIMIZE_SIZE__` and `__NO_INLINE__`.
    pub opt_level: OptLevel,
    /// Whether there is a standard library, which is `-ffreestanding` turned around.
    pub hosted: bool,
    /// Which link the output is for, from `-fPIC` and `-fPIE`. It decides `__PIE__`, since
    /// `__PIC__` is defined either way and says only that there are no absolute addresses.
    pub pic: Pic,
    /// `__DATE__` and `__TIME__`.
    pub timestamp: Timestamp,
    /// The glibc release the headers are, as the minor number alone, when they are ours.
    ///
    /// `__GLIBC_MINOR__` and nothing else: `__GLIBC__` is 2 in the tree itself, which is how Zig's
    /// own patched `features.h` has it, and a version the compiler supplied and a version the
    /// header supplied would be two answers to one question.
    pub glibc_minor: Option<u32>,
    /// Whether an operation may raise an exception the program looks at, from `-ftrapping-math`.
    pub trapping_math: bool,
    /// The rest of the `-ffast-math` family. Each licence has a macro of its own and the family
    /// together decides `__FAST_MATH__` and whether the arithmetic is still IEC 60559's.
    pub math: Math,
    /// Whether an exception may unwind through this unit, from `-fexceptions`.
    pub exceptions: bool,
    /// `-D` in command line order. `FOO` means `FOO=1`, as GCC has it.
    pub defines: Vec<String>,
    /// `-U` in command line order, applied after the defines.
    pub undefines: Vec<String>,
    /// The instruction set extensions the unit is built for, which decides `__SSE4_2__` and the
    /// rest of that family on x86-64 and nothing anywhere else.
    pub isa: Isa,
}

impl Predef {
    /// The default dialect, `gnu23`, at `-O0`.
    pub fn new() -> Predef {
        Predef {
            std: Std::default(),
            gnu_extensions: true,
            gnu89_inline: false,
            gnuc: GnucVersion::default(),
            opt_level: OptLevel::O0,
            hosted: true,
            pic: Pic::Executable,
            timestamp: Timestamp::now(),
            glibc_minor: None,
            trapping_math: true,
            math: Math::default(),
            exceptions: false,
            defines: Vec::new(),
            undefines: Vec::new(),
            isa: Isa::baseline(),
        }
    }
}

impl Predef {
    /// The set the command line asked for.
    ///
    /// The mapping lives here rather than in the driver because it is the definition of what
    /// each flag means to the macro set, and the driver's job is to parse a command line, not
    /// to know that `-ffreestanding` is `__STDC_HOSTED__` being zero.
    pub fn for_options(opts: &Options) -> Predef {
        Predef {
            std: opts.std,
            gnu_extensions: opts.gnu_extensions,
            gnu89_inline: opts.gnu89_inline,
            gnuc: opts.gnuc,
            opt_level: opts.opt_level,
            hosted: opts.hosted,
            pic: opts.pic,
            timestamp: Timestamp::now(),
            glibc_minor: opts.glibc_minor,
            trapping_math: opts.trapping_math,
            math: opts.math,
            exceptions: opts.exceptions,
            defines: opts.defines.clone(),
            undefines: opts.undefines.clone(),
            isa: opts.isa,
        }
    }
}

impl Default for Predef {
    fn default() -> Predef {
        Predef::new()
    }
}

/// A file of `#define` lines being built up.
struct Defs {
    text: String,
}

impl Defs {
    fn new() -> Defs {
        Defs { text: String::new() }
    }

    /// `#define name value`.
    fn set(&mut self, name: &str, value: &str) {
        self.text.push_str("#define ");
        self.text.push_str(name);
        self.text.push(' ');
        self.text.push_str(value);
        self.text.push('\n');
    }

    /// `#define name 1`, which is what a macro that is only ever tested for needs.
    fn flag(&mut self, name: &str) {
        self.set(name, "1");
    }

    fn set_if(&mut self, when: bool, name: &str, value: &str) {
        if when {
            self.set(name, value);
        }
    }

    fn flag_if(&mut self, when: bool, name: &str) {
        if when {
            self.flag(name);
        }
    }
}

/// The whole predefined set for a target, as the text of a file.
pub(crate) fn built_in(target: &TargetInfo, opts: &Predef) -> String {
    let mut d = Defs::new();
    identity(&mut d, target, opts);
    // `__DATE__` and `__TIME__` are fixed for the whole translation unit, which is what the
    // standard asks for, so they are ordinary object-like macros and the expander needs to
    // know nothing about them.
    d.set("__DATE__", &format!("\"{}\"", opts.timestamp.date));
    d.set("__TIME__", &format!("\"{}\"", opts.timestamp.time));
    dialect(&mut d, target, opts);
    optimization(&mut d, opts);
    platform(&mut d, target, opts);
    sizes(&mut d, target);
    integers(&mut d, target);
    floats(&mut d, target, opts);
    atomics(&mut d, target);
    d.text
}

/// `-D` and `-U`, as the text of a file.
///
/// Empty when there are none, so that the caller can skip adding a file that would say
/// nothing. The undefines come last whatever order they were written in, because `-U` beats
/// `-D` in GCC no matter which side of it the `-D` was on.
pub(crate) fn command_line(opts: &Predef) -> String {
    let mut d = Defs::new();
    for define in &opts.defines {
        match define.split_once('=') {
            Some((name, value)) => d.set(name, value),
            // `-DFOO` is `-DFOO=1`. A macro nobody gave a value to is one that is only ever
            // tested for, and giving it an empty body would break `#if FOO`.
            None => d.flag(define),
        }
    }
    for name in &opts.undefines {
        d.text.push_str("#undef ");
        d.text.push_str(name);
        d.text.push('\n');
    }
    d.text
}

/// What this compiler says its own version is.
///
/// Read from the manifest at build time rather than written here, because a number written in a
/// second place is a number that goes stale: these five macros said 0.1.0 through sixty seven
/// releases. A program testing `__rucc_major__` for a feature was told the answer for a version
/// nobody has run since, and a build log recording `__VERSION__` recorded the wrong compiler.
const VERSION: &str = env!("CARGO_PKG_VERSION");

/// One dotted field of a version, as the digits at the front of it.
///
/// `0.10.68-rc.1` has a patch level of 68 and not of `68-rc`, and a field that is not there at all
/// is zero, which is what a two field version means by its third. Neither shape is one this
/// workspace publishes, and a macro that expands to something no `#if` can read is worse than a
/// macro that is approximately right.
fn field(version: &str, n: usize) -> &str {
    let part = version.split('.').nth(n).unwrap_or("0");
    let digits = part.trim_start_matches(|c: char| !c.is_ascii_digit());
    let end = digits.find(|c: char| !c.is_ascii_digit()).unwrap_or(digits.len());
    if end == 0 { "0" } else { &digits[..end] }
}

/// Who the compiler says it is.
fn identity(d: &mut Defs, target: &TargetInfo, opts: &Predef) {
    d.flag("__rucc__");
    d.set("__rucc_version__", &format!("\"{VERSION}\""));
    d.set("__rucc_major__", field(VERSION, 0));
    d.set("__rucc_minor__", field(VERSION, 1));
    d.set("__rucc_patchlevel__", field(VERSION, 2));
    // The promise from section 4.5. Everything in the matrix hangs off this line.
    d.set("__GNUC__", &opts.gnuc.major.to_string());
    d.set("__GNUC_MINOR__", &opts.gnuc.minor.to_string());
    d.set("__GNUC_PATCHLEVEL__", &opts.gnuc.patch.to_string());
    d.set("__VERSION__", &format!("\"rucc {VERSION}\""));
    // Not `__clang__`, deliberately. Section 4.5 says so, and a header that takes the Clang
    // path expects Clang's extension surface rather than GCC's.
    //
    // Which of the two readings of `inline` is in force, which a header reads to decide how to
    // write its own inline definitions: glibc's `__extern_inline` is `extern __inline` under the
    // one and adds `__attribute__ ((__gnu_inline__))` under the other. C99 changed the meaning of
    // the keyword and gcc follows the dialect, so the C89 ones keep GNU's reading and every
    // dialect after them takes C's until `-fgnu89-inline` says otherwise.
    let gnu_inline = opts.gnu89_inline || opts.std == Std::C89;
    d.flag_if(gnu_inline, "__GNUC_GNU_INLINE__");
    d.flag_if(!gnu_inline, "__GNUC_STDC_INLINE__");
    // The charsets a literal is converted to. Both are fixed here rather than settable, since
    // there is no `-fexec-charset` to set them with, and both are what gcc answers with none.
    // The wide one follows `wchar_t`, which is sixteen bits on Windows and thirty two
    // everywhere else, so it is the one target fact in this function.
    d.set("__GNUC_EXECUTION_CHARSET_NAME", "\"UTF-8\"");
    let wide = if target.wchar_width == 16 { "\"UTF-16LE\"" } else { "\"UTF-32LE\"" };
    d.set("__GNUC_WIDE_EXECUTION_CHARSET_NAME", wide);
    // The C++ ABI this would be if it compiled C++, which gcc defines in C as well. It is not
    // a claim about this compiler so much as a number headers read: libstdc++ is not the only
    // thing that tests it, and a C header shared with a C++ one reaches it through `extern
    // "C"` guards. The value is gcc 16's.
    d.set("__GXX_ABI_VERSION", "1021");
}

/// What the dialect flags say.
fn dialect(d: &mut Defs, target: &TargetInfo, opts: &Predef) {
    d.flag("__STDC__");
    d.set_if(opts.hosted, "__STDC_HOSTED__", "1");
    d.set_if(!opts.hosted, "__STDC_HOSTED__", "0");
    if let Some(version) = opts.std.stdc_version() {
        d.set("__STDC_VERSION__", version);
    }
    // Defined exactly when the extensions are off, which is the whole difference between
    // `-std=c23` and `-std=gnu23` as far as the preprocessor is concerned.
    d.flag_if(!opts.gnu_extensions, "__STRICT_ANSI__");
    d.flag("__STDC_UTF_16__");
    d.flag("__STDC_UTF_32__");
    // What glibc's `<pthread.h>` reads to spell `pthread_cleanup_push` with a `cleanup` attribute
    // rather than with `setjmp`, and gcc defines it in C for `-fexceptions` and for
    // `-fnon-call-exceptions` alone.
    d.flag_if(opts.exceptions, "__EXCEPTIONS");
    // Only while the arithmetic is IEC 60559's, which a fast math licence ends. glibc's
    // `<stdc-predef.h>` writes the same four from `__GCC_IEC_559` and writes none of them when that
    // is zero, so saying them here under `-ffast-math` would be the redefinition described below
    // with the opposite sign.
    let iec = opts.math.iec_559(opts.trapping_math);
    d.flag_if(iec, "__STDC_IEC_559__");
    d.flag_if(iec, "__STDC_IEC_559_COMPLEX__");
    // TS 18661-1's date, in every dialect, which is gcc 16's answer rather than the standard's.
    // C23 folded that document into Annex F and gave the macro a date of its own, so 202311L is
    // the value C23 asks for, and writing it is what a reading of the standard alone produces.
    // It also breaks every translation unit that reaches glibc. `<stdc-predef.h>` is included
    // ahead of the first line of the file and defines this name as 201404L whenever
    // `__GCC_IEC_559` is positive, which it is here, so a different value is a redefinition with
    // a different body and that is a diagnostic on a line the program never wrote. The cost is
    // not only noise: sqlite's configure runs its feature tests through autosetup's `cctest
    // -nooutput 1`, which reads any output at all as a failed test, and the readline completion
    // test failed for no other reason than this warning.
    d.set_if(iec, "__STDC_IEC_60559_BFP__", "201404L");
    // The same date for the complex half, which is the other name `<stdc-predef.h>` writes and
    // which was missing here. Withholding it looked like the careful answer and was not one, for
    // two reasons. `__STDC_NO_COMPLEX__` is defined, so there is no complex arithmetic for the
    // claim to be about and a program that reads one of these has already been told there is
    // none. And the library makes the claim anyway: the `#else` in `<stdc-predef.h>` is reached
    // by a compiler that says nothing about its intent, and it presumes an older compiler that
    // meant yes. Saying nothing therefore does not withhold anything, it only makes the value
    // arrive from somewhere else.
    d.set_if(iec, "__STDC_IEC_60559_COMPLEX__", "201404L");
    // A promise that every `wchar_t` holds a UCS code point in every locale, which glibc's
    // `<stdc-predef.h>` makes and Apple's library does not: a Mac `wchar_t` in a legacy locale
    // is not Unicode, and clang for Apple leaves the macro out for that reason. A program that
    // reads it to skip `mbstowcs` is the one that would be wrong.
    let apple = matches!(target.tuple.os(), tuple::Os::MacOs | tuple::Os::IOs);
    d.set_if(!apple, "__STDC_ISO_10646__", "201706L");
    // The type behind `char8_t`, which C23 added and no dialect before it has. It sits here
    // rather than next to `__CHAR16_TYPE__` and `__CHAR32_TYPE__` because those two are the
    // same in every dialect and this one is not, which is the whole reason a header can test
    // for it: gcc's own `stdatomic.h` writes `atomic_char8_t` under `#ifdef __CHAR8_TYPE__`
    // and gets it in C23 and not in C17.
    d.set_if(opts.std >= Std::C23, "__CHAR8_TYPE__", "unsigned char");
    // C11 made these conditional features, and a header that sees `__STDC_VERSION__` at
    // 201112 with no `__STDC_NO_ATOMICS__` next to it will use `_Atomic`. Each one here is a
    // claim not to have something, so each one is only correct while it stays true: atomics
    // because there is no `stdatomic.h` to include, threads because there is no `threads.h`,
    // and complex because the arithmetic is not lowered.
    //
    // Variable length arrays are not on this list, because they work. Claiming otherwise is
    // not a harmless overstatement of caution: glibc's `regex.h` writes the bound of
    // `regexec`'s match array as `_REGEX_NELTS (__nmatch)`, which is the parameter when the
    // dialect has them and nothing at all when a compiler says it does not, so the claim
    // silently changes a declaration in a header rather than turning something off.
    if opts.std.has_c11() {
        d.flag("__STDC_NO_ATOMICS__");
        d.flag("__STDC_NO_THREADS__");
        d.flag("__STDC_NO_COMPLEX__");
    }
    // What `__has_embed` answers with. They are defined in every dialect and not only in C23,
    // because the operator is answerable in every dialect and a header that writes
    // `#if __has_embed(...) == __STDC_EMBED_FOUND__` under `-std=gnu17` would otherwise be
    // comparing against zero and taking the not found branch on a resource that is there.
    d.set("__STDC_EMBED_NOT_FOUND__", "0");
    d.set("__STDC_EMBED_FOUND__", "1");
    d.set("__STDC_EMBED_EMPTY__", "2");
}

/// The memory orders and the lock free answers.
///
/// These are here whether or not `_Atomic` is, and `__STDC_NO_ATOMICS__` does not turn them
/// off, because they are the numbering the `__atomic` builtins take rather than a promise
/// about the language. musl's `stdatomic.h` writes `memory_order_relaxed = __ATOMIC_RELAXED`
/// with no test around it at all, so a compiler without them prints an enumerator whose value
/// is an identifier.
///
/// Two means always lock free, and every integer type gets a two on all three targets, which
/// are all sixty four bit machines. `long long` is the one that would change on a thirty two
/// bit target, where a double word load is an instruction the machine may or may not have.
fn atomics(d: &mut Defs, target: &TargetInfo) {
    d.set("__ATOMIC_RELAXED", "0");
    d.set("__ATOMIC_CONSUME", "1");
    d.set("__ATOMIC_ACQUIRE", "2");
    d.set("__ATOMIC_RELEASE", "3");
    d.set("__ATOMIC_ACQ_REL", "4");
    d.set("__ATOMIC_SEQ_CST", "5");
    // The gate is the machine word rather than `long`, because Windows has a thirty two bit
    // `long` on a sixty four bit machine and its `long long` is still one instruction.
    let llong = if target.pointer_width == 64 { "2" } else { "1" };
    for name in [
        "BOOL", "CHAR", "CHAR8_T", "CHAR16_T", "CHAR32_T", "WCHAR_T", "SHORT", "INT", "LONG",
        "POINTER",
    ] {
        d.set(&format!("__GCC_ATOMIC_{name}_LOCK_FREE"), "2");
    }
    // The one that is not always two: a target whose word is thirty two bits wide can only
    // promise `long long` is lock free if it has a double word instruction, and the honest
    // answer there is sometimes rather than always.
    d.set("__GCC_ATOMIC_LLONG_LOCK_FREE", llong);
    d.set("__GCC_ATOMIC_TEST_AND_SET_TRUEVAL", "1");
    // What `__sync_bool_compare_and_swap` works on, one macro per width in bytes. Every target
    // here has the instruction at all four, and glibc reads these rather than the `__atomic_*`
    // set because they are the older question and the answer is the same one.
    for width in [1, 2, 4, 8] {
        d.flag(&format!("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_{width}"));
    }
    // The two flag bits an x86 memory order can carry, for the hardware lock elision prefixes.
    // They are numbers a program passes back to a builtin rather than a claim that the prefix
    // is emitted, and a program that computes one on a machine where the macro is missing gets
    // a preprocessor error rather than a slower atomic.
    if target.tuple.arch() == tuple::Arch::X86_64 {
        d.set("__ATOMIC_HLE_ACQUIRE", "65536");
        d.set("__ATOMIC_HLE_RELEASE", "131072");
    }
}

/// What the optimizer level says.
fn optimization(d: &mut Defs, opts: &Predef) {
    d.flag_if(opts.opt_level.runs_optimizer(), "__OPTIMIZE__");
    d.flag_if(opts.opt_level.is_size(), "__OPTIMIZE_SIZE__");
    // glibc's headers test this before deciding whether to define a function as an inline
    // wrapper, so getting it wrong changes what a program links against.
    d.flag_if(!opts.opt_level.runs_optimizer(), "__NO_INLINE__");
    // Zero, and one under `-ffinite-math-only`, which `-ffast-math` implies. glibc's `math.h`
    // reads it to decide whether to declare the `__*_finite` aliases, so it has to be defined
    // rather than merely not claimed: a header testing `#if __FINITE_MATH_ONLY__ > 0` on a
    // compiler that leaves it undefined takes the same branch, but one writing `#if
    // !__FINITE_MATH_ONLY__` is a different question and gcc gives it an answer.
    let math = &opts.math;
    let trapping = opts.trapping_math;
    d.set("__FINITE_MATH_ONLY__", if math.finite_only { "1" } else { "0" });
    // One macro per licence, each defined only when it was given, which is how gcc 16 spells
    // them. `__FAST_MATH__` is all of them at once and is worked out rather than remembered from
    // the flag, so `-ffast-math -ftrapping-math` does not claim it, and regrouping is the one gcc
    // drops unless nothing could tell it happened.
    d.flag_if(math.fast(trapping), "__FAST_MATH__");
    d.flag_if(!math.errno, "__NO_MATH_ERRNO__");
    d.flag_if(!trapping, "__NO_TRAPPING_MATH__");
    d.flag_if(!math.signed_zeros, "__NO_SIGNED_ZEROS__");
    d.flag_if(math.reciprocal, "__RECIPROCAL_MATH__");
    d.flag_if(math.associative(trapping), "__ASSOCIATIVE_MATH__");
}

/// The architecture, the operating system and the object format.
fn platform(d: &mut Defs, target: &TargetInfo, opts: &Predef) {
    // The macros a target with no backend predefines are not written down here. They are a
    // header's whole view of the machine, a wrong one is a header taking a branch written for
    // another processor, and there is nothing cheap that would catch it. The driver takes a three
    // field triple, so a target this cannot spell is one nobody can ask for yet rather than a
    // hole in what it answers.
    let Some(triple) = Triple::from_tuple(target.tuple) else {
        return;
    };
    match triple.arch {
        Arch::X86_64 => {
            d.flag("__x86_64__");
            d.flag("__x86_64");
            d.flag("__amd64__");
            d.flag("__amd64");
            // One macro per extension the unit is built for, which is `__SSE__`, `__SSE2__`,
            // `__MMX__` and `__FXSR__` for the baseline every x86-64 has, and `__SSE4_2__` and
            // its relatives for what `-march=` and `-msse4.2` add. Only the extensions this
            // compiler has the intrinsics for get one, see `rucc_target::isa`.
            for name in opts.isa.macros() {
                d.flag(&name);
            }
            d.flag("__SSE_MATH__");
            d.flag("__SSE2_MATH__");
            d.flag("__k8");
            d.flag("__k8__");
            // The small code model, which is the default and the only one a program gets without
            // being told otherwise.
            d.flag("__code_model_small__");
            // The MMX registers are not used on x86-64: the sixty four bit operations go
            // through SSE instead. gcc's own `xmmintrin.h` reads this to decide how to write
            // `_mm_maskmove_si64`, so a compiler that leaves it undefined is handed a
            // different function body than gcc is, which is what the header sweep found.
            d.flag("__MMX_WITH_SSE__");
        }
        Arch::Aarch64 => {
            d.flag("__aarch64__");
            d.flag("__AARCH64EL__");
            d.set("__ARM_ARCH", "8");
            d.set("__ARM_ARCH_PROFILE", "'A'");
            d.set("__ARM_64BIT_STATE", "1");
            d.set("__ARM_ALIGN_MAX_PWR", "28");
            d.set("__ARM_FP", "0xe");
            d.set("__ARM_NEON", "1");
            d.set("__ARM_FEATURE_UNALIGNED", "1");
            d.set("__ARM_PCS_AAPCS64", "1");
            // The rest of what gcc says for a plain Armv8-A. Every one is an instruction the
            // base architecture has, so none of them depends on a `-march` this compiler does
            // not take yet, and a program that tests one to choose `__builtin_clz` or a
            // hardware divide over a portable loop takes the same branch it takes under gcc.
            d.set("__ARM_ARCH_8A", "1");
            d.set("__ARM_ARCH_ISA_A64", "1");
            d.set("__ARM_FEATURE_CLZ", "1");
            d.set("__ARM_FEATURE_FMA", "1");
            d.set("__ARM_FEATURE_IDIV", "1");
            d.set("__ARM_FEATURE_NUMERIC_MAXMIN", "1");
            d.set("__ARM_ALIGN_MAX_STACK_PWR", "16");
            d.set("__ARM_SIZEOF_MINIMAL_ENUM", "4");
            d.set("__ARM_SIZEOF_WCHAR_T", "4");
            d.set("__AARCH64_CMODEL_SMALL__", "1");
            // A fused multiply add is one instruction here, and glibc's `math.h` turns these
            // into `FP_FAST_FMA` and `FP_FAST_FMAF`, which a program reads to decide whether
            // calling `fma` is cheaper than writing the product and the sum apart.
            for name in ["", "F", "F32", "F64", "F32x"] {
                d.set(&format!("__FP_FAST_FMA{name}"), "1");
            }
        }
        Arch::Riscv64 => {
            d.flag("__riscv");
            d.set("__riscv_xlen", "64");
            d.set("__riscv_flen", "64");
            d.flag("__riscv_float_abi_double");
            d.flag("__riscv_muldiv");
            d.flag("__riscv_atomic");
            d.flag("__riscv_compressed");
            d.set("__riscv_cmodel_medlow", "1");
        }
    }
    match triple.os {
        Os::Linux => {
            d.flag("__linux__");
            d.flag("__linux");
            d.flag("__unix__");
            d.flag("__unix");
            d.flag("__gnu_linux__");
            d.flag("__ELF__");
            // The unarmoured spellings are not reserved identifiers, so a strict mode may not
            // define them. Autoconf still tests for `linux`, which is why they exist at all.
            if opts.gnu_extensions {
                d.flag("linux");
                d.flag("unix");
            }
        }
        Os::Darwin => {
            // No `__unix__`, `__unix` or `unix`. clang for Apple defines none of them, and code
            // that tests `__unix__` before `__APPLE__` takes the path written for Linux, where
            // it reaches for `<linux/...>` headers or `/proc` and fails at build time or at
            // run time. What a Mac is identified by is `__APPLE__` and `__MACH__`.
            d.flag("__APPLE__");
            d.flag("__MACH__");
            d.set("__APPLE_CC__", "6000");
            d.set("__DYNAMIC__", "1");
            if triple.arch == Arch::Aarch64 {
                // Apple's own spelling of the architecture, which its headers use rather than
                // __aarch64__. sys/cdefs.h tests for it by name and reaches an #error called
                // "Unsupported architecture" without it, so every system header on this
                // platform fails on the first include until these two are here.
                d.flag("__arm64__");
                d.flag("__arm64");
                // Older Apple spellings that the SDK still reads. `arm/arch.h` sets its own
                // `_ARM_ARCH_*` family from `__ARM64_ARCH_8__`, and a header that tests
                // `__ARM_NEON__` rather than `__ARM_NEON` is taking the portable path without
                // the Advanced SIMD one. clang defines all three for every Apple arm64 target.
                d.flag("__ARM64_ARCH_8__");
                d.flag("__ARM_NEON__");
                d.flag("__AARCH64_SIMD__");
            }
            // clang says this on every little endian target and gcc says it on none, which is
            // why it is here rather than beside the byte order macros. Apple's headers were
            // written for clang alone, and `CFByteOrder.h` and `architecture/byte_order.h` both
            // choose their swaps from it.
            d.flag("__LITTLE_ENDIAN__");
            deployment_target(d, target);
        }
        Os::Windows => {
            // Every spelling gcc has for this platform, because the mingw-w64 tree reads more
            // than one of them and a missing one is a declaration that quietly is not there.
            // `winuser.h` guards `EndTask` with `#ifdef WINNT` and `rpcdcep.h` guards six
            // declarations with `#ifndef WINNT`, so a compiler that leaves it undefined
            // preprocesses `windows.h` to a different set of functions than gcc does, which is
            // what the token comparison against a real mingw install found.
            d.flag("_WIN32");
            d.flag("__WIN32");
            d.flag("__WIN32__");
            d.flag("__WINNT");
            d.flag("__WINNT__");
            d.flag("__MINGW32__");
            // Not the machine word: `_WIN64` says the pointer is sixty four bits wide, and
            // i686-w64-mingw32-gcc defines neither it nor `__MINGW64__`.
            if target.pointer_width == 64 {
                d.flag("_WIN64");
                d.flag("__WIN64");
                d.flag("__WIN64__");
                d.flag("__MINGW64__");
            }
            // Which kind of exception machinery the platform has, and on this one there is only
            // the one: a table the operating system reads rather than anything the prologue
            // registers. mingw's `setjmp.h` reads this to choose the two argument `_setjmp`,
            // whose second argument is `__builtin_frame_address(0)` and becomes the frame
            // `longjmp` asks `RtlUnwindEx` to unwind to. That is the same address the function's
            // own unwind record reports, because the record names the frame pointer with an
            // offset of zero and the prologue leaves the pointer holding the body's stack
            // pointer, so the number the builtin answers with and the number the walk arrives at
            // are the same number by construction. Only for the architecture whose records this
            // compiler writes: x86_64-w64-mingw32-gcc defines it and i686-w64-mingw32-gcc does
            // not, because a thirty two bit Windows unwinds some other way.
            if triple.arch == Arch::X86_64 && target.pointer_width == 64 {
                d.flag("__SEH__");
            }
            // Which C runtime the headers are configured for. The sysroot this compiler fetches
            // is built `--with-default-msvcrt=msvcrt` to match the link line, which names
            // `libmsvcrt.a`, and gcc defines this for the same tree.
            d.flag("__MSVCRT__");
            // The widest integer the compiler has, which is what Microsoft's headers ask
            // instead of asking about `long long`.
            d.set("_INTEGRAL_MAX_BITS", "64");
            // The unarmoured three, which are not reserved identifiers, so a strict mode may
            // not define them and gcc does not. Windows code tests all three anyway, the same
            // way portable Unix code still tests `linux`.
            if opts.gnu_extensions {
                d.flag("WIN32");
                d.flag("WINNT");
                if target.pointer_width == 64 {
                    d.flag("WIN64");
                }
            }
            windows_spellings(d, opts);
        }
        Os::None => {
            // Freestanding. `__ELF__` still holds, because the object format is a property of
            // the target rather than of having an operating system under it.
            d.flag("__ELF__");
        }
    }
    match triple.env {
        Env::Musl => d.flag("__musl__"),
        Env::Gnu | Env::None | Env::Msvc => {}
    }
    // The version of the libc's headers, and only when they are the tree we bundle. One tree serves
    // every glibc release with the differences written as `#if __GLIBC_MINOR__ >= n` inside the
    // files, so the release is the part of it the target supplies and the compiler is what supplies
    // it. Zig patches the same macro into the same tree the same way, which is where the spelling
    // comes from rather than from a scheme of ours: `__GLIBC_PREREQ` reads it and so does every
    // autoconf probe ever written.
    //
    // The condition is the whole of it and it is not here. A host glibc defines this macro in its
    // own `features.h` and so does a tree the user named, and a second definition with a different
    // value is a warning on every compilation, so the driver decides and this writes down what it
    // decided.
    if let Some(minor) = opts.glibc_minor {
        d.set("__GLIBC_MINOR__", &minor.to_string());
    }
    // LP64 is the model everywhere except Windows, and a great deal of code tests for it
    // rather than testing pointer and long widths separately.
    if target.long_width == 64 && target.pointer_width == 64 {
        d.flag("__LP64__");
        d.flag("_LP64");
    }
    // What the assembler prepends to a C name to get the symbol. Mach-O keeps the leading
    // underscore that every a.out toolchain had and ELF dropped it. It has to be defined even
    // where it is empty, because of how it is used: glibc writes `__asm__ (__ASMNAME (name))`
    // and that stringifies `__USER_LABEL_PREFIX__`, so a compiler that leaves it undefined
    // does not get an error, it gets the name of the macro as the string and renames the
    // function.
    d.set("__USER_LABEL_PREFIX__", if triple.os == Os::Darwin { "_" } else { "" });
    // Its counterpart, what the assembler puts in front of a register name. Empty on every
    // target here, since all three assemble in a syntax that does not mark registers, and
    // defined anyway for the same reason as the line above: it is used inside a stringize.
    d.set("__REGISTER_PREFIX__", "");

    // Position independent code is the default on the ELF targets and on Apple's, which is
    // what a distribution build expects. The value 2 is GCC's for `-fPIC` rather than `-fpic`.
    //
    // Both are defined whichever link the output is for, because `__PIC__` says there are no
    // absolute addresses in the text and that is true either way. What says which link it is is
    // `__PIE__`, and a program reads it to find out whether a name it exports is one something
    // else may replace. gcc defines it under `-fPIE` and under the default on a distribution
    // where the default is an executable, which is the default here too.
    if !matches!(triple.os, Os::Windows) {
        d.set("__PIC__", "2");
        d.set("__pic__", "2");
        if opts.pic == Pic::Executable {
            d.set("__PIE__", "2");
            d.set("__pie__", "2");
        }
    }
}

/// The five spellings a Windows header writes a calling convention and an attribute in.
///
/// `int __cdecl f(void);` is the second declaration in mingw-w64's `stdio.h` and it stops a parser
/// that has never heard of `__cdecl`, which reads it as the name being declared and then finds a
/// second one. None of the five is a keyword, though: gcc defines every one of them as a macro over
/// the GNU spelling of the same thing, which is why they are keywords on Windows and nowhere else
/// without anything in its lexer being told what the target is. `-dM -E` on a mingw-w64 gcc prints
/// exactly the lines below.
///
/// `__declspec(x)` being the GNU spelling of its argument is the part worth saying out loud, since
/// it means `__declspec(dllimport)` and `__attribute__((dllimport))` cannot come to mean different
/// things: there is one attribute and two ways of writing it, and everything that reads attributes
/// reads both.
///
/// On x86-64 all four conventions name the one convention the target has, so the attributes go
/// where every attribute nothing implements goes, which is left on the declaration. On i386 they
/// differ over who pops the arguments and the choice is written into the symbol name, which is
/// document 06.5 and is that target's work when there is one.
/// The deployment target, which is the oldest release of the OS the program is promised to run
/// on. `Availability.h` reads it through `__ENVIRONMENT_OS_VERSION_MIN_REQUIRED__` and the older
/// per platform spelling, and turns it into `__MAC_OS_X_VERSION_MIN_REQUIRED`, which the whole
/// SDK tests to decide which declarations exist and which are marked unavailable. Without it
/// every one of those tests sees no version at all.
///
/// The version comes from the tuple, as in `aarch64-macos.13`, where `-mmacosx-version-min=`
/// also puts it. With none given this is 11.0 on macOS, the first release that ran on Apple
/// silicon, and 14.0 on iOS, the oldest a current SDK builds for. The oldest answer is the one
/// that cannot hand a program a declaration the machine it runs on does not have. The encoding
/// is two digits each for the major, minor and patch numbers, so 13.4 is 130400.
fn deployment_target(d: &mut Defs, target: &TargetInfo) {
    let (platform, default) = match target.tuple.os() {
        tuple::Os::MacOs => ("MAC_OS_X", tuple::Version::new(11, 0)),
        tuple::Os::IOs => ("IPHONE_OS", tuple::Version::new(14, 0)),
        _ => return,
    };
    let version = target.tuple.os_version().unwrap_or(default);
    let encoded = version.major_part() * 10000
        + version.minor_part().unwrap_or(0) * 100
        + version.patch_part().unwrap_or(0);
    d.set(&format!("__ENVIRONMENT_{platform}_VERSION_MIN_REQUIRED__"), &encoded.to_string());
    d.set("__ENVIRONMENT_OS_VERSION_MIN_REQUIRED__", &encoded.to_string());
}

fn windows_spellings(d: &mut Defs, opts: &Predef) {
    for name in ["cdecl", "stdcall", "fastcall", "thiscall"] {
        d.set(&format!("__{name}"), &format!("__attribute__((__{name}__))"));
        // The single underscore spellings are not in the reserved namespace, so an implementation
        // may not take them in a strict ISO mode and gcc does not.
        if opts.gnu_extensions {
            d.set(&format!("_{name}"), &format!("__attribute__((__{name}__))"));
        }
    }
    d.set("__declspec(x)", "__attribute__((x))");
}

/// `__CHAR_BIT__`, the `__SIZEOF_*__` family and the alignment macros.
fn sizes(d: &mut Defs, target: &TargetInfo) {
    let pointer = target.pointer_width / 8;
    // The two hardware interference sizes, which say how far apart two objects have to be for
    // a write to one not to invalidate the other's cache line, and how close together two have
    // to be to share one. A cache line is sixty four bytes on every target here, and x86-64
    // gives that for both. Arm cores have been built with lines up to 256 bytes, so gcc and
    // clang both give 256 for the distance that has to be safe on any of them.
    // Apple's cores are the exception that is known exactly, a 128 byte line, and clang for
    // Apple says 128.
    let destructive = match (target.tuple.arch(), target.tuple.os()) {
        (tuple::Arch::Aarch64, tuple::Os::MacOs | tuple::Os::IOs) => "128",
        (tuple::Arch::Aarch64, _) => "256",
        _ => "64",
    };
    d.set("__GCC_CONSTRUCTIVE_SIZE", "64");
    d.set("__GCC_DESTRUCTIVE_SIZE", destructive);
    let long = target.long_width / 8;
    let long_double = target.long_double_width / 8;
    d.set("__CHAR_BIT__", "8");
    d.set("__SIZEOF_SHORT__", "2");
    d.set("__SIZEOF_INT__", "4");
    d.set("__SIZEOF_LONG__", &long.to_string());
    d.set("__SIZEOF_LONG_LONG__", "8");
    d.set("__SIZEOF_INT128__", "16");
    d.set("__SIZEOF_FLOAT__", "4");
    d.set("__SIZEOF_DOUBLE__", "8");
    d.set("__SIZEOF_LONG_DOUBLE__", &long_double.to_string());
    // Where the type has its old name and nowhere else, which is gcc's rule and the reason the
    // macro is the one portable code tests before it writes `__float128`. PowerPC also says
    // `__FLOAT128__`, which gcc defines there and not on x86.
    if target.type_names().iter().any(|&(name, _)| name == "__float128") {
        d.set("__SIZEOF_FLOAT128__", "16");
        if target.tuple.arch() == tuple::Arch::PowerPc64 {
            d.set("__FLOAT128__", "1");
        }
    }
    d.set("__SIZEOF_POINTER__", &pointer.to_string());
    d.set("__SIZEOF_SIZE_T__", &pointer.to_string());
    d.set("__SIZEOF_PTRDIFF_T__", &pointer.to_string());
    d.set("__SIZEOF_WCHAR_T__", &wchar(target).size.to_string());
    // From the spelling rather than from a constant, because Windows makes `wint_t` a
    // `short unsigned int` and this said four bytes there while `__WINT_WIDTH__` said sixteen
    // bits two hundred lines away.
    d.set("__SIZEOF_WINT_T__", &(wint(target).width / 8).to_string());
    // The alignment of the most aligned scalar, which is `max_align_t`'s. That is sixteen where
    // `long double` is sixteen bytes and eight on Apple arm64, where it is a `double`. What
    // `aligned` with no argument gives is a separate number and is sixteen on every target,
    // clang for Apple included.
    let biggest = match (target.tuple.arch(), target.tuple.os()) {
        (tuple::Arch::Aarch64, tuple::Os::MacOs | tuple::Os::IOs) => "8",
        _ => "16",
    };
    d.set("__BIGGEST_ALIGNMENT__", biggest);
    // The `__BYTE_ORDER__` family, which the kernel and every serialisation library read.
    // The names of the orders are defined whichever one is in force, because code compares
    // against both.
    d.set("__ORDER_LITTLE_ENDIAN__", "1234");
    d.set("__ORDER_BIG_ENDIAN__", "4321");
    d.set("__ORDER_PDP_ENDIAN__", "3412");
    let order =
        if target.little_endian { "__ORDER_LITTLE_ENDIAN__" } else { "__ORDER_BIG_ENDIAN__" };
    d.set("__BYTE_ORDER__", order);
    d.set("__FLOAT_WORD_ORDER__", order);
    d.flag_if(!target.char_is_signed, "__CHAR_UNSIGNED__");
}

/// How `wchar_t` is spelled on a target, and what it holds.
struct Wchar {
    /// The C type it is a name for.
    spelling: &'static str,
    /// Its width in bytes.
    size: u32,
    /// `__WCHAR_MAX__`.
    max: &'static str,
    /// `__WCHAR_MIN__`.
    min: &'static str,
}

/// `wchar_t` is the type that divides the targets most and is written down least.
///
/// Windows makes it 16 bits so that a wide string is UTF-16. AArch64 Linux makes it unsigned,
/// following the psABI's rule for plain `char`, while x86-64 Linux makes it signed. Code that
/// compares a `wchar_t` against a negative value is correct on one and not on the other.
///
/// The width and the signedness come from the target description rather than from another match
/// on the triple, because the lexer needs the same two facts to convert a wide literal and the
/// two answers have to be the same one.
fn wchar(target: &TargetInfo) -> Wchar {
    match (target.wchar_width, target.wchar_is_signed) {
        (16, false) => Wchar { spelling: "short unsigned int", size: 2, max: "0xffff", min: "0" },
        (16, true) => Wchar { spelling: "short int", size: 2, max: "0x7fff", min: "(-32767 - 1)" },
        (_, false) => Wchar { spelling: "unsigned int", size: 4, max: "0xffffffffU", min: "0U" },
        (_, true) => {
            Wchar { spelling: "int", size: 4, max: "0x7fffffff", min: "(-__WCHAR_MAX__ - 1)" }
        }
    }
}

/// How `wint_t` is spelled on a target, and what it holds.
struct Wint {
    /// The C type it is a name for.
    spelling: &'static str,
    /// `__WINT_MAX__`.
    max: &'static str,
    /// `__WINT_MIN__`.
    min: &'static str,
    /// `__WINT_WIDTH__`, which follows the spelling rather than `__SIZEOF_WINT_T__`.
    width: u32,
}

/// `wint_t` does not follow `wchar_t`, and Darwin is where that shows.
///
/// Apple makes it a signed `int`, so that `WEOF` is negative the way `EOF` is, while Linux
/// makes it `unsigned int` and gives `WEOF` the value `0xffffffff`. The SDK's `arm/_types.h`
/// spells `__darwin_wint_t` as `__WINT_TYPE__` and nothing else, so getting this wrong changes
/// the signedness of every wide character function's argument on that platform.
fn wint(target: &TargetInfo) -> Wint {
    match target.tuple.os() {
        tuple::Os::Windows => {
            Wint { spelling: "short unsigned int", max: "0xffff", min: "0", width: 16 }
        }
        os if os.is_darwin() => {
            Wint { spelling: "int", max: "0x7fffffff", min: "(-__WINT_MAX__ - 1)", width: 32 }
        }
        _ => Wint { spelling: "unsigned int", max: "0xffffffffU", min: "0U", width: 32 },
    }
}

/// The integer type names, their limits, and the exact width family.
fn integers(d: &mut Defs, target: &TargetInfo) {
    // The one fact everything below turns on: which type is 64 bits wide. On LP64 it is
    // `long`, and on Windows LLP64 it is `long long`, and every `size_t`, `intmax_t` and
    // `int64_t` spelling follows from that.
    let lp64 = target.long_width == 64;
    let wide = if lp64 { "long int" } else { "long long int" };
    let wide_unsigned = if lp64 { "long unsigned int" } else { "long long unsigned int" };
    let wide_suffix = if lp64 { "L" } else { "LL" };
    let wide_max = format!("0x7fffffffffffffff{wide_suffix}");
    let wide_umax = format!("0xffffffffffffffffU{wide_suffix}");
    // Apple is LP64 and still makes `int64_t` a `long long`, which `<sys/_types/_int64_t.h>`
    // writes out by hand. The exact, least and fast sixty four bit types follow it, while
    // `intmax_t`, `intptr_t` and `size_t` stay `long`. Saying `long` here gave a freestanding
    // `stdint.h` an `int64_t` that the SDK's own typedef then redefined as a different type.
    let apple = matches!(target.tuple.os(), tuple::Os::MacOs | tuple::Os::IOs);
    let (int64, uint64, int64_suffix) = if apple {
        ("long long int", "long long unsigned int", "LL")
    } else {
        (wide, wide_unsigned, wide_suffix)
    };
    let int64_max = format!("0x7fffffffffffffff{int64_suffix}");
    let int64_umax = format!("0xffffffffffffffffU{int64_suffix}");

    d.set("__SCHAR_MAX__", "0x7f");
    d.set("__SHRT_MAX__", "0x7fff");
    d.set("__INT_MAX__", "0x7fffffff");
    d.set("__LONG_MAX__", if lp64 { "0x7fffffffffffffffL" } else { "0x7fffffffL" });
    d.set("__LONG_LONG_MAX__", "0x7fffffffffffffffLL");
    d.set("__INTMAX_MAX__", &wide_max);
    d.set("__UINTMAX_MAX__", &wide_umax);
    d.set("__SIZE_MAX__", &wide_umax);
    d.set("__PTRDIFF_MAX__", &wide_max);
    d.set("__INTPTR_MAX__", &wide_max);
    d.set("__UINTPTR_MAX__", &wide_umax);
    d.set("__SIG_ATOMIC_MAX__", "0x7fffffff");
    d.set("__SIG_ATOMIC_MIN__", "(-__SIG_ATOMIC_MAX__ - 1)");
    // The widest `_BitInt` this compiler builds, which is narrower than gcc 16's sixty five
    // thousand five hundred and thirty five because a folded constant here is a hundred and
    // twenty eight bits wide. A program that reads this macro to decide what to write gets an
    // answer it can rely on, which is the point of saying a number smaller than gcc's rather
    // than saying gcc's and refusing what it asked for. `MAX_BIT_INT_WIDTH` in `rucc-sema` is
    // the same number and has to be changed with it.
    d.set("__BITINT_MAXWIDTH__", "128");

    let wchar = wchar(target);
    d.set("__WCHAR_TYPE__", wchar.spelling);
    d.set("__WCHAR_MAX__", wchar.max);
    d.set("__WCHAR_MIN__", wchar.min);
    let wint = wint(target);
    d.set("__WINT_TYPE__", wint.spelling);
    d.set("__WINT_MAX__", wint.max);
    d.set("__WINT_MIN__", wint.min);
    d.set("__SIZE_TYPE__", wide_unsigned);
    d.set("__PTRDIFF_TYPE__", wide);
    d.set("__INTMAX_TYPE__", wide);
    d.set("__UINTMAX_TYPE__", wide_unsigned);
    d.set("__INTPTR_TYPE__", wide);
    d.set("__UINTPTR_TYPE__", wide_unsigned);
    d.set("__SIG_ATOMIC_TYPE__", "int");
    d.set("__CHAR16_TYPE__", "short unsigned int");
    d.set("__CHAR32_TYPE__", "unsigned int");
    d.set("__INTMAX_C(c)", &format!("c ## {wide_suffix}"));
    d.set("__UINTMAX_C(c)", &format!("c ## U{wide_suffix}"));

    // The exact width family, which is what a freestanding `stdint.h` is written out of.
    exact(d, 8, "signed char", "unsigned char", "0x7f", "0xff", "");
    exact(d, 16, "short int", "short unsigned int", "0x7fff", "0xffff", "");
    // No suffix. An `int` needs none, and the `U` on the unsigned side is added by `exact`
    // rather than being part of the width.
    exact(d, 32, "int", "unsigned int", "0x7fffffff", "0xffffffffU", "");
    exact(d, 64, int64, uint64, &int64_max, &int64_umax, int64_suffix);

    // The fast types. GCC makes the 16 and 32 bit ones `long` on sixty four bit glibc, which
    // is what glibc's `stdint.h` says under `__WORDSIZE == 64` whatever the processor, and
    // `int` everywhere else. A header that computes a printf format from the type name notices
    // the difference. gcc for aarch64, riscv64, powerpc64le and s390x all say `long int`.
    //
    // musl is the reason this is not simply a question of the architecture. musl defines
    // `int_fast16_t` and `int_fast32_t` as `int32_t` on every target it supports, GCC built
    // for a musl target agrees with it, and GCC built for glibc on the same processor does
    // not. The place it shows is `stdatomic.h`, which GCC ships and writes directly out of
    // these macros: `typedef _Atomic __INT_FAST16_TYPE__ atomic_int_fast16_t;`. Get this wrong
    // and every atomic fast type in the program is the wrong width.
    let fast_is_wide =
        target.tuple.os() == tuple::Os::Linux && lp64 && target.tuple.env() != tuple::Env::Musl;
    let fast_middle = if fast_is_wide { wide } else { "int" };
    // Windows is the exception in the other direction, and it is only the 16 bit one. mingw's
    // `stdint.h` makes `int_fast16_t` a `short` and gcc for that target says the same, while
    // `int_fast32_t` there is the `int` it is nearly everywhere, so the two cannot share an
    // answer on this platform the way they do on the others. The measurement is the mingw tree,
    // which is the only Windows header tree this compiler fetches, and the msvc environment is
    // given the same answer because nothing compiles against a tree of Microsoft's yet. Apple's
    // `stdint.h` is the same shape, `int16_t` for the 16 bit one and `int32_t` for the other.
    let fast16_is_short =
        matches!(target.tuple.os(), tuple::Os::Windows | tuple::Os::MacOs | tuple::Os::IOs);
    d.set("__INT_FAST8_TYPE__", "signed char");
    d.set("__UINT_FAST8_TYPE__", "unsigned char");
    d.set("__INT_FAST8_MAX__", "0x7f");
    d.set("__UINT_FAST8_MAX__", "0xff");
    for width in [16, 32] {
        let (signed, unsigned, max, umax) = if width == 16 && fast16_is_short {
            ("short int", "short unsigned int", "0x7fff", "0xffff")
        } else if fast_middle == "int" {
            ("int", "unsigned int", "0x7fffffff", "0xffffffffU")
        } else {
            (wide, wide_unsigned, wide_max.as_str(), wide_umax.as_str())
        };
        d.set(&format!("__INT_FAST{width}_TYPE__"), signed);
        d.set(&format!("__UINT_FAST{width}_TYPE__"), unsigned);
        d.set(&format!("__INT_FAST{width}_MAX__"), max);
        d.set(&format!("__UINT_FAST{width}_MAX__"), umax);
    }
    d.set("__INT_FAST64_TYPE__", int64);
    d.set("__UINT_FAST64_TYPE__", uint64);
    d.set("__INT_FAST64_MAX__", &int64_max);
    d.set("__UINT_FAST64_MAX__", &int64_umax);

    let fast32 = if fast_is_wide { 64 } else { 32 };
    widths(d, target, &wchar, &wint, if fast16_is_short { 16 } else { fast32 }, fast32);
}

/// The widths, which C23's `limits.h` and `stdint.h` are written out of.
///
/// Twenty macros and not a few more: there is no `__INT8_WIDTH__`, because the width of an
/// exact width type is in its name and gcc does not define one, and there is no unsigned member
/// of any of these pairs, because a signed type and its unsigned counterpart have the same
/// width and `UINTMAX_WIDTH` is written `__INTMAX_WIDTH__` in every header that needs it.
///
/// Each of these says how many value bits and sign bits the type has, which is not the same as
/// how many bits it occupies. They agree for every type on every target here, and the day one of
/// them does not, this is the family that has to say the smaller number.
fn widths(d: &mut Defs, target: &TargetInfo, wchar: &Wchar, wint: &Wint, fast16: u32, fast32: u32) {
    let pointer = target.pointer_width;
    d.set("__SCHAR_WIDTH__", "8");
    d.set("__SHRT_WIDTH__", "16");
    d.set("__INT_WIDTH__", "32");
    d.set("__LONG_WIDTH__", &target.long_width.to_string());
    d.set("__LONG_LONG_WIDTH__", "64");
    d.set("__INTMAX_WIDTH__", "64");
    d.set("__INTPTR_WIDTH__", &pointer.to_string());
    d.set("__PTRDIFF_WIDTH__", &pointer.to_string());
    d.set("__SIZE_WIDTH__", &pointer.to_string());
    d.set("__SIG_ATOMIC_WIDTH__", "32");
    d.set("__WCHAR_WIDTH__", &(wchar.size * 8).to_string());
    d.set("__WINT_WIDTH__", &wint.width.to_string());
    for width in [8, 16, 32, 64] {
        d.set(&format!("__INT_LEAST{width}_WIDTH__"), &width.to_string());
    }
    d.set("__INT_FAST8_WIDTH__", "8");
    d.set("__INT_FAST16_WIDTH__", &fast16.to_string());
    d.set("__INT_FAST32_WIDTH__", &fast32.to_string());
    d.set("__INT_FAST64_WIDTH__", "64");
}

/// One width of the exact and least families, which are the same types.
fn exact(
    d: &mut Defs,
    width: u32,
    signed: &str,
    unsigned: &str,
    max: &str,
    umax: &str,
    // The suffix the width needs and nothing more, so `""`, `"L"` or `"LL"`. The `U` that
    // makes a constant unsigned is added below and is not part of this, because a caller that
    // wrote it here would produce `UU` on the unsigned macro and a stray `U` on the signed one.
    width_suffix: &str,
) {
    d.set(&format!("__INT{width}_TYPE__"), signed);
    d.set(&format!("__UINT{width}_TYPE__"), unsigned);
    d.set(&format!("__INT{width}_MAX__"), max);
    d.set(&format!("__UINT{width}_MAX__"), umax);
    d.set(&format!("__INT_LEAST{width}_TYPE__"), signed);
    d.set(&format!("__UINT_LEAST{width}_TYPE__"), unsigned);
    d.set(&format!("__INT_LEAST{width}_MAX__"), max);
    d.set(&format!("__UINT_LEAST{width}_MAX__"), umax);
    // The constant makers. `__INT8_C(1)` is `1` and not `1 ## `, because a paste with nothing
    // on the right is not a token the expander should have to think about.
    //
    // The `U` goes on only where the type is still unsigned after promotion. `uint8_t` and
    // `uint16_t` are narrower than `int`, so an integer promotion turns them into a signed
    // `int` and `UINT8_C(1)` has that type in gcc and in the standard's own words. Writing
    // `1U` there is not a harmless extra: `UINT8_C(1) - 2` comes out as four billion odd
    // instead of minus one, and a `_Generic` on it picks the unsigned arm. Every target this
    // compiler has makes `int` thirty two bits, which is what makes the width enough to decide.
    let unsigned_after_promotion = width >= 32;
    let u = if unsigned_after_promotion { "U" } else { "" };
    if width_suffix.is_empty() && u.is_empty() {
        d.set(&format!("__INT{width}_C(c)"), "c");
        d.set(&format!("__UINT{width}_C(c)"), "c");
    } else if width_suffix.is_empty() {
        d.set(&format!("__INT{width}_C(c)"), "c");
        d.set(&format!("__UINT{width}_C(c)"), &format!("c ## {u}"));
    } else {
        d.set(&format!("__INT{width}_C(c)"), &format!("c ## {width_suffix}"));
        d.set(&format!("__UINT{width}_C(c)"), &format!("c ## {u}{width_suffix}"));
    }
}

/// What a header needs to know about one floating format, as the text the macros expand to.
///
/// The four values are written to the digit gcc writes them to rather than rounded to something
/// tidier, because a header carrying its own copy of a limit compares the two spellings and a
/// difference in the last place is a difference.
struct Characteristics {
    mant_dig: &'static str,
    dig: &'static str,
    min_exp: &'static str,
    min_10_exp: &'static str,
    max_exp: &'static str,
    max_10_exp: &'static str,
    decimal_dig: &'static str,
    max: &'static str,
    /// The largest value with a full significand, which is `max` for every format whose values
    /// all have one and is smaller for the double-double, whose largest values do not.
    ///
    /// A double-double's high half can be as large as a `double` gets while its low half is
    /// nowhere near, and the sum is then a number above anything the format can write with a
    /// hundred and six significand bits behind it. So `LDBL_MAX` on PowerPC is `DBL_MAX` and
    /// `LDBL_NORM_MAX` is a bit under half of it, and a program that reaches for the largest
    /// value it can compute with wants the second.
    norm_max: &'static str,
    min: &'static str,
    epsilon: &'static str,
    denorm_min: &'static str,
    /// Whether the format is one IEC 60559 describes, which every one of them is but the brain
    /// float, whose significand is a `float`'s with sixteen bits cut off the end of it, and the
    /// double-double, which is not a binary floating point format in IEC 60559's sense at all.
    is_iec_60559: &'static str,
}

/// IEEE binary16, which is `_Float16`.
const HALF: Characteristics = Characteristics {
    mant_dig: "11",
    dig: "3",
    min_exp: "(-13)",
    min_10_exp: "(-4)",
    max_exp: "16",
    max_10_exp: "4",
    decimal_dig: "5",
    max: "6.55040000000000000000000000000000000e+4",
    norm_max: "6.55040000000000000000000000000000000e+4",
    min: "6.10351562500000000000000000000000000e-5",
    epsilon: "9.76562500000000000000000000000000000e-4",
    denorm_min: "5.96046447753906250000000000000000000e-8",
    is_iec_60559: "1",
};

/// The brain float, which nothing here names yet and which every format table has a row for.
const BFLOAT16: Characteristics = Characteristics {
    mant_dig: "8",
    dig: "2",
    min_exp: "(-125)",
    min_10_exp: "(-37)",
    max_exp: "128",
    max_10_exp: "38",
    decimal_dig: "4",
    max: "3.38953138925153547590470800371487867e+38",
    norm_max: "3.38953138925153547590470800371487867e+38",
    min: "1.17549435082228750796873653722224568e-38",
    epsilon: "7.81250000000000000000000000000000000e-3",
    denorm_min: "9.18354961579912115600575419704879436e-41",
    is_iec_60559: "0",
};

/// IEEE binary32, which is `float` and `_Float32`.
const SINGLE: Characteristics = Characteristics {
    mant_dig: "24",
    dig: "6",
    min_exp: "(-125)",
    min_10_exp: "(-37)",
    max_exp: "128",
    max_10_exp: "38",
    decimal_dig: "9",
    max: "3.40282346638528859811704183484516925e+38",
    norm_max: "3.40282346638528859811704183484516925e+38",
    min: "1.17549435082228750796873653722224568e-38",
    epsilon: "1.19209289550781250000000000000000000e-7",
    denorm_min: "1.40129846432481707092372958328991613e-45",
    is_iec_60559: "1",
};

/// IEEE binary64, which is `double`, `_Float64`, `_Float32x` and `long double` on Apple and
/// on Windows.
const DOUBLE: Characteristics = Characteristics {
    mant_dig: "53",
    dig: "15",
    min_exp: "(-1021)",
    min_10_exp: "(-307)",
    max_exp: "1024",
    max_10_exp: "308",
    decimal_dig: "17",
    max: "1.79769313486231570814527423731704357e+308",
    norm_max: "1.79769313486231570814527423731704357e+308",
    min: "2.22507385850720138309023271733240406e-308",
    epsilon: "2.22044604925031308084726333618164062e-16",
    denorm_min: "4.94065645841246544176568792868221372e-324",
    is_iec_60559: "1",
};

/// The x87 eighty bit format, which on x86-64 is both `long double` and `_Float64x`.
const X87: Characteristics = Characteristics {
    mant_dig: "64",
    dig: "18",
    min_exp: "(-16381)",
    min_10_exp: "(-4931)",
    max_exp: "16384",
    max_10_exp: "4932",
    decimal_dig: "21",
    max: "1.18973149535723176502126385303097021e+4932",
    norm_max: "1.18973149535723176502126385303097021e+4932",
    min: "3.36210314311209350626267781732175260e-4932",
    epsilon: "1.08420217248550443400745280086994171e-19",
    denorm_min: "3.64519953188247460252840593361941982e-4951",
    is_iec_60559: "1",
};

/// IEEE binary128, which is `_Float128`, `_Float64x` off x86 and `long double` on AArch64 and
/// RISC-V Linux.
const QUAD: Characteristics = Characteristics {
    mant_dig: "113",
    dig: "33",
    min_exp: "(-16381)",
    min_10_exp: "(-4931)",
    max_exp: "16384",
    max_10_exp: "4932",
    decimal_dig: "36",
    max: "1.18973149535723176508575932662800702e+4932",
    norm_max: "1.18973149535723176508575932662800702e+4932",
    min: "3.36210314311209350626267781732175260e-4932",
    epsilon: "1.92592994438723585305597794258492732e-34",
    denorm_min: "6.47517511943802511092443895822764655e-4966",
    is_iec_60559: "1",
};

/// IBM double-double, which is `long double` on 64-bit PowerPC.
///
/// The row that does not follow from a precision and an exponent range, because the format has
/// neither. `MANT_DIG` is 106 and `DIG` is 31, which are the figures near the top of the
/// significand and not everywhere. `MAX` is a little above `DBL_MAX`, since the high half can be
/// `DBL_MAX` and the low half then adds to it, and `NORM_MAX` is about half of that, so this is
/// the one row where the two are different numbers. `EPSILON` is the same number as `DENORM_MIN`,
/// two to the minus one thousand and seventy four, because the smallest value that changes a
/// double-double near one is a subnormal in the low half rather than one unit in the last place
/// of anything. `MIN` is two to the minus nine hundred and sixty nine rather than `DBL_MIN`,
/// because below that the low half has no room left to be normal in.
///
/// Every value here is what the reference compiler prints for `powerpc64le-linux-gnu`, checked
/// rather than derived, on the same terms as the data layouts in `rucc-abi`. The format is one
/// where deriving them is how the four wrong numbers in those layouts happened.
const DOUBLE_DOUBLE: Characteristics = Characteristics {
    mant_dig: "106",
    dig: "31",
    min_exp: "(-968)",
    min_10_exp: "(-291)",
    max_exp: "1024",
    max_10_exp: "308",
    decimal_dig: "33",
    max: "1.79769313486231580793728971405301e+308",
    norm_max: "8.98846567431157953864652595394501e+307",
    min: "2.00416836000897277799610805135016e-292",
    epsilon: "4.94065645841246544176568792868221e-324",
    denorm_min: "4.94065645841246544176568792868221e-324",
    is_iec_60559: "0",
};

/// The row of the table a format has, so that a type the target chooses the format of can look
/// its own limits up rather than have them written out again per architecture.
const fn characteristics(format: Format) -> &'static Characteristics {
    match format {
        Format::Half => &HALF,
        Format::BFloat16 => &BFLOAT16,
        Format::Single => &SINGLE,
        Format::Double => &DOUBLE,
        Format::X87Extended => &X87,
        Format::Quad => &QUAD,
        Format::DoubleDouble => &DOUBLE_DOUBLE,
        // No target has a decimal `long double` or `_Float64x`, which are the two rows a target
        // chooses, and the decimal types have `__DEC*` macros of their own rather than a row here.
        Format::Decimal32 | Format::Decimal64 | Format::Decimal128 => {
            panic!("a binary type's format is never a decimal one")
        }
    }
}

/// The `float.h` characteristics.
///
/// Nine families of them, which is `float`, `double` and `long double` and the six C23 named
/// them after. Two of the nine have a format the target decides: `long double`, which is x87 on
/// x86-64 Linux, quad on AArch64 and RISC-V Linux and a `double` on Apple and on Windows, and
/// `_Float64x`, which is the widest format the processor has and so does not follow `long
/// double` down on the targets that shrink it.
///
/// Three more have a target that decides whether they are there at all. `_Float64x` is missing
/// on a machine with nothing wider than a `double`, and `_Float16` and `_Float128` are missing
/// wherever the machine has no such format, which is four of the seven rows for the half and one
/// of them for the quad.
///
/// `__FLT128X_*__` is deliberately missing. `_Float128x` is a type no target gcc supports has,
/// so gcc defines nothing for it and neither does this.
fn floats(d: &mut Defs, target: &TargetInfo, opts: &Predef) {
    d.set("__FLT_RADIX__", "2");
    // Real arithmetic follows IEC 60559 in every format on every target here, which is what the
    // value two says. The complex one beside it says the same about complex arithmetic, and gcc
    // gives both the value two on every target this compiler has. These two are read rather than
    // tested: glibc's `<stdc-predef.h>` asks what the compiler intended and writes the
    // `__STDC_IEC_559` family from the answer, and a compiler that says nothing is presumed to
    // have meant yes. So the choice is not between claiming and not claiming, it is between
    // saying so and having it said for us. Zero for both once a fast math licence is given,
    // which is gcc's answer and what keeps glibc from claiming the family on our behalf.
    let iec = if opts.math.iec_559(opts.trapping_math) { "2" } else { "0" };
    d.set("__GCC_IEC_559", iec);
    d.set("__GCC_IEC_559_COMPLEX", iec);
    // Every operation is done in the type of its operands, which is what SSE2 and the AArch64
    // and RISC-V floating units all do. The other two names are the same answer asked under the
    // rules of C99 and of TS 18661-3, which are the same rules for a target with no excess
    // precision to have, and glibc's `<math.h>` reads the last of the three.
    d.set("__FLT_EVAL_METHOD__", "0");
    d.set("__FLT_EVAL_METHOD_C99__", "0");
    d.set("__FLT_EVAL_METHOD_TS_18661_3__", "0");

    family(d, "FLT", &SINGLE, |value| format!("{value}F"));
    // gcc writes the `double` values as `long double` constants cast back down, which is exact
    // in every format `long double` has and is the one family whose values are not a suffix.
    family(d, "DBL", &DOUBLE, |value| format!("((double){value}L)"));
    family(d, "LDBL", characteristics(target.long_double_format), |value| format!("{value}L"));

    // The two named types that are not on every machine, each written where the type is and left
    // out where it is not. A program reads `__FLT128_MANT_DIG__` to find out whether it may write
    // the type, which is what glibc's `<float.h>` and `<math.h>` do, so the macros and the type
    // have to agree or the header asks for something the compiler will refuse.
    if target.has_float16 {
        family(d, "FLT16", &HALF, |value| format!("{value}F16"));
    }
    family(d, "FLT32", &SINGLE, |value| format!("{value}F32"));
    family(d, "FLT64", &DOUBLE, |value| format!("{value}F64"));
    if target.has_float128 {
        family(d, "FLT128", &QUAD, |value| format!("{value}F128"));
    }
    family(d, "FLT32X", &DOUBLE, |value| format!("{value}F32x"));
    // Nothing at all on a target whose widest format is a `double`, which is what gcc does
    // there: `_Float64x` is not a type on that machine and the family that describes it is not a
    // set of macros with a smaller answer in them.
    if let Some(format) = target.float64x_format {
        family(d, "FLT64X", characteristics(format), |value| format!("{value}F64x"));
    }

    // The number itself rather than the name of the other macro. The value is the same either
    // way, since `long double` is the widest format here, but the two are not the same thing to
    // read: `-dM` prints what the macro is, and a program that undefines `__LDBL_DECIMAL_DIG__`
    // takes this one with it. gcc writes the number.
    d.set("__DECIMAL_DIG__", characteristics(target.long_double_format).decimal_dig);
    if target.has_decimal_float {
        decimals(d);
    }
}

/// The limits of the three decimal types, on the one target that has them.
///
/// Written out rather than worked out, because each is a fact of the interchange format and the
/// three rows are all there will ever be. The spellings are gcc's, down to the parentheses around a
/// negative exponent and the suffix on every constant. `__DEC64X_*` is not here: `_Decimal64x` has
/// a suffix of its own the lexer does not read yet, so the macros would be constants nothing can
/// use. `__DEC_EVAL_METHOD__` is 2 because it is 2 in gcc, and a program that reads it is asking
/// what gcc would do.
fn decimals(d: &mut Defs) {
    let rows = [
        ("32", "DF", "7", "(-94)", "97", "1E-95", "9.999999E96", "1E-6", "0.000001E-95"),
        (
            "64",
            "DD",
            "16",
            "(-382)",
            "385",
            "1E-383",
            "9.999999999999999E384",
            "1E-15",
            "0.000000000000001E-383",
        ),
        (
            "128",
            "DL",
            "34",
            "(-6142)",
            "6145",
            "1E-6143",
            "9.999999999999999999999999999999999E6144",
            "1E-33",
            "0.000000000000000000000000000000001E-6143",
        ),
    ];
    for (bits, suffix, mant_dig, min_exp, max_exp, min, max, epsilon, subnormal_min) in rows {
        d.set(&format!("__DEC{bits}_MANT_DIG__"), mant_dig);
        d.set(&format!("__DEC{bits}_MIN_EXP__"), min_exp);
        d.set(&format!("__DEC{bits}_MAX_EXP__"), max_exp);
        d.set(&format!("__DEC{bits}_MIN__"), &format!("{min}{suffix}"));
        d.set(&format!("__DEC{bits}_MAX__"), &format!("{max}{suffix}"));
        d.set(&format!("__DEC{bits}_EPSILON__"), &format!("{epsilon}{suffix}"));
        d.set(&format!("__DEC{bits}_SUBNORMAL_MIN__"), &format!("{subnormal_min}{suffix}"));
    }
    d.set("__DEC_EVAL_METHOD__", "2");
}

/// One family of `float.h` macros, named `__{prefix}_*__`.
///
/// `write` turns a value into the constant its macro expands to, which is a suffix for every
/// family but `double`.
fn family(d: &mut Defs, prefix: &str, c: &Characteristics, write: impl Fn(&str) -> String) {
    d.set(&format!("__{prefix}_MANT_DIG__"), c.mant_dig);
    d.set(&format!("__{prefix}_DIG__"), c.dig);
    d.set(&format!("__{prefix}_MIN_EXP__"), c.min_exp);
    d.set(&format!("__{prefix}_MIN_10_EXP__"), c.min_10_exp);
    d.set(&format!("__{prefix}_MAX_EXP__"), c.max_exp);
    d.set(&format!("__{prefix}_MAX_10_EXP__"), c.max_10_exp);
    d.set(&format!("__{prefix}_DECIMAL_DIG__"), c.decimal_dig);
    d.set(&format!("__{prefix}_MAX__"), &write(c.max));
    d.set(&format!("__{prefix}_NORM_MAX__"), &write(c.norm_max));
    d.set(&format!("__{prefix}_MIN__"), &write(c.min));
    d.set(&format!("__{prefix}_EPSILON__"), &write(c.epsilon));
    d.set(&format!("__{prefix}_DENORM_MIN__"), &write(c.denorm_min));
    d.set(&format!("__{prefix}_IS_IEC_60559__"), c.is_iec_60559);
    d.set(&format!("__{prefix}_HAS_DENORM__"), "1");
    d.set(&format!("__{prefix}_HAS_INFINITY__"), "1");
    d.set(&format!("__{prefix}_HAS_QUIET_NAN__"), "1");
}

#[cfg(test)]
mod tests {
    use rucc_target::Triple;

    use super::*;

    fn set_for(triple: &str) -> String {
        let triple: Triple = triple.parse().expect("a triple the compiler supports");
        built_in(&TargetInfo::new(triple), &Predef::new())
    }

    /// The same, for a machine the three field triple cannot spell.
    fn set_for_tuple(tuple: &str) -> String {
        let target = TargetInfo::for_tuple(tuple.parse().expect("a row in the target table"));
        built_in(&target, &Predef::new())
    }

    fn has(text: &str, line: &str) -> bool {
        text.lines().any(|l| l == line)
    }

    #[test]
    fn the_version_macros_say_the_version_this_compiler_was_built_at() {
        // They said 0.1.0 through sixty seven releases, because the number was written here as
        // well as in the manifest, so a program asking which rucc it was is now told.
        let text = set_for("x86_64-unknown-linux-gnu");
        assert!(has(&text, &format!("#define __rucc_version__ \"{VERSION}\"")), "{text}");
        assert!(has(&text, &format!("#define __VERSION__ \"rucc {VERSION}\"")), "{text}");
        assert!(has(&text, &format!("#define __rucc_major__ {}", field(VERSION, 0))));
        assert!(has(&text, &format!("#define __rucc_minor__ {}", field(VERSION, 1))));
        assert!(has(&text, &format!("#define __rucc_patchlevel__ {}", field(VERSION, 2))));

        // And what each of them expands to is something an `#if` can read, which is the whole
        // reason the three numbers are separate macros from the string.
        for n in 0..3 {
            assert!(field(VERSION, n).parse::<u32>().is_ok(), "{}", field(VERSION, n));
        }
    }

    #[test]
    fn a_version_field_is_the_digits_at_the_front_of_it() {
        assert_eq!(
            (field("0.10.68", 0), field("0.10.68", 1), field("0.10.68", 2)),
            ("0", "10", "68")
        );

        // A pre-release suffix belongs to the string and not to the number an `#if` compares, and
        // a field that is not there at all is what a two field version means by its third.
        assert_eq!(field("0.10.68-rc.1", 2), "68");
        assert_eq!(field("1.0", 2), "0");
        assert_eq!(field("", 0), "0");
    }

    #[test]
    fn the_set_is_driven_by_the_target_rather_than_by_the_host() {
        let x86 = set_for("x86_64-unknown-linux-gnu");
        let arm = set_for("aarch64-unknown-linux-gnu");
        assert!(has(&x86, "#define __x86_64__ 1"));
        assert!(!has(&x86, "#define __aarch64__ 1"));
        assert!(has(&arm, "#define __aarch64__ 1"));
        assert!(!has(&arm, "#define __x86_64__ 1"));
        assert!(has(&x86, "#define __linux__ 1") && has(&arm, "#define __linux__ 1"));
    }

    #[test]
    fn windows_is_the_target_that_makes_long_thirty_two_bits() {
        let windows = set_for("x86_64-pc-windows-msvc");
        let linux = set_for("x86_64-unknown-linux-gnu");
        assert!(has(&windows, "#define __SIZEOF_LONG__ 4"));
        assert!(has(&windows, "#define __SIZE_TYPE__ long long unsigned int"));
        assert!(has(&windows, "#define __INT64_TYPE__ long long int"));
        assert!(!has(&windows, "#define __LP64__ 1"));
        assert!(has(&linux, "#define __SIZEOF_LONG__ 8"));
        assert!(has(&linux, "#define __SIZE_TYPE__ long unsigned int"));
        assert!(has(&linux, "#define __INT64_TYPE__ long int"));
        assert!(has(&linux, "#define __LP64__ 1"));
    }

    #[test]
    fn windows_spells_a_calling_convention_and_an_attribute_as_macros() {
        // The second declaration in mingw-w64's stdio.h is `int __cdecl __mingw_sscanf(...)`, so
        // a Windows target where these are missing reads no header at all.
        let windows = set_for("x86_64-pc-windows-gnu");
        assert!(has(&windows, "#define __cdecl __attribute__((__cdecl__))"));
        assert!(has(&windows, "#define __stdcall __attribute__((__stdcall__))"));
        assert!(has(&windows, "#define __fastcall __attribute__((__fastcall__))"));
        assert!(has(&windows, "#define __thiscall __attribute__((__thiscall__))"));
        assert!(has(&windows, "#define _cdecl __attribute__((__cdecl__))"));
        assert!(has(&windows, "#define __declspec(x) __attribute__((x))"));
        let linux = set_for("x86_64-unknown-linux-gnu");
        assert!(!has(&linux, "#define __cdecl __attribute__((__cdecl__))"));
        assert!(!has(&linux, "#define __declspec(x) __attribute__((x))"));
    }

    #[test]
    fn a_strict_mode_keeps_the_spellings_that_are_not_the_implementations_to_take() {
        // `_cdecl` is a name a program may use and `__cdecl` is not, so gcc defines the first
        // only where the extensions are on and the second everywhere.
        let mut opts = Predef::new();
        opts.gnu_extensions = false;
        let triple: Triple = "x86_64-pc-windows-gnu".parse().expect("a triple");
        let strict = built_in(&TargetInfo::new(triple), &opts);
        assert!(has(&strict, "#define __cdecl __attribute__((__cdecl__))"));
        assert!(!has(&strict, "#define _cdecl __attribute__((__cdecl__))"));
    }

    #[test]
    fn wchar_t_is_the_type_that_divides_the_targets() {
        // Signed on x86-64 Linux, unsigned on AArch64 Linux, and sixteen bits on Windows.
        assert!(has(&set_for("x86_64-unknown-linux-gnu"), "#define __WCHAR_TYPE__ int"));
        assert!(has(&set_for("aarch64-unknown-linux-gnu"), "#define __WCHAR_TYPE__ unsigned int"));
        let windows = set_for("x86_64-pc-windows-msvc");
        assert!(has(&windows, "#define __WCHAR_TYPE__ short unsigned int"));
        assert!(has(&windows, "#define __SIZEOF_WCHAR_T__ 2"));
    }

    #[test]
    fn apple_spells_the_architecture_its_own_way_and_its_headers_only_know_that_spelling() {
        // sys/cdefs.h reaches #error "Unsupported architecture" without these, which is the
        // first line of the first header of every program on the platform.
        let darwin = set_for("aarch64-apple-darwin");
        assert!(has(&darwin, "#define __arm64__ 1"));
        assert!(has(&darwin, "#define __arm64 1"));
        assert!(has(&darwin, "#define __aarch64__ 1"), "the portable spelling stays too");
        let linux = set_for("aarch64-unknown-linux-gnu");
        assert!(!has(&linux, "#define __arm64__ 1"), "Apple's spelling is Apple's alone");
        assert!(!has(&set_for("x86_64-apple-darwin"), "#define __arm64__ 1"));
    }

    #[test]
    fn every_limit_is_spelled_in_hexadecimal_the_way_gcc_spells_it() {
        // The value was never in question and the spelling is, because these macros reach a
        // program's text. glibc's `limits.h` writes `#define INT_MAX __INT_MAX__`, openssl
        // writes `((unsigned int)INT_MAX + 1)`, and `-E` over that header printed a decimal
        // number where gcc printed a hexadecimal one. The type is the same either way here,
        // which is why the suffixes are unchanged: `0x7fffffff` and `2147483647` are both
        // `int`, and `0xffffffffffffffffUL` and its decimal twin are both `unsigned long`.
        let linux = set_for("x86_64-unknown-linux-gnu");
        for line in [
            "#define __SCHAR_MAX__ 0x7f",
            "#define __SHRT_MAX__ 0x7fff",
            "#define __INT_MAX__ 0x7fffffff",
            "#define __LONG_MAX__ 0x7fffffffffffffffL",
            "#define __LONG_LONG_MAX__ 0x7fffffffffffffffLL",
            "#define __INTMAX_MAX__ 0x7fffffffffffffffL",
            "#define __UINTMAX_MAX__ 0xffffffffffffffffUL",
            "#define __SIZE_MAX__ 0xffffffffffffffffUL",
            "#define __PTRDIFF_MAX__ 0x7fffffffffffffffL",
            "#define __SIG_ATOMIC_MAX__ 0x7fffffff",
            "#define __INT8_MAX__ 0x7f",
            "#define __UINT8_MAX__ 0xff",
            "#define __INT16_MAX__ 0x7fff",
            "#define __UINT16_MAX__ 0xffff",
            "#define __INT32_MAX__ 0x7fffffff",
            "#define __UINT32_MAX__ 0xffffffffU",
            "#define __INT64_MAX__ 0x7fffffffffffffffL",
            "#define __UINT64_MAX__ 0xffffffffffffffffUL",
            "#define __INT_FAST8_MAX__ 0x7f",
            "#define __UINT_FAST8_MAX__ 0xff",
        ] {
            assert!(has(&linux, line), "{line}");
        }
        // Windows, where `long` is thirty two bits, so the wide suffix moves and the narrow
        // `long` limit is not the same number.
        let windows = set_for("x86_64-pc-windows-msvc");
        assert!(has(&windows, "#define __LONG_MAX__ 0x7fffffffL"));
        assert!(has(&windows, "#define __INTMAX_MAX__ 0x7fffffffffffffffLL"));
        assert!(has(&windows, "#define __UINTMAX_MAX__ 0xffffffffffffffffULL"));
    }

    #[test]
    fn apple_says_what_clang_for_apple_says_and_not_what_linux_does() {
        // Each line is the value clang 17 prints for `-target arm64-apple-macos11 -dM`.
        let darwin = set_for("aarch64-apple-darwin");
        for line in [
            "#define __INT64_TYPE__ long long int",
            "#define __UINT64_TYPE__ long long unsigned int",
            "#define __INT64_MAX__ 0x7fffffffffffffffLL",
            "#define __UINT64_MAX__ 0xffffffffffffffffULL",
            "#define __INT64_C(c) c ## LL",
            "#define __UINT64_C(c) c ## ULL",
            "#define __INT_LEAST64_TYPE__ long long int",
            "#define __INT_FAST64_TYPE__ long long int",
            "#define __UINT_FAST64_MAX__ 0xffffffffffffffffULL",
            // `intmax_t` and `size_t` stay `long` on Apple, which is why they are not the same
            // type as `int64_t` there.
            "#define __INTMAX_TYPE__ long int",
            "#define __SIZE_TYPE__ long unsigned int",
            "#define __BIGGEST_ALIGNMENT__ 8",
            "#define __GCC_DESTRUCTIVE_SIZE 128",
        ] {
            assert!(has(&darwin, line), "{line}");
        }
        for name in ["__unix__", "__unix", "unix", "__STDC_ISO_10646__"] {
            assert!(!darwin.contains(&format!("#define {name} ")), "{name}");
        }
        // The same processor under Linux keeps every one of them.
        let linux = set_for("aarch64-unknown-linux-gnu");
        assert!(has(&linux, "#define __INT64_TYPE__ long int"));
        assert!(has(&linux, "#define __BIGGEST_ALIGNMENT__ 16"));
        assert!(has(&linux, "#define __unix__ 1"));
        assert!(linux.contains("#define __STDC_ISO_10646__ "));
        // And an Intel Mac takes Apple's `int64_t` with its own alignment.
        let intel = set_for("x86_64-apple-darwin");
        assert!(has(&intel, "#define __INT64_TYPE__ long long int"));
        assert!(has(&intel, "#define __BIGGEST_ALIGNMENT__ 16"));
        assert!(!intel.contains("#define __unix__ "));
    }

    #[test]
    fn wint_t_does_not_follow_wchar_t() {
        // Apple makes it signed so that WEOF is negative the way EOF is. Linux does not.
        let darwin = set_for("aarch64-apple-darwin");
        assert!(has(&darwin, "#define __WINT_TYPE__ int"));
        assert!(has(&darwin, "#define __WINT_MAX__ 0x7fffffff"));
        assert!(has(&darwin, "#define __WCHAR_TYPE__ int"));
        let linux = set_for("aarch64-unknown-linux-gnu");
        assert!(has(&linux, "#define __WINT_TYPE__ unsigned int"));
        assert!(has(&linux, "#define __WINT_MAX__ 0xffffffffU"));
        assert!(has(&linux, "#define __WCHAR_TYPE__ unsigned int"), "and wchar_t is its own");
        assert!(has(
            &set_for("x86_64-pc-windows-msvc"),
            "#define __WINT_TYPE__ short unsigned int"
        ));
    }

    #[test]
    fn the_widths_say_what_the_type_holds_and_follow_the_target_that_changes_it() {
        // Twenty of them, which is gcc's set: no exact width member, since the width of an
        // `int32_t` is in its name, and no unsigned member, since a header that wants
        // `UINTMAX_WIDTH` writes `__INTMAX_WIDTH__`.
        let linux = set_for("x86_64-unknown-linux-gnu");
        assert_eq!(linux.lines().filter(|line| line.contains("_WIDTH__")).count(), 20);
        assert!(has(&linux, "#define __LONG_WIDTH__ 64"));
        assert!(has(&linux, "#define __SIZE_WIDTH__ 64"));
        assert!(has(&linux, "#define __WCHAR_WIDTH__ 32"));
        assert!(has(&linux, "#define __INT_LEAST16_WIDTH__ 16"));
        // x86-64 glibc is where `int_fast16_t` is a `long`, and the width has to say so or a
        // program that switches on it picks the wrong branch.
        assert!(has(&linux, "#define __INT_FAST16_WIDTH__ 64"));
        assert!(has(&set_for("x86_64-unknown-linux-musl"), "#define __INT_FAST16_WIDTH__ 32"));
        // Windows has a thirty two bit `long` and a sixteen bit `wint_t`, and the pointer
        // sized types stay sixty four bits wide whatever `long` does.
        let windows = set_for("x86_64-pc-windows-msvc");
        assert!(has(&windows, "#define __LONG_WIDTH__ 32"));
        assert!(has(&windows, "#define __WINT_WIDTH__ 16"));
        assert!(has(&windows, "#define __SIZE_WIDTH__ 64"));
        assert!(has(&windows, "#define __INTMAX_WIDTH__ 64"));
    }

    #[test]
    fn a_constant_maker_gets_the_suffix_its_width_needs_and_no_other() {
        // Found by diffing `-dM` against the system compiler. The 32 bit row was passing `U`
        // as its width suffix, which put a `U` on the signed macro and two on the unsigned
        // one, and `UINT32_C(1)` expanded to `1UU`, which is not a token.
        let linux = set_for("x86_64-unknown-linux-gnu");
        assert!(has(&linux, "#define __INT32_C(c) c"));
        assert!(has(&linux, "#define __UINT32_C(c) c ## U"));
        assert!(has(&linux, "#define __INT16_C(c) c"));
        // No `U` on the two narrow ones, because `uint8_t` and `uint16_t` promote to a
        // signed `int` and the constant has that type. gcc leaves it off for the same reason.
        assert!(has(&linux, "#define __UINT16_C(c) c"));
        assert!(has(&linux, "#define __UINT8_C(c) c"));
        // The wide ones do take a suffix, and the `U` goes in front of it.
        assert!(has(&linux, "#define __INT64_C(c) c ## L"));
        assert!(has(&linux, "#define __UINT64_C(c) c ## UL"));
        // Windows has a thirty two bit `long`, so its sixty four bit constants are `long long`.
        let windows = set_for("x86_64-pc-windows-msvc");
        assert!(has(&windows, "#define __INT64_C(c) c ## LL"));
        assert!(has(&windows, "#define __UINT64_C(c) c ## ULL"));
    }

    #[test]
    fn the_symbol_prefix_is_defined_everywhere_including_where_it_is_empty() {
        // Empty is not the same as absent, because glibc stringifies it. Leaving it undefined
        // turns `__asm__ (__ASMNAME ("__xpg_strerror_r"))` into an asm name of
        // "__USER_LABEL_PREFIX__" "__xpg_strerror_r", which renames the function instead of
        // failing, and that is a bug found at link time or later.
        for triple in
            ["x86_64-unknown-linux-gnu", "aarch64-unknown-linux-gnu", "x86_64-pc-windows-msvc"]
        {
            assert!(has(&set_for(triple), "#define __USER_LABEL_PREFIX__ "), "{triple}");
        }
        // Mach-O keeps the underscore that ELF dropped.
        assert!(has(&set_for("aarch64-apple-darwin"), "#define __USER_LABEL_PREFIX__ _"));
    }

    /// `-ffast-math` as gcc 16 spells it on x86-64 Linux: one macro per licence, the finite promise
    /// as a one, and the IEC 60559 family gone from both the compiler's lines and the ones glibc
    /// would write from `__GCC_IEC_559`.
    #[test]
    fn fast_math_defines_what_gcc_16_defines_for_it() {
        let target = TargetInfo::new("x86_64-unknown-linux-gnu".parse().expect("a triple"));
        let mut opts = Predef::new();
        opts.trapping_math = opts.math.set_fast(true);
        let fast = built_in(&target, &opts);
        for line in [
            "#define __FAST_MATH__ 1",
            "#define __FINITE_MATH_ONLY__ 1",
            "#define __NO_MATH_ERRNO__ 1",
            "#define __NO_TRAPPING_MATH__ 1",
            "#define __NO_SIGNED_ZEROS__ 1",
            "#define __RECIPROCAL_MATH__ 1",
            "#define __ASSOCIATIVE_MATH__ 1",
            "#define __GCC_IEC_559 0",
            "#define __GCC_IEC_559_COMPLEX 0",
        ] {
            assert!(has(&fast, line), "{line}");
        }
        for name in ["__STDC_IEC_559__", "__STDC_IEC_559_COMPLEX__", "__STDC_IEC_60559_BFP__"] {
            assert!(!fast.contains(&format!("#define {name} ")), "{name}");
        }

        // `-ffast-math -ftrapping-math` keeps the members that do not need trapping off and
        // loses the name for the whole, and regrouping with it, which is gcc's answer.
        opts.trapping_math = true;
        let trapping = built_in(&target, &opts);
        assert!(has(&trapping, "#define __NO_MATH_ERRNO__ 1"));
        assert!(has(&trapping, "#define __GCC_IEC_559 0"));
        for name in ["__FAST_MATH__", "__NO_TRAPPING_MATH__", "__ASSOCIATIVE_MATH__"] {
            assert!(!trapping.contains(&format!("#define {name} ")), "{name}");
        }

        // And none of it by default.
        let plain = built_in(&target, &Predef::new());
        for name in ["__FAST_MATH__", "__NO_MATH_ERRNO__", "__NO_TRAPPING_MATH__"] {
            assert!(!plain.contains(&format!("#define {name} ")), "{name}");
        }
        assert!(has(&plain, "#define __STDC_IEC_559__ 1"));
    }

    /// `__EXCEPTIONS` is the one macro `-fexceptions` adds in C, and it is not there without it.
    #[test]
    fn exceptions_are_announced_to_the_headers_that_ask() {
        let target = TargetInfo::new("x86_64-unknown-linux-gnu".parse().expect("a triple"));
        let mut opts = Predef::new();
        assert!(!built_in(&target, &opts).contains("__EXCEPTIONS"));
        opts.exceptions = true;
        assert!(has(&built_in(&target, &opts), "#define __EXCEPTIONS 1"));
    }

    /// The set gcc defines that headers read and that are true here. Written out one line at a
    /// time rather than counted, because the value is the whole point of each of them: a header
    /// asking `#if __FINITE_MATH_ONLY__` wants the number and not the existence.
    #[test]
    fn the_toolchain_macros_gcc_defines_are_defined_with_gccs_values() {
        let linux = set_for("x86_64-unknown-linux-gnu");
        for line in [
            "#define __GNUC_EXECUTION_CHARSET_NAME \"UTF-8\"",
            "#define __GNUC_WIDE_EXECUTION_CHARSET_NAME \"UTF-32LE\"",
            "#define __GXX_ABI_VERSION 1021",
            "#define __REGISTER_PREFIX__ ",
            "#define __FINITE_MATH_ONLY__ 0",
            "#define __GCC_IEC_559 2",
            "#define __GCC_IEC_559_COMPLEX 2",
            "#define __GCC_CONSTRUCTIVE_SIZE 64",
            "#define __GCC_DESTRUCTIVE_SIZE 64",
            "#define __GCC_HAVE_SYNC_COMPARE_AND_SWAP_1 1",
            "#define __GCC_HAVE_SYNC_COMPARE_AND_SWAP_2 1",
            "#define __GCC_HAVE_SYNC_COMPARE_AND_SWAP_4 1",
            "#define __GCC_HAVE_SYNC_COMPARE_AND_SWAP_8 1",
            "#define __ATOMIC_HLE_ACQUIRE 65536",
            "#define __ATOMIC_HLE_RELEASE 131072",
            "#define __FXSR__ 1",
            "#define __MMX_WITH_SSE__ 1",
            "#define __code_model_small__ 1",
        ] {
            assert!(has(&linux, line), "{line}");
        }
        // The five that are the processor's rather than the compiler's stay on the processor.
        let arm = set_for("aarch64-unknown-linux-gnu");
        for name in ["__ATOMIC_HLE_ACQUIRE", "__FXSR__", "__MMX_WITH_SSE__", "__code_model_small__"]
        {
            assert!(!arm.contains(name), "{name}");
        }
        assert!(has(&arm, "#define __GCC_HAVE_SYNC_COMPARE_AND_SWAP_8 1"));
        // A wide character is sixteen bits on Windows, so a wide string is UTF-16 there.
        let windows = set_for("x86_64-pc-windows-msvc");
        assert!(has(&windows, "#define __GNUC_WIDE_EXECUTION_CHARSET_NAME \"UTF-16LE\""));
    }

    #[test]
    fn the_extensions_the_unit_is_built_for_are_macros() {
        // tamnd/rucc#2003. The baseline is four macros and SSE4.2 is six more, which is gcc 16's
        // `-msse4.2 -dM` output, and the unit's set is what decides it rather than the target.
        let triple: Triple = "x86_64-unknown-linux-gnu".parse().expect("a triple");
        let mut choices = rucc_target::Choices::new();
        choices.read("sse4.2").expect("a name gcc knows");
        let opts = Predef { isa: choices.over(Isa::baseline()), ..Predef::new() };
        let text = built_in(&TargetInfo::new(triple), &opts);
        for name in
            ["SSE", "SSE2", "MMX", "FXSR", "SSE3", "SSSE3", "SSE4_1", "SSE4_2", "POPCNT", "CRC32"]
        {
            assert!(has(&text, &format!("#define __{name}__ 1")), "{name}");
        }
        let plain = set_for("x86_64-unknown-linux-gnu");
        assert!(has(&plain, "#define __SSE2__ 1"));
        for name in ["__SSE3__", "__SSE4_2__", "__POPCNT__", "__CRC32__"] {
            assert!(!plain.contains(name), "{name}");
        }
        // AArch64 has none of them whatever the set says, since the set is an x86-64 one.
        let arm: Triple = "aarch64-unknown-linux-gnu".parse().expect("a triple");
        assert!(!built_in(&TargetInfo::new(arm), &opts).contains("__SSE"));
    }

    #[test]
    fn the_memory_orders_are_there_even_without_atomics() {
        // musl's stdatomic.h writes `memory_order_relaxed = __ATOMIC_RELAXED` with no test
        // around it, so these are not a promise about `_Atomic`, they are the numbering the
        // builtins take, and a compiler without them prints an enumerator whose value is an
        // identifier.
        let linux = set_for("x86_64-unknown-linux-gnu");
        assert!(has(&linux, "#define __ATOMIC_RELAXED 0"));
        assert!(has(&linux, "#define __ATOMIC_SEQ_CST 5"));
        assert!(has(&linux, "#define __STDC_NO_ATOMICS__ 1"), "and we still have no _Atomic");
        assert!(has(&linux, "#define __GCC_ATOMIC_INT_LOCK_FREE 2"));
        assert!(has(&linux, "#define __GCC_ATOMIC_LLONG_LOCK_FREE 2"));
        assert!(has(&set_for("x86_64-pc-windows-msvc"), "#define __GCC_ATOMIC_LLONG_LOCK_FREE 2"));
    }

    #[test]
    fn long_double_is_three_types_and_the_macros_say_which() {
        assert!(has(&set_for("x86_64-unknown-linux-gnu"), "#define __LDBL_MANT_DIG__ 64"));
        assert!(has(&set_for("aarch64-unknown-linux-gnu"), "#define __LDBL_MANT_DIG__ 113"));
        assert!(has(&set_for("aarch64-apple-darwin"), "#define __LDBL_MANT_DIG__ 53"));
    }

    #[test]
    fn the_size_of_float128_is_defined_where_gcc_has_the_name() {
        let line = "#define __SIZEOF_FLOAT128__ 16";
        assert!(has(&set_for("x86_64-unknown-linux-gnu"), line));
        assert!(has(&set_for_tuple("i686-linux-gnu"), line));
        let power = set_for_tuple("powerpc64le-linux-gnu");
        assert!(has(&power, line));
        assert!(has(&power, "#define __FLOAT128__ 1"));
        assert!(!set_for("x86_64-unknown-linux-gnu").contains("__FLOAT128__"));
        assert!(!set_for("aarch64-unknown-linux-gnu").contains("__SIZEOF_FLOAT128__"));
    }

    #[test]
    fn the_extended_floating_types_have_the_limits_their_formats_have() {
        // Every one of these but `_Float64x` is the same format on every target, which is the
        // point of the interchange types, so the limits are the same everywhere too.
        let linux = set_for("x86_64-unknown-linux-gnu");
        assert!(has(&linux, "#define __FLT16_MANT_DIG__ 11"));
        assert!(has(&linux, "#define __FLT32_MANT_DIG__ 24"));
        assert!(has(&linux, "#define __FLT64_MANT_DIG__ 53"));
        assert!(has(&linux, "#define __FLT128_MANT_DIG__ 113"));
        assert!(has(&linux, "#define __FLT32X_MANT_DIG__ 53"));
        // Each family writes its values with its own suffix, so a header that assigns one to an
        // object of the type gets the type back rather than a conversion.
        assert!(has(&linux, "#define __FLT16_MAX__ 6.55040000000000000000000000000000000e+4F16"));
        assert!(has(
            &linux,
            "#define __FLT32X_MIN__ 2.22507385850720138309023271733240406e-308F32x"
        ));
        // `_Float128x` is a type no target has, so gcc defines nothing for it and neither
        // does this.
        assert!(!linux.contains("__FLT128X_"));
    }

    #[test]
    fn the_family_for_a_named_type_is_written_where_the_type_is_and_nowhere_else() {
        // gcc 13's rows, measured with the cross compilers: the half is on x86-64, AArch64 and
        // RISC-V, and the quad is on every one of the seven but armv7. A program asks the macro
        // to find out whether it may write the type, so a row where the two disagree is a header
        // that asks for a type the compiler then refuses.
        let has_family = |target: &str, prefix: &str| {
            set_for_tuple(target).contains(&format!("#define __{prefix}_MANT_DIG__ "))
        };
        assert!(has_family("x86_64-linux-gnu", "FLT16"));
        assert!(has_family("aarch64-linux-gnu", "FLT16"));
        assert!(has_family("riscv64-linux-gnu", "FLT16"));
        assert!(!has_family("i686-linux-gnu", "FLT16"));
        assert!(!has_family("s390x-linux-gnu", "FLT16"));
        assert!(!has_family("armv7-linux-gnueabihf", "FLT16"));

        assert!(has_family("i686-linux-gnu", "FLT128"));
        assert!(has_family("s390x-linux-gnu", "FLT128"));
        assert!(!has_family("armv7-linux-gnueabihf", "FLT128"));

        // The families every machine has are still there on the machine that has least, and so
        // is `_Float64x` on the machines that have a format for it.
        let arm = set_for_tuple("armv7-linux-gnueabihf");
        for prefix in ["FLT", "DBL", "LDBL", "FLT32", "FLT64", "FLT32X"] {
            assert!(arm.contains(&format!("#define __{prefix}_MANT_DIG__ ")), "__{prefix}_");
        }
        assert!(!arm.contains("__FLT64X_"));
    }

    #[test]
    fn float64x_keeps_the_width_that_long_double_loses_on_apple() {
        // The two are the same eighty bit x87 format on x86-64 and part company everywhere
        // else, because `_Float64x` follows the processor and `long double` follows the ABI.
        let linux = set_for("x86_64-unknown-linux-gnu");
        assert!(has(&linux, "#define __FLT64X_MANT_DIG__ 64"));
        assert!(has(&linux, "#define __LDBL_MANT_DIG__ 64"));
        let mac = set_for("aarch64-apple-darwin");
        assert!(has(&mac, "#define __FLT64X_MANT_DIG__ 113"));
        assert!(has(&mac, "#define __LDBL_MANT_DIG__ 53"));
        let windows = set_for("x86_64-pc-windows-msvc");
        assert!(has(&windows, "#define __FLT64X_MANT_DIG__ 64"));
        assert!(has(&windows, "#define __LDBL_MANT_DIG__ 53"));
    }

    #[test]
    fn the_largest_value_of_an_ieee_format_is_also_its_largest_normal_one() {
        // `NORM_MAX` is only ever smaller than `MAX` for a format that holds values above its
        // largest normal one, and no IEEE encoding does. The double-double does, which is why
        // the two are separate fields now, and no target here has one.
        let linux = set_for("x86_64-unknown-linux-gnu");
        for prefix in ["FLT", "DBL", "LDBL", "FLT16", "FLT32", "FLT64", "FLT128", "FLT32X"] {
            let value = |suffix: &str| {
                let name = format!("#define __{prefix}_{suffix}__ ");
                let line = linux
                    .lines()
                    .find(|line| line.starts_with(&name))
                    .unwrap_or_else(|| panic!("__{prefix}_{suffix}__ is defined"));
                line[name.len()..].to_owned()
            };
            assert_eq!(value("MAX"), value("NORM_MAX"), "__{prefix}_NORM_MAX__");
        }
    }

    #[test]
    fn the_double_double_is_the_row_where_the_largest_value_is_not_the_largest_normal_one() {
        // No target here has a double-double `long double`, so this asks the row rather than the
        // macros. It is the reason `norm_max` is a field: a program that wants the largest value
        // it can still compute a full significand with wants `NORM_MAX`, and on PowerPC that is
        // a bit under half of `MAX`.
        let c = characteristics(Format::DoubleDouble);
        assert_ne!(c.max, c.norm_max);
        // `NORM_MAX` is two to the one thousand and twenty three, which is about half of `MAX`,
        // and `MAX` is a shade above `DBL_MAX` because the high half can be `DBL_MAX` and the low
        // half then adds to it. Both are what the reference prints.
        assert!(c.norm_max.starts_with("8.98846567431157953864652595394501e+307"));
        assert!(c.max.starts_with("1.7976931348623158"));
        // Epsilon is the odd one. The smallest value that changes a double-double near one is a
        // subnormal in the low half rather than one unit in the last place of anything, so it is
        // the same number as this format's own `DENORM_MIN`, which no other row can say.
        assert_eq!(c.epsilon, c.denorm_min);
        for format in [Format::Half, Format::Single, Format::Double, Format::X87Extended] {
            assert_ne!(characteristics(format).epsilon, characteristics(format).denorm_min);
        }
        // And it is not an IEC 60559 format, which only the brain float can also say.
        assert_eq!(c.is_iec_60559, "0");
    }

    #[test]
    fn the_widest_bit_int_is_said_in_every_dialect() {
        // gcc defines it under `-std=c17` as well as `-std=c23`, and a header that reaches for
        // `_BitInt` tests the macro rather than the version, so an absent one reads as a
        // compiler without the type at all.
        let mut opts = Predef::new();
        let target = TargetInfo::new("x86_64-unknown-linux-gnu".parse().unwrap());
        assert!(has(&built_in(&target, &opts), "#define __BITINT_MAXWIDTH__ 128"));
        opts.std = Std::C17;
        assert!(has(&built_in(&target, &opts), "#define __BITINT_MAXWIDTH__ 128"));
    }

    #[test]
    fn char_signedness_is_recorded_only_when_it_is_unsigned() {
        // Which is how GCC does it: the macro exists to mark the unusual case.
        assert!(has(&set_for("aarch64-unknown-linux-gnu"), "#define __CHAR_UNSIGNED__ 1"));
        assert!(!has(&set_for("x86_64-unknown-linux-gnu"), "#define __CHAR_UNSIGNED__ 1"));
    }

    #[test]
    fn the_dialect_decides_the_standard_macros() {
        let mut opts = Predef::new();
        let target = TargetInfo::new("x86_64-unknown-linux-gnu".parse().unwrap());
        assert!(has(&built_in(&target, &opts), "#define __STDC_VERSION__ 202311L"));
        assert!(!has(&built_in(&target, &opts), "#define __STRICT_ANSI__ 1"));
        assert!(has(&built_in(&target, &opts), "#define linux 1"));

        opts.gnu_extensions = false;
        assert!(has(&built_in(&target, &opts), "#define __STRICT_ANSI__ 1"));
        assert!(!has(&built_in(&target, &opts), "#define linux 1"), "not a reserved name");

        opts.std = Std::C89;
        let c89 = built_in(&target, &opts);
        assert!(!c89.contains("__STDC_VERSION__"), "C89 does not define it at all");
        assert!(has(&c89, "#define __STDC__ 1"));
    }

    /// The conditional feature macros are claims not to have something, and a claim that is
    /// not true changes what a header declares rather than turning anything off.
    #[test]
    fn the_only_things_claimed_missing_are_the_ones_that_are_missing() {
        let target = TargetInfo::new("x86_64-unknown-linux-gnu".parse().unwrap());
        let opts = Predef::new();
        let set = built_in(&target, &opts);
        assert!(has(&set, "#define __STDC_NO_ATOMICS__ 1"), "there is no stdatomic.h to include");
        assert!(has(&set, "#define __STDC_NO_THREADS__ 1"), "nor a threads.h");
        assert!(has(&set, "#define __STDC_NO_COMPLEX__ 1"), "the arithmetic is not lowered");
        assert!(!set.contains("__STDC_NO_VLA__"), "variable length arrays work");
    }

    /// gcc's own `stdatomic.h` declares `atomic_char8_t` under `#ifdef __CHAR8_TYPE__`, so a
    /// compiler that defines it in C17 declares a type gcc does not and one that never defines
    /// it is missing one in C23. Both were caught by preprocessing that header both ways.
    #[test]
    fn the_type_behind_char8_t_is_defined_in_c23_and_in_no_dialect_before_it() {
        let target = TargetInfo::new("x86_64-unknown-linux-gnu".parse().unwrap());
        let mut opts = Predef::new();
        assert!(has(&built_in(&target, &opts), "#define __CHAR8_TYPE__ unsigned char"));

        for older in [Std::C17, Std::C11, Std::C99, Std::C89] {
            opts.std = older;
            assert!(!built_in(&target, &opts).contains("__CHAR8_TYPE__"), "{older:?}");
        }
    }

    /// glibc's `<stdc-predef.h>` is read before the first line of every translation unit and
    /// writes `#define __STDC_IEC_60559_BFP__ 201404L` whenever `__GCC_IEC_559` is positive.
    /// Any other value here is a redefinition with a different body, which is a warning the
    /// program did not ask for and which a configure script reads as a failed feature test.
    #[test]
    fn the_ieee_annex_macro_carries_the_value_glibcs_own_header_writes() {
        let target = TargetInfo::new("x86_64-unknown-linux-gnu".parse().unwrap());
        let mut opts = Predef::new();
        for std in [Std::C23, Std::C17, Std::C11, Std::C99, Std::C89] {
            opts.std = std;
            let set = built_in(&target, &opts);
            assert!(has(&set, "#define __STDC_IEC_60559_BFP__ 201404L"), "{std:?}");
            assert!(has(&set, "#define __STDC_IEC_60559_COMPLEX__ 201404L"), "{std:?}");
            // The two the library reads to decide whether to write the four above itself.
            assert!(has(&set, "#define __GCC_IEC_559 2"), "{std:?}");
            assert!(has(&set, "#define __GCC_IEC_559_COMPLEX 2"), "{std:?}");
        }
    }

    #[test]
    fn the_optimizer_level_is_visible_to_the_preprocessor() {
        let target = TargetInfo::new("x86_64-unknown-linux-gnu".parse().unwrap());
        let mut opts = Predef::new();
        assert!(has(&built_in(&target, &opts), "#define __NO_INLINE__ 1"));
        assert!(!built_in(&target, &opts).contains("__OPTIMIZE__"));

        opts.opt_level = OptLevel::O2;
        assert!(has(&built_in(&target, &opts), "#define __OPTIMIZE__ 1"));
        assert!(!built_in(&target, &opts).contains("__OPTIMIZE_SIZE__"));

        opts.opt_level = OptLevel::Os;
        assert!(has(&built_in(&target, &opts), "#define __OPTIMIZE_SIZE__ 1"));
    }

    #[test]
    fn a_command_line_define_with_no_value_is_one() {
        let mut opts = Predef::new();
        opts.defines = vec!["FOO".to_owned(), "BAR=2".to_owned(), "F(x)=x + 1".to_owned()];
        opts.undefines = vec!["__linux__".to_owned()];
        let text = command_line(&opts);
        assert!(has(&text, "#define FOO 1"));
        assert!(has(&text, "#define BAR 2"));
        assert!(has(&text, "#define F(x) x + 1"));
        // The undefine comes last, because `-U` beats `-D` whichever side of it it was on.
        assert!(text.trim_end().ends_with("#undef __linux__"));
    }

    #[test]
    fn no_command_line_macros_is_no_file_at_all() {
        assert!(command_line(&Predef::new()).is_empty());
    }

    #[test]
    fn a_date_is_spelled_the_way_the_standard_fixes() {
        // The epoch itself, and a day that needs the space padding the format asks for.
        let epoch = Timestamp::from_unix(0);
        assert_eq!(epoch.date, "Jan  1 1970");
        assert_eq!(epoch.time, "00:00:00");
        let leap = Timestamp::from_unix(1_709_164_800);
        assert_eq!(leap.date, "Feb 29 2024", "2024 is a leap year");
        let late = Timestamp::from_unix(1_735_689_599);
        assert_eq!(late.date, "Dec 31 2024");
        assert_eq!(late.time, "23:59:59");
    }

    #[test]
    fn a_date_before_the_epoch_still_comes_out_right() {
        // Not because anyone compiles in 1969, but because the arithmetic that gets this
        // wrong is the same arithmetic that gets a time zone offset wrong.
        assert_eq!(Timestamp::from_unix(-1).date, "Dec 31 1969");
        assert_eq!(Timestamp::from_unix(-1).time, "23:59:59");
    }

    #[test]
    fn the_gnuc_version_is_a_knob_rather_than_a_constant() {
        let target = TargetInfo::new("x86_64-unknown-linux-gnu".parse().unwrap());
        let mut opts = Predef::new();
        assert!(has(&built_in(&target, &opts), "#define __GNUC__ 16"));
        opts.gnuc = GnucVersion { major: 15, minor: 1, patch: 0 };
        assert!(has(&built_in(&target, &opts), "#define __GNUC__ 15"));
        assert!(has(&built_in(&target, &opts), "#define __GNUC_MINOR__ 1"));
    }

    /// Which of the two inline macros is defined, over the two things that decide it.
    ///
    /// Exactly one of them is defined at a time, which is what a header reads: glibc's
    /// `__extern_inline` writes `extern __inline` under one and adds `__gnu_inline__` under the
    /// other, so both being defined or neither being defined is a header taking a path it was
    /// never meant to take.
    #[test]
    fn one_of_the_two_inline_macros_is_defined_and_three_things_can_pick_which() {
        let target = TargetInfo::new("x86_64-unknown-linux-gnu".parse().unwrap());
        let gnu = "#define __GNUC_GNU_INLINE__ 1";
        let stdc = "#define __GNUC_STDC_INLINE__ 1";

        let mut opts = Predef::new();
        assert!(has(&built_in(&target, &opts), stdc));
        assert!(!has(&built_in(&target, &opts), gnu));

        opts.gnu89_inline = true;
        assert!(has(&built_in(&target, &opts), gnu));
        assert!(!has(&built_in(&target, &opts), stdc));

        // The dialect on its own, which is where the older reading came from.
        let mut opts = Predef::new();
        opts.std = Std::C89;
        assert!(has(&built_in(&target, &opts), gnu));
        assert!(!has(&built_in(&target, &opts), stdc));
    }

    #[test]
    fn a_darwin_target_says_its_deployment_target_as_the_sdk_reads_it() {
        let default = set_for("aarch64-apple-darwin");
        assert!(has(&default, "#define __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ 110000"));
        assert!(has(&default, "#define __ENVIRONMENT_OS_VERSION_MIN_REQUIRED__ 110000"));
        let pinned = set_for_tuple("aarch64-macos.13.4");
        assert!(has(&pinned, "#define __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ 130400"));
        assert!(has(&pinned, "#define __ENVIRONMENT_OS_VERSION_MIN_REQUIRED__ 130400"));
        let linux = set_for("aarch64-unknown-linux-gnu");
        assert!(!linux.contains("VERSION_MIN_REQUIRED"));
    }

    #[test]
    fn apple_arm64_has_the_older_spellings_its_sdk_reads() {
        let darwin = set_for("aarch64-apple-darwin");
        for line in [
            "#define __ARM64_ARCH_8__ 1",
            "#define __ARM_NEON__ 1",
            "#define __AARCH64_SIMD__ 1",
            "#define __LITTLE_ENDIAN__ 1",
        ] {
            assert!(has(&darwin, line), "{line}");
        }
        // gcc defines none of them for Linux, and a header that tests `__LITTLE_ENDIAN__` there
        // is one written for clang that gcc users already build without it.
        let linux = set_for("aarch64-unknown-linux-gnu");
        assert!(!linux.contains("__ARM_NEON__"));
        assert!(!linux.contains("#define __LITTLE_ENDIAN__"));
    }

    #[test]
    fn sixty_four_bit_glibc_makes_the_fast_types_long_on_every_processor() {
        // glibc's `stdint.h` picks `long` under `__WORDSIZE == 64` and never asks which
        // processor it is on, and gcc for aarch64, riscv64 and powerpc64le all agree.
        for triple in ["aarch64-unknown-linux-gnu", "riscv64-unknown-linux-gnu"] {
            let set = set_for(triple);
            assert!(has(&set, "#define __INT_FAST16_TYPE__ long int"), "{triple}");
            assert!(has(&set, "#define __UINT_FAST32_TYPE__ long unsigned int"), "{triple}");
            assert!(has(&set, "#define __INT_FAST32_WIDTH__ 64"), "{triple}");
        }
        assert!(has(&set_for("aarch64-unknown-linux-musl"), "#define __INT_FAST16_TYPE__ int"));
        // Apple's `stdint.h` makes the 16 bit one `int16_t` and the 32 bit one `int32_t`.
        let darwin = set_for("aarch64-apple-darwin");
        assert!(has(&darwin, "#define __INT_FAST16_TYPE__ short int"));
        assert!(has(&darwin, "#define __INT_FAST32_TYPE__ int"));
    }

    #[test]
    fn armv8_a_says_what_the_base_architecture_has() {
        let arm = set_for("aarch64-unknown-linux-gnu");
        for line in [
            "#define __ARM_ARCH_ISA_A64 1",
            "#define __ARM_FEATURE_CLZ 1",
            "#define __ARM_FEATURE_IDIV 1",
            "#define __ARM_FEATURE_FMA 1",
            "#define __FP_FAST_FMA 1",
            "#define __GCC_DESTRUCTIVE_SIZE 256",
        ] {
            assert!(has(&arm, line), "{line}");
        }
        let x86 = set_for("x86_64-unknown-linux-gnu");
        assert!(!x86.contains("__ARM_FEATURE_CLZ"));
        assert!(!x86.contains("__FP_FAST_FMA"));
        assert!(has(&x86, "#define __GCC_DESTRUCTIVE_SIZE 64"));
    }

    #[test]
    fn musl_and_glibc_disagree_about_the_fast_types_on_the_same_processor() {
        // The same x86-64 machine, two libcs, two answers. GCC built for glibc says `long int`
        // and GCC built for musl says `int`, because musl defines `int_fast16_t` as `int32_t`
        // everywhere. It shows in `stdatomic.h`, which GCC writes out of these macros, so
        // getting it wrong makes every atomic fast type the wrong width.
        let gnu = set_for("x86_64-unknown-linux-gnu");
        let musl = set_for("x86_64-unknown-linux-musl");
        assert!(has(&gnu, "#define __INT_FAST16_TYPE__ long int"));
        assert!(has(&gnu, "#define __INT_FAST32_TYPE__ long int"));
        assert!(has(&gnu, "#define __UINT_FAST16_TYPE__ long unsigned int"));
        assert!(has(&musl, "#define __INT_FAST16_TYPE__ int"));
        assert!(has(&musl, "#define __INT_FAST32_TYPE__ int"));
        assert!(has(&musl, "#define __UINT_FAST16_TYPE__ unsigned int"));
        // The limits have to move with the types or a header that checks them stops agreeing
        // with the header that uses them.
        assert!(has(&gnu, "#define __INT_FAST16_MAX__ 0x7fffffffffffffffL"));
        assert!(has(&musl, "#define __INT_FAST16_MAX__ 0x7fffffff"));
        assert!(has(&musl, "#define __UINT_FAST16_MAX__ 0xffffffffU"));
    }

    #[test]
    fn the_libc_only_moves_the_two_fast_types_it_is_allowed_to_move() {
        // 8 and 64 are the same on both, and so is everything outside the fast family. A libc
        // is not a processor and this is the whole of what it is permitted to change here.
        let gnu = set_for("x86_64-unknown-linux-gnu");
        let musl = set_for("x86_64-unknown-linux-musl");
        for line in [
            "#define __INT_FAST8_TYPE__ signed char",
            "#define __INT_FAST64_TYPE__ long int",
            "#define __INT64_TYPE__ long int",
            "#define __SIZE_TYPE__ long unsigned int",
            "#define __SIZEOF_LONG__ 8",
            "#define __LP64__ 1",
        ] {
            assert!(has(&gnu, line), "glibc lost {line}");
            assert!(has(&musl, line), "musl lost {line}");
        }
    }

    #[test]
    fn windows_is_the_one_target_where_the_two_middle_fast_types_differ_from_each_other() {
        // mingw's `stdint.h` declares `int_fast16_t` a `short` and `int_fast32_t` an `int`, and
        // x86_64-w64-mingw32-gcc says the same, so this is the one platform where the pair does
        // not share an answer.
        let windows = set_for("x86_64-pc-windows-gnu");
        assert!(has(&windows, "#define __INT_FAST16_TYPE__ short int"));
        assert!(has(&windows, "#define __UINT_FAST16_TYPE__ short unsigned int"));
        assert!(has(&windows, "#define __INT_FAST16_MAX__ 0x7fff"));
        assert!(has(&windows, "#define __UINT_FAST16_MAX__ 0xffff"));
        assert!(has(&windows, "#define __INT_FAST16_WIDTH__ 16"));
        assert!(has(&windows, "#define __INT_FAST32_TYPE__ int"));
        assert!(has(&windows, "#define __UINT_FAST32_TYPE__ unsigned int"));
        assert!(has(&windows, "#define __INT_FAST32_WIDTH__ 32"));
        // The two ends of the family are the same as everywhere.
        assert!(has(&windows, "#define __INT_FAST8_TYPE__ signed char"));
        assert!(has(&windows, "#define __INT_FAST64_TYPE__ long long int"));
    }

    #[test]
    fn windows_answers_to_every_name_gcc_gives_it() {
        // The mingw tree reads more than one spelling of the platform and a missing one is a
        // declaration that quietly is not there: `winuser.h` guards `EndTask` with `#ifdef
        // WINNT` and `rpcdcep.h` guards six `I_Rpc` declarations with `#ifndef WINNT`.
        let windows = set_for("x86_64-pc-windows-gnu");
        let every = "_WIN32 __WIN32 __WIN32__ __WINNT __WINNT__ __MINGW32__ \
                     _WIN64 __WIN64 __WIN64__ __MINGW64__ __MSVCRT__ __SEH__ WIN32 WIN64 WINNT";
        for name in every.split_whitespace() {
            assert!(has(&windows, &format!("#define {name} 1")), "no {name}");
        }
        assert!(has(&windows, "#define _INTEGRAL_MAX_BITS 64"));
    }

    #[test]
    fn a_thirty_two_bit_windows_is_not_told_its_pointer_is_sixty_four_bits_wide() {
        // `_WIN64` is about the pointer rather than the processor, and i686-w64-mingw32-gcc
        // defines neither it nor `__MINGW64__`, nor `__SEH__`, since the unwind records this
        // compiler writes are the sixty four bit format and a thirty two bit Windows unwinds
        // some other way. The target is made by hand because the three field triple has no
        // 32-bit row yet, so `i686-windows-gnu` predefines nothing at all and there is no other
        // way to reach this arm.
        let mut target = TargetInfo::new("x86_64-pc-windows-gnu".parse().expect("a triple"));
        target.pointer_width = 32;
        let windows = built_in(&target, &Predef::new());
        assert!(has(&windows, "#define _WIN32 1"));
        assert!(has(&windows, "#define __MINGW32__ 1"));
        for name in ["_WIN64", "__WIN64", "__WIN64__", "__MINGW64__", "__SEH__", "WIN64"] {
            assert!(!has(&windows, &format!("#define {name} 1")), "{name} on a 32 bit target");
        }
    }

    #[test]
    fn the_three_unreserved_windows_names_need_the_gnu_dialect() {
        // `WIN32`, `WIN64` and `WINNT` are in the user's namespace, so gcc drops all three under
        // `-std=c11` and keeps the underscored ones. Windows code tests them anyway, the same
        // way portable Unix code still tests `linux`.
        let triple: Triple = "x86_64-pc-windows-gnu".parse().expect("a triple");
        let mut opts = Predef::new();
        opts.gnu_extensions = false;
        let strict = built_in(&TargetInfo::new(triple), &opts);
        for name in ["WIN32", "WIN64", "WINNT"] {
            assert!(!has(&strict, &format!("#define {name} 1")), "{name} under -std=c11");
        }
        assert!(has(&strict, "#define _WIN32 1"));
        assert!(has(&strict, "#define __WINNT__ 1"));
    }
}