Evaluation of VM-typed expression operand to `typeof`

[fuhsnn]

With the test:

#include <stdio.h>

#define TEST(_arrsz, ...)                                                      \
  do {                                                                         \
    int (*p)[_arrsz];                                                          \
    p = (void *)0;                                                             \
    do {                                                                       \
      __VA_ARGS__                                                              \
    } while (0);                                                               \
    printf("ptr: int(*p)[%s], statmemt: { %s }, operand evaluated : %d\n",     \
           #_arrsz, #__VA_ARGS__, (p != (void *)0));                           \
  } while (0)

#define TEST2(...)                                                             \
  TEST(3, __VA_ARGS__);                                                        \
  TEST(i, __VA_ARGS__)

void fn(int i) {
  TEST2(__typeof__(*p++) var;);
  //  TEST2(typeof(*p++) var;);
  TEST2(sizeof(*p++););
  TEST2(_Alignof(*p++););
  //  TEST2( _Countof(*p++);   );
}

int main(void) { fn(3); }

GCC/Clang

ptr: int(*p)[3], statmemt: { __typeof__(*p++) var; }, operand evaluated : 0
ptr: int(*p)[i], statmemt: { __typeof__(*p++) var; }, operand evaluated : 1
ptr: int(*p)[3], statmemt: { sizeof(*p++); }, operand evaluated : 0
ptr: int(*p)[i], statmemt: { sizeof(*p++); }, operand evaluated : 1
ptr: int(*p)[3], statmemt: { _Alignof(*p++); }, operand evaluated : 0
ptr: int(*p)[i], statmemt: { _Alignof(*p++); }, operand evaluated : 0
ptr: int(*p)[3], statmemt: { _Countof(*p++); }, operand evaluated : 0
ptr: int(*p)[i], statmemt: { _Countof(*p++); }, operand evaluated : 1

icc:

ptr: int(*p)[3], statmemt: { __typeof__(*p++) var; }, operand evaluated : 0
ptr: int(*p)[i], statmemt: { __typeof__(*p++) var; }, operand evaluated : 0
ptr: int(*p)[3], statmemt: { sizeof(*p++); }, operand evaluated : 0
ptr: int(*p)[i], statmemt: { sizeof(*p++); }, operand evaluated : 1
ptr: int(*p)[3], statmemt: { _Alignof(*p++); }, operand evaluated : 0
ptr: int(*p)[i], statmemt: { _Alignof(*p++); }, operand evaluated : 0

Pelles C

ptr: int(*p)[3], statmemt: { __typeof__(*p++) var; }, operand evaluated : 0
ptr: int(*p)[i], statmemt: { __typeof__(*p++) var; }, operand evaluated : 0
ptr: int(*p)[3], statmemt: { sizeof(*p++); }, operand evaluated : 0
ptr: int(*p)[i], statmemt: { sizeof(*p++); }, operand evaluated : 0

DigitalMars C

ptr: int(*p)[3], statmemt: { sizeof(*p++); }, operand evaluated : 0
ptr: int(*p)[i], statmemt: { sizeof(*p++); }, operand evaluated : 0

TinyCC,cproc,kefir,chibicc,xcc:

ptr: int(*p)[3], statmemt: { __typeof__(*p++) var; }, operand evaluated : 0
ptr: int(*p)[i], statmemt: { __typeof__(*p++) var; }, operand evaluated : 0
ptr: int(*p)[3], statmemt: { sizeof(*p++); }, operand evaluated : 0
ptr: int(*p)[i], statmemt: { sizeof(*p++); }, operand evaluated : 0
ptr: int(*p)[3], statmemt: { _Alignof(*p++); }, operand evaluated : 0
ptr: int(*p)[i], statmemt: { _Alignof(*p++); }, operand evaluated : 0

[fuhsnn]

More weird stuff: https://godbolt.org/z/ff4TKaTxM
Basically, you can trick typeof into executing anything by wrapping it inside a VM pointer type.

#include <stdio.h>

void fn1(int i) {
  /* expression wrapped behind cast re-evaluated 
    every time a new variable is declared */
  typeof((typeof(int[i++])*)(puts("repeat 1"),(void*)0)) 
    v1 = (puts("foo"), (void*)0),
    v2 = (puts("bar"), (void*)0),
    v3 = (puts("baz"), (void*)0);

  /* but the actual variably-modified part of the
    type, array size "i++", is only evaluated once */
  printf("i = %d\n", i);
  printf("i = %d\n", (int)(sizeof(*v1) / sizeof(int)));
  printf("i = %d\n", (int)(sizeof(*v2) / sizeof(int)));
  printf("i = %d\n", (int)(sizeof(*v3) / sizeof(int)));
}

void fn2(int i) {
  /* statically initialized pointer, but its 
    type expression is re-evaluated every time
    execution passes by */
  static typeof((typeof(int[i])*)(puts("repeat 2"),(void*)0)) p2;
  
  printf("adr %lld\n", (long long)&p2);
  if (i)
    fn2(i-1);
}

void fn3(int i) {
    int i1 = 0;
    _Atomic volatile int i2 = 0;

    typeof((typeof(int[i++])*)(
        i1++,
        i2++,
        // ({ goto LABEL; LABEL:; 0;}), // Clang crashes on this line
        // ({ for (int i = 0; i < 1; i++); }), // GCC crashes on this line
        ({ printf("only repeat with "); puts("clang"); }),
        ({ for (int i = 0; i < 1; i++) puts("not repeated"); 0;}),
        puts("repeat 3"),
        (void*)0))
        x = (void*)0, 
        y = (void*)0,
        z = (void*)0;

    /* GCC only increments i2 once, it being
      "atomic volatile" seems to have opposite effect */
    printf("i1 inc: %d\n", i1);
    printf("i2 inc: %d\n", i2);
}

int main() {
    fn1(5);
    fn2(3);
    fn3(1);
}

[fuhsnn]

The behavior has been implemented for sizeof and _Countof: cf08c3d.

I'm going to put typeof on hold until a well established codebase is shown to rely on this pattern with justified reason. Not only the "re-execute on declaration site" behavior illustrated above isn't like anything else in C, irregular behaviors from both GCC/Clang in fn3() also hint at it not being an intended/supported/actively-used pattern at all.

So slimcc's current behavior in terms of the op test is:

ptr: int(*p)[3], statmemt: { typeof(*p++) var; }, operand evaluated : 0
ptr: int(*p)[i], statmemt: { typeof(*p++) var; }, operand evaluated : 0
ptr: int(*p)[3], statmemt: { sizeof(*p++); }, operand evaluated : 0
ptr: int(*p)[i], statmemt: { sizeof(*p++); }, operand evaluated : 1
ptr: int(*p)[3], statmemt: { _Alignof(*p++); }, operand evaluated : 0
ptr: int(*p)[i], statmemt: { _Alignof(*p++); }, operand evaluated : 0
ptr: int(*p)[3], statmemt: { _Countof(*p++); }, operand evaluated : 0
ptr: int(*p)[i], statmemt: { _Countof(*p++); }, operand evaluated : 1

[fuhsnn]

8fb03d6
Added a check to report unsupported status for typeof, also reverted the support for sizeof/_Countof because I found conditional operators are now supposed to provide run-time type selection for VLA pointers. This obsession over what essentially is RTTI via VLA types is sucking away my enthusiasm for modern C.