[Clang] Add __builtin_bswapg (#162433)

Add a new builtin function __builtin_bswapg. It works on any integral
types that has a multiple of 16 bits as well as a single byte.

Closes #160266

Author: clingfei

clang/docs/ReleaseNotes.rst

@@ -312,6 +312,10 @@ Non-comprehensive list of changes in this release
   allocator-level heap organization strategies. A feature to instrument all
   allocation functions with a token ID can be enabled via the
   ``-fsanitize=alloc-token`` flag.
+ 
+- A new generic byte swap builtin function ``__builtin_bswapg`` that extends the existing 
+  __builtin_bswap{16,32,64} function family to support all standard integer types.
+
 - A builtin ``__builtin_infer_alloc_token(<args>, ...)`` is provided to allow
   compile-time querying of allocation token IDs, where the builtin arguments
   mirror those normally passed to an allocation function.

clang/include/clang/Basic/Builtins.td

@@ -755,6 +755,12 @@ def BSwap : Builtin, Template<["unsigned short", "uint32_t", "uint64_t"],
   let Prototype = "T(T)";
 }
 
+def BSwapg : Builtin {
+  let Spellings = ["__builtin_bswapg"];
+  let Attributes = [NoThrow, Const, Constexpr, CustomTypeChecking];
+  let Prototype = "int(...)";
+}
+
 def Bitreverse : BitInt8_16_32_64BuiltinsTemplate, Builtin {
   let Spellings = ["__builtin_bitreverse"];
   let Attributes = [NoThrow, Const, Constexpr];

clang/include/clang/Basic/DiagnosticSemaKinds.td

@@ -12967,6 +12967,9 @@ def err_builtin_invalid_arg_type: Error<
   "%plural{0:|: }3"
   "%plural{[0,3]:type|:types}1 (was %4)">;
 
+def err_bswapg_invalid_bit_width : Error<
+  "_BitInt type %0 (%1 bits) must be a multiple of 16 bits for byte swapping">;
+
 def err_builtin_trivially_relocate_invalid_arg_type: Error <
   "first%select{||| and second}0 argument%select{|||s}0 to "
   "'__builtin_trivially_relocate' must be"

clang/lib/AST/ByteCode/InterpBuiltin.cpp

@@ -972,9 +972,10 @@ static bool interp__builtin_bswap(InterpState &S, CodePtr OpPC,
                                   const InterpFrame *Frame,
                                   const CallExpr *Call) {
   const APSInt &Val = popToAPSInt(S, Call->getArg(0));
-  assert(Val.getActiveBits() <= 64);
-
-  pushInteger(S, Val.byteSwap(), Call->getType());
+  if (Val.getBitWidth() == 8)
+    pushInteger(S, Val, Call->getType());
+  else
+    pushInteger(S, Val.byteSwap(), Call->getType());
   return true;
 }
 
@@ -3687,7 +3688,7 @@ bool InterpretBuiltin(InterpState &S, CodePtr OpPC, const CallExpr *Call,
   case Builtin::BI__builtin_elementwise_ctzg:
     return interp__builtin_elementwise_countzeroes(S, OpPC, Frame, Call,
                                                    BuiltinID);
-
+  case Builtin::BI__builtin_bswapg:
   case Builtin::BI__builtin_bswap16:
   case Builtin::BI__builtin_bswap32:
   case Builtin::BI__builtin_bswap64:

clang/lib/AST/ExprConstant.cpp

@@ -15306,13 +15306,15 @@ bool IntExprEvaluator::VisitBuiltinCallExpr(const CallExpr *E,
 
     return Success(Val.reverseBits(), E);
   }
-
+  case Builtin::BI__builtin_bswapg:
   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;
+    if (Val.getBitWidth() == 8)
+      return Success(Val, E);
 
     return Success(Val.byteSwap(), E);
   }

clang/lib/CodeGen/CGBuiltin.cpp

@@ -3618,6 +3618,19 @@ RValue CodeGenFunction::EmitBuiltinExpr(const GlobalDecl GD, unsigned BuiltinID,
           Builder.CreateArithmeticFence(ArgValue, ConvertType(ArgType)));
     return RValue::get(ArgValue);
   }
+  case Builtin::BI__builtin_bswapg: {
+    Value *ArgValue = EmitScalarExpr(E->getArg(0));
+    llvm::IntegerType *IntTy = cast<llvm::IntegerType>(ArgValue->getType());
+    assert(IntTy && "LLVM's __builtin_bswapg only supports integer variants");
+    assert(((IntTy->getBitWidth() % 16 == 0 && IntTy->getBitWidth() != 0) ||
+            IntTy->getBitWidth() == 8) &&
+           "LLVM's __builtin_bswapg only supports integer variants that has a "
+           "multiple of 16 bits as well as a single byte");
+    if (IntTy->getBitWidth() == 8)
+      return RValue::get(ArgValue);
+    return RValue::get(
+        emitBuiltinWithOneOverloadedType<1>(*this, E, Intrinsic::bswap));
+  }
   case Builtin::BI__builtin_bswap16:
   case Builtin::BI__builtin_bswap32:
   case Builtin::BI__builtin_bswap64:

clang/lib/Sema/SemaChecking.cpp

@@ -2218,6 +2218,39 @@ static bool BuiltinCpu(Sema &S, const TargetInfo &TI, CallExpr *TheCall,
   return false;
 }
 
+/// Checks that __builtin_bswapg was called with a single argument, which is an
+/// unsigned integer, and overrides the return value type to the integer type.
+static bool BuiltinBswapg(Sema &S, CallExpr *TheCall) {
+  if (S.checkArgCount(TheCall, 1))
+    return true;
+  ExprResult ArgRes = S.DefaultLvalueConversion(TheCall->getArg(0));
+  if (ArgRes.isInvalid())
+    return true;
+
+  Expr *Arg = ArgRes.get();
+  TheCall->setArg(0, Arg);
+  if (Arg->isTypeDependent())
+    return false;
+
+  QualType ArgTy = Arg->getType();
+
+  if (!ArgTy->isIntegerType()) {
+    S.Diag(Arg->getBeginLoc(), diag::err_builtin_invalid_arg_type)
+        << 1 << /*scalar=*/1 << /*unsigned integer=*/1 << /*floating point=*/0
+        << ArgTy;
+    return true;
+  }
+  if (const auto *BT = dyn_cast<BitIntType>(ArgTy)) {
+    if (BT->getNumBits() % 16 != 0 && BT->getNumBits() != 8) {
+      S.Diag(Arg->getBeginLoc(), diag::err_bswapg_invalid_bit_width)
+          << ArgTy << BT->getNumBits();
+      return true;
+    }
+  }
+  TheCall->setType(ArgTy);
+  return false;
+}
+
 /// Checks that __builtin_popcountg was called with a single argument, which is
 /// an unsigned integer.
 static bool BuiltinPopcountg(Sema &S, CallExpr *TheCall) {
@@ -3522,6 +3555,10 @@ Sema::CheckBuiltinFunctionCall(FunctionDecl *FDecl, unsigned BuiltinID,
     }
     break;
   }
+  case Builtin::BI__builtin_bswapg:
+    if (BuiltinBswapg(*this, TheCall))
+      return ExprError();
+    break;
   case Builtin::BI__builtin_popcountg:
     if (BuiltinPopcountg(*this, TheCall))
       return ExprError();

clang/test/AST/ByteCode/builtin-functions.cpp

@@ -837,6 +837,39 @@ namespace bswap {
   int h3 = __builtin_bswap16(0x1234) == 0x3412 ? 1 : f();
   int h4 = __builtin_bswap32(0x1234) == 0x34120000 ? 1 : f();
   int h5 = __builtin_bswap64(0x1234) == 0x3412000000000000 ? 1 : f();
+  int h6 = __builtin_bswapg(0x12) == 0x12 ? 1 : f();
+  int h7 = __builtin_bswapg(0x1234) == 0x3412 ? 1 : f();
+  int h8 = __builtin_bswapg(0x00001234) == 0x34120000 ? 1 : f();
+  int h9 = __builtin_bswapg(0x0000000000001234) == 0x3412000000000000 ? 1 : f();
+#ifndef __AVR__
+  int h10 = __builtin_bswapg((_BitInt(8))0x12) == (_BitInt(8))0x12 ? 1 : f();
+  int h11 = __builtin_bswapg((_BitInt(16))0x1234) == (_BitInt(16))0x3412 ? 1 : f();
+  int h12 = __builtin_bswapg((_BitInt(32))0x00001234) == (_BitInt(32))0x34120000 ? 1 : f();
+  int h13 = __builtin_bswapg((_BitInt(64))0x0000000000001234) == (_BitInt(64))0x3412000000000000 ? 1 : f();
+  int h14 = __builtin_bswapg(~(_BitInt(128))0) == (~(_BitInt(128))0) ? 1 : f();
+  int h15 = __builtin_bswapg((_BitInt(24))0x1234) == (_BitInt(24))0x3412 ? 1 : f();
+  // expected-error@-1 {{_BitInt type '_BitInt(24)' (24 bits) must be a multiple of 16 bits for byte swapping}}
+  // ref-error@-2 {{_BitInt type '_BitInt(24)' (24 bits) must be a multiple of 16 bits for byte swapping}}
+#endif
+
+  constexpr const int const_expr = 0x1234;
+
+  void test_constexpr_reference() {
+    const int expr = 0x1234; 
+    const int& ref = expr; // #declare
+    
+    constexpr const int& const_ref = const_expr;
+
+    constexpr auto result2 = __builtin_bswapg(ref); 
+    //expected-error@-1 {{constexpr variable 'result2' must be initialized by a constant expression}}
+    //expected-note@-2 {{initializer of 'ref' is not a constant expression}}
+    //expected-note@#declare {{declared here}}
+    //ref-error@-4 {{constexpr variable 'result2' must be initialized by a constant expression}}
+    //ref-note@-5 {{initializer of 'ref' is not a constant expression}}
+    //ref-note@#declare {{declared here}}
+      
+    constexpr auto result3 = __builtin_bswapg(const_ref);
+  }
 }
 
 #define CFSTR __builtin___CFStringMakeConstantString

clang/test/CodeGen/builtins.c

@@ -130,7 +130,15 @@ int main(void) {
   P(object_size, (s0, 3));
 
   // Whatever
-
+  P(bswapg, ((char)N));
+  P(bswapg, ((short)N));
+  P(bswapg, ((int)N));
+  P(bswapg, ((unsigned long)N));
+  P(bswapg, ((_BitInt(8))N));
+  P(bswapg, ((_BitInt(16))N));
+  P(bswapg, ((_BitInt(32))N));
+  P(bswapg, ((_BitInt(64))N));
+  P(bswapg, ((_BitInt(128))N));
   P(bswap16, (N));
   P(bswap32, (N));
   P(bswap64, (N));
@@ -1277,3 +1285,35 @@ void test_builtin_ctzg(unsigned char uc, unsigned short us, unsigned int ui,
 }
 
 #endif
+
+// CHECK-LABEL: define{{.*}} void @test_builtin_bswapg
+void test_builtin_bswapg(unsigned char uc, unsigned short us, unsigned int ui,
+                       unsigned long ul, unsigned long long ull,
+                       unsigned __int128 ui128, _BitInt(8) bi8,
+                       _BitInt(16) bi16, _BitInt(32) bi32, 
+                       _BitInt(64) bi64, _BitInt(128) bi128) {
+  uc = __builtin_bswapg(uc);
+  // CHECK: %1 = load i8, ptr %uc.addr
+  // CHECK: store i8 %1, ptr %uc.addr
+  us = __builtin_bswapg(us);
+  // CHECK: call i16 @llvm.bswap.i16
+  ui = __builtin_bswapg(ui);
+  // CHECK: call i32 @llvm.bswap.i32
+  ul = __builtin_bswapg(ul);
+  // CHECK: call i64 @llvm.bswap.i64
+  ull = __builtin_bswapg(ull);
+  // CHECK: call i64 @llvm.bswap.i64
+  ui128 = __builtin_bswapg(ui128);
+  // CHECK: call i128 @llvm.bswap.i128
+  bi8 = __builtin_bswapg(bi8);
+  // CHECK: %17 = load i8, ptr %bi8.addr, align 1
+  // CHECK: store i8 %17, ptr %bi8.addr
+  bi16 = __builtin_bswapg(bi16);
+  // CHECK: call i16 @llvm.bswap.i16
+  bi32 = __builtin_bswapg(bi32);
+  // CHECK: call i32 @llvm.bswap.i32
+  bi64 = __builtin_bswapg(bi64);
+  // CHECK: call i64 @llvm.bswap.i64
+  bi128 = __builtin_bswapg(bi128);
+  // CHECK: call i128 @llvm.bswap.i128
+}

clang/test/CodeGenCXX/builtins.cpp

@@ -83,3 +83,59 @@ int structured_binding_size() {
   return __builtin_structured_binding_size(S2);
   // CHECK: ret i32 2
 }
+
+void test_int_reference(int& a) {
+  __builtin_bswapg(a);
+}
+// CHECK-LABEL: @_Z18test_int_referenceRi
+// CHECK: store ptr %a, ptr
+// CHECK: load ptr, ptr
+// CHECK: load i32, ptr
+// CHECK: call i32 @llvm.bswap.i32
+
+void test_long_reference(long& a) {
+  __builtin_bswapg(a);
+}
+// CHECK-LABEL: @_Z19test_long_referenceRl
+// CHECK: store ptr %a, ptr
+// CHECK: load ptr, ptr
+// CHECK: load i64, ptr
+// CHECK: call i64 @llvm.bswap.i64
+
+void test_short_reference(short& a) {
+  __builtin_bswapg(a);
+}
+// CHECK-LABEL: @_Z20test_short_referenceRs
+// CHECK: store ptr %a, ptr
+// CHECK: load ptr, ptr 
+// CHECK: load i16, ptr
+// CHECK: call i16 @llvm.bswap.i16
+
+void test_char_reference(char& a) {
+  __builtin_bswapg(a);
+}
+// CHECK-LABEL: @_Z19test_char_referenceRc
+// CHECK: store ptr %a, ptr
+// CHECK: load ptr, ptr
+// CHECK-NOT: call i8 @llvm.bswap.i8
+// CHECK: ret void
+
+void test_bitint() {
+  _BitInt(8) a = 0x12;
+  __builtin_bswapg(a);
+  _BitInt(16) b = 0x1234;
+  __builtin_bswapg(b);
+  _BitInt(32) c = 0x00001234;
+  __builtin_bswapg(c);
+  _BitInt(64) d = 0x0000000000001234;
+  __builtin_bswapg(d);
+  _BitInt(128) e = ~(_BitInt(128))0;
+  __builtin_bswapg(e);
+}
+// CHECK-LABEL: @_Z11test_bitintv
+// CHECK-NOT: call i8 @llvm.bswap.i8
+// CHECK: call i16 @llvm.bswap.i16
+// CHECK: call i32 @llvm.bswap.i32
+// CHECK: call i64 @llvm.bswap.i64
+// CHECK: call i128 @llvm.bswap.i128
+// CHECK: ret void