abi: a type may name the form it takes in a register

[psiha]

pass_in_reg<T> decides by value versus by reference on can_be_passed_in_reg<T>, and then carries T itself. That is the right call for a type whose in-memory form is also its natural register form. It is not for a type that is a byte array in memory and a plain word in a register - a packed integer, say: passing it by value moves the bytes, and every comparator or lookup that receives it re-assembles the word per compare.

This adds one customization point:

• reg_form<T> names the form a T takes in a register. It defaults to T, so nothing changes for any existing type. A type specializes it to name its register form; the contract is round-trip: T must convert to the form and be constructible from it. pass_in_reg<T> then stores reg_form_t<T>, decides by-value on that, converts on construction and offers the conversion back (operator value_type(), only when the two differ), so the boundary converts once in each direction and a consumer that wants the word gets the word.
• reg_form_wrapper: a trivial wrapper inherits its value's register form when it names its value_type, can rebind itself to another value type, has its value's size and converts to and from the wrapper of the register form. A wrapper whose narrowing conversion is deliberately explicit does not qualify and keeps travelling as itself - opting in is one conversion function on the wrapper.

The primary pass_in_reg constructor is unchanged; brace-init of the stored form from the argument covers the conversion. The deduction guide is unchanged.

Measured downstream on an LTO Release build with a 3-byte packed integer as the specialized type: the change is neutral to a few percent better on the workloads where the packed key is probed in a hot loop, and neutral elsewhere. On the SysV ABI a 3-byte trivially-copyable struct already travels in a register, so the gain is the removed per-compare re-assembly rather than the calling convention.

🤖 Generated with Claude Code