[Bug c++/111842] New: Unable to disable conversion warning in case of _Float16

[Bug c++/111842] New: Unable to disable conversion warning in case of _Float16

[n.deshmukh at samsung dot com]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=111842

            Bug ID: 111842
           Summary: Unable to disable conversion warning in case of
                    _Float16
           Product: gcc
           Version: unknown
            Status: UNCONFIRMED
          Severity: normal
          Priority: P3
         Component: c++
          Assignee: unassigned at gcc dot gnu.org
          Reporter: n.deshmukh at samsung dot com
  Target Milestone: ---

The following code when compiled with gcc-13.1 results in the following output:

int main() {
    _Float16 a = 5.0;
    float b = a;
     return 0;
}

<source>: In function 'int main()':
<source>:2:18: warning: converting to '_Float16' from 'double' with greater
conversion rank
    2 |     _Float16 a = 5.0;
      |                  ^~~
Compiler returned: 0

There is no way to disable this warning as it is not classified under any -W
categories. Is there a way to disable this warning without using an explicit
cast?

[Bug c++/111842] Unable to disable conversion warning in case of _Float16

[pinskia at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=111842

--- Comment #1 from Andrew Pinski <pinskia at gcc dot gnu.org> ---
I think you should be using 5.0f16 instead ...

[Bug c++/111842] Unable to disable conversion warning in case of _Float16

[pinskia at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=111842

Andrew Pinski <pinskia at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
             Status|UNCONFIRMED                 |RESOLVED
         Resolution|---                         |INVALID

--- Comment #2 from Andrew Pinski <pinskia at gcc dot gnu.org> ---
As defined by the standard:
https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2020/p1467r4.html#implicit

You could either use f16 or add an explicit cast to avoid the (ped)warning

[Bug c++/111842] Unable to disable conversion warning in case of _Float16

[pinskia at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=111842

--- Comment #3 from Andrew Pinski <pinskia at gcc dot gnu.org> ---
>Is there a way to disable this warning without using an explicit cast?

No and this is by design because this is how C++ defines extended floating
point types and implict casts.

[Bug c++/111842] Unable to disable conversion warning in case of _Float16

[egallager at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=111842

Eric Gallager <egallager at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
                 CC|                            |egallager at gcc dot gnu.org

--- Comment #4 from Eric Gallager <egallager at gcc dot gnu.org> ---
I think the part about the warning not being controlled by a specific flag is
still valid, though? It'd fit under the bug 44209 meta-bug.

[Bug c++/111842] Unable to disable conversion warning in case of _Float16

[n.deshmukh at samsung dot com]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=111842

n.deshmukh at samsung dot com <n.deshmukh at samsung dot com> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
         Resolution|INVALID                     |---
             Status|RESOLVED                    |UNCONFIRMED

--- Comment #5 from n.deshmukh at samsung dot com <n.deshmukh at samsung dot com> ---
(In reply to Andrew Pinski from comment #3)
> >Is there a way to disable this warning without using an explicit cast?
> 
> No and this is by design because this is how C++ defines extended floating
> point types and implict casts.

(In reply to Eric Gallager from comment #4)
> I think the part about the warning not being controlled by a specific flag
> is still valid, though? It'd fit under the bug 44209 meta-bug.

Yes this is what I meant. Sorry for not being clear in my initial description.
The warning is valid but I wish to suppress it like the other conversion
warning using -Wno flag. But it does not come under a flag. It is still printed
with -Wno-pedantic option. 

The code is part of a third party library hence adding a explicit cast is not
possible.

[Bug c++/111842] Unable to disable conversion warning in case of _Float16

[pinskia at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=111842

Andrew Pinski <pinskia at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
             Status|UNCONFIRMED                 |RESOLVED
         Resolution|---                         |WONTFIX

--- Comment #6 from Andrew Pinski <pinskia at gcc dot gnu.org> ---
(In reply to n.deshmukh@samsung.com from comment #5)
> The code is part of a third party library hence adding a explicit cast is
> not possible.

Well that third party library is NOT valid C++ code ... The whole point of the
warning (and the reason why -Wno-pedantic does not turn off the warning) is
point that out and more over point out the code should be fixed.

Even more things like:
```
template<typename T>
void f(T a) requires requires(T a) { a = 5.0;}
{

}

void g()
{
        f<_Float16> (5.0);
}
```

Will not work.
Clang currently incorrectly accepts the above code even.

[Bug c++/111842] Unable to disable conversion warning in case of _Float16

[n.deshmukh at samsung dot com]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=111842

--- Comment #7 from n.deshmukh at samsung dot com <n.deshmukh at samsung dot com> ---
How about the following code: 

int f(double a) {
    float b = a;
     return 0;
}

int g(double a) {
    _Float16 b = a;
     return 0;
}

It generates the following errors: 

<source>: In function 'int f(double)':
<source>:2:15: warning: conversion from 'double' to 'float' may change value
[-Wfloat-conversion]
    2 |     float b = a;
      |               ^
<source>: In function 'int g(double)':
<source>:7:18: warning: converting to '_Float16' from 'double' with greater
conversion rank
    7 |     _Float16 b = a;
      |                  ^
Compiler returned: 0

Is there a reason why the second error is not categorized under
-Wfloat-conversion diagnostic?

[Bug c++/111842] Unable to disable conversion warning in case of _Float16

[pinskia at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=111842

--- Comment #8 from Andrew Pinski <pinskia at gcc dot gnu.org> ---
(In reply to n.deshmukh@samsung.com from comment #7)
> 
> Is there a reason why the second error is not categorized under
> -Wfloat-conversion diagnostic?

Did you read what I linked?
I will link it again:
https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2020/p1467r4.html#implicit

It even mentions why things won't change.
Again the code:
```
float a;
_Float16 b = a;
```
is invalid C++ code as defined by that paper (which was addopted for C++23).
While:
```
double a;
float b = a;
```
is still valid even.

[Bug c++/111842] Unable to disable conversion warning in case of _Float16

[n.deshmukh at samsung dot com]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=111842

--- Comment #9 from n.deshmukh at samsung dot com <n.deshmukh at samsung dot com> ---
(In reply to Andrew Pinski from comment #8)
> (In reply to n.deshmukh@samsung.com from comment #7)
> > 
> > Is there a reason why the second error is not categorized under
> > -Wfloat-conversion diagnostic?
> 
> Did you read what I linked?
> I will link it again:
> https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2020/p1467r4.
> html#implicit
> 
> It even mentions why things won't change.
> Again the code:
> ```
> float a;
> _Float16 b = a;
> ```
> is invalid C++ code as defined by that paper (which was addopted for C++23).
> While:
> ```
> double a;
> float b = a;
> ```
> is still valid even.

Yes I went through the link and I understand that double to float conversion is
valid code. My question was regarding the use of the diagnostic flag. My
understanding was that the diagnostic flag was implementation defined. That's
why I was asking.

[Bug c++/111842] Unable to disable conversion warning in case of _Float16

[egallager at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=111842

--- Comment #10 from Eric Gallager <egallager at gcc dot gnu.org> ---
(In reply to Andrew Pinski from comment #6)
> (In reply to n.deshmukh@samsung.com from comment #5)
> > The code is part of a third party library hence adding a explicit cast is
> > not possible.
> 
> Well that third party library is NOT valid C++ code ... The whole point of
> the warning (and the reason why -Wno-pedantic does not turn off the warning)
> is point that out and more over point out the code should be fixed.

That is not a reason that I have ever heard for not assigning a flag to a
warning before. I was under the impression that the principle of "All warnings
should have a flag assigned to them" held regardless of how invalid the code
they warn about is, or how badly said code should be fixed. Again, see bug
44209.

[Bug c++/111842] Unable to disable conversion warning in case of _Float16

[redi at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=111842

Jonathan Wakely <redi at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
                 CC|                            |jakub at gcc dot gnu.org

--- Comment #11 from Jonathan Wakely <redi at gcc dot gnu.org> ---
But this is not a warning of the kind controlled by -Wall etc.

This is a diagnostic that is *required* by the C++ standard. It's implemented
in GCC as a pedwarn, which is a warning unless -pedantic-errors is used, then
it's an error. So it *is* linked to a diagnostic option, as the title of PR
44209 says it should be.

There is no option to disable the warning, because the code is invalid.

On the other hand, we do allow disabling narrowing diagnostics, which are also
required by the standard. -Wno-narrowing can be used to disable those. But
narrowing cases were not errors in C++98 and the introduction of the C++11
rules caused massive compatibility problems for old code. There is no such
concern for _Float16 because that type has never been used in existing C++
code.

We could link this one to -Wnarrowing too, as converting to a floating-point
type of lesser rank is a kind of narrowing. I don't see any great need to do
that though. There's no compatability concern here, why not just write the code
correctly in the first place?

[Bug c++/111842] Unable to disable conversion warning in case of _Float16

[redi at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=111842

--- Comment #12 from Jonathan Wakely <redi at gcc dot gnu.org> ---
(In reply to n.deshmukh@samsung.com from comment #5)
> The warning is valid but I wish to suppress it like the other
> conversion warning using -Wno flag.

Why?

Why not just write the code correctly? It's new code, not legacy code that
needs to be maintained. It can't be legacy code, because it would not have
compiled before GCC 13.

[Bug c++/111842] Unable to disable conversion warning in case of _Float16

[n.deshmukh at samsung dot com]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=111842

--- Comment #13 from n.deshmukh at samsung dot com <n.deshmukh at samsung dot com> ---
(In reply to Jonathan Wakely from comment #12)
> (In reply to n.deshmukh@samsung.com from comment #5)
> > The warning is valid but I wish to suppress it like the other
> > conversion warning using -Wno flag.
> 
> Why?
> 
> Why not just write the code correctly? It's new code, not legacy code that
> needs to be maintained. It can't be legacy code, because it would not have
> compiled before GCC 13.

The code was still working with GCC 12.1 where the same warning was classified
as a float-conversion warning. 

<source>:7:18: warning: conversion from 'double' to '_Float16' may change value
[-Wfloat-conversion]
    7 |     _Float16 b = a;
      |   

The code is part of a third party library. Ideally the code should be fixed to
avoid the warning. But until the next release of the library I wanted to
disable the warnings that we were getting in our builds. 

The change in behavior from gcc12 to gcc13 prompted me to come here to check if
that was an intended change.

[Bug c++/111842] Unable to disable conversion warning in case of _Float16

[pinskia at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=111842

--- Comment #14 from Andrew Pinski <pinskia at gcc dot gnu.org> ---
_Float16 was added in GCC 12 not as an extended floating point type but rather
some target specific type which had its own rules and such. GCC 13 was the
first release where _Float16 became a real C++23 extended floatpoint type and
with it came the rules of C++23 extended types rather than a hacked in floating
point type.

[Bug c++/111842] Unable to disable conversion warning in case of _Float16

[cvs-commit at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=111842

--- Comment #15 from CVS Commits <cvs-commit at gcc dot gnu.org> ---
The master branch has been updated by Jonathan Wakely <redi@gcc.gnu.org>:

https://gcc.gnu.org/g:69d69865a792a93cce2905617c53913769d0f260

commit r14-5436-g69d69865a792a93cce2905617c53913769d0f260
Author: Jonathan Wakely <jwakely@redhat.com>
Date:   Mon Nov 13 12:03:31 2023 +0000

    c++: Link extended FP conversion pedwarns to -Wnarrowing [PR111842]

    Several users have been confused by the status of these warnings,
    which can be misunderstood as "this might not be what you want",
    rather than diagnostics required by the C++ standard. Add the text "ISO
    C++ does not allow" to make this clear.

    Also link them to -Wnarrowing so that they can be disabled or promoted
    to errors independently of other pedwarns.

            PR c++/111842
            PR c++/112498

    gcc/cp/ChangeLog:

            * call.cc (convert_like_internal): Use OPT_Wnarrowing for
            pedwarns about illformed conversions involving extended
            floating-point types. Clarify that ISO C++ requires these
            diagnostics.

    gcc/testsuite/ChangeLog:

            * g++.dg/cpp23/ext-floating16.C: New test.
            * g++.dg/cpp23/ext-floating17.C: New test.

[Bug c++/111842] Unable to disable conversion warning in case of _Float16

[xry111 at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=111842

Xi Ruoyao <xry111 at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
                 CC|                            |xry111 at gcc dot gnu.org
         Resolution|WONTFIX                     |FIXED

--- Comment #16 from Xi Ruoyao <xry111 at gcc dot gnu.org> ---
So it's fixed now.

[Bug c++/111842] Unable to disable conversion warning in case of _Float16

[redi at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=111842

Jonathan Wakely <redi at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
   Target Milestone|---                         |14.0

--- Comment #17 from Jonathan Wakely <redi at gcc dot gnu.org> ---
For GCC 14 -Wno-narrowing will disable the warning.