Re: c/3711: ICE in instantiate_virtual_regs_1, at function.c:3880

[Nicola Pero]

>  > 
> http://gcc.gnu.org/cgi-bin/gnatsweb.pl?cmd=view%20audit-trail&database=gcc&pr=3711
> 
> Incidentally, I believe this test case to be in error.  The type of the 
> argument in the caller and the callee is different.  In particular, the 
> size of the argument is static in the caller and variable in the callee. 
>  Whether or not an argument has variable size affects calling 
> conventions, and thus affects how the callee should find the argument in 
> varargs.
> 
> A correct test case would have the caller have a variable sized 
> structure as well.

Hmmm ... well this testcase arrives from a real example ... forwarding
code in some advanced OO stuff which worked perfectly well with all GCC
releases up to now (code from mframe.m in gnustep-base).

If that is wrong, other code is wrong ... and well variable size structs
are much less useful ... are you meaning that if I have

int size = 255;

struct
{
  char text[size];
} SMSmessage;

then I can't pass the SMSmessage to a function accepting a struct {char
text[255]; } as argument ?

So I can use SMSmessages in place of a struct {char text[255];} everywhere
I want, but I can't pass it in place of a struct {char text[255];} to a
function ?

This is very confusing for users I must say.  And it is not how it worked
in previous versions of the compiler.

Anyway - if that does not longer work on GCC 3.1, at least let me know how
do we make our code to work with GCC 3.1.

I think you understood what the function in the testcase "wants/needs" to
do - which is that it can be called with an arbitrary struct (fixed size)
as the second argument, and it is informed of the size of the struct from
the first argument (which is just to say, a source providing the info at
runtime), and it needs to be able to access the bytes in the struct.

This is needed to implement proper forwarding of methods when there are
structs.

I guess there might be other problems then - here is an excerpt of code
needing to return a struct of a certain (fixed) size, which is only known
when the function is called -

    case _C_ARY_B:
    case _C_STRUCT_B:
    case _C_UNION_B:
      {
        typedef struct {
          char  val[size];
        } block;
        inline block retframe_block(void *rframe)
        {
          __builtin_return (rframe);
        }
        *(block*)buffer = retframe_block(retframe);
        break;
      }

This works with GCC < 3.1.  If what you say is true, this will no longer
work with GCC 3.1, because 'block' is a variable size struct, and can't
replace a fixed size struct as the return type.

So - question - since this stuff which worked fine on all previous
compilers no longer works, and you say the code is broken - ok then how do
we fix the code ?