Reduce maximum width of _ExtInt from 2^24-1 to 2^23 to workaround SelectionDAG issue.

[craig.topper]

Summary

SelectionDAG type legalization requires a power of 2 type with at
least as many bits as the _ExtInt. This power of 2 type size must
fit in 24 bits since an llvm::IntegerType will be created. This
places an effective limit of 2^23 on any integer types if they go
through SelectionDAG.

Fixes part of PR51829.

[erichkeane]

Changes to the tests are less intense than I would have thought! In general I'm Ok with this, I don't think anyone would really notice/mind this all that much, and since we can't actually implement this in the backends, it doesn't really make sense to have some sort of flag for this. I have a slight bit of sympathy for the backends that could consume this, but I'd think we need to have our implementation-limit be the least-common-denominator of our backends anyway.

[aaron.ballman]

LGTM modulo a request for some comments in the code. It makes me sad that we have a max number of bits specified by LLVM that's kinda useless. "You can store this many bits into this integer value, but if you attempt to add 0 to that value, it sometimes breaks" doesn't sound like a useful maximum. :-D

clang/lib/Sema/SemaType.cpp

2272

I'd appreciate some extra comments here explaining why the max int bit width is insufficient.

[craig.topper]

Add comment.

[craig.topper]

Abandoning in favor of D109721

clang/docs/ReleaseNotes.rst

 Improvements to Clang's diagnostics
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 - ...
 
 Non-comprehensive list of changes in this release
 -------------------------------------------------
 
-- ...
+- Maximum _ExtInt size was decreased from 16,777,215 bits to 8,388,608 bits.
+  Motivation for this was discussed in PR51829.
 
 New Compiler Flags
 ------------------
 
 - ...
 
 Deprecated Compiler Flags
 -------------------------

clang/lib/Sema/SemaType.cpp

 //===--- SemaType.cpp - Semantic Analysis for Types -----------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
if (!IsUnsigned && NumBits < 2) {
     return QualType();
   }
 
   if (IsUnsigned && NumBits < 1) {
     Diag(Loc, diag::err_ext_int_bad_size) << 1;
     return QualType();
   }
 
-  if (NumBits > llvm::IntegerType::MAX_INT_BITS) {
-    Diag(Loc, diag::err_ext_int_max_size) << IsUnsigned
-                                          << llvm::IntegerType::MAX_INT_BITS;
+  int MaxBits = PowerOf2Floor(llvm::IntegerType::MAX_INT_BITS);
+  if (NumBits > MaxBits) {
+    Diag(Loc, diag::err_ext_int_max_size) << IsUnsigned << MaxBits;
     return QualType();
   }
 
   return Context.getExtIntType(IsUnsigned, NumBits);
 }
 
 /// Check whether the specified array bound can be evaluated using the relevant
 /// language rules. If so, returns the possibly-converted expression and sets

clang/test/CodeGen/ext-int.c

void VLATest(_ExtInt(3) A, _ExtInt(99) B, _ExtInt(123456) C) {
   // CHECK: %[[VLA2:.+]] = alloca i32, i[[INDXSIZE]] %[[B]]
   int AR3[C];
   // CHECK: %[[C:.+]] = trunc i123456 %{{.+}} to i[[INDXSIZE]]
   // CHECK: %[[VLA3:.+]] = alloca i32, i[[INDXSIZE]] %[[C]]
 }
 
 struct S {
   _ExtInt(17) A;
-  _ExtInt(16777200) B;
+  _ExtInt(8388600) B;
   _ExtInt(17) C;
 };
 
 void OffsetOfTest() {
   // CHECK: define {{.*}}void @OffsetOfTest
   int A = __builtin_offsetof(struct S,A);
   // CHECK: store i32 0, i32* %{{.+}}
   int B = __builtin_offsetof(struct S,B);
   // CHECK64: store i32 8, i32* %{{.+}}
   // LIN32: store i32 4, i32* %{{.+}}
   // WINCHECK32: store i32 8, i32* %{{.+}}
   int C = __builtin_offsetof(struct S,C);
-  // CHECK64: store i32 2097160, i32* %{{.+}}
-  // LIN32: store i32 2097156, i32* %{{.+}}
-  // WIN32: store i32 2097160, i32* %{{.+}}
+  // CHECK64: store i32 1048584, i32* %{{.+}}
+  // LIN32: store i32 1048580, i32* %{{.+}}
+  // WIN32: store i32 1048584, i32* %{{.+}}
 }
 
 void Size1ExtIntParam(unsigned _ExtInt(1) A) {
   // CHECK: define {{.*}}void @Size1ExtIntParam(i1{{.*}}  %[[PARAM:.+]])
   // CHECK: %[[PARAM_ADDR:.+]] = alloca i1
   // CHECK: %[[B:.+]] = alloca [5 x i1]
   // CHECK: store i1 %[[PARAM]], i1* %[[PARAM_ADDR]]
   unsigned _ExtInt(1) B[5];
 
   // CHECK: %[[PARAM_LOAD:.+]] = load i1, i1* %[[PARAM_ADDR]]
   // CHECK: %[[IDX:.+]] = getelementptr inbounds [5 x i1], [5 x i1]* %[[B]]
   // CHECK: store i1 %[[PARAM_LOAD]], i1* %[[IDX]]
   B[2] = A;
 }

clang/test/CodeGenCXX/ext-int.cpp

void TakesVarargs(int i, ...) {
   // WIN: %[[CUR4:.+]] = load i8*, i8** %[[ARGS]]
   // WIN: %[[NEXT4:.+]] = getelementptr inbounds i8, i8* %[[CUR4]], i64 8
   // WIN: store i8* %[[NEXT4]], i8** %[[ARGS]]
   // WIN: %[[BC4:.+]] = bitcast i8* %[[CUR4]] to i129**
   // WIN: %[[LOADP4:.+]] = load i129*, i129** %[[BC4]]
   // WIN: %[[LOADV4:.+]] = load i129, i129* %[[LOADP4]]
   // WIN: store i129 %[[LOADV4]], i129*
 
-  _ExtInt(16777200) E = __builtin_va_arg(args, _ExtInt(16777200));
+  _ExtInt(8388600) E = __builtin_va_arg(args, _ExtInt(8388600));
   // LIN: %[[AD5:.+]] = getelementptr inbounds [1 x %struct.__va_list_tag], [1 x %struct.__va_list_tag]* %[[ARGS]]
   // LIN: %[[OFA_P5:.+]] = getelementptr inbounds %struct.__va_list_tag, %struct.__va_list_tag* %[[AD5]], i32 0, i32 2
   // LIN: %[[OFA5:.+]] = load i8*, i8** %[[OFA_P5]]
-  // LIN: %[[BC5:.+]] = bitcast i8* %[[OFA5]] to i16777200*
-  // LIN: %[[OFANEXT5:.+]] = getelementptr i8, i8* %[[OFA5]], i32 2097152
+  // LIN: %[[BC5:.+]] = bitcast i8* %[[OFA5]] to i8388600*
+  // LIN: %[[OFANEXT5:.+]] = getelementptr i8, i8* %[[OFA5]], i32 1048576
   // LIN: store i8* %[[OFANEXT5]], i8** %[[OFA_P5]]
-  // LIN: %[[LOAD5:.+]] = load i16777200, i16777200* %[[BC5]]
-  // LIN: store i16777200 %[[LOAD5]], i16777200*
+  // LIN: %[[LOAD5:.+]] = load i8388600, i8388600* %[[BC5]]
+  // LIN: store i8388600 %[[LOAD5]], i8388600*
 
   // WIN: %[[CUR5:.+]] = load i8*, i8** %[[ARGS]]
   // WIN: %[[NEXT5:.+]] = getelementptr inbounds i8, i8* %[[CUR5]], i64 8
   // WIN: store i8* %[[NEXT5]], i8** %[[ARGS]]
-  // WIN: %[[BC5:.+]] = bitcast i8* %[[CUR5]] to i16777200**
-  // WIN: %[[LOADP5:.+]] = load i16777200*, i16777200** %[[BC5]]
-  // WIN: %[[LOADV5:.+]] = load i16777200, i16777200* %[[LOADP5]]
-  // WIN: store i16777200 %[[LOADV5]], i16777200*
+  // WIN: %[[BC5:.+]] = bitcast i8* %[[CUR5]] to i8388600**
+  // WIN: %[[LOADP5:.+]] = load i8388600*, i8388600** %[[BC5]]
+  // WIN: %[[LOADV5:.+]] = load i8388600, i8388600* %[[LOADP5]]
+  // WIN: store i8388600 %[[LOADV5]], i8388600*
 
   __builtin_va_end(args);
   // LIN: %[[ENDAD:.+]] = getelementptr inbounds [1 x %struct.__va_list_tag], [1 x %struct.__va_list_tag]* %[[ARGS]]
   // LIN: %[[ENDAD1:.+]] = bitcast %struct.__va_list_tag* %[[ENDAD]] to i8*
   // LIN: call void @llvm.va_end(i8* %[[ENDAD1]])
   // WIN: %[[ARGSEND:.+]] = bitcast i8** %[[ARGS]] to i8*
   // WIN: call void @llvm.va_end(i8* %[[ARGSEND]])
 }
void ExplicitCasts() {
   i = a;
   // CHECK: %[[CONV:.+]] = trunc i33 %{{.+}} to i32
   i = b;
   // CHECK: %[[CONV:.+]] = sext i31 %{{.+}} to i32
 }
 
 struct S {
   _ExtInt(17) A;
-  _ExtInt(16777200) B;
+  _ExtInt(8388600) B;
   _ExtInt(17) C;
 };
 
 void OffsetOfTest() {
   // LIN: define{{.*}} void @_Z12OffsetOfTestv()
   // WIN: define dso_local void @"?OffsetOfTest@@YAXXZ"()
 
   auto A = __builtin_offsetof(S,A);
   // CHECK: store i64 0, i64* %{{.+}}
   auto B = __builtin_offsetof(S,B);
   // CHECK: store i64 8, i64* %{{.+}}
   auto C = __builtin_offsetof(S,C);
-  // CHECK: store i64 2097160, i64* %{{.+}}
+  // CHECK: store i64 1048584, i64* %{{.+}}
 }
 
 
 void ShiftExtIntByConstant(_ExtInt(28) Ext) {
 // LIN: define{{.*}} void @_Z21ShiftExtIntByConstantU7_ExtIntILi28EEi
 // WIN: define dso_local void @"?ShiftExtIntByConstant@@YAXU?$_ExtInt@$0BM@@__clang@@@Z"
   Ext << 7;
   // CHECK: shl i28 %{{.+}}, 7

clang/test/SemaCXX/ext-int.cpp

_ExtInt(33) Declarations(_ExtInt(48) &Param) { // Useable in params and returns.
   unsigned _ExtInt(0) k;// expected-error{{unsigned _ExtInt must have a bit size of at least 1}}
   unsigned _ExtInt(1) l;
   signed _ExtInt(1) m; // expected-error{{signed _ExtInt must have a bit size of at least 2}}
 
   constexpr _ExtInt(6) n = 33; // expected-warning{{implicit conversion from 'int' to 'const _ExtInt(6)' changes value from 33 to -31}}
   constexpr _ExtInt(7) o = 33;
 
   // Check LLVM imposed max size.
-  _ExtInt(0xFFFFFFFFFF) p; // expected-error {{signed _ExtInt of bit sizes greater than 16777215 not supported}}
-  unsigned _ExtInt(0xFFFFFFFFFF) q; // expected-error {{unsigned _ExtInt of bit sizes greater than 16777215 not supported}}
+  _ExtInt(8388609) p; // expected-error {{signed _ExtInt of bit sizes greater than 8388608 not supported}}
+  unsigned _ExtInt(0xFFFFFFFFFF) q; // expected-error {{unsigned _ExtInt of bit sizes greater than 8388608 not supported}}
 
 // Ensure template params are instantiated correctly.
   // expected-error@5{{signed _ExtInt must have a bit size of at least 2}}
   // expected-error@6{{unsigned _ExtInt must have a bit size of at least 1}}
   // expected-note@+1{{in instantiation of template class }}
   HasExtInt<-1> r;
   // expected-error@5{{signed _ExtInt must have a bit size of at least 2}}
   // expected-error@6{{unsigned _ExtInt must have a bit size of at least 1}}