llvmbot wrote:
<!--LLVM PR SUMMARY COMMENT--> @llvm/pr-subscribers-clang Author: Aaron Ballman (AaronBallman) <details> <summary>Changes</summary> There's so much overlap between the cited papers so this condenses the status page into a single entry rather than trying to test conformance against multiple papers doing conflicting things. --- Full diff: https://github.com/llvm/llvm-project/pull/88161.diff 2 Files Affected: - (added) clang/test/C/C99/n809.c (+97) - (modified) clang/www/c_status.html (+8-22) ``````````diff diff --git a/clang/test/C/C99/n809.c b/clang/test/C/C99/n809.c new file mode 100644 index 00000000000000..8d26744443eec4 --- /dev/null +++ b/clang/test/C/C99/n809.c @@ -0,0 +1,97 @@ +// RUN: %clang_cc1 -verify -std=c99 %s + +/* WG14 N620, N638, N657, N694, N809: Yes* + * Complex and imaginary support in <complex.h> + * + * NB: Clang supports _Complex but not _Imaginary. In C99, _Complex support is + * required outside of freestanding, but _Imaginary support is fully optional. + * In C11, both are made fully optional. We claim full conformance because we + * are actually conforming, but this gets an asterisk because it's also only + * partially implemented in a way and users should know about that. + * + * Because the functionality is so intertwined between the various papers, + * we're testing all of the functionality in one file. + */ + +// Demonstrate that we support spelling complex floating-point objects. +float _Complex f1; +_Complex float f2; + +double _Complex d1; +_Complex double d2; + +long double _Complex ld1; +_Complex long double ld2; + +// Show that we don't support spelling imaginary types. +float _Imaginary fi1; // expected-error {{imaginary types are not supported}} +_Imaginary float fi2; // expected-error {{imaginary types are not supported}} + +double _Imaginary di1; // expected-error {{imaginary types are not supported}} +_Imaginary double di2; // expected-error {{imaginary types are not supported}} + +long double _Imaginary ldi1; // expected-error {{imaginary types are not supported}} +_Imaginary long double ldi2; // expected-error {{imaginary types are not supported}} + +// Each complex type has the same representation and alignment as an array +// containing two elements of the corresponding real type. +_Static_assert(sizeof(float _Complex) == sizeof(struct { float mem[2]; }), ""); +_Static_assert(_Alignof(float _Complex) == _Alignof(struct { float mem[2]; }), ""); + +_Static_assert(sizeof(double _Complex) == sizeof(struct { double mem[2]; }), ""); +_Static_assert(_Alignof(double _Complex) == _Alignof(struct { double mem[2]; }), ""); + +_Static_assert(sizeof(long double _Complex) == sizeof(struct { long double mem[2]; }), ""); +_Static_assert(_Alignof(long double _Complex) == _Alignof(struct { long double mem[2]; }), ""); + +// The first element corresponds to the real part and the second element +// corresponds to the imaginary part. +_Static_assert(__real((float _Complex){ 1.0f, 2.0f }) == 1.0f, ""); +_Static_assert(__imag((float _Complex){ 1.0f, 2.0f }) == 2.0f, ""); + +_Static_assert(__real((double _Complex){ 1.0, 2.0 }) == 1.0, ""); +_Static_assert(__imag((double _Complex){ 1.0, 2.0 }) == 2.0, ""); + +_Static_assert(__real((long double _Complex){ 1.0L, 2.0L }) == 1.0L, ""); +_Static_assert(__imag((long double _Complex){ 1.0L, 2.0L }) == 2.0L, ""); + +// When a real value is converted to a complex value, the real part follows the +// usual conversion rules and the imaginary part should be zero. +_Static_assert(__real((float _Complex)1.0f) == 1.0f, ""); +_Static_assert(__imag((float _Complex)1.0f) == 0.0f, ""); + +_Static_assert(__real((double _Complex)1.0f) == 1.0, ""); +_Static_assert(__imag((double _Complex)1.0f) == 0.0, ""); + +_Static_assert(__real((long double _Complex)1.0f) == 1.0L, ""); +_Static_assert(__imag((long double _Complex)1.0f) == 0.0L, ""); + +// When a complex value is converted to a real value, the real part follows the +// usual conversion rules and the imaginary part is discarded. +_Static_assert((float)(float _Complex){ 1.0f, 2.0f } == 1.0f, ""); +_Static_assert((double)(float _Complex){ 1.0f, 2.0f } == 1.0, ""); +_Static_assert((long double)(float _Complex){ 1.0f, 2.0f } == 1.0L, ""); + +// Complex values are only equal if both the real and imaginary parts are equal. +_Static_assert((float _Complex){ 1.0f, 2.0f } == (float _Complex){ 1.0f, 2.0f }, ""); +_Static_assert((double _Complex){ 1.0, 2.0 } == (double _Complex){ 1.0, 2.0 }, ""); +_Static_assert((long double _Complex){ 1.0L, 2.0L } == (long double _Complex){ 1.0L, 2.0L }, ""); + +_Static_assert((float _Complex){ 1.0f, 2.0f } != (float _Complex){ 2.0f, 0.0f }, ""); +_Static_assert((double _Complex){ 1.0, 2.0 } != (double _Complex){ 2.0, 0.0 }, ""); +_Static_assert((long double _Complex){ 1.0L, 2.0L } != (long double _Complex){ 2.0L, 0.0L }, ""); + +// You cannot use relational operator on complex values. +int i1 = (float _Complex){ 1.0f, 2.0f } < 10; // expected-error {{invalid operands to binary expression}} +int i2 = (double _Complex){ 1.0f, 2.0f } > 10; // expected-error {{invalid operands to binary expression}} +int i3 = (long double _Complex){ 1.0f, 2.0f } <= 10; // expected-error {{invalid operands to binary expression}} +int i4 = (float _Complex){ 1.0f, 2.0f } >= 10; // expected-error {{invalid operands to binary expression}} + +// As a type specifier, _Complex cannot appear alone; however, we support it as +// an extension by assuming _Complex double. +_Complex c = 1.0f; // expected-warning {{plain '_Complex' requires a type specifier; assuming '_Complex double'}} +// Because we don't support imaginary types, we don't extend the extension to +// that type specifier. +// FIXME: the warning diagnostic here is incorrect and should not be emitted. +_Imaginary i = 1.0f; // expected-warning {{plain '_Complex' requires a type specifier; assuming '_Complex double'}} \ + expected-error {{imaginary types are not supported}} diff --git a/clang/www/c_status.html b/clang/www/c_status.html index 7ee1d2b507e88c..99a65bfb0a48e5 100644 --- a/clang/www/c_status.html +++ b/clang/www/c_status.html @@ -132,29 +132,11 @@ <h2 id="c99">C99 implementation status</h2> <td>Unknown</td> <td class="full" align="center">Yes</td> </tr> - <tr id="complex"> - <td rowspan="6">complex and imaginary support in <complex.h></td> + <tr> + <td>complex and imaginary support in <complex.h></td> + <td><a href="https://www.open-std.org/jtc1/sc22/wg14/www/docs/n693.ps";>N693</a></td> + <td class="full" align="center">Yes <a href="#complex">(1)</a></td> </tr> - <tr> - <td><a href="https://www.open-std.org/jtc1/sc22/wg14/www/docs/n620.ps";>N620</a></td> - <td class="unknown" align="center">Unknown</td> - </tr> - <tr> - <td><a href="https://www.open-std.org/jtc1/sc22/wg14/www/docs/n638.ps";>N638</a></td> - <td class="unknown" align="center">Unknown</td> - </tr> - <tr> - <td><a href="https://www.open-std.org/jtc1/sc22/wg14/www/docs/n657.ps";>N657</a></td> - <td class="unknown" align="center">Unknown</td> - </tr> - <tr> - <td><a href="https://www.open-std.org/jtc1/sc22/wg14/www/docs/n694.ps";>N694</a></td> - <td class="unknown" align="center">Unknown</td> - </tr> - <tr> - <td><a href="https://www.open-std.org/jtc1/sc22/wg14/www/docs/n809.ps";>N809</a></td> - <td class="unknown" align="center">Unknown</td> - </tr> <tr> <td>type-generic math macros in <tgmath.h></td> <td><a href="https://www.open-std.org/jtc1/sc22/wg14/www/docs/n693.ps";>N693</a></td> @@ -373,6 +355,10 @@ <h2 id="c99">C99 implementation status</h2> <td class="full" align="center">Yes</td> </tr> </table> +<span id="complex">(1): Clang supports <code>_Complex</code> type specifiers but +does not support <code>_Imaginary</code> type specifiers. Support for +<code>_Imaginary</code> is optional in C99 which is why Clang is fully conforming. +</span> </details> <h2 id="c11">C11 implementation status</h2> `````````` </details> https://github.com/llvm/llvm-project/pull/88161 _______________________________________________ cfe-commits mailing list cfe-commits@lists.llvm.org https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
