Enable constexpr on BITREVERSE builtin intrinsics (PR47249)

[RKSimon]

Summary

This enables us to use the __builtin_bitreverse 8/16/32/64 intrinsics inside constexpr code.

[erichkeane]

This looks right to me.

[rsmith]

Can you also add documentation to LanguageExtensions.rst? Thanks!

clang/docs/ReleaseNotes.rst

65

There's no such thing as a "constexpr expression". The right term is "constant expressions".

clang/docs/LanguageExtensions.rst

.. code-block:: c++
       uint16_t rev_x = __builtin_bitreverse16(x);
       uint32_t rev_y = __builtin_bitreverse32(y);
       uint64_t rev_z = __builtin_bitreverse64(z);
 
 **Description**:
 
 The '``__builtin_bitreverse``' family of builtins is used to reverse
 the bitpattern of an integer value; for example ``0b10110110`` becomes
-``0b01101101``.
+``0b01101101``. These builtins can be used within constant expressions.
 
 ``__builtin_rotateleft``
 ------------------------
 
 * ``__builtin_rotateleft8``
 * ``__builtin_rotateleft16``
 * ``__builtin_rotateleft32``
 * ``__builtin_rotateleft64``

clang/docs/ReleaseNotes.rst

 Improvements to Clang's diagnostics
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 - ...
 
 Non-comprehensive list of changes in this release
 -------------------------------------------------
 
+- The builtin intrinsics ``__builtin_bitreverse8``, ``__builtin_bitreverse16``,
+  ``__builtin_bitreverse32`` and ``__builtin_bitreverse64`` may now be used
+  within constant expressions.
+
 - The builtin intrinsics ``__builtin_rotateleft8``, ``__builtin_rotateleft16``,
   ``__builtin_rotateleft32`` and ``__builtin_rotateleft64`` may now be used
   within constant expressions.
 
 - The builtin intrinsics ``__builtin_rotateright8``, ``__builtin_rotateright16``,
   ``__builtin_rotateright32`` and ``__builtin_rotateright64`` may now be used
   within constant expressions.
 
 New Compiler Flags
 ------------------
 

clang/lib/AST/ExprConstant.cpp

case Builtin::BI__builtin_align_down: {
     if (!Src.isInt())
       return Error(E);
     APSInt AlignedVal =
         APSInt(Src.getInt() & ~(Alignment - 1), Src.getInt().isUnsigned());
     assert(AlignedVal.getBitWidth() == Src.getInt().getBitWidth());
     return Success(AlignedVal, E);
   }
 
+  case Builtin::BI__builtin_bitreverse8:
+  case Builtin::BI__builtin_bitreverse16:
+  case Builtin::BI__builtin_bitreverse32:
+  case Builtin::BI__builtin_bitreverse64: {
+    APSInt Val;
+    if (!EvaluateInteger(E->getArg(0), Val, Info))
+      return false;
+
+    return Success(Val.reverseBits(), E);
+  }
+
   case Builtin::BI__builtin_bswap16:
   case Builtin::BI__builtin_bswap32:
   case Builtin::BI__builtin_bswap64: {
     APSInt Val;
     if (!EvaluateInteger(E->getArg(0), Val, Info))
       return false;
 
     return Success(Val.byteSwap(), E);

clang/test/Sema/constant-builtins-2.c

 char parity4[__builtin_parity(0xb823) == 1 ? 1 : -1];
 char parity5[__builtin_parity(0xb824) == 0 ? 1 : -1];
 char parity6[__builtin_parity(0xb825) == 1 ? 1 : -1];
 char parity7[__builtin_parity(0xb826) == 1 ? 1 : -1];
 char parity8[__builtin_parity(~0) == 0 ? 1 : -1];
 char parity9[__builtin_parityl(1L << (BITSIZE(long) - 1)) == 1 ? 1 : -1];
 char parity10[__builtin_parityll(1LL << (BITSIZE(long long) - 1)) == 1 ? 1 : -1];
 
+char bitreverse1[__builtin_bitreverse8(0x01) == 0x80 ? 1 : -1];
+char bitreverse2[__builtin_bitreverse16(0x3C48) == 0x123C ? 1 : -1];
+char bitreverse3[__builtin_bitreverse32(0x12345678) == 0x1E6A2C48 ? 1 : -1];
+char bitreverse4[__builtin_bitreverse64(0x0123456789ABCDEFULL) == 0xF7B3D591E6A2C480 ? 1 : -1];
+
 char rotateleft1[__builtin_rotateleft8(0x01, 5) == 0x20 ? 1 : -1];
 char rotateleft2[__builtin_rotateleft16(0x3210, 11) == 0x8190 ? 1 : -1];
 char rotateleft2[__builtin_rotateleft32(0x76543210, 22) == 0x841D950C ? 1 : -1];
 char rotateleft2[__builtin_rotateleft64(0xFEDCBA9876543210ULL, 55) == 0x87F6E5D4C3B2A19ULL ? 1 : -1];
 
 char rotateright1[__builtin_rotateright8(0x01, 5) == 0x08 ? 1 : -1];
 char rotateright2[__builtin_rotateright16(0x3210, 11) == 0x4206 ? 1 : -1];
 char rotateright2[__builtin_rotateright32(0x76543210, 22) == 0x50C841D9 ? 1 : -1];