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

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

[pinskia at gcc dot gnu dot org]

------- Comment #25 from pinskia at gcc dot gnu dot org  2005-12-23 15:52 -------
*** Bug 25544 has been marked as a duplicate of this bug. ***


-- 


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

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

[pinskia at gcc dot gnu dot org]

------- Comment #26 from pinskia at gcc dot gnu dot org  2007-05-12 14:44 -------
*** Bug 31905 has been marked as a duplicate of this bug. ***


-- 

pinskia at gcc dot gnu dot org changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
                 CC|                            |blaisorblade_spam at yahoo
                   |                            |dot it


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

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

[blaisorblade_spam at yahoo dot it]

------- Comment #27 from blaisorblade_spam at yahoo dot it  2007-05-15 02:36 -------
What about actually doing as suggested comment #8? I.e. adding a nice error
message rather than an ICE?


-- 


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

[Bug c++/11078] [ABI] decltype(T()) doesn't work

[jason at gcc dot gnu dot org]

------- Comment #28 from jason at gcc dot gnu dot org  2007-10-03 23:54 -------
Changing the testcase to use decltype instead of typeof produces this error
with current sources:

wa.C:2: sorry, unimplemented: zero-operand casts cannot be mangled due to a
defect in the C++ ABI

Now that we have decltype, I think we don't need to worry about mangling
typeof.  I'm just going to add a sorry to suggest that people use decltype
instead.


-- 

jason at gcc dot gnu dot org changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
                 CC|                            |doug dot gregor at gmail dot
                   |                            |com
           Keywords|ice-on-valid-code           |rejects-valid
            Summary|[ABI] ICE in write_type with|[ABI] decltype(T()) doesn't
                   |typeof and templates        |work


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

[Bug c++/11078] [ABI] decltype(T()) doesn't work

[aldot at gcc dot gnu dot org]

[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #1: Type: text/plain, Size: 875 bytes --]



------- Comment #29 from aldot at gcc dot gnu dot org  2008-08-19 13:43 -------
4.3.1 and later give:

GNU C++ (Debian 4.3.1-8) version 4.3.1 (i486-linux-gnu)
        compiled by GNU C version 4.3.1, GMP version 4.2.2, MPFR version 2.3.1.
GGC heuristics: --param ggc-min-expand=100 --param ggc-min-heapsize=131072
Compiler executable checksum: 1a96b3b5ffa5cfd9037de3acec5e6692
known.C: In instantiation of ‘__typeof__ ((T1() + T2())) add(T1, T2) [with T1 =
double, T2 = char]’:
known.C:3:   instantiated from here
known.C:2: sorry, unimplemented: mangling typeof, use decltype instead


-- 

aldot at gcc dot gnu dot org changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
      Known to work|                            |4.3.1


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

[Bug c++/11078] [ABI] decltype(T()) doesn't work

[paolo dot carlini at oracle dot com]

------- Comment #30 from paolo dot carlini at oracle dot com  2008-08-19 17:52 -------
Yes, this can be considered fixed.


-- 

paolo dot carlini at oracle dot com changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
             Status|ASSIGNED                    |RESOLVED
         Resolution|                            |FIXED


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

[Bug c++/11078] New: typeof and templates.... internal compiler error

[jtotland1@chello.no]

PLEASE REPLY TO gcc-bugzilla@gcc.gnu.org ONLY, *NOT* gcc-bugs@gcc.gnu.org.

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

           Summary: typeof and templates.... internal compiler error
           Product: gcc
           Version: 3.3
            Status: UNCONFIRMED
          Severity: normal
          Priority: P2
         Component: c++
        AssignedTo: unassigned@gcc.gnu.org
        ReportedBy: jtotland1@chello.no
                CC: gcc-bugs@gcc.gnu.org

Tested on debian, with gcc 3.0, 3,2 and 3.3

Here is a short snippet that reproduces the error:

template <class T1, class T2>
typeof(T1() + T2()) add(T1 a, T2 b) { return a+b; }
static double foo = add(3.1, 'c');



------- You are receiving this mail because: -------
You are on the CC list for the bug, or are watching someone who is.

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

[giovannibajo at libero dot it]

------- Additional Comments From giovannibajo at libero dot it  2004-07-31 01:18 -------
The segfault should just be a sorry(): we don't currently have a way to mangle 
this in the C++ ABI.

-- 
           What    |Removed                     |Added
----------------------------------------------------------------------------
         AssignedTo|unassigned at gcc dot gnu   |giovannibajo at libero dot
                   |dot org                     |it
             Status|NEW                         |ASSIGNED
            Summary|ICE in write_type with      |[ABI] ICE in write_type with
                   |typeof and templates        |typeof and templates


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

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

[giovannibajo at libero dot it]

------- Additional Comments From giovannibajo at libero dot it  2004-07-31 10:26 -------
Ian, what do you suggest here? It might make sense to mangle it as "v17typeofe" 
and "v17typeoft" (we need different mangling for the expression vs type case of 
course). I'm sure there won't be an official ABI mangling of "typeof", 
especially if the C++ committee is going to use "auto" and "decltype", so we 
could probably go ahead and use the vendor extension.

-- 


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

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

[gdr at integrable-solutions dot net]

------- Additional Comments From gdr at integrable-solutions dot net  2004-07-31 17:33 -------
Subject: Re:  [ABI] ICE in write_type with typeof and templates

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

| Ian, what do you suggest here? It might make sense to mangle it as "v17typeofe" 
| and "v17typeoft" (we need different mangling for the expression vs type case of 
| course). I'm sure there won't be an official ABI mangling of "typeof", 
| especially if the C++ committee is going to use "auto" and "decltype", so we 
| could probably go ahead and use the vendor extension.

Even if/when the C++ standards committee decides on decltype, we still
need something for typeof or similar operator.

-- Gaby


-- 


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

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

[ian at wasabisystems dot com]

------- Additional Comments From ian at wasabisystems dot com  2004-08-03 20:57 -------
It would be nice to be able to use something as simple as v16typeof, or
v17typeofe/v17typeoft, but it is not.  The problem is that typeof can introduce
expressions in cases where the mangling ABI does not permit them.  Consider the
test case in this PR:

template <class T1, class T2>
typeof(T1() + T2()) add(T1 a, T2 b) { return a+b; }
static double foo = add(3.1, 'c');

When mangling add<double, char>(double, char), we need to mangle the return
type.  The mangling ABI requires this to be a <type>.  If we are going to mangle
this using typeof, then we need to be able to use an <expression> in a <type>. 
But the mangling ABI does not provide any mechanism for that.

However, I note that we don't actually have to use typeof when mangling this
name.  When the compiler sees the template arguments, it can always resolve the
typeof down to a basic type.  Would it be reasonable to address the issue in
that way?

In fact, in general the compiler can resolve typeof.  In what cases will it not
be able to?

If there a case in which the compiler can not resolve typeof, I think we should
use the vendor extended operator syntax.  Separating typeoft and typeofe doesn't
actually work, because the parameter to typeof may itself be an expression
involving types.  What we need is a way to express a <type> as an
<expr-primary>.  Since typeof only cares about the types of its arguments, I
think we can get away with representing a type using the existing L <type>
<value> E syntax, and always using the value "0".

But I think we need some examples.  My current guess is that the example in this
PR should not require us to mangle typeof.  Any thoughts on this?

If it does require us to mangle typeof, then we need to decide how to express
typeof in a <type>, which will require an ABI extension.

-- 


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

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

[boris at kolpackov dot net]

------- Additional Comments From boris at kolpackov dot net  2004-08-03 21:27 -------
Subject: Re:  [ABI] ICE in write_type with typeof and templates

ian at wasabisystems dot com <gcc-bugzilla@gcc.gnu.org> writes:

> In fact, in general the compiler can resolve typeof.  
> In what cases will it not be able to?

The only thing I can think of is code like this:

struct
{
} a;

static void
fa (typeof (a)&)
{
}

struct
{
} b;

static void
fb (typeof (b)&)
{
}


void
f ()
{
  fa (a);
  fb (b);
}


It compiles with g++ 3.4.1. nm shows the following:

0000000c T f()
00000000 t fa(._0&)
00000006 t fb(._1&)
00000000 B a
00000001 B b

Which suggest that gcc assigns internal names even to anonymous
types. So I think it's true that any typeof-expression can be 
reduced to a type-name.



-- 


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

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

[bangerth at dealii dot org]

------- Additional Comments From bangerth at dealii dot org  2004-08-03 21:40 -------
Fortunately, the example in comment #12 just became illegal on mainline. 
We now get this: 
x.cc:3: error: non-local variable `<anonymous struct> a' uses anonymous type 
x.cc:12: error: non-local variable `<anonymous struct> b' uses anonymous type 
 
That's good, because I can think of all kinds of unpleasant surprises if 
you declare such variables in header files, where they may get different 
internal names dependending on the translation units that includes them. 
If such names are taken over into mangled names, this is asking for big 
trouble. 
 
W. 

-- 


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

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

[giovannibajo at libero dot it]

------- Additional Comments From giovannibajo at libero dot it  2004-08-09 02:40 -------
Subject: Re:  [ABI] ICE in write_type with typeof and templates

ian at wasabisystems dot com wrote:

> The problem is that typeof can introduce expressions in cases where the
> mangling ABI does not permit them.

> template <class T1, class T2>
> typeof(T1() + T2()) add(T1 a, T2 b) { return a+b; }
> static double foo = add(3.1, 'c');
>
> When mangling add<double, char>(double, char), we need to mangle the
> return  type.  The mangling ABI requires this to be a <type>.  If we are
> going to mangle this using typeof, then we need to be able to use
> an <expression> in a <type>.
> But the mangling ABI does not provide any mechanism for that.

OK, there is no way to use it *directly*, but that would not make sense.
Instead, there are already <expression> nested within <type>, through the
IX<expression>E production.
I see the problem though. Something like this would suffice:

<type> ::= <typeof-type>
<typeof-type> ::= Y <expression> E

but this is a real ABI extension. Do we want this? I definitely *do* want it,
much better than an ICE or erroring out.
Using the built-in extension "u6typeof" does seem worse in the longer run since
it's clearly an abuse of it.

> However, I note that we don't actually have to use typeof when
> mangling this name.  When the compiler sees the template arguments,
> it can always resolve the typeof down to a basic type.
> Would it be reasonable to address the issue in that way?

No. There are many expressions that *could* be folded and simplified while
mangling the name (within a template argument), but the ABI explicitally
forbids this. Quoting: "Note that the expression is mangled without constant
folding or other simplification, and without parentheses, which are implicit in
the prefix representation. Except for the parentheses, therefore, it represents
the source token stream".

> What we need is a way to express a <type> as an
> <expr-primary>.  Since typeof only cares about the types of its
> arguments, I think we can get away with representing a type using
> the existing L <type> <value> E syntax, and always using the value "0".

I don't follow. We are trying to mangle a *type*, so we need to represent
typeof() in the context of <type>, not viceversa.

Also, notice that the example of this PR needs also *another* ABI extension,
see PR 6424 where I am going to add a comment about this.

Giovanni Bajo




-- 


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

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

[ian at wasabisystems dot com]

------- Additional Comments From ian at wasabisystems dot com  2004-08-09 13:55 -------
OK, if we need to be able to express typeof() when describing a return type,
then I agree that we need an extension to <type>.  I think your suggestion of
<type> ::= Y <expression> E is the best one.

The issue of <type> within <expr-primary> is for cases like c<typeof(int*)>. 
The current compiler treats that as being identical to c<int*>.  If that is
wrong, then we need to use the proposed Y <expression> E extension, and we need
to have <type> appear in an <expression>, which is currently not directly
possible.  Rather than introduce another extension, I propose mangling that as
1cIYLPi0EEE -- that is, we express (int*) as a constant of type (int*) and value
0.  I guess the drawback is that this means that c<typeof(int)> and c<typeof(0)>
might have identical manglings.  If that is not permissible, then we need
another extension, and we as well reuse 'Y', as in expression ::= Y <type>. 
Then c<typeof(int)> would be mangled as 1cIYXYiEEE.

If somebody gets a patch into the compiler, I will change the libiberty demangler.

-- 


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

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

[gdr at integrable-solutions dot net]

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

"ian at wasabisystems dot com" <gcc-bugzilla@gcc.gnu.org> writes:

[...]

| possible.  Rather than introduce another extension, I propose mangling that as
| 1cIYLPi0EEE -- that is, we express (int*) as a constant of type (int*) and value
| 0.  I guess the drawback is that this means that c<typeof(int)> and c<typeof(0)>
| might have identical manglings.  If that is not permissible, then we need

I object to that deviation.  For the same reasons we don't "fold"
expressions, we should not be doing that transmutation.

-- Gaby


-- 


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

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

[giovannibajo at libero dot it]

------- Additional Comments From giovannibajo at libero dot it  2004-08-09 14:39 -------
(In reply to comment #15)

> The issue of <type> within <expr-primary> is for cases like c<typeof(int*)>. 
> The current compiler treats that as being identical to c<int*>.  

Question: do we really need typeof(<type>)? It does not make sense to me. typeof
(type) is always "type", so I cannot see why we should wrap it within a typeof. 
If GCC currently accepts this, we could easily flag it as an error and reject 
it. Gaby?

After this, we don't need anything more than the "<type> ::= Y <expression> E" 
extension.

-- 


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

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

[ian at wasabisystems dot com]

------- Additional Comments From ian at wasabisystems dot com  2004-08-09 14:47 -------
typeof(int*) has been in the gcc docs for ages.  See the gcc docs for examples
where it is useful.

-- 


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

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

[giovannibajo at libero dot it]

------- Additional Comments From giovannibajo at libero dot it  2004-08-09 15:05 -------
I went and read the docs, and still fail to see how it can be useful. But you 
have a point in that we cannot probably drop support for it so easily. 

What about stripping out typeof(type) while mangling, then? It really does not 
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]);

In other words, we can easily strip typeof(type) while mangling, and encoding 
typeof(expr) as Y <expression> E. 

If we agree on this, I can prepare a little patch in the following days (even 
if I am not sure it will be accepted, but hey).

-- 


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

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

[gdr at integrable-solutions dot net]

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

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

| (In reply to comment #15)
| 
| > The issue of <type> within <expr-primary> is for cases like c<typeof(int*)>. 
| > The current compiler treats that as being identical to c<int*>.  
| 
| Question: do we really need typeof(<type>)? 

At some point, the decltype/auto proposal considered that possibility.
It has the advantage that it provides a convenient way of having an
unnamed typedef and can be used as a simple-type-specifier.
Subsequent refeniment did no longer mention it, but nothing is
definitive. 

| It does not make sense to me. 

It does make sense; see above.

| typeof (type) is always "type", so I cannot see why we should wrap
| it within a typeof. 

It does not bring much when "type" is a simple-typecifier.  But, it
has some value when you consider more elaborated type-specifier.

| If GCC currently accepts this, we could
| easily flag it as an error and reject it. Gaby?

I have no strong opinion but I would lean toward supporting 
typeof(type), unless it is proven to be really useless.

-- Gaby


-- 


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

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

[gdr at integrable-solutions dot net]

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

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

| I went and read the docs, and still fail to see how it can be useful. But you 
| have a point in that we cannot probably drop support for it so easily. 
| 
| What about stripping out typeof(type) while mangling, then? It really does not 
| 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. 

| 
| In other words, we can easily strip typeof(type) while mangling, and encoding 
| typeof(expr) as Y <expression> E. 
| 
| If we agree on this,

I don't think we reach a conclusion based on the arguments you
developed above.

-- Gaby


-- 


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

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

[giovannibajo at libero dot it]

------- Additional Comments From giovannibajo at libero dot it  2004-08-10 00:49 -------
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.
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]);

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.

Giovanni Bajo




-- 


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

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

[gdr at integrable-solutions dot net]

------- 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

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

[pinskia at gcc dot gnu dot org]

------- Additional Comments From pinskia at gcc dot gnu dot org  2004-11-10 02:00 -------
*** Bug 18413 has been marked as a duplicate of this bug. ***

-- 
           What    |Removed                     |Added
----------------------------------------------------------------------------
                 CC|                            |kong at ece dot ucdavis dot
                   |                            |edu


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