[Bug c++/11078] [ABI] ICE in write_type with typeof and templates

["gdr at integrable-solutions dot net" <gcc-bugzilla at gcc dot gnu dot org>]

------- Additional Comments From gdr at integrable-solutions dot net  2004-08-10 01:35 -------
Subject: Re:  [ABI] ICE in write_type with typeof and templates

"giovannibajo at libero dot it" <gcc-bugzilla@gcc.gnu.org> writes:

| Subject: Re:  [ABI] ICE in write_type with typeof and templates
| 
| gdr at integrable-solutions dot net wrote:
| 
| >> buy us anything. Plus, I don't think we want to say that the
| >> following declarations are declaring two different functions:
| >>
| >> void foo(typeof(int*));
| >> void foo(int*);
| >>
| >> or these:
| >>
| >> void bar(typeof(typeof(char*) [4]) blah);
| >> void bar(char *blah[4]);
| >
| > As I said before, the problem is inexistent for ordinary functions
| > because we don't care about the retun type of those.
| > The issue is with function templates, and there we do care.
| > So I don't believe in arguments based on ordinary functions to strip
| > out typeof.
| 
| I am not speaking of return types (only) here. I am speaking of the mangling of
| typeof(<type>), wherever it appears in a mangled part of a function signature.

The issue is of interest only for function templates.  For
non-templates, it is moot.  It is moot for non-templates because we
always use the normal form of their signatures.  
For templates, we use their token streams, where the problem come to
interest. 

| Anyway, in case I am missing something, the same argument can be brought for
| template functions. I suggest we mangle each element in the following couple
| (or better -- each instantiation with the same set of arguments) with the same
| name:
| 
| template <int> void foo(typeof(int*));
| template <int> void foo(int*);
| 
| template <class T> void foo(typeof(typeof(T*)[4]) blah);
| template <class T> void foo(T *blah[4]);

These two declarations are not equivalent, as the template parameter
in the first declaration appears in non-deducible context whereas it
is deducible in the second.  If they are not equivalent, you cannot
decide that they will mangle the same, for the very same reasons I
outlined before.  And it is very easy to construct examples where you
screw up things, just like in my previous messages.  If you insist in
mangling them the same, there are modifications to the current
semantics you ought to make before getting to that point. 
Also notice that currently, we have no problem mangling the above.

[...]

| My conclusion is the same as before:
| 
| >> In other words, we can easily strip typeof(type) while mangling, and
| >> encoding typeof(expr) as Y <expression> E.


In the current state of affairs, that would be an ill-informed thing
to do.  And I would strongly advise against.

-- Gaby


-- 


http://gcc.gnu.org/bugzilla/show_bug.cgi?id=11078