[clang] Link libbitint for large division of _BitInt

[mgehre-amd]

Summary

According to the RFC [0], this review contains the clang parts of large integer divison for _BitInt.

It contains the following parts:

• Driver: Gnu, MinGW: Link libbitint when available
• Add -fexperimental_max_bitint_width=N

[0] https://discourse.llvm.org/t/rfc-add-support-for-division-of-large-bitint-builtins-selectiondag-globalisel-clang/60329

[erichkeane]

clang/include/clang/Basic/DiagnosticSemaKinds.td

8422

Can you explain the issue here? This is supposed to be well-defined behavior.

clang/include/clang/Basic/TargetInfo.h

599

This is definitely a TODO we need to do before accepting this. The purpose of this function is that each individual target can 'override' this function. This is an 'opt in'.

clang/lib/Lex/LiteralSupport.cpp

1232

Can you explain what is going on here? This isn't at all obvious to me.

[mgehre-amd]

clang/include/clang/Basic/DiagnosticSemaKinds.td

8422

I saw Assertion LC != RTLIB::UNKNOWN_LIBCALL && "Don't know how to expand this SINT_TO_FP!"' failed. in the backend. I think we would need to add library calls for floating to bitint (and vice versa) to the bitint library to enable that.

clang/lib/Lex/LiteralSupport.cpp

1232

When I adapted the test case clang/test/Lexer/bitint-constants.c https://reviews.llvm.org/D122234#change-GjEFAAe2jzfe to test literals with 2097152 hex digits, clang spend minutes in the code below to try to turn that literal into a ApInt of 8388608 bits.

That is because the code below does a generic Val *= Radix and Val += Digit. The Val *= Radix is very slow on a ApInt with 8388608 bits, and it's also not needed when
we know that Radix is a power of two. Then one can just copy the bits from each Digit into the right position in Val.

If the integer literals can just be 128 bits or something, it doesn't matter, but now we need to support really big integer literals with having increased the limit on _BitInt width.

[aaron.ballman]

clang/include/clang/Basic/DiagnosticSemaKinds.td

8422

Good catch! I think we'll need to solve that before we can enable wide bit-width support (users are going to expect assignment and initialization to not crash as those are basic builtin operators). FWIW, this is a reproducer from Clang 13 where we still allowed large widths: https://godbolt.org/z/hvzWq1KTK

[erichkeane]

clang/lib/Lex/LiteralSupport.cpp

1232

Hmm, so this is only really an issue with base-10 integer values? Is the same 'clang spent minutes in...' still a problem for base 10 literals? It would be unfortunate if we cannot just fix that.

Additionally, I'd like some comment to explain this, it isn't particularly clear what it is doing.

[mgehre-amd]

clang/include/clang/Basic/DiagnosticSemaKinds.td

8422

I don't think I agree.

Right now users will get a diagnostic that _BitInt > 128 bit cannot be used. With this PR, they can use them but get a diagnostic when they try to convert large _BitInts to floats or back.
I think there is huge value in allowing large _BitInts even when float to/from conversion will cause a clang diagnostic because at least in my use case that is pretty uncommon,
so I propose to move forward with this PR (lifting the limit on _BitInt width) without having the compiler-rt support for float conversions.

clang/lib/Lex/LiteralSupport.cpp

1232

Yes, clang is still slow if a user writes a decimal literal to initialize a 8388608 bit ApInt, but maybe that is just what the called for.
You can also have a very slow compilation when you create complicated recursive templates or huge macros; that isn't inherently the compilers fault.

I mainly fixed it for the hex case to be able to write a test case which says this literal is still accepted and this literal is too big and cannot be represented.

I will add comments to make the code clearer.

[aaron.ballman]

clang/include/clang/Basic/DiagnosticSemaKinds.td

8422

Right now users will get a diagnostic that _BitInt > 128 bit cannot be used. With this PR, they can use them but get a diagnostic when they try to convert large _BitInts to floats or back.

This is certainly better than crashing, no doubt.

I think there is huge value in allowing large _BitInts even when float to/from conversion will cause a clang diagnostic because at least in my use case that is pretty uncommon,

That's the problem -- this is a new basic datatype; we can't make assumptions that our constituent uses cases are the common pattern. My experience thus far with this feature has been that people are using it for all sorts of reasons in ways I wouldn't have expected, like as a big int, as a regular int that doesn't integer promote, as bit-fields, etc.

To me, the bar for whether we allow large bit widths than we do today is: do all basic mathematical operators on any bit-width work correctly at runtime without crashing or major compile-time or runtime performance issues for the given target you want to change the limit for? Assignment and conversion are basic mathematical operators I'd definitely expect to work; these aren't weird situations -- assigning a float to an integer happens with some regularity, so there's no reason to assume it won't happen when the integer is a larger bit-precise integer: https://godbolt.org/z/hx5sYbjGK.

I'd *much* rather slow-roll the feature than have people's first impression be that they can't trust the feature because it's too flaky. The whole point to the BITINT_MAXWIDTH macro is to give the user a reliable way to know what bit widths are supported; lying will not do us any favors.

[mgehre-amd]

clang/include/clang/Basic/DiagnosticSemaKinds.td

8422

Ok, then let me propose the following:

• Keep the default max. _BitInt size limit at 128 with this PR
• Remove the code that emits the float-to-int/int-to-float warnings for bit _BitInts
• Add a cc1 option -fmax-bitint-size=N to allow overwriting the max. _BitInt size for tests (so we can test big division even when float-to-int isn't there yet)

What do you think?

[aaron.ballman]

clang/include/clang/Basic/DiagnosticSemaKinds.td

8422

I was hoping to avoid something like that, but I think it's not entirely unreasonable as a stopgap measure either.

How about we name it -fexperimental-max-bitint-width=N to make it clear that this option is not expected to stick around forever? (I'd like to not ship a release of Clang with this flag). I suppose we'd still have to make sure the user doesn't specify a value larger than what LLVM supports, too.

[mgehre-amd]

• Remove diagnostics for float-to-bitint
• Remove lexer changes (will be another PR)
• Add -fexperimental-max-bitint-width=N

[mgehre-amd]

clang/lib/Serialization/ASTReader.cpp

315 ↗

(On Diff #418861)

This macro was taking the wrong number of arguments, but nobody noticed because there was no BENIGN_VALUE_LANGOPT before.

[aaron.ballman]

This looks generally correct to me, but precommit CI is currently failing with a relevant issue (what a nice change of pace):

Failed Tests (1):

Clang :: Driver/linux-ld.c

clang/include/clang/Basic/TargetInfo.h

601

So we get the return type correct? (I doubt this matters.)

clang/lib/Serialization/ASTReader.cpp

315 ↗

(On Diff #418861)

Good catch!

[MaskRay]

clang/lib/Driver/ToolChains/Hexagon.cpp

456 ↗

(On Diff #418861)

The runtime library order matters and roughly reflects a topological order.
For instances, -lc is higher level than libgcc_s/libclang_rt.builtins.a therefore -lc precedes them.

[mgehre-amd]

I split the introduction of -fexperimental-max-bitint-width into https://reviews.llvm.org/D127287 because there is still discussion about the bitint libraries in the backend PRs.

[mgehre-amd]

Instead of linking to libbitint, I instead created a backend pass to transform div/rem instructions: https://reviews.llvm.org/D130076

clang/include/clang/Basic/DiagnosticSemaKinds.td

def err_overflow_builtin_must_be_int : Error<
   "operand argument to overflow builtin must be an integer (%0 invalid)">;
 def err_overflow_builtin_must_be_ptr_int : Error<
   "result argument to overflow builtin must be a pointer "
   "to a non-const integer (%0 invalid)">;
 def err_overflow_builtin_bit_int_max_size : Error<
   "__builtin_mul_overflow does not support 'signed _BitInt' operands of more "
   "than %0 bits">;
 
+def err_int_to_float_bit_int_max_size : Error<
+  "cannot convert '_BitInt' operands of more than %0 bits to floating point">;
+
+def err_float_to_int_bit_int_max_size : Error<
+  "cannot convert floating point operands to a '_BitInt' of more than %0 bits">;
+
 def err_atomic_load_store_uses_lib : Error<
   "atomic %select{load|store}0 requires runtime support that is not "
   "available for this target">;
 
 def err_nontemporal_builtin_must_be_pointer : Error<
   "address argument to nontemporal builtin must be a pointer (%0 invalid)">;
 def err_nontemporal_builtin_must_be_pointer_intfltptr_or_vector : Error<
   "address argument to nontemporal builtin must be a pointer to integer, float, "

clang/include/clang/Basic/TargetInfo.h

 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/IntrusiveRefCntPtr.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/SmallSet.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/Frontend/OpenMP/OMPGridValues.h"
+#include "llvm/IR/DerivedTypes.h"
 #include "llvm/Support/DataTypes.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/VersionTuple.h"
 #include <cassert>
 #include <string>
 #include <vector>
 
 namespace llvm {
public:
   /// chance to do implementation work if needed.
   virtual bool hasBitIntType() const {
     return false;
   }
 
   // Different targets may support a different maximum width for the _BitInt
   // type, depending on what operations are supported.
   virtual size_t getMaxBitIntWidth() const {
-    // FIXME: this value should be llvm::IntegerType::MAX_INT_BITS, which is
-    // maximum bit width that LLVM claims its IR can support. However, most
-    // backends currently have a bug where they only support division
-    // operations on types that are <= 128 bits and crash otherwise. We're
-    // setting the max supported value to 128 to be conservative.
-    return 128;
+    // TODO: Return 128 for targets that don't link libbitint?
+    return llvm::IntegerType::MAX_INT_BITS;
   }
 
   /// Determine whether _Float16 is supported on this target.
   virtual bool hasLegalHalfType() const { return HasLegalHalfType; }
 
   /// Determine whether the __float128 type is supported on this target.
   virtual bool hasFloat128Type() const { return HasFloat128; }
 
   /// Determine whether the _Float16 type is supported on this target.

clang/include/clang/Sema/Sema.h

public:
   /// Warn if we're implicitly casting from a _Nullable pointer type to a
   /// _Nonnull one.
   void diagnoseNullableToNonnullConversion(QualType DstType, QualType SrcType,
                                            SourceLocation Loc);
 
   /// Warn when implicitly casting 0 to nullptr.
   void diagnoseZeroToNullptrConversion(CastKind Kind, const Expr *E);
 
+  /// Error out when casting a floating point value to a large _BitInt
+  void diagnoseBitIntToFloating(CastKind Kind, const Expr *E);
+  void diagnoseFloatingToBitInt(CastKind Kind, QualType Ty, const Expr *E);
+
   ParsingDeclState PushParsingDeclaration(sema::DelayedDiagnosticPool &pool) {
     return DelayedDiagnostics.push(pool);
   }
   void PopParsingDeclaration(ParsingDeclState state, Decl *decl);
 
   typedef ProcessingContextState ParsingClassState;
   ParsingClassState PushParsingClass() {
     ParsingClassDepth++;

clang/lib/Driver/ToolChains/CommonArgs.h

void linkSanitizerRuntimeDeps(const ToolChain &TC,
                               llvm::opt::ArgStringList &CmdArgs);
 
 bool addXRayRuntime(const ToolChain &TC, const llvm::opt::ArgList &Args,
                     llvm::opt::ArgStringList &CmdArgs);
 
 void linkXRayRuntimeDeps(const ToolChain &TC,
                          llvm::opt::ArgStringList &CmdArgs);
 
+void addBitIntRuntime(const ToolChain &TC, llvm::opt::ArgStringList &CmdArgs,
+                      const llvm::opt::ArgList &Args);
+
 void AddRunTimeLibs(const ToolChain &TC, const Driver &D,
                     llvm::opt::ArgStringList &CmdArgs,
                     const llvm::opt::ArgList &Args);
 
 void AddStaticDeviceLibsLinking(Compilation &C, const Tool &T,
                                 const JobAction &JA,
                                 const InputInfoList &Inputs,
                                 const llvm::opt::ArgList &DriverArgs,

clang/lib/Driver/ToolChains/CommonArgs.cpp

if (AddExportDynamic)
     CmdArgs.push_back("--export-dynamic");
 
   if (SanArgs.hasCrossDsoCfi() && !AddExportDynamic)
     CmdArgs.push_back("--export-dynamic-symbol=__cfi_check");
 
   return !StaticRuntimes.empty() || !NonWholeStaticRuntimes.empty();
 }
 
+void tools::addBitIntRuntime(const ToolChain &TC, ArgStringList &CmdArgs,
+                             const ArgList &Args) {
+  std::string BitIntPath = TC.getCompilerRT(Args, "bitint");
+
+  // While building compiler-rt itself, this library is not available,
+  // so we don't try to link it.
+  if (TC.getVFS().exists(BitIntPath))
+    CmdArgs.push_back(Args.MakeArgString(BitIntPath));
+}
+
 bool tools::addXRayRuntime(const ToolChain&TC, const ArgList &Args, ArgStringList &CmdArgs) {
   if (Args.hasArg(options::OPT_shared))
     return false;
 
   if (TC.getXRayArgs().needsXRayRt()) {
     CmdArgs.push_back("-whole-archive");
     CmdArgs.push_back(TC.getCompilerRTArgString(Args, "xray"));
     for (const auto &Mode : TC.getXRayArgs().modeList())

clang/lib/Driver/ToolChains/Gnu.cpp

if (!Args.hasArg(options::OPT_nodefaultlibs)) {
       // require librt. Most modern Linux platforms do, but some may not.
       if (addOpenMPRuntime(CmdArgs, ToolChain, Args, StaticOpenMP,
                            JA.isHostOffloading(Action::OFK_OpenMP),
                            /* GompNeedsRT= */ true))
         // OpenMP runtimes implies pthreads when using the GNU toolchain.
         // FIXME: Does this really make sense for all GNU toolchains?
         WantPthread = true;
 
+      addBitIntRuntime(getToolChain(), CmdArgs, Args);
+
       AddRunTimeLibs(ToolChain, D, CmdArgs, Args);
 
       if (WantPthread && !isAndroid)
         CmdArgs.push_back("-lpthread");
 
       if (Args.hasArg(options::OPT_fsplit_stack))
         CmdArgs.push_back("--wrap=pthread_create");
 

clang/lib/Driver/ToolChains/MinGW.cpp

 }
 
 void tools::MinGW::Linker::AddLibGCC(const ArgList &Args,
                                      ArgStringList &CmdArgs) const {
   if (Args.hasArg(options::OPT_mthreads))
     CmdArgs.push_back("-lmingwthrd");
   CmdArgs.push_back("-lmingw32");
 
+  addBitIntRuntime(getToolChain(), CmdArgs, Args);
+
   // Make use of compiler-rt if --rtlib option is used
   ToolChain::RuntimeLibType RLT = getToolChain().GetRuntimeLibType(Args);
   if (RLT == ToolChain::RLT_Libgcc) {
     bool Static = Args.hasArg(options::OPT_static_libgcc) ||
                   Args.hasArg(options::OPT_static);
     bool Shared = Args.hasArg(options::OPT_shared);
     bool CXX = getToolChain().getDriver().CCCIsCXX();
 

clang/lib/Lex/LiteralSupport.cpp

for (const char *Ptr = DigitsBegin; Ptr != SuffixBegin; ++Ptr)
         N = N * radix + llvm::hexDigitValue(*Ptr);
 
     // This will truncate the value to Val's input width. Simply check
     // for overflow by comparing.
     Val = N;
     return Val.getZExtValue() != N;
   }
 
-  Val = 0;
   const char *Ptr = DigitsBegin;
 
+  if (llvm::isPowerOf2_32(radix)) {
+    unsigned BitsPerDigit = llvm::Log2(radix);
+    unsigned BitPos = NumDigits * BitsPerDigit;
+
+    llvm::APInt Temp(BitPos, 0);
+
+    while (Ptr < SuffixBegin) {
+      if (isDigitSeparator(*Ptr)) {
+        ++Ptr;
+        continue;
+      }
+      unsigned C = llvm::hexDigitValue(*Ptr++);
+      BitPos -= BitsPerDigit;
+      Temp.insertBits(C, BitPos, BitsPerDigit);
+    }
+
+    // Due to digit separators, BitPos might be greater than zero.
+    Temp.lshrInPlace(BitPos);
+
+    Val = Temp.zextOrTrunc(Val.getBitWidth());
+    return Temp.getActiveBits() > Val.getBitWidth();
+  }
+
+  Val = 0;
   llvm::APInt RadixVal(Val.getBitWidth(), radix);
   llvm::APInt CharVal(Val.getBitWidth(), 0);
   llvm::APInt OldVal = Val;
 
   bool OverflowOccurred = false;
   while (Ptr < SuffixBegin) {
     if (isDigitSeparator(*Ptr)) {
       ++Ptr;

clang/lib/Sema/Sema.cpp

if (Diags.getSuppressSystemWarnings() &&
       SourceMgr.isInSystemMacro(MaybeMacroLoc) &&
       !findMacroSpelling(MaybeMacroLoc, "NULL"))
     return;
 
   Diag(E->getBeginLoc(), diag::warn_zero_as_null_pointer_constant)
       << FixItHint::CreateReplacement(E->getSourceRange(), "nullptr");
 }
 
+void Sema::diagnoseBitIntToFloating(CastKind Kind, const Expr *E) {
+  if (Kind != CK_IntegralToFloating)
+    return;
+
+  auto Ty = E->getType();
+  if (Ty->isBitIntType() && getASTContext().getIntWidth(Ty) > 128) {
+    Diag(E->getBeginLoc(), diag::err_int_to_float_bit_int_max_size) << 128;
+  }
+}
+
+void Sema::diagnoseFloatingToBitInt(CastKind Kind, QualType Ty, const Expr *E) {
+  if (Kind != CK_FloatingToIntegral)
+    return;
+
+  if (Ty->isBitIntType() && getASTContext().getIntWidth(Ty) > 128) {
+    Diag(E->getBeginLoc(), diag::err_float_to_int_bit_int_max_size) << 128;
+  }
+}
+
 /// ImpCastExprToType - If Expr is not of type 'Type', insert an implicit cast.
 /// If there is already an implicit cast, merge into the existing one.
 /// The result is of the given category.
 ExprResult Sema::ImpCastExprToType(Expr *E, QualType Ty,
                                    CastKind Kind, ExprValueKind VK,
                                    const CXXCastPath *BasePath,
                                    CheckedConversionKind CCK) {
 #ifndef NDEBUG
if (VK == VK_PRValue && !E->isPRValue()) {
     }
   }
   assert((VK == VK_PRValue || Kind == CK_Dependent || !E->isPRValue()) &&
          "can't cast prvalue to glvalue");
 #endif
 
   diagnoseNullableToNonnullConversion(Ty, E->getType(), E->getBeginLoc());
   diagnoseZeroToNullptrConversion(Kind, E);
+  diagnoseBitIntToFloating(Kind, E);
+  diagnoseFloatingToBitInt(Kind, Ty, E);
 
   QualType ExprTy = Context.getCanonicalType(E->getType());
   QualType TypeTy = Context.getCanonicalType(Ty);
 
   if (ExprTy == TypeTy)
     return E;
 
   if (Kind == CK_ArrayToPointerDecay) {

clang/lib/Sema/SemaCast.cpp

void CastOperation::CheckCStyleCast() {
 
   DiagnoseCastOfObjCSEL(Self, SrcExpr, DestType);
   DiagnoseCallingConvCast(Self, SrcExpr, DestType, OpRange);
   DiagnoseBadFunctionCast(Self, SrcExpr, DestType);
   Kind = Self.PrepareScalarCast(SrcExpr, DestType);
   if (SrcExpr.isInvalid())
     return;
 
+  Self.diagnoseBitIntToFloating(Kind, SrcExpr.get());
+  Self.diagnoseFloatingToBitInt(Kind, DestType, SrcExpr.get());
+
   if (Kind == CK_BitCast)
     checkCastAlign();
 }
 
 void CastOperation::CheckBuiltinBitCast() {
   QualType SrcType = SrcExpr.get()->getType();
 
   if (Self.RequireCompleteType(OpRange.getBegin(), DestType,

clang/test/CodeGen/ext-int-cc.c

 // ARM: define{{.*}} arm_aapcscc void @ParamPassing3(i15 signext %{{.+}}, i31 signext %{{.+}})
 
 #if __BITINT_MAXWIDTH__ > 128
 // When supported, bit-precise types that are >128 are passed indirectly. Note,
 // FileCheck doesn't pay attention to the preprocessor, so all of these tests
 // are negated. This will give an error when a target does support larger
 // _BitInt widths to alert us to enable the test.
 void ParamPassing4(_BitInt(129) a) {}
-// LIN64-NOT: define{{.*}} void @ParamPassing4(i129* byval(i129) align 8 %{{.+}})
-// WIN64-NOT: define dso_local void @ParamPassing4(i129* %{{.+}})
-// LIN32-NOT: define{{.*}} void @ParamPassing4(i129* %{{.+}})
-// WIN32-NOT: define dso_local void @ParamPassing4(i129* %{{.+}})
-// NACL-NOT: define{{.*}} void @ParamPassing4(i129* byval(i129) align 8 %{{.+}})
-// NVPTX64-NOT: define{{.*}} void @ParamPassing4(i129* byval(i129) align 8 %{{.+}})
-// NVPTX-NOT: define{{.*}} void @ParamPassing4(i129* byval(i129) align 8 %{{.+}})
-// SPARCV9-NOT: define{{.*}} void @ParamPassing4(i129* %{{.+}})
-// SPARC-NOT: define{{.*}} void @ParamPassing4(i129* byval(i129) align 8 %{{.+}})
-// MIPS64-NOT: define{{.*}} void @ParamPassing4(i129* byval(i129) align 8 %{{.+}})
-// MIPS-NOT: define{{.*}} void @ParamPassing4(i129* byval(i129) align 8 %{{.+}})
-// SPIR64-NOT: define{{.*}} spir_func void @ParamPassing4(i129* byval(i129) align 8 %{{.+}})
-// SPIR-NOT: define{{.*}} spir_func void @ParamPassing4(i129* byval(i129) align 8 %{{.+}})
-// HEX-NOT: define{{.*}} void @ParamPassing4(i129* byval(i129) align 8 %{{.+}})
-// LANAI-NOT: define{{.*}} void @ParamPassing4(i129* byval(i129) align 4 %{{.+}})
-// R600-NOT: define{{.*}} void @ParamPassing4(i129 addrspace(5)* byval(i129) align 8 %{{.+}})
-// ARC-NOT: define{{.*}} void @ParamPassing4(i129* byval(i129) align 4 %{{.+}})
-// XCORE-NOT: define{{.*}} void @ParamPassing4(i129* byval(i129) align 4 %{{.+}})
-// RISCV64-NOT: define{{.*}} void @ParamPassing4(i129* %{{.+}})
-// RISCV32-NOT: define{{.*}} void @ParamPassing4(i129* %{{.+}})
-// WASM-NOT: define{{.*}} void @ParamPassing4(i129* byval(i129) align 8 %{{.+}})
-// SYSTEMZ-NOT: define{{.*}} void @ParamPassing4(i129* %{{.+}})
-// PPC64-NOT: define{{.*}} void @ParamPassing4(i129* byval(i129) align 8 %{{.+}})
-// PPC32-NOT: define{{.*}} void @ParamPassing4(i129* byval(i129) align 8 %{{.+}})
-// AARCH64-NOT: define{{.*}} void @ParamPassing4(i129* byval(i129) align 8 %{{.+}})
-// AARCH64DARWIN-NOT: define{{.*}} void @ParamPassing4(i129* byval(i129) align 8 %{{.+}})
-// ARM-NOT: define{{.*}} arm_aapcscc void @ParamPassing4(i129* byval(i129) align 8 %{{.+}})
+// LIN64: define{{.*}} void @ParamPassing4(i129* byval(i129) align 8 %{{.+}})
+// WIN64: define dso_local void @ParamPassing4(i129* %{{.+}})
+// LIN32: define{{.*}} void @ParamPassing4(i129* %{{.+}})
+// WIN32: define dso_local void @ParamPassing4(i129* %{{.+}})
+// NACL: define{{.*}} void @ParamPassing4(i129* byval(i129) align 8 %{{.+}})
+// NVPTX64: define{{.*}} void @ParamPassing4(i129* byval(i129) align 8 %{{.+}})
+// NVPTX: define{{.*}} void @ParamPassing4(i129* byval(i129) align 8 %{{.+}})
+// SPARCV9: define{{.*}} void @ParamPassing4(i129* %{{.+}})
+// SPARC: define{{.*}} void @ParamPassing4(i129* byval(i129) align 8 %{{.+}})
+// MIPS64: define{{.*}} void @ParamPassing4(i129* byval(i129) align 8 %{{.+}})
+// MIPS: define{{.*}} void @ParamPassing4(i129* byval(i129) align 8 %{{.+}})
+// SPIR64: define{{.*}} spir_func void @ParamPassing4(i129* byval(i129) align 8 %{{.+}})
+// SPIR: define{{.*}} spir_func void @ParamPassing4(i129* byval(i129) align 8 %{{.+}})
+// HEX: define{{.*}} void @ParamPassing4(i129* byval(i129) align 8 %{{.+}})
+// LANAI: define{{.*}} void @ParamPassing4(i129* byval(i129) align 4 %{{.+}})
+// R600: define{{.*}} void @ParamPassing4(i129 addrspace(5)* byval(i129) align 8 %{{.+}})
+// ARC: define{{.*}} void @ParamPassing4(i129* byval(i129) align 4 %{{.+}})
+// XCORE: define{{.*}} void @ParamPassing4(i129* byval(i129) align 4 %{{.+}})
+// RISCV64: define{{.*}} void @ParamPassing4(i129* %{{.+}})
+// RISCV32: define{{.*}} void @ParamPassing4(i129* %{{.+}})
+// WASM: define{{.*}} void @ParamPassing4(i129* byval(i129) align 8 %{{.+}})
+// SYSTEMZ: define{{.*}} void @ParamPassing4(i129* %{{.+}})
+// PPC64: define{{.*}} void @ParamPassing4(i129* byval(i129) align 8 %{{.+}})
+// PPC32: define{{.*}} void @ParamPassing4(i129* byval(i129) align 8 %{{.+}})
+// AARCH64: define{{.*}} void @ParamPassing4(i129* byval(i129) align 8 %{{.+}})
+// AARCH64DARWIN: define{{.*}} void @ParamPassing4(i129* byval(i129) align 8 %{{.+}})
+// ARM: define{{.*}} arm_aapcscc void @ParamPassing4(i129* byval(i129) align 8 %{{.+}})
 #endif
 
 _BitInt(63) ReturnPassing(void){}
 // LIN64: define{{.*}} i64 @ReturnPassing(
 // WIN64: define dso_local i63 @ReturnPassing(
 // LIN32: define{{.*}} i63 @ReturnPassing(
 // WIN32: define dso_local i63 @ReturnPassing(
 // NACL: define{{.*}} i63 @ReturnPassing(

 // PPC64: define{{.*}} i128 @ReturnPassing4(
 // PPC32: define{{.*}} void @ReturnPassing4(i128* noalias sret
 // AARCH64: define{{.*}} i128 @ReturnPassing4(
 // AARCH64DARWIN: define{{.*}} i128 @ReturnPassing4(
 // ARM: define{{.*}} arm_aapcscc void @ReturnPassing4(i128* noalias sret
 
 #if __BITINT_MAXWIDTH__ > 128
 _BitInt(129) ReturnPassing5(void){}
-// LIN64-NOT: define{{.*}} void @ReturnPassing5(i129* noalias sret
-// WIN64-NOT: define dso_local void @ReturnPassing5(i129* noalias sret
-// LIN32-NOT: define{{.*}} void @ReturnPassing5(i129* noalias sret
-// WIN32-NOT: define dso_local void @ReturnPassing5(i129* noalias sret
-// NACL-NOT: define{{.*}} void @ReturnPassing5(i129* noalias sret
-// NVPTX64-NOT: define{{.*}} i129 @ReturnPassing5(
-// NVPTX-NOT: define{{.*}} i129 @ReturnPassing5(
-// SPARCV9-NOT: define{{.*}} i129 @ReturnPassing5(
-// SPARC-NOT: define{{.*}} void @ReturnPassing5(i129* noalias sret
-// MIPS64-NOT: define{{.*}} void @ReturnPassing5(i129* noalias sret
-// MIPS-NOT: define{{.*}} void @ReturnPassing5(i129* noalias sret
-// SPIR64-NOT: define{{.*}} spir_func void @ReturnPassing5(i129* noalias sret
-// SPIR-NOT: define{{.*}} spir_func void @ReturnPassing5(i129* noalias sret
-// HEX-NOT: define{{.*}} void @ReturnPassing5(i129* noalias sret
-// LANAI-NOT: define{{.*}} void @ReturnPassing5(i129* noalias sret
-// R600-NOT: define{{.*}} void @ReturnPassing5(i129 addrspace(5)* noalias sret
-// ARC-NOT: define{{.*}} void @ReturnPassing5(i129* inreg noalias sret
-// XCORE-NOT: define{{.*}} void @ReturnPassing5(i129* noalias sret
-// RISCV64-NOT: define{{.*}} void @ReturnPassing5(i129* noalias sret
-// RISCV32-NOT: define{{.*}} void @ReturnPassing5(i129* noalias sret
-// WASM-NOT: define{{.*}} void @ReturnPassing5(i129* noalias sret
-// SYSTEMZ-NOT: define{{.*}} void @ReturnPassing5(i129* noalias sret
-// PPC64-NOT: define{{.*}} void @ReturnPassing5(i129* noalias sret
-// PPC32-NOT: define{{.*}} void @ReturnPassing5(i129* noalias sret
-// AARCH64-NOT: define{{.*}} void @ReturnPassing5(i129* noalias sret
-// AARCH64DARWIN-NOT: define{{.*}} void @ReturnPassing5(i129* noalias sret
-// ARM-NOT: define{{.*}} arm_aapcscc void @ReturnPassing5(i129* noalias sret
+// LIN64: define{{.*}} void @ReturnPassing5(i129* noalias sret
+// WIN64: define dso_local void @ReturnPassing5(i129* noalias sret
+// LIN32: define{{.*}} void @ReturnPassing5(i129* noalias sret
+// WIN32: define dso_local void @ReturnPassing5(i129* noalias sret
+// NACL: define{{.*}} void @ReturnPassing5(i129* noalias sret
+// NVPTX64: define{{.*}} i129 @ReturnPassing5(
+// NVPTX: define{{.*}} i129 @ReturnPassing5(
+// SPARCV9: define{{.*}} i129 @ReturnPassing5(
+// SPARC: define{{.*}} void @ReturnPassing5(i129* noalias sret
+// MIPS64: define{{.*}} void @ReturnPassing5(i129* noalias sret
+// MIPS: define{{.*}} void @ReturnPassing5(i129* noalias sret
+// SPIR64: define{{.*}} spir_func void @ReturnPassing5(i129* noalias sret
+// SPIR: define{{.*}} spir_func void @ReturnPassing5(i129* noalias sret
+// HEX: define{{.*}} void @ReturnPassing5(i129* noalias sret
+// LANAI: define{{.*}} void @ReturnPassing5(i129* noalias sret
+// R600: define{{.*}} void @ReturnPassing5(i129 addrspace(5)* noalias sret
+// ARC: define{{.*}} void @ReturnPassing5(i129* inreg noalias sret
+// XCORE: define{{.*}} void @ReturnPassing5(i129* noalias sret
+// RISCV64: define{{.*}} void @ReturnPassing5(i129* noalias sret
+// RISCV32: define{{.*}} void @ReturnPassing5(i129* noalias sret
+// WASM: define{{.*}} void @ReturnPassing5(i129* noalias sret
+// SYSTEMZ: define{{.*}} void @ReturnPassing5(i129* noalias sret
+// PPC64: define{{.*}} void @ReturnPassing5(i129* noalias sret
+// PPC32: define{{.*}} void @ReturnPassing5(i129* noalias sret
+// AARCH64: define{{.*}} void @ReturnPassing5(i129* noalias sret
+// AARCH64DARWIN: define{{.*}} void @ReturnPassing5(i129* noalias sret
+// ARM: define{{.*}} arm_aapcscc void @ReturnPassing5(i129* noalias sret
 
 // SparcV9 is odd in that it has a return-size limit of 256, not 128 or 64
 // like other platforms, so test to make sure this behavior will still work.
 _BitInt(256) ReturnPassing6(void) {}
-// SPARCV9-NOT: define{{.*}} i256 @ReturnPassing6(
+// SPARCV9: define{{.*}} i256 @ReturnPassing6(
 _BitInt(257) ReturnPassing7(void) {}
-// SPARCV9-NOT: define{{.*}} void @ReturnPassing7(i257* noalias sret
+// SPARCV9: define{{.*}} void @ReturnPassing7(i257* noalias sret
 #endif

clang/test/Driver/linux-ld.c

 // CHECK-CLANGXX-NO-LIBGCC: "-lgcc_s" "-lgcc"
 //
 // RUN: %clang -static -no-canonical-prefixes %s -### -o %t.o 2>&1 \
 // RUN:     --target=x86_64-unknown-linux -rtlib=platform --unwindlib=platform \
 // RUN:     --gcc-toolchain="" \
 // RUN:     --sysroot=%S/Inputs/basic_linux_tree \
 // RUN:   | FileCheck --check-prefix=CHECK-CLANG-NO-LIBGCC-STATIC %s
 // CHECK-CLANG-NO-LIBGCC-STATIC: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]"
-// CHECK-CLANG-NO-LIBGCC-STATIC: "--start-group" "-lgcc" "-lgcc_eh" "-lc" "--end-group"
+// CHECK-CLANG-NO-LIBGCC-STATIC: "--start-group" "{{[^"]*}}/libclang_rt.bitint{{[^"]*}}" "-lgcc" "-lgcc_eh" "-lc" "--end-group"
 //
 // RUN: %clang -static-pie -no-canonical-prefixes %s -### -o %t.o 2>&1 \
 // RUN:     --target=x86_64-unknown-linux -rtlib=platform --unwindlib=platform \
 // RUN:     --gcc-toolchain="" \
 // RUN:     --sysroot=%S/Inputs/basic_linux_tree \
 // RUN:   | FileCheck --check-prefix=CHECK-CLANG-LD-STATIC-PIE %s
 // CHECK-CLANG-LD-STATIC-PIE: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]"
 // CHECK-CLANG-LD-STATIC-PIE: "-static"
 // CHECK-CLANG-LD-STATIC-PIE: "-pie"
 // CHECK-CLANG-LD-STATIC-PIE: "--no-dynamic-linker"
 // CHECK-CLANG-LD-STATIC-PIE: "-z"
 // CHECK-CLANG-LD-STATIC-PIE: "text"
 // CHECK-CLANG-LD-STATIC-PIE: "-m" "elf_x86_64"
 // CHECK-CLANG-LD-STATIC-PIE: "{{.*}}rcrt1.o"
-// CHECK-CLANG-LD-STATIC-PIE: "--start-group" "-lgcc" "-lgcc_eh" "-lc" "--end-group"
+// CHECK-CLANG-LD-STATIC-PIE: "--start-group" "{{[^"]*}}/libclang_rt.bitint{{[^"]*}}" "-lgcc" "-lgcc_eh" "-lc" "--end-group"
 //
 // RUN: %clang -static-pie -pie -no-canonical-prefixes %s -no-pie -### -o %t.o 2>&1 \
 // RUN:     --target=x86_64-unknown-linux -rtlib=platform --unwindlib=platform \
 // RUN:     --gcc-toolchain="" \
 // RUN:     --sysroot=%S/Inputs/basic_linux_tree \
 // RUN:   | FileCheck --check-prefix=CHECK-CLANG-LD-STATIC-PIE-PIE %s
 // CHECK-CLANG-LD-STATIC-PIE-PIE: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]"
 // CHECK-CLANG-LD-STATIC-PIE-PIE: "-static"
 // CHECK-CLANG-LD-STATIC-PIE-PIE: "-pie"
 // CHECK-CLANG-LD-STATIC-PIE-PIE: "--no-dynamic-linker"
 // CHECK-CLANG-LD-STATIC-PIE-PIE: "-z"
 // CHECK-CLANG-LD-STATIC-PIE-PIE: "text"
 // CHECK-CLANG-LD-STATIC-PIE-PIE: "-m" "elf_x86_64"
 // CHECK-CLANG-LD-STATIC-PIE-PIE: "{{.*}}rcrt1.o"
-// CHECK-CLANG-LD-STATIC-PIE-PIE: "--start-group" "-lgcc" "-lgcc_eh" "-lc" "--end-group"
+// CHECK-CLANG-LD-STATIC-PIE-PIE: "--start-group" "{{[^"]*}}/libclang_rt.bitint{{[^"]*}}" "-lgcc" "-lgcc_eh" "-lc" "--end-group"
 //
 // RUN: %clang -static-pie -static -no-canonical-prefixes %s -no-pie -### -o %t.o 2>&1 \
 // RUN:     --target=x86_64-unknown-linux -rtlib=platform --unwindlib=platform \
 // RUN:     --gcc-toolchain="" \
 // RUN:     --sysroot=%S/Inputs/basic_linux_tree \
 // RUN:   | FileCheck --check-prefix=CHECK-CLANG-LD-STATIC-PIE-STATIC %s
 // CHECK-CLANG-LD-STATIC-PIE-STATIC: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]"
 // CHECK-CLANG-LD-STATIC-PIE-STATIC: "-static"
 // CHECK-CLANG-LD-STATIC-PIE-STATIC: "-pie"
 // CHECK-CLANG-LD-STATIC-PIE-STATIC: "--no-dynamic-linker"
 // CHECK-CLANG-LD-STATIC-PIE-STATIC: "-z"
 // CHECK-CLANG-LD-STATIC-PIE-STATIC: "text"
 // CHECK-CLANG-LD-STATIC-PIE-STATIC: "-m" "elf_x86_64"
 // CHECK-CLANG-LD-STATIC-PIE-STATIC: "{{.*}}rcrt1.o"
-// CHECK-CLANG-LD-STATIC-PIE-STATIC: "--start-group" "-lgcc" "-lgcc_eh" "-lc" "--end-group"
+// CHECK-CLANG-LD-STATIC-PIE-STATIC: "--start-group" "{{[^"]*}}/libclang_rt.bitint{{[^"]*}}" "-lgcc" "-lgcc_eh" "-lc" "--end-group"
 //
 // RUN: %clang -static-pie -nopie -no-canonical-prefixes %s -no-pie -### -o %t.o 2>&1 \
 // RUN:     --target=x86_64-unknown-linux -rtlib=platform \
 // RUN:     --gcc-toolchain="" \
 // RUN:     --sysroot=%S/Inputs/basic_linux_tree \
 // RUN:   | FileCheck --check-prefix=CHECK-CLANG-LD-STATIC-PIE-NOPIE %s
 // CHECK-CLANG-LD-STATIC-PIE-NOPIE: error: cannot specify 'nopie' along with 'static-pie'
 //

 // CHECK-LD-64-STATIC: "-m" "elf_x86_64"
 // CHECK-LD-64-STATIC-NOT: "-dynamic-linker"
 // CHECK-LD-64-STATIC: "-static"
 // CHECK-LD-64-STATIC: "{{.*}}/usr/lib/gcc/x86_64-unknown-linux/10.2.0{{/|\\\\}}crtbeginT.o"
 // CHECK-LD-64-STATIC: "-L[[SYSROOT]]/usr/lib/gcc/x86_64-unknown-linux/10.2.0"
 // CHECK-LD-64-STATIC: "-L[[SYSROOT]]/usr/lib/gcc/x86_64-unknown-linux/10.2.0/../../../../x86_64-unknown-linux/lib"
 // CHECK-LD-64-STATIC: "-L[[SYSROOT]]/lib"
 // CHECK-LD-64-STATIC: "-L[[SYSROOT]]/usr/lib"
-// CHECK-LD-64-STATIC: "--start-group" "-lgcc" "-lgcc_eh" "-lc" "--end-group"
+// CHECK-LD-64-STATIC: "--start-group" "{{[^"]*}}/libclang_rt.bitint{{[^"]*}}" "-lgcc" "-lgcc_eh" "-lc" "--end-group"
 
 // RUN: %clang -no-pie -### %s --target=x86_64-unknown-linux -rtlib=platform --unwindlib=platform -shared -static \
 // RUN:   --gcc-toolchain= --sysroot=%S/Inputs/basic_linux_tree 2>&1 | FileCheck --check-prefix=CHECK-LD-SHARED-STATIC %s
 // CHECK-LD-SHARED-STATIC: "-shared" "-static"
 // CHECK-LD-SHARED-STATIC: "{{.*}}/usr/lib/gcc/x86_64-unknown-linux/10.2.0{{/|\\\\}}crtbeginS.o"
 // CHECK-LD-SHARED-STATIC: "{{.*}}/usr/lib/gcc/x86_64-unknown-linux/10.2.0{{/|\\\\}}crtendS.o"
 
 // Check that flags can be combined. The -static dominates.

clang/test/Lexer/bitint-constants.c

void InvalidSuffix(void) {
   1uwbwb; // expected-error {{invalid suffix}}
 }
 
 void ValidSuffixInvalidValue(void) {
   // This is a valid suffix, but the value is larger than one that fits within
   // the width of BITINT_MAXWIDTH. When this value changes in the future, the
   // test cases should pick a new value that can't be represented by a _BitInt,
   // but also add a test case that a 129-bit literal still behaves as-expected.
-  _Static_assert(__BITINT_MAXWIDTH__ <= 128,
-               "Need to pick a bigger constant for the test case below.");
-  0xFFFF'FFFF'FFFF'FFFF'FFFF'FFFF'FFFF'FFFF'1wb; // expected-error {{integer literal is too large to be represented in any signed integer type}}
-  0xFFFF'FFFF'FFFF'FFFF'FFFF'FFFF'FFFF'FFFF'1uwb; // expected-error {{integer literal is too large to be represented in any integer type}}
+  0xFFFF'FFFF'FFFF'FFFF'FFFF'FFFF'FFFF'FFFF'1wb; // 129 bits are fine
+  0xFFFF'FFFF'FFFF'FFFF'FFFF'FFFF'FFFF'FFFF'1uwb; // 129 bit unsigned are fine
+
+  #define CONCAT(X,Y) X ## Y
+  #define REPEAT2(X) CONCAT(X,X)
+  #define REPEAT4(X) REPEAT2(REPEAT2(X))
+  #define REPEAT16(X) REPEAT4(REPEAT4(X))
+  #define REPEAT256(X) REPEAT16(REPEAT16(X))
+  #define REPEAT65536(X) REPEAT256(REPEAT256(X))
+  #define REPEAT2097152(X)  REPEAT65536(REPEAT16(REPEAT2(X)))
+  #define _LITERAL(X, Suffix) 0x ## X ## Suffix
+  #define LITERAL(X, Suffix) _LITERAL(X, Suffix)
+
+  _Static_assert(__BITINT_MAXWIDTH__ <= 8388608,
+                "Need to pick a bigger constant for the test case below.");
+
+  // 8388608 bits are represented by 2097152 hex digits
+  LITERAL(REPEAT2097152(7), wb); // 262143 bits plus one sign bit are fine
+  LITERAL(REPEAT2097152(F), wb); // expected-error {{integer literal is too large to be represented in any signed integer type}}
+
+  LITERAL(REPEAT2097152(F), uwb); // 262144 bits unsigned are fine
+  LITERAL(REPEAT2097152(F), 1uwb); // expected-error {{integer literal is too large to be represented in any integer type}}
 }
 
 void TestTypes(void) {
   // 2 value bits, one sign bit
   _Static_assert(__builtin_types_compatible_p(__typeof__(3wb), _BitInt(3)));
   // 2 value bits, one sign bit
   _Static_assert(__builtin_types_compatible_p(__typeof__(-3wb), _BitInt(3)));
   // 2 value bits, no sign bit
   _Static_assert(__builtin_types_compatible_p(__typeof__(3uwb), unsigned _BitInt(2)));
   // 4 value bits, one sign bit
   _Static_assert(__builtin_types_compatible_p(__typeof__(0xFwb), _BitInt(5)));
   // 4 value bits, one sign bit
   _Static_assert(__builtin_types_compatible_p(__typeof__(-0xFwb), _BitInt(5)));
   // 4 value bits, no sign bit
   _Static_assert(__builtin_types_compatible_p(__typeof__(0xFuwb), unsigned _BitInt(4)));
 }

clang/test/Preprocessor/init-aarch64.c

 // AARCH64-NEXT: #define __ATOMIC_ACQUIRE 2
 // AARCH64-NEXT: #define __ATOMIC_ACQ_REL 4
 // AARCH64-NEXT: #define __ATOMIC_CONSUME 1
 // AARCH64-NEXT: #define __ATOMIC_RELAXED 0
 // AARCH64-NEXT: #define __ATOMIC_RELEASE 3
 // AARCH64-NEXT: #define __ATOMIC_SEQ_CST 5
 // AARCH64:      #define __BIGGEST_ALIGNMENT__ 16
 // AARCH64_BE-NEXT: #define __BIG_ENDIAN__ 1
-// AARCH64-NEXT: #define __BITINT_MAXWIDTH__ 128
+// AARCH64-NEXT: #define __BITINT_MAXWIDTH__ 8388608
 // AARCH64-NEXT: #define __BOOL_WIDTH__ 8
 // AARCH64_BE-NEXT: #define __BYTE_ORDER__ __ORDER_BIG_ENDIAN__
 // AARCH64_LE-NEXT: #define __BYTE_ORDER__ __ORDER_LITTLE_ENDIAN__
 // AARCH64-NEXT: #define __CHAR16_TYPE__ unsigned short
 // AARCH64-NEXT: #define __CHAR32_TYPE__ unsigned int
 // AARCH64-NEXT: #define __CHAR_BIT__ 8
 // AARCH64-NEXT: #define __CLANG_ATOMIC_BOOL_LOCK_FREE 2
 // AARCH64-NEXT: #define __CLANG_ATOMIC_CHAR16_T_LOCK_FREE 2

clang/test/Preprocessor/init.c

 // EMSCRIPTEN-THREADS:#define _REENTRANT 1
 // WEBASSEMBLY-NEXT:#define __ATOMIC_ACQUIRE 2
 // WEBASSEMBLY-NEXT:#define __ATOMIC_ACQ_REL 4
 // WEBASSEMBLY-NEXT:#define __ATOMIC_CONSUME 1
 // WEBASSEMBLY-NEXT:#define __ATOMIC_RELAXED 0
 // WEBASSEMBLY-NEXT:#define __ATOMIC_RELEASE 3
 // WEBASSEMBLY-NEXT:#define __ATOMIC_SEQ_CST 5
 // WEBASSEMBLY-NEXT:#define __BIGGEST_ALIGNMENT__ 16
-// WEBASSEMBLY-NEXT:#define __BITINT_MAXWIDTH__ 128
+// WEBASSEMBLY-NEXT:#define __BITINT_MAXWIDTH__ 8388608
 // WEBASSEMBLY-NEXT:#define __BOOL_WIDTH__ 8
 // WEBASSEMBLY-NEXT:#define __BYTE_ORDER__ __ORDER_LITTLE_ENDIAN__
 // WEBASSEMBLY-NEXT:#define __CHAR16_TYPE__ unsigned short
 // WEBASSEMBLY-NEXT:#define __CHAR32_TYPE__ unsigned int
 // WEBASSEMBLY-NEXT:#define __CHAR_BIT__ 8
 // WEBASSEMBLY-NOT:#define __CHAR_UNSIGNED__
 // WEBASSEMBLY-NEXT:#define __CLANG_ATOMIC_BOOL_LOCK_FREE 2
 // WEBASSEMBLY-NEXT:#define __CLANG_ATOMIC_CHAR16_T_LOCK_FREE 2

clang/test/Sema/ext-int.c

void FromPaper1(void) {
   _Static_assert(EXPR_HAS_TYPE(a2 * a3, _BitInt(3)), "");
   _Static_assert(EXPR_HAS_TYPE(a2 * c, int), "");
   _Static_assert(EXPR_HAS_TYPE(a33 * c, _BitInt(33)), "");
 }
 
 void FromPaper2(_BitInt(8) a1, _BitInt(24) a2) {
   _Static_assert(EXPR_HAS_TYPE(a1 * (_BitInt(32))a2, _BitInt(32)), "");
 }
+
+
+void LargeBitIntToFloat(_BitInt(129) a) {
+  float fa = a; // expected-error {{cannot convert '_BitInt' operands of more than 128 bits to floating point}}
+  fa = (float)a; // expected-error {{cannot convert '_BitInt' operands of more than 128 bits to floating point}}
+  fa = a + 0.1; // expected-error {{cannot convert '_BitInt' operands of more than 128 bits to floating point}}
+}
+
+_BitInt(129) LargeBitIntFromFloat(float f) {
+  _BitInt(129) b = f; // expected-error {{cannot convert floating point operands to a '_BitInt' of more than 128 bits}}
+  b = (_BitInt(129))f; // expected-error {{cannot convert floating point operands to a '_BitInt' of more than 128 bits}}
+  return f; // expected-error {{cannot convert floating point operands to a '_BitInt' of more than 128 bits}}
+}

clang/test/SemaCXX/ext-int.cpp

_BitInt(33) Declarations(_BitInt(48) &Param) { // Useable in params and returns.
   _BitInt(43) long b;  // expected-error {{'long _BitInt' is invalid}}
 
   // These should all be fine:
   const _BitInt(5) c = 3;
   const unsigned _BitInt(5) d; // expected-error {{default initialization of an object of const type 'const unsigned _BitInt(5)'}}
   unsigned _BitInt(5) e = 5;
   _BitInt(5) unsigned f;
 
-  _BitInt(-3) g; // expected-error{{signed _BitInt of bit sizes greater than 128 not supported}}
+  _BitInt(-3) g; // expected-error{{signed _BitInt of bit sizes greater than 8388608 not supported}}
   _BitInt(0) h; // expected-error{{signed _BitInt must have a bit size of at least 2}}
   _BitInt(1) i; // expected-error{{signed _BitInt must have a bit size of at least 2}}
   _BitInt(2) j;;
   unsigned _BitInt(0) k;// expected-error{{unsigned _BitInt must have a bit size of at least 1}}
   unsigned _BitInt(1) l;
   signed _BitInt(1) m; // expected-error{{signed _BitInt must have a bit size of at least 2}}
 
   constexpr _BitInt(6) n = 33; // expected-warning{{implicit conversion from 'int' to 'const _BitInt(6)' changes value from 33 to -31}}
   constexpr _BitInt(7) o = 33;
 
   // Check imposed max size.
-  _BitInt(129) p;               // expected-error {{signed _BitInt of bit sizes greater than 128 not supported}}
-  unsigned _BitInt(0xFFFFFFFFFF) q; // expected-error {{unsigned _BitInt of bit sizes greater than 128 not supported}}
+  _BitInt(8388609) p;                // expected-error {{signed _BitInt of bit sizes greater than 8388608 not supported}}
+  unsigned _BitInt(0xFFFFFFFFFF) q; // expected-error {{unsigned _BitInt of bit sizes greater than 8388608 not supported}}
 
 // Ensure template params are instantiated correctly.
-  // expected-error@5{{signed _BitInt of bit sizes greater than 128 not supported}}
-  // expected-error@6{{unsigned _BitInt of bit sizes greater than 128 not supported}}
+  // expected-error@5{{signed _BitInt of bit sizes greater than 8388608 not supported}}
+  // expected-error@6{{unsigned _BitInt of bit sizes greater than 8388608 not supported}}
   // expected-note@+1{{in instantiation of template class }}
   HasExtInt<-1> r;
   // expected-error@5{{signed _BitInt must have a bit size of at least 2}}
   // expected-error@6{{unsigned _BitInt must have a bit size of at least 1}}
   // expected-note@+1{{in instantiation of template class }}
   HasExtInt<0> s;
   // expected-error@5{{signed _BitInt must have a bit size of at least 2}}
   // expected-note@+1{{in instantiation of template class }}
void FromPaper1() {
   static_assert(is_same<decltype(a2 * a3), _BitInt(3)>::value, "");
   static_assert(is_same<decltype(a2 * c), int>::value, "");
   static_assert(is_same<decltype(a33 * c), _BitInt(33)>::value, "");
 }
 
 void FromPaper2(_BitInt(8) a1, _BitInt(24) a2) {
   static_assert(is_same<decltype(a1 * (_BitInt(32))a2), _BitInt(32)>::value, "");
 }
+
+void LargeBitIntToFloat(_BitInt(129) a) {
+  float fa = a; // expected-error {{cannot convert '_BitInt' operands of more than 128 bits to floating point}}
+  fa = static_cast<float>(a); // expected-error {{cannot convert '_BitInt' operands of more than 128 bits to floating point}}
+  fa = a + 0.1; // expected-error {{cannot convert '_BitInt' operands of more than 128 bits to floating point}}
+}
+
+_BitInt(129) LargeBitIntFromFloat(float f) {
+  _BitInt(129) a = f; // expected-error {{cannot convert floating point operands to a '_BitInt' of more than 128 bits}}
+  a = f; // expected-error {{cannot convert floating point operands to a '_BitInt' of more than 128 bits}}
+  a = static_cast<_BitInt(129)>(f); // expected-error {{cannot convert floating point operands to a '_BitInt' of more than 128 bits}}
+  return f; // expected-error {{cannot convert floating point operands to a '_BitInt' of more than 128 bits}}
+}