Implement _ExtInt conversion rules

[aaron.ballman]

Summary

Clang implemented the _ExtInt datatype as a bit-precise integer type, which was then proposed to WG14. WG14 has accepted the proposal (http://www.open-std.org/jtc1/sc22/wg14/www/docs/n2709.pdf), but Clang requires some additional work as a result.

In the original Clang implementation, we elected to disallow implicit conversions involving these types until after WG14 finalized the rules. This patch implements the rules decided by WG14: no integer promotion for bit-precise types, conversions prefer the larger of the two types and in the event of a tie (say _ExtInt(32) and a 32-bit int), the standard type wins.

There are more changes still needed to conform to N2709, but those will be handled in follow-up patches.

[erichkeane]

clang/test/Sema/ext-int.c

7–9

Wouldn't mind some type-checking tests here if possible. Or at least SOMEWHERE to make sure this produces the correct types, something with a static-assert would be great!

[aaron.ballman]

clang/test/Sema/ext-int.c

7–9

There's not a super easy way to do is_same in C, but I could add some AST dumping tests that involve __typeof__ if that'd work for you?

[erichkeane]

clang/test/Sema/ext-int.c

7–9

yep! That'd be fine.

[rsmith]

clang/test/Sema/ext-int.c

7–9

Can you build is_same out of _Generic? Eg, _Static_assert(_Generic(b ? s30 : s31a, EI31: 1, default: 0, "");

[aaron.ballman]

clang/test/Sema/ext-int.c

7–9

@rsmith -- great minds think alike, I was just heading down that route. :-)

[aaron.ballman]

Added more test coverage in C for conversion type results.

[aaron.ballman]

Ping. FWIW, I'm hoping to get these changes into the Clang 13 branch before we split off. I don't think we'll get fully conforming support for the feature in Clang 13 (we need some ABI discussion before I think we'll be ready to rename _ExtInt to _BitInt, but I'd like to get as close to conforming as possible).

[mibintc]

LGTM

[aaron.ballman]

Thanks for the reviews; I've committed in 6bb042e70024354acc65457e153b40d50cada4f5.

clang/lib/Sema/SemaExpr.cpp

if (!LHSBitfieldPromoteTy.isNull())
     LHSType = LHSBitfieldPromoteTy;
   if (LHSType != LHSUnpromotedType && ACK != ACK_CompAssign)
     LHS = ImpCastExprToType(LHS.get(), LHSType, CK_IntegralCast);
 
   // If both types are identical, no conversion is needed.
   if (LHSType == RHSType)
     return LHSType;
 
-  // ExtInt types aren't subject to conversions between them or normal integers,
-  // so this fails.
-  if(LHSType->isExtIntType() || RHSType->isExtIntType())
-    return QualType();
-
   // At this point, we have two different arithmetic types.
 
   // Diagnose attempts to convert between __float128 and long double where
   // such conversions currently can't be handled.
   if (unsupportedTypeConversion(*this, LHSType, RHSType))
     return QualType();
 
   // Handle complex types first (C99 6.3.1.8p1).

clang/test/Sema/ext-int.c

-// RUN: %clang_cc1 -fsyntax-only -verify %s -Wimplicit-int-conversion -triple x86_64-gnu-linux
+// RUN: %clang_cc1 -fsyntax-only -verify %s -Wimplicit-int-conversion -Wno-unused -triple x86_64-gnu-linux
 
 typedef _ExtInt(31) EI31;
 
 void Ternary(_ExtInt(30) s30, EI31 s31a, _ExtInt(31) s31b,
              _ExtInt(32) s32, int b) {
-  b ? s30 : s31a; // expected-error{{incompatible operand types}}
-  b ? s31a : s30; // expected-error{{incompatible operand types}}
-  b ? s32 : 0; // expected-error{{incompatible operand types}}
+  b ? s30 : s31a;
+  b ? s31a : s30;
+  b ? s32 : 0;
   (void)(b ? s31a : s31b);
   (void)(s30 ? s31a : s31b);
 }
+
+struct CursedBitField {
+  _ExtInt(4) A : 8; // expected-error {{width of bit-field 'A' (8 bits) exceeds the width of its type (4 bits)}}
+};
+
+#define EXPR_HAS_TYPE(EXPR, TYPE) _Generic((EXPR), default : 0, TYPE : 1)
+
+void Ops(void) {
+  _ExtInt(4) x4_s = 1;
+  _ExtInt(32) x32_s = 1;
+  _ExtInt(43) x43_s = 1;
+  unsigned _ExtInt(4) x4_u = 1;
+  unsigned _ExtInt(43) x43_u = 1;
+  unsigned _ExtInt(32) x32_u = 1;
+  int x_int = 1;
+  unsigned x_uint = 1;
+
+  // Same size/sign ops don't change type.
+  _Static_assert(EXPR_HAS_TYPE(x43_s + x43_s, _ExtInt(43)), "");
+  _Static_assert(EXPR_HAS_TYPE(x4_s - x4_s, _ExtInt(4)), "");
+  _Static_assert(EXPR_HAS_TYPE(x43_u * x43_u, unsigned _ExtInt(43)), "");
+  _Static_assert(EXPR_HAS_TYPE(x4_u / x4_u, unsigned _ExtInt(4)), "");
+
+  // Unary ops shouldn't go through integer promotions.
+  _Static_assert(EXPR_HAS_TYPE(x4_s++, _ExtInt(4)), "");
+  _Static_assert(EXPR_HAS_TYPE(++x4_s, _ExtInt(4)), "");
+  _Static_assert(EXPR_HAS_TYPE(x4_u++, unsigned _ExtInt(4)), "");
+  _Static_assert(EXPR_HAS_TYPE(++x4_u, unsigned _ExtInt(4)), "");
+  _Static_assert(EXPR_HAS_TYPE(+x4_s, _ExtInt(4)), "");
+  _Static_assert(EXPR_HAS_TYPE(-x4_s, _ExtInt(4)), "");
+  _Static_assert(EXPR_HAS_TYPE(~x4_u, unsigned _ExtInt(4)), "");
+
+  // This one really does convert to a different result type though.
+  _Static_assert(EXPR_HAS_TYPE(!x4_u, int), "");
+
+  // Test binary ops pick the correct common type.
+  _Static_assert(EXPR_HAS_TYPE(x43_s + x_int, _ExtInt(43)), "");
+  _Static_assert(EXPR_HAS_TYPE(x43_u + x_int, unsigned _ExtInt(43)), "");
+  _Static_assert(EXPR_HAS_TYPE(x32_s + x_int, int), "");
+  _Static_assert(EXPR_HAS_TYPE(x32_u + x_int, unsigned int), "");
+  _Static_assert(EXPR_HAS_TYPE(x32_s + x_uint, unsigned int), "");
+  _Static_assert(EXPR_HAS_TYPE(x32_u + x_uint, unsigned int), "");
+  _Static_assert(EXPR_HAS_TYPE(x4_s + x_int, int), "");
+  _Static_assert(EXPR_HAS_TYPE(x4_u + x_int, int), "");
+  _Static_assert(EXPR_HAS_TYPE(x4_s + x_uint, unsigned int), "");
+  _Static_assert(EXPR_HAS_TYPE(x4_u + x_uint, unsigned int), "");
+}
+
+void FromPaper1(void) {
+  // Test the examples of conversion and promotion rules from C2x 6.3.1.8.
+  _ExtInt(2) a2 = 1;
+  _ExtInt(3) a3 = 2;
+  _ExtInt(33) a33 = 1;
+  char c = 3;
+
+  _Static_assert(EXPR_HAS_TYPE(a2 * a3, _ExtInt(3)), "");
+  _Static_assert(EXPR_HAS_TYPE(a2 * c, int), "");
+  _Static_assert(EXPR_HAS_TYPE(a33 * c, _ExtInt(33)), "");
+}
+
+void FromPaper2(_ExtInt(8) a1, _ExtInt(24) a2) {
+  _Static_assert(EXPR_HAS_TYPE(a1 * (_ExtInt(32))a2, _ExtInt(32)), "");
+}

clang/test/SemaCXX/ext-int.cpp

-// RUN: %clang_cc1 -fsyntax-only -verify %s -Wimplicit-int-conversion -triple x86_64-gnu-linux
+// RUN: %clang_cc1 -fsyntax-only -verify %s -Wimplicit-int-conversion -Wno-unused -Wunevaluated-expression -triple x86_64-gnu-linux
 
 template<int Bounds>
 struct HasExtInt {
   _ExtInt(Bounds) b;
   unsigned _ExtInt(Bounds) b2;
 };
 
 // Delcaring variables:
void Ops() {
   unsigned _ExtInt(sizeof(unsigned) * 8) x32_u = 1, y32_u = 1;
   _ExtInt(4) x4_s = 1, y4_s = 1;
   unsigned _ExtInt(43) x43_u = 1, y43_u = 1;
   unsigned _ExtInt(4) x4_u = 1, y4_u = 1;
   int x_int = 1, y_int = 1;
   unsigned x_uint = 1, y_uint = 1;
   bool b;
 
-  // Disabling mixed conversions:
   // Signed/unsigned mixed.
-  // expected-error@+1{{invalid operands to binary expression}}
   x43_u + y43_s;
-  // expected-error@+1{{invalid operands to binary expression}}
   x4_s - y4_u;
-  // expected-error@+1{{invalid operands to binary expression}}
   x43_s * y43_u;
-  // expected-error@+1{{invalid operands to binary expression}}
   x4_u / y4_s;
 
   // Different Sizes.
-  // expected-error@+1{{invalid operands to binary expression}}
   x43_s + y4_s;
-  // expected-error@+1{{invalid operands to binary expression}}
   x43_s - y4_u;
-  // expected-error@+1{{invalid operands to binary expression}}
   x43_u * y4_u;
-  // expected-error@+1{{invalid operands to binary expression}}
   x4_u / y43_u;
 
   // Mixed with standard types.
-  // expected-error@+1{{invalid operands to binary expression}}
   x43_s + x_int;
-  // expected-error@+1{{invalid operands to binary expression}}
   x43_u - x_int;
-  // expected-error@+1{{invalid operands to binary expression}}
   x32_s * x_int;
-  // expected-error@+1{{invalid operands to binary expression}}
   x32_u / x_int;
-  // expected-error@+1{{invalid operands to binary expression}}
   x32_s * x_uint;
-  // expected-error@+1{{invalid operands to binary expression}}
   x32_u / x_uint;
-  // expected-error@+1{{invalid operands to binary expression}}
   x4_s + x_int;
-  // expected-error@+1{{invalid operands to binary expression}}
   x4_u - x_int;
-  // expected-error@+1{{invalid operands to binary expression}}
   x4_s + b;
-  // expected-error@+1{{invalid operands to binary expression}}
   x4_u - b;
-  // expected-error@+1{{invalid operands to binary expression}}
   x43_s + b;
-  // expected-error@+1{{invalid operands to binary expression}}
   x43_u - b;
+  static_assert(is_same<decltype(x43_s + x_int), _ExtInt(43)>::value, "");
+  static_assert(is_same<decltype(x43_u + x_int), unsigned _ExtInt(43)>::value, "");
+  static_assert(is_same<decltype(x32_s + x_int), int>::value, "");
+  static_assert(is_same<decltype(x32_u + x_int), unsigned int>::value, "");
+  static_assert(is_same<decltype(x32_s + x_uint), unsigned int>::value, "");
+  static_assert(is_same<decltype(x32_u + x_uint), unsigned int>::value, "");
+  static_assert(is_same<decltype(x4_s + x_int), int>::value, "");
+  static_assert(is_same<decltype(x4_u + x_int), int>::value, "");
+  static_assert(is_same<decltype(x4_s + x_uint), unsigned int>::value, "");
+  static_assert(is_same<decltype(x4_u + x_uint), unsigned int>::value, "");
 
   // Bitwise checks.
-  // expected-error@+1{{invalid operands to binary expression}}
   x43_s % y4_u;
-  // expected-error@+1{{invalid operands to binary expression}}
   x43_u % y4_s;
-  // expected-error@+1{{invalid operands to binary expression}}
   x4_s | y43_u;
-  // expected-error@+1{{invalid operands to binary expression}}
   x4_u | y43_s;
 
   // compassign.
-  // expected-error@+1{{invalid operands to binary expression}}
   x43_s += 33;
 
   // Comparisons.
-  // expected-error@+1{{invalid operands to binary expression}}
   x43_s > 33;
-  // expected-error@+1{{invalid operands to binary expression}}
-  x4_s > 33;
+  x4_s > 33; // expected-warning {{result of comparison of constant 33 with expression of type '_ExtInt(4)' is always false}}
 
   // Same size/sign ops don't change type.
   static_assert(is_same<decltype(x43_s + y43_s), _ExtInt(43)>::value,"");
   static_assert(is_same<decltype(x4_s - y4_s), _ExtInt(4)>::value,"");
   static_assert(is_same<decltype(x43_u * y43_u), unsigned _ExtInt(43)>::value,"");
   static_assert(is_same<decltype(x4_u / y4_u), unsigned _ExtInt(4)>::value,"");
 
   // Unary ops shouldn't go through integer promotions.

 
 // no errors expected, this should 'just work'.
 struct UsedAsBitField {
   _ExtInt(3) F : 3;
   _ExtInt(3) G : 3;
   _ExtInt(3) H : 3;
 };
 
+struct CursedBitField {
+  _ExtInt(4) A : 8; // expected-warning {{width of bit-field 'A' (8 bits) exceeds the width of its type; value will be truncated to 4 bits}}
+};
+
 // expected-error@+1{{mode attribute only supported for integer and floating-point types}}
 typedef _ExtInt(33) IllegalMode __attribute__((mode(DI)));
 
 void ImplicitCasts(_ExtInt(31) s31, _ExtInt(33) s33, int i) {
   // expected-warning@+1{{implicit conversion loses integer precision}}
   s31 = i;
   // expected-warning@+1{{implicit conversion loses integer precision}}
   s31 = s33;
   s33 = i;
   s33 = s31;
   i = s31;
   // expected-warning@+1{{implicit conversion loses integer precision}}
   i = s33;
 }
 
 void Ternary(_ExtInt(30) s30, _ExtInt(31) s31a, _ExtInt(31) s31b,
              _ExtInt(32) s32, bool b) {
-  b ? s30 : s31a; // expected-error{{incompatible operand types}}
-  b ? s31a : s30; // expected-error{{incompatible operand types}}
-  b ? s32 : (int)0; // expected-error{{incompatible operand types}}
+  b ? s30 : s31a;
+  b ? s31a : s30;
+  b ? s32 : (int)0;
   (void)(b ? s31a : s31b);
   (void)(s30 ? s31a : s31b);
+
+  static_assert(is_same<decltype(b ? s30 : s31a), _ExtInt(31)>::value, "");
+  static_assert(is_same<decltype(b ? s32 : s30), _ExtInt(32)>::value, "");
+  static_assert(is_same<decltype(b ? s30 : 0), int>::value, "");
+}
+
+void FromPaper1() {
+  // Test the examples of conversion and promotion rules from C2x 6.3.1.8.
+  _ExtInt(2) a2 = 1;
+  _ExtInt(3) a3 = 2;
+  _ExtInt(33) a33 = 1;
+  char c = 3;
+
+  static_assert(is_same<decltype(a2 * a3), _ExtInt(3)>::value, "");
+  static_assert(is_same<decltype(a2 * c), int>::value, "");
+  static_assert(is_same<decltype(a33 * c), _ExtInt(33)>::value, "");
+}
+
+void FromPaper2(_ExtInt(8) a1, _ExtInt(24) a2) {
+  static_assert(is_same<decltype(a1 * (_ExtInt(32))a2), _ExtInt(32)>::value, "");
 }