rucc-sema 0.10.21

//! `__builtin_expect` and `__builtin_expect_with_probability`, which are their first argument.
//!
//! Design: `spec/13-gnu-compat.md` section 13.5.
//!
//! These two say which way a branch is expected to go. The value of `__builtin_expect(x, c)` is
//! `x`, and everything after the first argument is a hint about how often that value will turn out
//! to be `c`. So the answer is the first argument, and the hint is dropped here because there is
//! nothing yet that could read it: branch weights arrive with the optimizer, and until then a node
//! carrying one would be a node every pass has to step over for no gain. `Opcode::Expect` is in the
//! IR waiting for that day.
//!
//! # Why this is not a link error, which is what it was
//!
//! A builtin nothing lowers reaches the assembler as a call to a name no object file defines, and
//! this is the one where that matters most. glibc's `<stdio.h>` writes `getc_unlocked` and its
//! neighbours as extern inline functions in terms of `__builtin_expect` as soon as `__OPTIMIZE__`
//! is set, so before this every program that included that header, called one of those functions
//! and asked for `-O1` failed to link on a name it never wrote. The wider defect, which is that any
//! unimplemented builtin does this rather than saying so, is tamnd/rucc#303.
//!
//! # Why the answer is taken after the call is checked and not before
//!
//! The families next door are recognised before the callee is looked up, because their type comes
//! out of the call and there is no prototype to check them against. These two have one:
//! `long(long, long)` in `features.toml`, which is what gcc gives them, and it is worth keeping.
//! It is where the argument count message comes from, it is what converts the first argument to
//! `long` so that `sizeof(__builtin_expect((char)1, 1))` is eight the way gcc has it, and it is
//! what reports a structure handed to the first parameter in the ordinary words. All of that would
//! have to be written again here to gain nothing.
//!
//! So the call is checked the whole ordinary way and the node is replaced at the end of it.
//!
//! # What happens to a side effect in the hint
//!
//! Whether the hint runs depends on the first argument, which is not a rule anybody would design
//! and is what gcc 16.2.0 does. A first argument that is a constant folds the whole call where it
//! is written and the hint goes with it, so `__builtin_expect(5, side())` never calls `side`. A
//! first argument that is not a constant leaves a call standing until well after the arguments
//! have been evaluated, so `__builtin_expect(x, side())` does call it.
//!
//! That was measured across five shapes at three optimization levels rather than reasoned about:
//! the hint dropped and the hint kept, the value used and the value thrown away, and a constant
//! first argument against a variable one. gcc gives the same answer at `-O0`, `-O1` and `-O2`.
//! This compiler agreed on the first two shapes and dropped the hint on the other three, which is
//! tamnd/rucc#584, and `execute/pr85156.c` in the GCC torture suite is a program that notices:
//! the value it returns is a `z++` written inside a hint.
//!
//! It is matched rather than tidied up because the whole reason a builtin exists is that a program
//! written against gcc gets gcc's answer, and there is no reading of this one that both keeps the
//! side effect and folds `sizeof(__builtin_expect((char)1, 1))` to eight.

use rucc_base::Symbol;
use rucc_diag::Span;

use crate::check::Checker;
use crate::expr::{Category, Expr, ExprId, ExprKind};

/// The names whose value is their first argument.
///
/// Both are rows of `features.toml` with a signature, which is what makes them ordinary calls up
/// to the point this replaces them, and the test at the bottom of this file is what keeps the two
/// lists from drifting apart.
const FAMILY: &[&str] = &["__builtin_expect", "__builtin_expect_with_probability"];

impl Checker<'_> {
    /// The value of a call to one of the hint builtins, if the name is one and it was handed
    /// something to answer with.
    ///
    /// Answers nothing for every other call in the program, which is every call, so the test that
    /// costs a byte goes first.
    ///
    /// The name decides this and not the declaration, the same way the library builtins are
    /// decided by their spelling: what `__builtin_expect` means is a fact about the name, since
    /// the prefix is what says the name belongs to the implementation, and a program that declares
    /// one itself has redeclared something it does not own rather than made a function of its own.
    pub(in crate::check) fn expect_builtin_value(
        &mut self,
        function: Option<Symbol>,
        args: &[ExprId],
        span: Span,
    ) -> Option<ExprId> {
        let name = function?;
        let spelled = self.text(name);
        if !spelled.starts_with("__builtin_") || !FAMILY.contains(&spelled) {
            return None;
        }
        // Nothing to answer with, which is the call with no arguments at all. The count has been
        // reported by this point, so the ordinary node is built and the program is refused for the
        // reason it was already going to be refused for.
        let &value = args.first()?;
        if self.is_poisoned(value) {
            return Some(self.poison(span));
        }
        // The folding is asked and its diagnostics are dropped, because the question here is
        // whether the first argument is a constant and not whether the program was allowed to
        // write one. An argument that is not a constant is not a mistake anywhere in this call.
        if self.eval().integer(value).is_ok() {
            return Some(value);
        }
        // Backwards, so that the hints are evaluated in the order they were written and the value
        // last: a comma runs its left side first, so wrapping from the inside out puts the first
        // hint outermost. The type of each of these is the type of the value, since a comma is its
        // right side and nothing here changes what the call answers with.
        let mut answer = value;
        for &hint in args[1..].iter().rev() {
            if self.is_poisoned(hint) {
                return Some(self.poison(span));
            }
            let ty = self.tast[answer].ty;
            let node = ExprKind::Comma { lhs: hint, rhs: answer };
            answer = self.tast.expr(Expr::new(node, ty, Category::Rvalue), span);
        }
        Some(answer)
    }
}

#[cfg(test)]
mod tests {
    use rucc_gnu::{Kind, Status};

    use super::*;

    /// Every name here has to be a row of the table, with a signature, because the signature is
    /// what the call is checked against before this replaces it. A row without one would never be
    /// declared and the call would be to an undeclared name.
    #[test]
    fn every_name_in_the_family_is_a_row_of_the_table_that_carries_a_signature() {
        for &name in FAMILY {
            let Some(feature) = rucc_gnu::lookup(Kind::Builtin, name) else {
                panic!("{name} is answered here and is not in features.toml");
            };
            assert_eq!(feature.status, Status::Implemented, "{name}");
            assert!(!feature.signature.is_empty(), "{name} is checked against its prototype");
            assert!(feature.library.is_empty(), "{name} is not a call to anything");
        }
    }
}