[LangRef] Correct value ranges for address space, vector, and float bit sizes.

[hliao]

Summary

• The current implementation checks them for 24-bit inegers but the document says 23-bit one effectively by listing the range as [1,2^23).
• Minor error message correction.

[arsenm]

llvm/lib/IR/DataLayout.cpp

308

probably should have test coverage for this

574

probably should have test coverage for this

llvm/docs/LangRef.rst

 ``p[n]:<size>:<abi>[:<pref>][:<idx>]``
     This specifies the *size* of a pointer and its ``<abi>`` and
     ``<pref>``\erred alignments for address space ``n``. ``<pref>`` is optional
     and defaults to ``<abi>``. The fourth parameter ``<idx>`` is the size of the
     index that used for address calculation. If not
     specified, the default index size is equal to the pointer size. All sizes
     are in bits. The address space, ``n``, is optional, and if not specified,
     denotes the default address space 0. The value of ``n`` must be
-    in the range [1,2^23).
+    in the range [1,2^24).
 ``i<size>:<abi>[:<pref>]``
     This specifies the alignment for an integer type of a given bit
-    ``<size>``. The value of ``<size>`` must be in the range [1,2^23).
+    ``<size>``. The value of ``<size>`` must be in the range [1,2^24).
     ``<pref>`` is optional and defaults to ``<abi>``.
     For ``i8``, the ``<abi>`` value must equal 8,
     that is, ``i8`` must be naturally aligned.
 ``v<size>:<abi>[:<pref>]``
     This specifies the alignment for a vector type of a given bit
-    ``<size>``. The value of ``<size>`` must be in the range [1,2^23).
+    ``<size>``. The value of ``<size>`` must be in the range [1,2^24).
     ``<pref>`` is optional and defaults to ``<abi>``.
 ``f<size>:<abi>[:<pref>]``
     This specifies the alignment for a floating-point type of a given bit
     ``<size>``. Only values of ``<size>`` that are supported by the target
     will work. 32 (float) and 64 (double) are supported on all targets; 80
     or 128 (different flavors of long double) are also supported on some
-    targets. The value of ``<size>`` must be in the range [1,2^23).
+    targets. The value of ``<size>`` must be in the range [1,2^24).
     ``<pref>`` is optional and defaults to ``<abi>``.
 ``a:<abi>[:<pref>]``
     This specifies the alignment for an object of aggregate type.
     ``<pref>`` is optional and defaults to ``<abi>``.
 ``F<type><abi>``
     This specifies the alignment for function pointers.
     The options for ``<type>`` are:
 

llvm/lib/IR/DataLayout.cpp

case 'e':
       break;
     case 'p': {
       // Address space.
       unsigned AddrSpace = 0;
       if (!Tok.empty())
         if (Error Err = getInt(Tok, AddrSpace))
           return Err;
       if (!isUInt<24>(AddrSpace))
-        return reportError("Invalid address space, must be a 24bit integer");
+        return reportError("Invalid address space, must be a 24-bit integer");
 
       // Size.
       if (Rest.empty())
         return reportError(
             "Missing size specification for pointer in datalayout string");
       if (Error Err = ::split(Rest, ':', Split))
         return Err;
       unsigned PointerMemSize;

 Error DataLayout::setAlignment(AlignTypeEnum AlignType, Align ABIAlign,
                                Align PrefAlign, uint32_t BitWidth) {
   // AlignmentsTy::ABIAlign and AlignmentsTy::PrefAlign were once stored as
   // uint16_t, it is unclear if there are requirements for alignment to be less
   // than 2^16 other than storage. In the meantime we leave the restriction as
   // an assert. See D67400 for context.
   assert(Log2(ABIAlign) < 16 && Log2(PrefAlign) < 16 && "Alignment too big");
   if (!isUInt<24>(BitWidth))
-    return reportError("Invalid bit width, must be a 24bit integer");
+    return reportError("Invalid bit width, must be a 24-bit integer");
   if (PrefAlign < ABIAlign)
     return reportError(
         "Preferred alignment cannot be less than the ABI alignment");
 
   SmallVectorImpl<LayoutAlignElem> *Alignments;
   switch (AlignType) {
   case AGGREGATE_ALIGN:
     StructAlignment.ABIAlign = ABIAlign;

llvm/test/Assembler/invalid-datalayout17.ll

 ; RUN: not llvm-as < %s 2>&1 | FileCheck %s
 target datalayout = "i16777216:16:16"
-; CHECK: Invalid bit width, must be a 24bit integer
+; CHECK: Invalid bit width, must be a 24-bit integer

llvm/test/Assembler/invalid-datalayout4.ll

 ; RUN: not llvm-as < %s 2>&1 | FileCheck %s
 target datalayout = "p16777216:64:64:64"
-; CHECK: Invalid address space, must be a 24bit integer
+; CHECK: Invalid address space, must be a 24-bit integer