Clang and GCC behave inconsistently on constant parameters

[huhu233]

#include <stdarg.h>
//#define va_arg(v, l) __builtin_va_arg(v, l)

void test(const va_list *a)
{
  va_arg(*a, unsigned long);
}

LLVM failed, as shown
https://godbolt.org/z/GTo7zfabM

<source>:6:3: error: read-only variable is not assignable
    6 |   va_arg(*a, unsigned long);
      |   ^      ~~
/opt/compiler-explorer/clang-trunk-20241008/lib/clang/20/include/__stdarg_va_arg.h:20:26: note: expanded from macro 'va_arg'
   20 | #define va_arg(ap, type) __builtin_va_arg(ap, type)
      |                          ^                ~~
1 error generated.
Compiler returned: 1

GCC pass,
https://godbolt.org/z/Mr5WE5jf7

[llvmbot]

@llvm/issue-subscribers-clang-frontend

Author: None (huhu233)

``` #include <stdarg.h> //#define va_arg(v, l) __builtin_va_arg(v, l)

void test(const va_list *a)
{
va_arg(*a, unsigned long);
}

LLVM failed, as shown
https://godbolt.org/z/GTo7zfabM
![image](https://github.com/user-attachments/assets/e5ca7057-81c0-4296-af3b-dbde43fa404e)



GCC pass,
https://godbolt.org/z/Mr5WE5jf7

</details>

[shafik]

Note it is not neccesary to include an image for console output, we can use ```console blocks instead.

[shafik]

Note sure why this fail but trying in C++ gives us more interesting diagnostics: https://godbolt.org/z/xdb1EKhPK maybe this is an oversight in how the builtin in designed.

CC @AaronBallman

[zygoloid]

va_arg must mutate the va_list -- it advances the internal state to point to the next argument -- so it doesn't seem correct to call it on a const va_list lvalue. Whether the C standard actually disallows this is less clear to me -- it says that the va_arg macro takes an argument of type va_list, but in Clang and GCC, va_list is an array type, so an argument of type const va_list (that is, const __va_list_tag *) is not compatible with a parameter of type va_list (that is, __va_list_tag *) at least in C++.

[AaronBallman]

Hmm, but isn't this notionally equivalent to:

typedef int foo[];
void other_test(const foo *a) {
  extern void f(foo);
  f(*a);
}

which yields warning: passing 'const foo' (aka 'const int[]') to parameter of type 'int *' discards qualifiers [-Wincompatible-pointer-types-discards-qualifiers] in C?

[zygoloid]

Yeah, it's possible that this should be an error in C++ and should implicitly discard the qualifier with a warning in C.