rucc-gnu 0.2.17

# The GNU compatibility matrix.
#
# Design: spec/13-gnu-compat.md section 13.2. This file is the source of truth for what
# `__has_attribute`, `__has_builtin`, `__has_feature`, `__has_extension` and
# `__has_c_attribute` answer, and `build.rs` turns it into the table the compiler reads. It
# is a table rather than prose because the alternative is a list that disagrees with the
# compiler, and a compiler that claims a feature it does not have is worse than one that
# admits it: a header that gets a yes and then fails to compile is far harder to diagnose
# than one that takes its fallback path.
#
# Fields:
#   name         the spelling the `__has_*` operator is asked about, without any `__` armour
#   kind         attribute, c-attribute, builtin, feature or extension
#   gcc_version  the GCC release that introduced it, for the record
#   status       unimplemented, partial, implemented or rejected
#   answer       what to answer when the status is not `implemented`, see below
#   value        what `__has_c_attribute` returns, which the standard fixes per attribute
#   used_by      projects known to need it, from the corpus in spec/15-testing.md
#   tests        the tests that prove the status, named as `crate::test` or as a file path
#   notes        anything a reader needs that the fields above do not say
#
# `answer` exists because ignoring an unimplemented attribute is not always harmless.
# Ignoring `hot` produces slower code. Ignoring `packed` produces wrong code, so a row marked
# `answer = "error"` is refused rather than warned about when it is finally parsed and found
# to be unimplemented. Both are section 13.4's rule, written down where the code can read it.
#
# Only `implemented` answers yes. `partial` answers no on purpose: a feature that works most
# of the time is exactly the case where the fallback path is the safer one.

# Preprocessor features, which are the ones that exist today.

[[feature]]
name = "__has_include"
kind = "feature"
gcc_version = "5.0"
status = "implemented"
used_by = ["linux", "glibc", "sqlite", "systemd"]
tests = ["rucc-pp::has_include_answers_from_the_search_path"]
notes = "C23 standard as well as a GNU extension. Answered against the same search path an `#include` on the same line would use."

[[feature]]
name = "__has_include_next"
kind = "feature"
gcc_version = "5.0"
status = "implemented"
used_by = ["glibc"]
tests = ["rucc-pp::has_include_next_starts_where_include_next_would"]

[[feature]]
name = "__has_embed"
kind = "feature"
gcc_version = "15.0"
status = "implemented"
used_by = []
tests = ["rucc-pp::has_embed_tells_missing_from_present_from_empty"]
notes = "Three answers rather than two, because a resource that exists and is empty needs different code from one that is missing."

[[feature]]
name = "__has_attribute"
kind = "feature"
gcc_version = "5.0"
status = "implemented"
used_by = ["linux", "glibc", "systemd", "curl"]
tests = ["rucc-pp::has_attribute_answers_out_of_the_matrix"]
notes = "The operator works. What it answers about is this table, so almost every attribute answers no until the parser lands."

[[feature]]
name = "__has_c_attribute"
kind = "feature"
gcc_version = "11.0"
status = "implemented"
used_by = ["systemd"]
tests = ["rucc-pp::the_scoped_spelling_of_an_attribute_is_the_same_question"]
notes = "Answers with the value the standard gives the attribute rather than with one, which is why the table carries a value column."

[[feature]]
name = "__has_builtin"
kind = "feature"
gcc_version = "10.0"
status = "implemented"
used_by = ["linux", "glibc", "ffmpeg"]
tests = ["rucc-pp::has_builtin_answers_no_until_the_builtin_is_real"]

[[feature]]
name = "__has_feature"
kind = "feature"
gcc_version = "14.0"
status = "implemented"
used_by = ["llvm"]
tests = ["rucc-pp::has_feature_and_has_extension_read_the_same_table"]
notes = "A Clang operator that GCC took, and headers ask it before asking anything else."

[[feature]]
name = "__has_extension"
kind = "feature"
gcc_version = "14.0"
status = "implemented"
used_by = ["llvm"]
tests = ["rucc-pp::has_feature_and_has_extension_read_the_same_table"]
notes = "Answers yes wherever `__has_feature` does, because a feature that is available is available whatever mode it is asked in."

[[feature]]
name = "pragma_once"
kind = "feature"
gcc_version = "3.4"
status = "implemented"
used_by = ["linux", "systemd", "sqlite"]
tests = ["rucc-pp::pragma_once_skips_the_second_read_and_does_not_reach_the_output"]

[[feature]]
name = "include_next"
kind = "extension"
gcc_version = "2.0"
status = "implemented"
used_by = ["glibc", "musl"]
tests = ["rucc-pp::include_next_continues_after_the_directory_the_file_came_from"]

[[feature]]
name = "variadic_macros"
kind = "feature"
gcc_version = "3.0"
status = "implemented"
used_by = ["linux", "glibc", "sqlite", "systemd", "curl"]
tests = ["rucc-pp::variadic_arguments_arrive_as_one_argument_with_the_commas_intact"]

[[feature]]
name = "gnu_variadic_macros"
kind = "extension"
gcc_version = "2.0"
status = "implemented"
used_by = ["linux", "glibc"]
tests = ["rucc-pp::the_gnu_named_variadic_form_works_the_same_way", "rucc-pp::the_gnu_comma_swallowing_extension_drops_the_comma"]
notes = "The named form `args...` and the `, ## __VA_ARGS__` comma swallowing, which the kernel's logging macros are built out of."

[[feature]]
name = "pragma_operator"
kind = "feature"
gcc_version = "3.0"
status = "implemented"
used_by = ["linux", "glibc", "ffmpeg"]
tests = ["rucc-pp::the_pragma_operator_works_from_inside_a_macro"]

[[feature]]
name = "counter_macro"
kind = "extension"
gcc_version = "4.3"
status = "implemented"
used_by = ["linux", "systemd"]
tests = ["rucc-pp::the_counter_is_a_different_number_every_time"]
notes = "`__COUNTER__`, which is how a macro makes a name nobody else will pick. The kernel's `BUILD_BUG_ON` is built out of it."

[[feature]]
name = "base_file_macro"
kind = "extension"
gcc_version = "2.0"
status = "implemented"
used_by = ["glibc"]
tests = ["rucc-pp::the_base_file_is_the_one_named_on_the_command_line"]
notes = "`__BASE_FILE__`, the file on the command line rather than the header the use is in."

[[feature]]
name = "include_level_macro"
kind = "extension"
gcc_version = "2.0"
status = "implemented"
used_by = ["glibc"]
tests = ["rucc-pp::the_include_level_counts_the_headers_above_it"]
notes = "`__INCLUDE_LEVEL__`, which glibc uses to tell a header included directly from one pulled in by another."

[[feature]]
name = "file_name_macro"
kind = "extension"
gcc_version = "12.0"
status = "implemented"
used_by = []
tests = ["rucc-pp::the_file_name_is_the_file_without_the_directories"]
notes = "`__FILE_NAME__`, `__FILE__` with the directories taken off. Clang had it first and GCC took it, and code uses it to keep build paths out of a binary."

[[feature]]
name = "embed"
kind = "feature"
gcc_version = "15.0"
status = "implemented"
used_by = []
tests = ["rucc-pp::embed_writes_the_bytes_of_the_resource"]
notes = "C23, with `limit`, `prefix`, `suffix`, `if_empty` and `gnu::offset`. The bytes become real tokens for now. The fast path that fills an initializer without making them needs the parser."

# Statement and expression extensions, from section 13.3. None of these can work before the
# parser lands in M2, and every one of them is in the kernel.

[[feature]]
name = "statement_expressions"
kind = "extension"
gcc_version = "2.0"
status = "unimplemented"
used_by = ["linux", "glibc", "systemd"]
tests = []
notes = "Every min, max and container_of variant in the kernel is one."

[[feature]]
name = "typeof"
kind = "extension"
gcc_version = "2.0"
status = "unimplemented"
used_by = ["linux", "glibc", "systemd"]
tests = []
notes = "C23 as `typeof`. `__typeof__` is the spelling that works in every mode."

[[feature]]
name = "labels_as_values"
kind = "extension"
gcc_version = "2.0"
status = "unimplemented"
used_by = ["cpython", "lua", "linux"]
tests = []
notes = "Constrains the optimizer: a block whose address is taken cannot be deleted or merged."

[[feature]]
name = "case_ranges"
kind = "extension"
gcc_version = "2.0"
status = "unimplemented"
used_by = ["linux", "ffmpeg"]
tests = []

[[feature]]
name = "binary_conditional"
kind = "extension"
gcc_version = "2.0"
status = "unimplemented"
used_by = ["linux", "glibc"]
tests = []
notes = "`x ?: y`, which evaluates `x` once."

[[feature]]
name = "zero_length_arrays"
kind = "extension"
gcc_version = "2.0"
status = "unimplemented"
used_by = ["linux", "glibc"]
tests = []

[[feature]]
name = "void_pointer_arithmetic"
kind = "extension"
gcc_version = "2.0"
status = "unimplemented"
used_by = ["linux", "glibc"]
tests = []

[[feature]]
name = "designated_initializer_ranges"
kind = "extension"
gcc_version = "2.0"
status = "unimplemented"
used_by = ["linux"]
tests = []
notes = "`[0 ... 9] = x`."

[[feature]]
name = "cast_to_union"
kind = "extension"
gcc_version = "2.0"
status = "unimplemented"
used_by = []
tests = []

[[feature]]
name = "extension_keyword"
kind = "extension"
gcc_version = "2.0"
status = "unimplemented"
used_by = ["glibc", "linux"]
tests = []
notes = "`__extension__`, which suppresses pedantic diagnostics for one expression."

[[feature]]
name = "nested_functions"
kind = "extension"
gcc_version = "2.0"
status = "rejected"
used_by = []
tests = []
notes = "The settled exception from spec/06-lexer-and-parser.md. They need an executable trampoline on the stack, which no hardened target allows. `-fnested-functions` says exactly this."

# Attributes, from section 13.4. `answer = \"error\"` marks the ones whose silent ignoring
# changes semantics rather than performance.

[[feature]]
name = "aligned"
kind = "attribute"
gcc_version = "2.0"
status = "unimplemented"
answer = "error"
used_by = ["linux", "glibc", "ffmpeg", "openssl"]
tests = []

[[feature]]
name = "packed"
kind = "attribute"
gcc_version = "2.0"
status = "unimplemented"
answer = "error"
used_by = ["linux", "systemd", "curl"]
tests = []

[[feature]]
name = "section"
kind = "attribute"
gcc_version = "2.0"
status = "unimplemented"
answer = "error"
used_by = ["linux", "systemd"]
tests = []
notes = "The kernel's initcall and section placement machinery is built on it, and ignoring it silently produces a kernel that does not boot."

[[feature]]
name = "no_sanitize"
kind = "attribute"
gcc_version = "4.8"
status = "unimplemented"
answer = "error"
used_by = ["linux"]
tests = []

[[feature]]
name = "naked"
kind = "attribute"
gcc_version = "4.7"
status = "unimplemented"
answer = "error"
used_by = ["linux"]
tests = []

[[feature]]
name = "mode"
kind = "attribute"
gcc_version = "2.0"
status = "unimplemented"
answer = "error"
used_by = ["glibc"]
tests = []

[[feature]]
name = "transparent_union"
kind = "attribute"
gcc_version = "2.0"
status = "unimplemented"
answer = "error"
used_by = ["glibc"]
tests = []

[[feature]]
name = "noreturn"
kind = "attribute"
gcc_version = "2.5"
status = "unimplemented"
used_by = ["linux", "glibc", "sqlite", "systemd"]
tests = []

[[feature]]
name = "always_inline"
kind = "attribute"
gcc_version = "3.1"
status = "unimplemented"
used_by = ["linux", "glibc", "ffmpeg"]
tests = []

[[feature]]
name = "noinline"
kind = "attribute"
gcc_version = "3.1"
status = "unimplemented"
used_by = ["linux", "glibc"]
tests = []

[[feature]]
name = "flatten"
kind = "attribute"
gcc_version = "4.1"
status = "unimplemented"
used_by = ["systemd"]
tests = []

[[feature]]
name = "hot"
kind = "attribute"
gcc_version = "4.3"
status = "unimplemented"
used_by = ["linux"]
tests = []

[[feature]]
name = "cold"
kind = "attribute"
gcc_version = "4.3"
status = "unimplemented"
used_by = ["linux", "systemd"]
tests = []

[[feature]]
name = "pure"
kind = "attribute"
gcc_version = "2.96"
status = "unimplemented"
used_by = ["linux", "glibc", "curl"]
tests = []

[[feature]]
name = "const"
kind = "attribute"
gcc_version = "2.5"
status = "unimplemented"
used_by = ["linux", "glibc"]
tests = []

[[feature]]
name = "malloc"
kind = "attribute"
gcc_version = "2.96"
status = "unimplemented"
used_by = ["glibc", "systemd"]
tests = []

[[feature]]
name = "returns_twice"
kind = "attribute"
gcc_version = "4.1"
status = "unimplemented"
answer = "error"
used_by = ["glibc"]
tests = []
notes = "`setjmp` is declared with it, and ignoring it means the register allocator may keep a value in a register across a `longjmp`."

[[feature]]
name = "no_instrument_function"
kind = "attribute"
gcc_version = "2.95"
status = "unimplemented"
used_by = ["linux"]
tests = []

[[feature]]
name = "no_stack_protector"
kind = "attribute"
gcc_version = "11.0"
status = "unimplemented"
answer = "error"
used_by = ["linux"]
tests = []

[[feature]]
name = "no_caller_saved_registers"
kind = "attribute"
gcc_version = "7.0"
status = "unimplemented"
answer = "error"
used_by = ["linux"]
tests = []

[[feature]]
name = "target"
kind = "attribute"
gcc_version = "4.4"
status = "unimplemented"
answer = "error"
used_by = ["ffmpeg", "openssl", "linux"]
tests = []

[[feature]]
name = "target_clones"
kind = "attribute"
gcc_version = "6.0"
status = "unimplemented"
used_by = ["glibc"]
tests = []

[[feature]]
name = "optimize"
kind = "attribute"
gcc_version = "4.4"
status = "unimplemented"
used_by = ["linux"]
tests = []

[[feature]]
name = "interrupt"
kind = "attribute"
gcc_version = "4.3"
status = "unimplemented"
answer = "error"
used_by = ["linux"]
tests = []

[[feature]]
name = "used"
kind = "attribute"
gcc_version = "3.1"
status = "unimplemented"
answer = "error"
used_by = ["linux", "systemd"]
tests = []
notes = "It is what keeps a symbol the linker script needs from being dropped."

[[feature]]
name = "unused"
kind = "attribute"
gcc_version = "2.0"
status = "unimplemented"
used_by = ["linux", "glibc", "systemd"]
tests = []

[[feature]]
name = "retain"
kind = "attribute"
gcc_version = "11.0"
status = "unimplemented"
answer = "error"
used_by = ["linux"]
tests = []

[[feature]]
name = "visibility"
kind = "attribute"
gcc_version = "3.3"
status = "unimplemented"
answer = "error"
used_by = ["glibc", "systemd", "openssl", "curl"]
tests = []

[[feature]]
name = "weak"
kind = "attribute"
gcc_version = "2.0"
status = "unimplemented"
answer = "error"
used_by = ["linux", "glibc", "musl"]
tests = []

[[feature]]
name = "alias"
kind = "attribute"
gcc_version = "2.0"
status = "unimplemented"
answer = "error"
used_by = ["glibc", "musl"]
tests = []

[[feature]]
name = "weakref"
kind = "attribute"
gcc_version = "4.2"
status = "unimplemented"
answer = "error"
used_by = ["glibc"]
tests = []

[[feature]]
name = "cleanup"
kind = "attribute"
gcc_version = "3.4"
status = "unimplemented"
answer = "error"
used_by = ["systemd", "linux", "glibc"]
tests = []
notes = "Runs the destructor on every scope exit including a goto out of the scope."

[[feature]]
name = "constructor"
kind = "attribute"
gcc_version = "2.0"
status = "unimplemented"
answer = "error"
used_by = ["glibc", "systemd", "openssl"]
tests = []

[[feature]]
name = "destructor"
kind = "attribute"
gcc_version = "2.0"
status = "unimplemented"
answer = "error"
used_by = ["glibc", "openssl"]
tests = []

[[feature]]
name = "deprecated"
kind = "attribute"
gcc_version = "3.1"
status = "unimplemented"
used_by = ["glibc", "openssl", "curl"]
tests = []

[[feature]]
name = "warning"
kind = "attribute"
gcc_version = "4.3"
status = "unimplemented"
used_by = ["glibc", "linux"]
tests = []

[[feature]]
name = "error"
kind = "attribute"
gcc_version = "4.3"
status = "unimplemented"
used_by = ["linux", "glibc"]
tests = []
notes = "The kernel turns a link failure into a compile-time message with it, so it has to fire after optimization, when it is known the call survives."

[[feature]]
name = "format"
kind = "attribute"
gcc_version = "2.0"
status = "unimplemented"
used_by = ["linux", "glibc", "systemd", "curl", "ffmpeg"]
tests = []
notes = "It has to actually work. It is the mechanism behind printf format checking, which is one of the few warnings that finds real bugs."

[[feature]]
name = "format_arg"
kind = "attribute"
gcc_version = "2.0"
status = "unimplemented"
used_by = ["glibc"]
tests = []

[[feature]]
name = "nonnull"
kind = "attribute"
gcc_version = "3.3"
status = "unimplemented"
used_by = ["glibc", "systemd"]
tests = []

[[feature]]
name = "returns_nonnull"
kind = "attribute"
gcc_version = "4.9"
status = "unimplemented"
used_by = ["glibc", "systemd"]
tests = []

[[feature]]
name = "warn_unused_result"
kind = "attribute"
gcc_version = "3.4"
status = "unimplemented"
used_by = ["linux", "glibc", "systemd"]
tests = []

[[feature]]
name = "sentinel"
kind = "attribute"
gcc_version = "4.0"
status = "unimplemented"
used_by = ["glibc"]
tests = []

[[feature]]
name = "access"
kind = "attribute"
gcc_version = "10.0"
status = "unimplemented"
used_by = ["glibc"]
tests = []

[[feature]]
name = "counted_by"
kind = "attribute"
gcc_version = "14.0"
status = "unimplemented"
used_by = ["linux"]
tests = []

[[feature]]
name = "fallthrough"
kind = "attribute"
gcc_version = "7.0"
status = "unimplemented"
used_by = ["linux", "systemd", "ffmpeg"]
tests = []

[[feature]]
name = "assume_aligned"
kind = "attribute"
gcc_version = "4.9"
status = "unimplemented"
used_by = ["glibc"]
tests = []

[[feature]]
name = "vector_size"
kind = "attribute"
gcc_version = "3.1"
status = "unimplemented"
answer = "error"
used_by = ["ffmpeg", "openssl"]
tests = []

[[feature]]
name = "may_alias"
kind = "attribute"
gcc_version = "3.3"
status = "unimplemented"
answer = "error"
used_by = ["ffmpeg", "glibc"]
tests = []

[[feature]]
name = "designated_init"
kind = "attribute"
gcc_version = "5.1"
status = "unimplemented"
used_by = ["linux"]
tests = []

[[feature]]
name = "nocommon"
kind = "attribute"
gcc_version = "2.0"
status = "unimplemented"
used_by = ["glibc"]
tests = []

# The C23 standard attributes, which `__has_c_attribute` answers with the number the standard
# gives them rather than with 1.

[[feature]]
name = "deprecated"
kind = "c-attribute"
gcc_version = "10.0"
status = "unimplemented"
value = "201904"
used_by = []
tests = []

[[feature]]
name = "fallthrough"
kind = "c-attribute"
gcc_version = "10.0"
status = "unimplemented"
value = "201904"
used_by = []
tests = []

[[feature]]
name = "maybe_unused"
kind = "c-attribute"
gcc_version = "10.0"
status = "unimplemented"
value = "202106"
used_by = []
tests = []

[[feature]]
name = "nodiscard"
kind = "c-attribute"
gcc_version = "10.0"
status = "unimplemented"
value = "202003"
used_by = []
tests = []

[[feature]]
name = "noreturn"
kind = "c-attribute"
gcc_version = "13.0"
status = "unimplemented"
value = "202202"
used_by = []
tests = []

[[feature]]
name = "unsequenced"
kind = "c-attribute"
gcc_version = "13.0"
status = "unimplemented"
value = "202207"
used_by = []
tests = []

[[feature]]
name = "reproducible"
kind = "c-attribute"
gcc_version = "13.0"
status = "unimplemented"
value = "202207"
used_by = []
tests = []

# Builtins, from section 13.5. The list is the part of the several hundred that real code
# reaches for first, and it grows as the matrix fills in.

[[feature]]
name = "__builtin_constant_p"
kind = "builtin"
gcc_version = "2.0"
status = "unimplemented"
used_by = ["linux", "glibc", "systemd"]
tests = []
notes = "Its value depends on how much optimization has run, so it is an IR intrinsic that later passes fold rather than a frontend decision. The kernel's BUILD_BUG_ON depends on it folding after inlining."

[[feature]]
name = "__builtin_expect"
kind = "builtin"
gcc_version = "2.96"
status = "unimplemented"
signature = "long(long, long)"
used_by = ["linux", "glibc", "sqlite", "systemd", "curl"]
tests = []

[[feature]]
name = "__builtin_expect_with_probability"
kind = "builtin"
gcc_version = "9.0"
status = "unimplemented"
signature = "long(long, long, double)"
used_by = ["linux"]
tests = []

[[feature]]
name = "__builtin_unreachable"
kind = "builtin"
gcc_version = "4.5"
status = "unimplemented"
signature = "void(void)"
used_by = ["linux", "glibc", "ffmpeg"]
tests = []

[[feature]]
name = "__builtin_trap"
kind = "builtin"
gcc_version = "4.0"
status = "unimplemented"
signature = "void(void)"
used_by = ["linux"]
tests = []

[[feature]]
name = "__builtin_types_compatible_p"
kind = "builtin"
gcc_version = "3.1"
status = "unimplemented"
used_by = ["linux"]
tests = []

[[feature]]
name = "__builtin_choose_expr"
kind = "builtin"
gcc_version = "3.1"
status = "unimplemented"
used_by = ["linux"]
tests = []

[[feature]]
name = "__builtin_offsetof"
kind = "builtin"
gcc_version = "4.0"
status = "unimplemented"
used_by = ["linux", "glibc", "musl"]
tests = []

[[feature]]
name = "__builtin_classify_type"
kind = "builtin"
gcc_version = "2.0"
status = "unimplemented"
used_by = ["linux"]
tests = []

[[feature]]
name = "__builtin_add_overflow"
kind = "builtin"
gcc_version = "5.0"
status = "unimplemented"
used_by = ["linux", "systemd"]
tests = []

[[feature]]
name = "__builtin_sub_overflow"
kind = "builtin"
gcc_version = "5.0"
status = "unimplemented"
used_by = ["linux", "systemd"]
tests = []

[[feature]]
name = "__builtin_mul_overflow"
kind = "builtin"
gcc_version = "5.0"
status = "unimplemented"
used_by = ["linux", "systemd"]
tests = []

[[feature]]
name = "__builtin_clz"
kind = "builtin"
gcc_version = "3.4"
status = "unimplemented"
signature = "int(unsigned int)"
used_by = ["linux", "ffmpeg", "sqlite"]
tests = []

[[feature]]
name = "__builtin_ctz"
kind = "builtin"
gcc_version = "3.4"
status = "unimplemented"
signature = "int(unsigned int)"
used_by = ["linux", "ffmpeg"]
tests = []

[[feature]]
name = "__builtin_popcount"
kind = "builtin"
gcc_version = "3.4"
status = "unimplemented"
signature = "int(unsigned int)"
used_by = ["linux", "sqlite"]
tests = []

[[feature]]
name = "__builtin_parity"
kind = "builtin"
gcc_version = "3.4"
status = "unimplemented"
signature = "int(unsigned int)"
used_by = []
tests = []

[[feature]]
name = "__builtin_ffs"
kind = "builtin"
gcc_version = "2.0"
status = "unimplemented"
signature = "int(int)"
used_by = ["linux"]
tests = []

[[feature]]
name = "__builtin_bswap16"
kind = "builtin"
gcc_version = "4.8"
status = "unimplemented"
signature = "uint16_t(uint16_t)"
used_by = ["linux", "ffmpeg", "curl"]
tests = []

[[feature]]
name = "__builtin_bswap32"
kind = "builtin"
gcc_version = "4.3"
status = "unimplemented"
signature = "uint32_t(uint32_t)"
used_by = ["linux", "ffmpeg", "curl"]
tests = []

[[feature]]
name = "__builtin_bswap64"
kind = "builtin"
gcc_version = "4.3"
status = "unimplemented"
signature = "uint64_t(uint64_t)"
used_by = ["linux", "ffmpeg"]
tests = []

[[feature]]
name = "__builtin_object_size"
kind = "builtin"
gcc_version = "4.1"
status = "unimplemented"
signature = "size_t(const void *, int)"
used_by = ["glibc", "linux"]
tests = []
notes = "_FORTIFY_SOURCE is built on it, so glibc's headers stop working correctly without it."

[[feature]]
name = "__builtin_dynamic_object_size"
kind = "builtin"
gcc_version = "12.0"
status = "unimplemented"
signature = "size_t(const void *, int)"
used_by = ["glibc", "linux"]
tests = []

[[feature]]
name = "__builtin_assume_aligned"
kind = "builtin"
gcc_version = "4.7"
status = "unimplemented"
signature = "void *(const void *, size_t, ...)"
used_by = ["glibc", "ffmpeg"]
tests = []

[[feature]]
name = "__builtin_prefetch"
kind = "builtin"
gcc_version = "3.1"
status = "unimplemented"
signature = "void(const void *, ...)"
used_by = ["linux", "sqlite"]
tests = []

[[feature]]
name = "__builtin_return_address"
kind = "builtin"
gcc_version = "2.0"
status = "unimplemented"
signature = "void *(unsigned int)"
used_by = ["linux", "glibc"]
tests = []

[[feature]]
name = "__builtin_frame_address"
kind = "builtin"
gcc_version = "2.0"
status = "unimplemented"
signature = "void *(unsigned int)"
used_by = ["linux", "glibc"]
tests = []

[[feature]]
name = "__builtin_alloca"
kind = "builtin"
gcc_version = "2.0"
status = "unimplemented"
signature = "void *(size_t)"
used_by = ["glibc", "systemd"]
tests = []

[[feature]]
name = "__builtin_va_list"
kind = "builtin"
gcc_version = "2.0"
status = "implemented"
used_by = ["linux", "glibc", "musl", "sqlite"]
tests = ["rucc-target::va_list_is_the_psabis_type_and_not_one_type_with_four_spellings", "rucc-sema::the_rest_of_the_family_is_handed_the_address_of_the_list_and_answers_nothing"]
notes = "A keyword naming a target defined type rather than a builtin function. gcc declares it as a typedef that is always in scope, which is the same type reached another way. Which type it is is the psABI's answer: an array of one structure on SysV, a structure on AAPCS, and a pointer everywhere else."

[[feature]]
name = "__builtin_va_start"
kind = "builtin"
gcc_version = "2.0"
status = "implemented"
used_by = ["linux", "glibc", "musl", "sqlite"]
tests = ["rucc-sema::va_start_wants_a_variadic_function_and_the_parameter_the_named_ones_stopped_at", "rucc-parse::the_variable_argument_family_is_syntax_and_not_four_calls"]
notes = "The second argument is required, as it is in gcc: C23 made it optional in the `va_start` macro and the macro passes a zero for it. It is checked against the last named parameter and then dropped, since it is not evaluated."

[[feature]]
name = "__builtin_va_arg"
kind = "builtin"
gcc_version = "2.0"
status = "implemented"
used_by = ["linux", "glibc", "musl", "sqlite"]
tests = ["rucc-sema::va_arg_has_the_type_it_was_asked_for_and_warns_where_it_could_not_be_passed", "rucc-sema::va_arg_refuses_a_list_that_is_not_one_and_a_type_with_no_size"]
notes = "An intrinsic down to the machine, because what it becomes is the psABI's answer. A structure or a union is not read yet."

[[feature]]
name = "__builtin_va_end"
kind = "builtin"
gcc_version = "2.0"
status = "implemented"
used_by = ["linux", "glibc", "musl", "sqlite"]
tests = ["rucc-sema::the_rest_of_the_family_is_handed_the_address_of_the_list_and_answers_nothing", "rucc-parse::the_variable_argument_family_is_syntax_and_not_four_calls"]
notes = "Nothing at all on every psABI here, and still emitted, since it is what says the list stops being read."

[[feature]]
name = "__builtin_va_copy"
kind = "builtin"
gcc_version = "3.0"
status = "implemented"
used_by = ["glibc", "musl", "curl"]
tests = ["rucc-sema::the_rest_of_the_family_is_handed_the_address_of_the_list_and_answers_nothing", "rucc-parse::the_variable_argument_family_is_syntax_and_not_four_calls"]

[[feature]]
name = "__builtin_memcpy"
kind = "builtin"
gcc_version = "2.0"
status = "unimplemented"
signature = "void *(void *, const void *, size_t)"
used_by = ["linux", "glibc"]
tests = []

[[feature]]
name = "__builtin_memset"
kind = "builtin"
gcc_version = "2.0"
status = "unimplemented"
signature = "void *(void *, int, size_t)"
used_by = ["linux", "glibc"]
tests = []

[[feature]]
name = "__builtin_strlen"
kind = "builtin"
gcc_version = "2.0"
status = "unimplemented"
signature = "size_t(const char *)"
used_by = ["glibc", "systemd"]
tests = []

[[feature]]
name = "__builtin_clzl"
kind = "builtin"
gcc_version = "3.4"
status = "unimplemented"
signature = "int(unsigned long)"
used_by = ["linux", "ffmpeg", "sqlite"]
tests = []

[[feature]]
name = "__builtin_clzll"
kind = "builtin"
gcc_version = "3.4"
status = "unimplemented"
signature = "int(unsigned long long)"
used_by = ["linux", "ffmpeg", "sqlite"]
tests = []

[[feature]]
name = "__builtin_ctzl"
kind = "builtin"
gcc_version = "3.4"
status = "unimplemented"
signature = "int(unsigned long)"
used_by = ["linux", "ffmpeg"]
tests = []

[[feature]]
name = "__builtin_ctzll"
kind = "builtin"
gcc_version = "3.4"
status = "unimplemented"
signature = "int(unsigned long long)"
used_by = ["linux", "ffmpeg"]
tests = []

[[feature]]
name = "__builtin_popcountl"
kind = "builtin"
gcc_version = "3.4"
status = "unimplemented"
signature = "int(unsigned long)"
used_by = ["linux", "sqlite"]
tests = []

[[feature]]
name = "__builtin_popcountll"
kind = "builtin"
gcc_version = "3.4"
status = "unimplemented"
signature = "int(unsigned long long)"
used_by = ["linux", "sqlite"]
tests = []

[[feature]]
name = "__builtin_parityl"
kind = "builtin"
gcc_version = "3.4"
status = "unimplemented"
signature = "int(unsigned long)"
used_by = []
tests = []

[[feature]]
name = "__builtin_parityll"
kind = "builtin"
gcc_version = "3.4"
status = "unimplemented"
signature = "int(unsigned long long)"
used_by = []
tests = []

[[feature]]
name = "__builtin_ffsl"
kind = "builtin"
gcc_version = "2.0"
status = "unimplemented"
signature = "int(long)"
used_by = ["linux"]
tests = []

[[feature]]
name = "__builtin_ffsll"
kind = "builtin"
gcc_version = "4.3"
status = "unimplemented"
signature = "int(long long)"
used_by = ["linux"]
tests = []

[[feature]]
name = "__builtin_fabs"
kind = "builtin"
gcc_version = "2.0"
status = "unimplemented"
signature = "double(double)"
used_by = ["sqlite", "ffmpeg", "glibc"]
tests = []
notes = "Apple's math.h writes every isinf and isfinite over it, so no program on that platform includes math.h without needing it."

[[feature]]
name = "__builtin_fabsf"
kind = "builtin"
gcc_version = "2.0"
status = "unimplemented"
signature = "float(float)"
used_by = ["sqlite", "ffmpeg", "glibc"]
tests = []

[[feature]]
name = "__builtin_fabsl"
kind = "builtin"
gcc_version = "2.0"
status = "unimplemented"
signature = "long double(long double)"
used_by = ["sqlite", "ffmpeg", "glibc"]
tests = []

[[feature]]
name = "__builtin_inf"
kind = "builtin"
gcc_version = "2.0"
status = "unimplemented"
signature = "double(void)"
used_by = ["sqlite", "glibc"]
tests = []

[[feature]]
name = "__builtin_inff"
kind = "builtin"
gcc_version = "2.0"
status = "unimplemented"
signature = "float(void)"
used_by = ["sqlite", "glibc"]
tests = []

[[feature]]
name = "__builtin_infl"
kind = "builtin"
gcc_version = "2.0"
status = "unimplemented"
signature = "long double(void)"
used_by = ["sqlite", "glibc"]
tests = []

[[feature]]
name = "__builtin_huge_val"
kind = "builtin"
gcc_version = "2.0"
status = "unimplemented"
signature = "double(void)"
used_by = ["sqlite", "glibc"]
tests = []

[[feature]]
name = "__builtin_huge_valf"
kind = "builtin"
gcc_version = "2.0"
status = "unimplemented"
signature = "float(void)"
used_by = ["sqlite", "glibc"]
tests = []

[[feature]]
name = "__builtin_huge_vall"
kind = "builtin"
gcc_version = "2.0"
status = "unimplemented"
signature = "long double(void)"
used_by = ["sqlite", "glibc"]
tests = []

[[feature]]
name = "__builtin_nan"
kind = "builtin"
gcc_version = "2.0"
status = "unimplemented"
signature = "double(const char *)"
used_by = ["glibc"]
tests = []

[[feature]]
name = "__builtin_nanf"
kind = "builtin"
gcc_version = "2.0"
status = "unimplemented"
signature = "float(const char *)"
used_by = ["glibc"]
tests = []

[[feature]]
name = "__builtin_nanl"
kind = "builtin"
gcc_version = "2.0"
status = "unimplemented"
signature = "long double(const char *)"
used_by = ["glibc"]
tests = []

[[feature]]
name = "__atomic_load_n"
kind = "builtin"
gcc_version = "4.7"
status = "unimplemented"
used_by = ["linux", "glibc", "openssl"]
tests = []

[[feature]]
name = "__atomic_store_n"
kind = "builtin"
gcc_version = "4.7"
status = "unimplemented"
used_by = ["linux", "glibc", "openssl"]
tests = []

[[feature]]
name = "__atomic_compare_exchange_n"
kind = "builtin"
gcc_version = "4.7"
status = "unimplemented"
used_by = ["linux", "glibc", "openssl"]
tests = []

[[feature]]
name = "__atomic_fetch_add"
kind = "builtin"
gcc_version = "4.7"
status = "unimplemented"
used_by = ["linux", "glibc"]
tests = []

[[feature]]
name = "__atomic_thread_fence"
kind = "builtin"
gcc_version = "4.7"
status = "unimplemented"
used_by = ["linux", "glibc"]
tests = []

[[feature]]
name = "__sync_synchronize"
kind = "builtin"
gcc_version = "4.1"
status = "unimplemented"
signature = "void(void)"
used_by = ["linux", "sqlite"]
tests = []
notes = "The one member of the __sync family that is not type generic, which is why it is the one with a signature here."

[[feature]]
name = "__sync_fetch_and_add"
kind = "builtin"
gcc_version = "4.1"
status = "unimplemented"
used_by = ["linux", "sqlite"]
tests = []

[[feature]]
name = "__sync_bool_compare_and_swap"
kind = "builtin"
gcc_version = "4.1"
status = "unimplemented"
used_by = ["linux", "sqlite"]
tests = []