[RFC] Handling implementation limits

[Mordante]

Summary

This is a proof-of-concept patch to be discussed on the dev ml.

[merge_guards_bot]

Unit tests: pass. 61168 tests passed, 0 failed and 728 were skipped.

clang-tidy: pass.

clang-format: pass.

Build artifacts: diff.json, clang-tidy.txt, clang-format.patch, CMakeCache.txt, console-log.txt, test-results.xml

[Mordante]

Added support for some additional features:

• Allow limits from the C standard, either sharing the C++ constants or separately.
• Allow to document the design choices for the limit.
• Allow to track the status of the limit. (This may become obsolete ones all limits are implemented, but that can take a while.)

Added some additional fields to test the C support.

Removed the .inc file from the patch, this should not be committed.

[craig.topper]

clang/docs/ImplementationQuantities.rst

71

should this say ‘not defined’?

[Mordante]

clang/docs/ImplementationQuantities.rst

71

Yes, thanks for catching it!

[Mordante]

Made some improvements based on feedback of @craig.topper:

• Adds a not
• Implements an example of the maximum string length when using -Wpedantic

[tahonermann]

clang/docs/ImplementationQuantities.rst

11

Typo: imposse -> impose.

[Mordante]

clang/docs/ImplementationQuantities.rst

11

Thanks, it will be updated in the next revision of the patch.

[rsmith]

clang/include/clang/AST/Decl.h

903

These bitfields are assumed to fit into an unsigned, and this can no longer be verified locally (changes to the .td file can break this assumption). Please add a static_assert(sizeof(ParmVarDeclBitfields) <= sizeof(unsigned), "...") next to the union below (and likewise for NonParmVarDeclBitfields).

903

I think IQ is too terse. We don't need a really short name for this; how about ImpLimits:: or similar?

clang/include/clang/Basic/ImplementationQuantities.td

107–111

Switching between upper- and lower-case names for these fields seems surprising. Please pick a consistent capitalization scheme.

clang/lib/CodeGen/CGRecordLayout.h

72

These three bitfields no longer obviously fit in 32 bits. Please keep the hard-coded 15 here and add an adjacent static_assert(IQ::BitFieldBits <= 15, "...") instead, or use some similar strategy so that the bit-field allocation and layout remains locally obvious.

[Mordante]

Thanks for the feedback!

clang/include/clang/AST/Decl.h

903

I feared ImpLimits would be considered too verbose, but I'll change it in the next revision.

903

I'm not too fond to use the static_assert(sizeof(ParamVarDeclBitFields <= sizeof(unsigned), "..."); here and use a hardcoded value and a static_assert in other places. If it's important to see the size of bit-field directly I prefer the style you suggested later: "Please keep the hard-coded 15 here and add an adjacent static_assert(IQ::BitFieldBits <= 15, "...") instead, or use some similar strategy so that the bit-field allocation and layout remains locally obvious."

I'll give it some more thoughts before updating the proposal.

clang/include/clang/Basic/ImplementationQuantities.td

107–111

This style is used in other .td files. But I'll switch to capitalize the is/has in the next revision.

clang/docs/ImplementationQuantities.rst

+..
+    -------------------------------------------------------------------
+    NOTE: This file is automatically generated by running clang-tblgen-gen
+    -clang-implementation-quantities-docs.Do not edit this file by hand !!
+   -------------------------------------------------------------------
+
+Introduction
+============
+
+This page lists the limits implemented in the Clang compiler. The available
+resources on the system running Clang may imposse other limits. For example,
+the system may have insufficient memory to compile the translation unit before
+the limits imposed by Clang are reached.
+
+
+C Standard defined quantities
+-----------------------------
+
+This is the list of limits as defined in the C standard's 'Translation limits'.
+
+Nesting levels of parenthesized declarators within a full declarator
+* Required: 63
+* Clang: *Unknown*
+
+Characters in a string literal (after concatenation).
+* Required: 509
+* Clang: 509
+* Remark: The limit is only enforced when the source is compiled in C89 mode with the compiler flag -Wpedantic.
+* Design choices: The value is required by the C89 standard.
+
+Characters in a string literal (after concatenation).
+* Required: 4095
+* Clang: 4095
+* Remark: The limit is only enforced when the source is compiled in C99 mode (or newer) with the compiler flag -Wpedantic.
+* Design choices: The value is required by the C99 and later standards.
+
+Nesting levels of conditional inclusion.
+* Required: 63
+* Clang: *Unknown*
+
+Nesting levels of parenthesized declarators within a full expression
+* Required: 63
+* Clang: *Unknown*
+
+Parameters in one function definition.
+* Required: 127
+* Clang: 65535 (16 bits)
+* Design choices: Unknown
+* Status: At least partially implemented.
+
+
+C++ Standard defined quantities
+-------------------------------
+
+This contains the Implementation Quantities of Clang as required by Annex B of
+the C++ standard.
+
+Nesting levels of conditional inclusion.
+* Recommended: 256
+* Clang: *Unknown*
+
+Nesting levels of parenthesized declarators within a full-expression.
+* Recommended: 256
+* Clang: *Unknown*
+
+Parameters in one function definition.
+* Recommended: 256
+* Clang: 65535 (16 bits)
+* Design choices: Unknown
+* Status: At least partially implemented.
+
+Recursively nested template instantiations, including substitution during template argumentdeduction.
+* Recommended: 1024
+* Clang: Controlled by option '-ftemplate-depth=N' default 1024
+* Design choices: Unknown
+* Status: At least partially implemented.
+
+Characters in a string literal (after concatenation).
+* Recommended: 65536
+* Clang: 65536
+* Remark: The limit is only enforced when the source is with the compiler flag -Wpedantic.
+* Design choices: The value is recommened by the C++ standard.
+
+
+Non standard defined quantities
+-------------------------------
+
+These limits are not defined in the standards, but are imposed in Clang.
+
+Maximum width of a bit-field.
+* Clang: 32767 (15 bits)
+* Design choices: This value avoids padding in `CodeGen::CGBitFieldInfo::CGBitFieldInfo`.
+* Status: Enforced by an assertion failure.
+
+Maximum number of nested function prototypes.
+* Clang: 127 (7 bits)
+* Design choices: Unknown
+* Status: Unknown
+

clang/docs/UsersManual.rst

.. option:: -fcomment-block-commands=[commands]
   as above.
 
 .. _c:
 
 C Language Features
 ===================
 
 The support for standard C in clang is feature-complete except for the
-C99 floating-point pragmas.
+C99 floating-point pragmas. For detailed information about implemented limits
+of C features please refer to :doc:`ImplementationQuantities`.
 
 Extensions supported by clang
 -----------------------------
 
 See :doc:`LanguageExtensions`.
 
 Differences between various standard modes
 ------------------------------------------
.. option:: -ftemplate-depth=N
   Sets the limit for recursively nested template instantiations to N.  The
   default is 1024.
 
 .. option:: -foperator-arrow-depth=N
 
   Sets the limit for iterative calls to 'operator->' functions to N.  The
   default is 256.
 
+For detailed information about implemented limits of C++ features please
+refer to :doc:`ImplementationQuantities`.
+
 .. _objc:
 
 Objective-C Language Features
 =============================
 
 .. _objcxx:
 
 Objective-C++ Language Features

clang/include/clang/AST/Decl.h

 #include "clang/AST/DeclarationName.h"
 #include "clang/AST/ExternalASTSource.h"
 #include "clang/AST/NestedNameSpecifier.h"
 #include "clang/AST/Redeclarable.h"
 #include "clang/AST/Type.h"
 #include "clang/Basic/AddressSpaces.h"
 #include "clang/Basic/Diagnostic.h"
 #include "clang/Basic/IdentifierTable.h"
+#include "clang/Basic/ImplementationQuantities.h"
 #include "clang/Basic/LLVM.h"
 #include "clang/Basic/Linkage.h"
 #include "clang/Basic/OperatorKinds.h"
 #include "clang/Basic/PartialDiagnostic.h"
 #include "clang/Basic/PragmaKinds.h"
 #include "clang/Basic/SourceLocation.h"
 #include "clang/Basic/Specifiers.h"
 #include "clang/Basic/Visibility.h"
protected:
 
   enum DefaultArgKind {
     DAK_None,
     DAK_Unparsed,
     DAK_Uninstantiated,
     DAK_Normal
   };
 
-  enum { NumScopeDepthOrObjCQualsBits = 7 };
-
   class ParmVarDeclBitfields {
     friend class ASTDeclReader;
     friend class ParmVarDecl;
 
     unsigned : NumVarDeclBits;
 
     /// Whether this parameter inherits a default argument from a
     /// prior declaration.
class ParmVarDeclBitfields {
 
     /// Whether this parameter is an ObjC method parameter or not.
     unsigned IsObjCMethodParam : 1;
 
     /// If IsObjCMethodParam, a Decl::ObjCDeclQualifier.
     /// Otherwise, the number of function parameter scopes enclosing
     /// the function parameter scope in which this parameter was
     /// declared.
-    unsigned ScopeDepthOrObjCQuals : NumScopeDepthOrObjCQualsBits;
+    unsigned ScopeDepthOrObjCQuals : IQ::NumScopeDepthOrObjCQualsBits;
 
     /// The number of parameters preceding this parameter in the
     /// function parameter scope in which it was declared.
     unsigned ParameterIndex : NumParameterIndexBits;
   };
 
   class NonParmVarDeclBitfields {
     friend class ASTDeclReader;
public:
   }
 
   unsigned getFunctionScopeDepth() const {
     if (ParmVarDeclBits.IsObjCMethodParam) return 0;
     return ParmVarDeclBits.ScopeDepthOrObjCQuals;
   }
 
   static constexpr unsigned getMaxFunctionScopeDepth() {
-    return (1u << NumScopeDepthOrObjCQualsBits) - 1;
+    return IQ::MaxNumScopeDepthOrObjCQuals;
   }
 
   /// Returns the index of this parameter in its prototype or method scope.
   unsigned getFunctionScopeIndex() const {
     return getParameterIndex();
   }
 
   ObjCDeclQualifier getObjCDeclQualifier() const {

clang/include/clang/AST/Type.h

 #define LLVM_CLANG_AST_TYPE_H
 
 #include "clang/AST/NestedNameSpecifier.h"
 #include "clang/AST/TemplateName.h"
 #include "clang/Basic/AddressSpaces.h"
 #include "clang/Basic/AttrKinds.h"
 #include "clang/Basic/Diagnostic.h"
 #include "clang/Basic/ExceptionSpecificationType.h"
+#include "clang/Basic/ImplementationQuantities.h"
 #include "clang/Basic/LLVM.h"
 #include "clang/Basic/Linkage.h"
 #include "clang/Basic/PartialDiagnostic.h"
 #include "clang/Basic/SourceLocation.h"
 #include "clang/Basic/Specifiers.h"
 #include "clang/Basic/Visibility.h"
 #include "llvm/ADT/APInt.h"
 #include "llvm/ADT/APSInt.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/FoldingSet.h"
 #include "llvm/ADT/None.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/PointerIntPair.h"
 #include "llvm/ADT/PointerUnion.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/ADT/iterator_range.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/PointerLikeTypeTraits.h"
-#include "llvm/Support/type_traits.h"
 #include "llvm/Support/TrailingObjects.h"
+#include "llvm/Support/type_traits.h"
 #include <cassert>
 #include <cstddef>
 #include <cstdint>
 #include <cstring>
 #include <string>
 #include <type_traits>
 #include <utility>
 

clang/include/clang/Basic/CMakeLists.txt

clang_tablegen(AttrSubMatchRulesList.inc -gen-clang-attr-subject-match-rule-list
   TARGET ClangAttrSubjectMatchRuleList)
 
 clang_tablegen(AttrHasAttributeImpl.inc -gen-clang-attr-has-attribute-impl
   -I ${CMAKE_CURRENT_SOURCE_DIR}/../../
   SOURCE Attr.td
   TARGET ClangAttrHasAttributeImpl
   )
 
+clang_tablegen(ImplementationQuantities.inc -gen-clang-implementation-quantities
+  -I ${CMAKE_CURRENT_SOURCE_DIR}/../../
+  SOURCE ImplementationQuantities.td
+  TARGET ClangImplementationQuantities
+)
+
 # ARM NEON and MVE
 clang_tablegen(arm_neon.inc -gen-arm-neon-sema
   SOURCE arm_neon.td
   TARGET ClangARMNeon)
 clang_tablegen(arm_fp16.inc -gen-arm-neon-sema
   SOURCE arm_fp16.td
   TARGET ClangARMFP16)
 clang_tablegen(arm_mve_builtins.inc -gen-arm-mve-builtin-def

clang/include/clang/Basic/ImplementationQuantities.h

+//===--- ImplementationQuantities.h ----------------------*- C++ -*-===//
+//
+// 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
+//
+//===--------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_BASIC_IMPLEMENTATIONQUANTITIES_H
+#define LLVM_CLANG_BASIC_IMPLEMENTATIONQUANTITIES_H
+
+namespace clang {
+
+#include "clang/Basic/ImplementationQuantities.inc"
+
+} // end namespace clang
+
+#endif

clang/include/clang/Basic/ImplementationQuantities.td

+//==--- ImplementationQuantities.td - Implementation quantities ----------===//
+//
+// 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
+//
+//===---------------------------------------------------------------------===//
+
+def GlobalDocumentation {
+  code Intro = [{..
+    -------------------------------------------------------------------
+    NOTE: This file is automatically generated by running clang-tblgen-gen
+    -clang-implementation-quantities-docs.Do not edit this file by hand !!
+   -------------------------------------------------------------------
+
+Introduction
+============
+
+This page lists the limits implemented in the Clang compiler. The available
+resources on the system running Clang may imposse other limits. For example,
+the system may have insufficient memory to compile the translation unit before
+the limits imposed by Clang are reached.
+
+}];
+
+  code C = [{
+C Standard defined quantities
+-----------------------------
+
+This is the list of limits as defined in the C standard's 'Translation limits'.
+
+}];
+
+  code CXX = [{
+C++ Standard defined quantities
+-------------------------------
+
+This contains the Implementation Quantities of Clang as required by Annex B of
+the C++ standard.
+
+}];
+
+code Non_standard = [{
+Non standard defined quantities
+-------------------------------
+
+These limits are not defined in the standards, but are imposed in Clang.
+
+}];
+}
+
+class IQ<string N, string T, int R> {
+  // The variable base name
+  string Name = N;
+
+  // The description of the limit, often a copy from [implimits]
+  string Description = T;
+
+  // The description of the limit as documented in the C standard. If the value
+  // is the same as C++ leave it empty.
+  string Description_C_standard = "";
+
+  // If the limit is controlled by a compiler flag this field contains the name
+  // of the flag.
+  // If the limit is controlled by a description this field contains the
+  // description of the limit.
+  string CompilerFlagOrDescription = "";
+
+  // Explains the the design choices made in Clang. This should aid developers
+  // to determine why the current limit has been choosen so they can determine
+  // the impact of changing the value.
+  string DesignChoices = "";
+
+  // The status of the implementation and enforcing of the limit in Clang.
+  string Status = "";
+
+  // The recommended value of [implimits]. If the quantity is not a standard
+  // quantity it is set to 0.
+  int Recommended = R;
+
+  // The required number of Translation limits.
+  int Required = 0;
+
+  // The number of bits of the limit.
+  int Bits = 0;
+
+  // The numeric value of the limit.
+  int Value = 0;
+
+  // The type of limit used is determined by one of these bits:
+  // * isBitLimit The quantity is limited by a number of bits:
+  //   * Bits Is the number of bits used
+  //   * Value Contains maximum value based on the number of Bits as an unsigned
+  //     bit-field.
+  // * isValueLimit The quantity is limited by a value:
+  //   * Bits Unused.
+  //   * Value The maximum value of the limit.
+  // * isCompilerFlagLimit The quantity is limited by a value based on a
+  //   compiler flag:
+  //   * Bits Unused.
+  //   * Value The default value of the limit.
+  // * isDescriptionLimit The quantity's limit is described by a text. For
+  //   exmple 'limited by the size of the stack'.
+  // * hasRemark if the limit is controlled by isBitLimit or isValueLimit
+  //   the CompilerFlagOrDescription can have an additional remark which is
+  //   stored in this field
+  bit isBitLimit = 0;
+  bit isValueLimit = 0;
+  bit isCompilerFlagLimit = 0;
+  bit isDescriptionLimit = 0;
+  bit hasRemark = 0;
+}
+
+class IQImpl<string N, string T, int R, string DC, string S> : IQ<N, T, R> {
+  let DesignChoices = DC;
+  let Status = S;
+}
+
+class IQBits<string N, string T, int R, int B, string DC, string S>
+    : IQImpl<N, T, R, DC, S> {
+  let Bits = B;
+  let isBitLimit = 1;
+}
+
+class IQValue<string N, string T, int R, int V, string DC, string S>
+    : IQImpl<N, T, R, DC, S> {
+  let Value = V;
+  let isValueLimit = 1;
+}
+
+class IQValueWithRemark<string N, string T, int R, int V, string DC, string S,
+                        string D> : IQImpl<N, T, R, DC, S> {
+  let Value = V;
+  let isValueLimit = 1;
+  let CompilerFlagOrDescription = D;
+  let hasRemark = 1;
+}
+
+class IQCompilerFlag<string N, string T, int R, string CF, int V, string DC,
+                     string S> : IQImpl<N, T, R, DC, S> {
+  let CompilerFlagOrDescription = CF;
+  let Value = V;
+  let isCompilerFlagLimit = 1;
+}
+
+class IQDescription<string N, string T, int R, string D, string DC, string S>
+    : IQImpl<N, T, R, DC, S> {
+  let CompilerFlagOrDescription = D;
+  let isDescriptionLimit = 1;
+}
+
+//
+// C only standard defined limits
+//
+
+let Required = 63 in
+def : IQ<"",
+              "Nesting levels of parenthesized declarators within a "
+              "full declarator", 0>;
+
+let Required = 509 in
+def : IQValueWithRemark<"StringLiteralLengthC89",
+                        "Characters in a string literal (after concatenation).",
+                        0,
+                        509,
+                        "The value is required by the C89 standard.",
+                        "",
+                        "The limit is only enforced when the source is "
+                        "compiled in C89 mode with the compiler flag "
+                        "-Wpedantic.">;
+
+let Required = 4095 in
+def : IQValueWithRemark<"StringLiteralLengthC99",
+                        "Characters in a string literal (after concatenation).",
+                        0,
+                        4095,
+                        "The value is required by the C99 and later standards.",
+                        "",
+                        "The limit is only enforced when the source is "
+                        "compiled in C99 mode (or newer) with the compiler "
+                        "flag -Wpedantic.">;
+
+//
+// C/C++ Standard defined quantities
+//
+
+
+let Required = 63 in
+def : IQ<"", "Nesting levels of conditional inclusion.", 256>;
+
+
+let Required = 63,
+Description_C_standard = "Nesting levels of parenthesized declarators within "
+                         "a full expression"  in
+def : IQ<"",
+              "Nesting levels of parenthesized declarators within a "
+              "full-expression.", 256>;
+
+
+let Required = 127 in
+def : IQBits<"NumParams", "Parameters in one function definition.", 256, 16,
+             "Unknown", "At least partially implemented.">;
+
+def : IQCompilerFlag<"InstantiationDepth",
+                     "Recursively nested template instantiations, including "
+                     "substitution during template argumentdeduction.",
+                     1024, "-ftemplate-depth=N", 1024, "Unknown",
+                     "At least partially implemented.">;
+
+def : IQValueWithRemark<
+          "StringLiteralLengthCXX",
+          "Characters in a string literal (after concatenation).",
+          65536,
+          65536,
+          "The value is recommened by the C++ standard.",
+          "",
+          "The limit is only enforced when the source is with the compiler "
+          "flag -Wpedantic.">;
+
+//
+//
+// TODO copy the other quantities of the Standard's Annex B.
+//
+//
+
+
+//
+// Non standard defined quantities
+//
+
+def BitFieldWidth : IQBits<"BitField", "Maximum width of a bit-field.", 0, 15,
+                           "This value avoids padding in "
+                           "`CodeGen::CGBitFieldInfo::CGBitFieldInfo`.",
+                           "Enforced by an assertion failure.">;
+
+def NestedFunctionPrototypes
+    : IQBits<"NumScopeDepthOrObjCQuals",
+             "Maximum number of nested function prototypes.", 0, 7,
+             "Unknown", "Unknown">;

clang/lib/CodeGen/CGRecordLayout.h

 //===--- CGRecordLayout.h - LLVM Record Layout Information ------*- C++ -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_LIB_CODEGEN_CGRECORDLAYOUT_H
 #define LLVM_CLANG_LIB_CODEGEN_CGRECORDLAYOUT_H
 
 #include "clang/AST/CharUnits.h"
 #include "clang/AST/DeclCXX.h"
+#include "clang/Basic/ImplementationQuantities.h"
 #include "clang/Basic/LLVM.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/IR/DerivedTypes.h"
 
 namespace llvm {
   class StructType;
 }
 

 ///   }
 ///
 struct CGBitFieldInfo {
   /// The offset within a contiguous run of bitfields that are represented as
   /// a single "field" within the LLVM struct type. This offset is in bits.
   unsigned Offset : 16;
 
   /// The total size of the bit-field, in bits.
-  unsigned Size : 15;
+  unsigned Size : IQ::BitFieldBits;
 
   /// Whether the bit-field is signed.
   unsigned IsSigned : 1;
 
   /// The storage size in bits which should be used when accessing this
   /// bitfield.
   unsigned StorageSize;
 

clang/lib/Frontend/CompilerInvocation.cpp

 #include "clang/Basic/Builtins.h"
 #include "clang/Basic/CharInfo.h"
 #include "clang/Basic/CodeGenOptions.h"
 #include "clang/Basic/CommentOptions.h"
 #include "clang/Basic/DebugInfoOptions.h"
 #include "clang/Basic/Diagnostic.h"
 #include "clang/Basic/DiagnosticOptions.h"
 #include "clang/Basic/FileSystemOptions.h"
+#include "clang/Basic/ImplementationQuantities.h"
 #include "clang/Basic/LLVM.h"
 #include "clang/Basic/LangOptions.h"
 #include "clang/Basic/LangStandard.h"
 #include "clang/Basic/ObjCRuntime.h"
 #include "clang/Basic/Sanitizers.h"
 #include "clang/Basic/SourceLocation.h"
 #include "clang/Basic/TargetOptions.h"
 #include "clang/Basic/Version.h"
Diags.Report(diag::err_fe_invalid_alignment) << A->getAsString(Args)
                                                  << A->getValue();
     Opts.NewAlignOverride = 0;
   }
   Opts.ConceptsTS = Args.hasArg(OPT_fconcepts_ts);
   Opts.HeinousExtensions = Args.hasArg(OPT_fheinous_gnu_extensions);
   Opts.AccessControl = !Args.hasArg(OPT_fno_access_control);
   Opts.ElideConstructors = !Args.hasArg(OPT_fno_elide_constructors);
   Opts.MathErrno = !Opts.OpenCL && Args.hasArg(OPT_fmath_errno);
-  Opts.InstantiationDepth =
-      getLastArgIntValue(Args, OPT_ftemplate_depth, 1024, Diags);
+  Opts.InstantiationDepth = getLastArgIntValue(
+      Args, OPT_ftemplate_depth, IQ::InstantiationDepthDefault, Diags);
   Opts.ArrowDepth =
       getLastArgIntValue(Args, OPT_foperator_arrow_depth, 256, Diags);
   Opts.ConstexprCallDepth =
       getLastArgIntValue(Args, OPT_fconstexpr_depth, 512, Diags);
   Opts.ConstexprStepLimit =
       getLastArgIntValue(Args, OPT_fconstexpr_steps, 1048576, Diags);
   Opts.EnableNewConstInterp =
       Args.hasArg(OPT_fexperimental_new_constant_interpreter);

clang/lib/Lex/LiteralSupport.cpp

 //===--- LiteralSupport.cpp - Code to parse and process literals ----------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the NumericLiteralParser, CharLiteralParser, and
 // StringLiteralParser interfaces.
 //
 //===----------------------------------------------------------------------===//
 
 #include "clang/Lex/LiteralSupport.h"
 #include "clang/Basic/CharInfo.h"
+#include "clang/Basic/ImplementationQuantities.h"
 #include "clang/Basic/LangOptions.h"
 #include "clang/Basic/SourceLocation.h"
 #include "clang/Basic/TargetInfo.h"
 #include "clang/Lex/LexDiagnostic.h"
 #include "clang/Lex/Lexer.h"
 #include "clang/Lex/Preprocessor.h"
 #include "clang/Lex/Token.h"
 #include "llvm/ADT/APInt.h"
if (GetStringLength() > 256) {
                       diag::err_pascal_string_too_long)
           << SourceRange(StringToks.front().getLocation(),
                          StringToks.back().getLocation());
       hadError = true;
       return;
     }
   } else if (Diags) {
     // Complain if this string literal has too many characters.
-    unsigned MaxChars = Features.CPlusPlus? 65536 : Features.C99 ? 4095 : 509;
+    unsigned MaxChars = Features.CPlusPlus
+                            ? IQ::MaxStringLiteralLengthCXX
+                            : Features.C99 ? IQ::MaxStringLiteralLengthC99
+                                           : IQ::MaxStringLiteralLengthC89;
 
     if (GetNumStringChars() > MaxChars)
       Diags->Report(StringToks.front().getLocation(),
                     diag::ext_string_too_long)
         << GetNumStringChars() << MaxChars
         << (Features.CPlusPlus ? 2 : Features.C99 ? 1 : 0)
         << SourceRange(StringToks.front().getLocation(),
                        StringToks.back().getLocation());

clang/utils/TableGen/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS Support)
 
 add_tablegen(clang-tblgen CLANG
   ASTTableGen.cpp
   ClangASTNodesEmitter.cpp
   ClangASTPropertiesEmitter.cpp
   ClangAttrEmitter.cpp
   ClangCommentCommandInfoEmitter.cpp
   ClangCommentHTMLNamedCharacterReferenceEmitter.cpp
   ClangCommentHTMLTagsEmitter.cpp
   ClangDataCollectorsEmitter.cpp
   ClangDiagnosticsEmitter.cpp
   ClangOpcodesEmitter.cpp
+  ClangImplementationQuantitiesEmitter.cpp
   ClangOpenCLBuiltinEmitter.cpp
   ClangOptionDocEmitter.cpp
   ClangSACheckersEmitter.cpp
   ClangTypeNodesEmitter.cpp
   MveEmitter.cpp
   NeonEmitter.cpp
   TableGen.cpp
   )
 set_target_properties(clang-tblgen PROPERTIES FOLDER "Clang tablegenning")

clang/utils/TableGen/ClangImplementationQuantitiesEmitter.cpp

+//===--- ClangCommentCommandInfoEmitter.cpp - Generate command lists -----====//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/TableGen/Error.h"
+#include "llvm/TableGen/Record.h"
+#include "llvm/TableGen/StringMatcher.h"
+#include "llvm/TableGen/TableGenBackend.h"
+#include <vector>
+
+using namespace llvm;
+
+namespace clang {
+
+void EmitClangImplementationQuantitiesDocs(RecordKeeper &Records,
+                                           raw_ostream &OS) {
+  // Get the documentation introduction paragraph.
+  const Record *Documentation = Records.getDef("GlobalDocumentation");
+  if (!Documentation) {
+    llvm::PrintFatalError("The Documentation top-level definition is missing, "
+                          "no documentation will be generated.");
+    return;
+  }
+
+  auto WriteValueAndSuffix = [&OS](Record *Tag) {
+    if (Tag->getValueAsBit("isBitLimit")) {
+      int Bits = Tag->getValueAsInt("Bits");
+      OS << ((1 << Bits) - 1) << " (" << Bits << " bits)";
+    } else if (Tag->getValueAsBit("isValueLimit"))
+      OS << Tag->getValueAsInt("Value");
+    else if (Tag->getValueAsBit("isCompilerFlagLimit"))
+      OS << "Controlled by option '"
+         << Tag->getValueAsString("CompilerFlagOrDescription") << "' default "
+         << Tag->getValueAsInt("Value");
+    else if (Tag->getValueAsBit("isDescriptionLimit"))
+      OS << Tag->getValueAsString("CompilerFlagOrDescription");
+    else
+      OS << "*Unknown*";
+
+    if (Tag->getValueAsBit("hasRemark"))
+      OS << "\n* Remark: "
+         << Tag->getValueAsString("CompilerFlagOrDescription");
+
+    std::string DC = Tag->getValueAsString("DesignChoices");
+    if (!DC.empty())
+      OS << "\n* Design choices: " << DC;
+
+    std::string Status = Tag->getValueAsString("Status");
+    if (!Status.empty())
+      OS << "\n* Status: " << Status;
+
+    OS << "\n\n";
+  };
+
+  OS << Documentation->getValueAsString("Intro");
+  std::vector<Record *> NonStandard;
+
+  OS << Documentation->getValueAsString("C");
+  for (auto Tag : Records.getAllDerivedDefinitions("IQ")) {
+    int Required = Tag->getValueAsInt("Required");
+    if (Required == 0) {
+      if (Tag->getValueAsInt("Recommended") == 0)
+        NonStandard.push_back(Tag);
+      continue;
+    }
+
+    std::string Decription = Tag->getValueAsString("Description_C_standard");
+    if (Decription.empty())
+      Decription = Tag->getValueAsString("Description");
+
+    OS << Decription << "\n* Required: " << Required << "\n* Clang: ";
+
+    WriteValueAndSuffix(Tag);
+  }
+
+  OS << Documentation->getValueAsString("CXX");
+  for (auto Tag : Records.getAllDerivedDefinitions("IQ")) {
+    int Recommended = Tag->getValueAsInt("Recommended");
+    if (Recommended == 0)
+      continue;
+
+    OS << Tag->getValueAsString("Description")
+       << "\n* Recommended: " << Recommended << "\n* Clang: ";
+
+    WriteValueAndSuffix(Tag);
+  }
+
+  if (NonStandard.empty())
+    return;
+
+  OS << Documentation->getValueAsString("Non_standard");
+
+  for (auto Tag : NonStandard) {
+    OS << Tag->getValueAsString("Description") << "\n* Clang: ";
+
+    WriteValueAndSuffix(Tag);
+  }
+}
+
+void EmitClangImplementationQuantities(RecordKeeper &Records, raw_ostream &OS) {
+  emitSourceFileHeader("A list of commands useable in documentation comments",
+                       OS);
+
+  OS << "namespace IQ {\n";
+
+  for (auto Tag : Records.getAllDerivedDefinitions("IQ")) {
+    if (Tag->getValueAsBit("isDescriptionLimit"))
+      continue;
+
+    auto Name = Tag->getValueAsString("Name");
+    if (Name.empty())
+      continue;
+
+    if (Tag->getValueAsBit("isBitLimit")) {
+      int Bits = Tag->getValueAsInt("Bits");
+      OS << "constexpr unsigned " << Name << "Bits = " << Bits << ";\n";
+      OS << "constexpr unsigned Max" << Name << " = " << ((1u << Bits) - 1)
+         << ";\n";
+    } else if (Tag->getValueAsBit("isValueLimit"))
+      OS << "constexpr unsigned Max" << Name << " = "
+         << Tag->getValueAsInt("Value") << ";\n";
+    else if (Tag->getValueAsBit("isCompilerFlagLimit"))
+      OS << "constexpr unsigned " << Name
+         << "Default = " << Tag->getValueAsInt("Value") << ";\n";
+    else
+      PrintWarning("No tag set for \"" + Name + "\" no output is generated.");
+  }
+  OS << "} // IQ namespace\n\n";
+}
+
+} // end namespace clang

clang/utils/TableGen/TableGen.cpp

enum ActionType {
   GenClangTypeWriter,
   GenClangOpcodes,
   GenClangSACheckers,
   GenClangCommentHTMLTags,
   GenClangCommentHTMLTagsProperties,
   GenClangCommentHTMLNamedCharacterReferences,
   GenClangCommentCommandInfo,
   GenClangCommentCommandList,
+  GenClangImplementationQuantitiesDocs,
+  GenClangImplementationQuantities,
   GenClangOpenCLBuiltins,
   GenArmNeon,
   GenArmFP16,
   GenArmNeonSema,
   GenArmNeonTest,
   GenArmMveHeader,
   GenArmMveBuiltinDef,
   GenArmMveBuiltinSema,
cl::values(
                    "Generate function to translate named character "
                    "references to UTF-8 sequences"),
         clEnumValN(GenClangCommentCommandInfo, "gen-clang-comment-command-info",
                    "Generate command properties for commands that "
                    "are used in documentation comments"),
         clEnumValN(GenClangCommentCommandList, "gen-clang-comment-command-list",
                    "Generate list of commands that are used in "
                    "documentation comments"),
+        clEnumValN(GenClangImplementationQuantitiesDocs,
+                   "gen-clang-implementation-quantities-docs",
+                   "Generate documentation of the implementation quantities "
+                   "as defined in the C++ standard"),
+        clEnumValN(GenClangImplementationQuantities,
+                   "gen-clang-implementation-quantities",
+                   "Generate of the implementation quantities "
+                   "as defined in the C++ standard"),
         clEnumValN(GenClangOpenCLBuiltins, "gen-clang-opencl-builtins",
                    "Generate OpenCL builtin declaration handlers"),
         clEnumValN(GenArmNeon, "gen-arm-neon", "Generate arm_neon.h for clang"),
         clEnumValN(GenArmFP16, "gen-arm-fp16", "Generate arm_fp16.h for clang"),
         clEnumValN(GenArmNeonSema, "gen-arm-neon-sema",
                    "Generate ARM NEON sema support for clang"),
         clEnumValN(GenArmNeonTest, "gen-arm-neon-test",
                    "Generate ARM NEON tests for clang"),
case GenClangCommentHTMLNamedCharacterReferences:
     EmitClangCommentHTMLNamedCharacterReferences(Records, OS);
     break;
   case GenClangCommentCommandInfo:
     EmitClangCommentCommandInfo(Records, OS);
     break;
   case GenClangCommentCommandList:
     EmitClangCommentCommandList(Records, OS);
     break;
+  case GenClangImplementationQuantitiesDocs:
+    EmitClangImplementationQuantitiesDocs(Records, OS);
+    break;
+  case GenClangImplementationQuantities:
+    EmitClangImplementationQuantities(Records, OS);
+    break;
   case GenClangOpenCLBuiltins:
     EmitClangOpenCLBuiltins(Records, OS);
     break;
   case GenArmNeon:
     EmitNeon(Records, OS);
     break;
   case GenArmFP16:
     EmitFP16(Records, OS);

clang/utils/TableGen/TableGenBackends.h

void EmitClangCommentHTMLTagsProperties(llvm::RecordKeeper &Records,
                                         llvm::raw_ostream &OS);
 void EmitClangCommentHTMLNamedCharacterReferences(llvm::RecordKeeper &Records,
                                                   llvm::raw_ostream &OS);
 
 void EmitClangCommentCommandInfo(llvm::RecordKeeper &Records,
                                  llvm::raw_ostream &OS);
 void EmitClangCommentCommandList(llvm::RecordKeeper &Records,
                                  llvm::raw_ostream &OS);
+
 void EmitClangOpcodes(llvm::RecordKeeper &Records, llvm::raw_ostream &OS);
 
+void EmitClangImplementationQuantitiesDocs(llvm::RecordKeeper &Records,
+                                           llvm::raw_ostream &OS);
+void EmitClangImplementationQuantities(llvm::RecordKeeper &Records,
+                                       llvm::raw_ostream &OS);
+
 void EmitNeon(llvm::RecordKeeper &Records, llvm::raw_ostream &OS);
 void EmitFP16(llvm::RecordKeeper &Records, llvm::raw_ostream &OS);
 void EmitNeonSema(llvm::RecordKeeper &Records, llvm::raw_ostream &OS);
 void EmitNeonTest(llvm::RecordKeeper &Records, llvm::raw_ostream &OS);
 void EmitNeon2(llvm::RecordKeeper &Records, llvm::raw_ostream &OS);
 void EmitNeonSema2(llvm::RecordKeeper &Records, llvm::raw_ostream &OS);
 void EmitNeonTest2(llvm::RecordKeeper &Records, llvm::raw_ostream &OS);