Re: VLA/VM [*] bug fixes for C

["Joseph S. Myers" <joseph at codesourcery dot com>]

On Sat, 6 May 2006, Mike Stump wrote:

> I'll entertain pointers to VLA/VM and [*] bugs for C, please send me pointers
> to reports in bugzilla.
> 
> Thanks.
> 
> I know about http://gcc.gnu.org/PR25802

Bugs 19771, 7948, 18740 (in general, look at the bugs on which bug 16989 
depends).  The question of when exactly an array size expression is 
evaluated requires careful thought and design to ensure it is always done 
at the right time, the other issues should be easier to resolve.

> I also would like to know what people think the standard (c99) says about:
> 
> void foo4(int o[*][4]) { }
> void foo5(int o[4][*]) { }

Invalid.

> void foo6(int (*o)(int p[*])) { }

Valid.

Function prototype scope is defined in 6.2.1#4.


More examples:

void foo(int a, int b[*][*], int c[static sizeof(*b)]);

is valid code, though what size is relevant for the [static] is more 
obscure.  sizeof a [*] array returns an indeterminate nonconstant value of 
type size_t, which can be used in expressions just like other values of 
type size_t.

void foo(int x[sizeof(int (*)[*])]);

should probably be considered invalid, as should

void foo(int [*]);

([*] being used in a type that's not a declaration).  (I'm not aware of 
anything to contradict Nick Maclaren's interpretation 
<http://groups.google.com/group/comp.std.c/msg/b01f49f6c9c0039a> here.)

The example I gave in WG14 reflector message 10731 ought probably to be 
invalid or at least undefined behavior at runtime - the latter is probably 
the best interpretation for now, since I haven't written or submitted a DR 
for that case.  To quote my message:

Consider the code

	int a, b, c, d, e, f;
	void *p1(void), *p2(void), *p3(void);
	int c1(void), c2(void);
	int d1(void), d2(void), d3(void);
	int z1(void), z2(void), z3(void);

	int
	h(void)
	{
	  int r = (c1()
	           ? (z1(), (int (*(*(*)[d1()])[])[])p1())
	           : (c2()
	              ? (z2(), (int (*(*(*)[])[d2()])[])p2())
	              : (z3(), (int (*(*(*)[])[])[d3()])p3())
	             )
	          )[a][b][c][d][e][f];
	  return r;
	}

	The outer conditional expression has a type which may informally be 
	described as "pointer to arrays [d1()] of pointers to arrays [d2()] of 
	pointers to arrays [d3()] of ints", by the composite type rules applied to 
	conditional expressions.  But when the expression is executed, all three 
	dimensions are needed to evaluate the [a][b][c][d][e][f] array reference, 
	but only one of the dimensions appears in an expression which should be 
	evaluated according to the rules for evaluation of conditional 
	expressions.  Furthermore, the return value of d2() may depend on the 
	prior calls to c2() and z2() in that part of the conditional expression, 
	so if c1() returns nonzero it might not suffice simply to evaluate d2() 
	and d3() as well as d1(); c2(), z2() and z3() would also need to be 
	evaluated.

	Which functions should be called when in the evaluation of the above 
	expression?  Or, should such constructs be disallowed and how would we 
	define what the invalid constructs are?

	(Much the same issue arises with compound literals of VM type as does with 
	casts to VM type.)

See also my DRs 311, 312, 313 (which deal with rather simpler cases).  
There's also a pre-DR I haven't submitted to WG14, 
<http://www.srcf.ucam.org/~jsm28/gcc/pre-dr-14.txt>.

-- 
Joseph S. Myers               http://www.srcf.ucam.org/~jsm28/gcc/
    jsm@polyomino.org.uk (personal mail)
    joseph@codesourcery.com (CodeSourcery mail)
    jsm28@gcc.gnu.org (Bugzilla assignments and CCs)