add failure tests and reference tests, and adjust checks according to conversation

Author: clingfei

clang/lib/AST/ExprConstant.cpp

@@ -13982,22 +13982,15 @@ bool IntExprEvaluator::VisitBuiltinCallExpr(const CallExpr *E,
 
     return Success(Val.reverseBits(), E);
   }
-  case Builtin::BI__builtin_bswapg: {
-    APSInt Val;
-    if (!EvaluateInteger(E->getArg(0), Val, Info))
-      return false;
-    if (Val.getBitWidth() == 8)
-      return Success(Val, E);
-
-    return Success(Val.byteSwap(), 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

@@ -3626,6 +3626,8 @@ RValue CodeGenFunction::EmitBuiltinExpr(const GlobalDecl GD, unsigned BuiltinID,
     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(

clang/lib/Sema/SemaChecking.cpp

@@ -2218,7 +2218,7 @@ static bool BuiltinBswapg(Sema &S, CallExpr *TheCall) {
 
   if (!ArgTy->isIntegerType()) {
     S.Diag(Arg->getBeginLoc(), diag::err_builtin_invalid_arg_type)
-        << 1 << /* scalar */ 1 << /* unsigned integer ty */ 1 << /* no fp */ 0
+        << 1 << /*scalar=*/ 1 << /*unsigned integer=*/ 1 << /*floating point=*/ 0
         << ArgTy;
     return true;
   }

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

@@ -828,6 +828,25 @@ namespace bswap {
   int h7 = __builtin_bswapg(0x1234) == 0x3412 ? 1 : f();
   int h8 = __builtin_bswapg(0x00001234) == 0x34120000 ? 1 : f();
   int h9 = __builtin_bswapg(0x0000000000001234) == 0x3412000000000000 ? 1 : f();
+
+  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/CodeGenCXX/builtins.cpp

@@ -83,3 +83,40 @@ 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
+
+// 2. 不同大小的引用测试
+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

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

@@ -483,6 +483,10 @@ int h6 = __builtin_bswapg((char)(0x12)) == (char)(0x12) ? 1 : f();
 int h7 = __builtin_bswapg((short)(0x1234)) == (short)(0x3412) ? 1 : f();
 int h8 = __builtin_bswapg(0x00001234) == 0x34120000 ? 1 : f();
 int h9 = __builtin_bswapg(0x0000000000001234ULL) == 0x3412000000000000 ? 1 : f();
+float h10 = __builtin_bswapg(1.0f); // expected-error {{1st argument must be a scalar integer type (was 'float')}}
+double h12 = __builtin_bswapg(1.0L); // expected-error {{1st argument must be a scalar integer type (was 'long double')}}
+char *h13 = __builtin_bswapg("hello"); // expected-error {{1st argument must be a scalar integer type (was 'char[6]')}}
+int h14 = __builtin_bswapg(1, 2); // expected-error {{too many arguments to function call, expected 1, have 2}}
 extern long int bi0;
 extern __typeof__(__builtin_expect(0, 0)) bi0;
 

clang/test/SemaCXX/builtin-bswapg.cpp

@@ -1,6 +1,5 @@
 // RUN: %clang_cc1 -fsyntax-only -verify %s
 // RUN: %clang_cc1 -fsyntax-only -verify -fexperimental-new-constant-interpreter %s
-// expected-no-diagnostics
 
 void test_basic_type_checks() {
   static_assert(__is_same(char, decltype(__builtin_bswapg((char)0))), "");
@@ -83,3 +82,79 @@ template struct ValueTemplateTypeTest<0x1234>;
 template struct ValueTemplateTypeTest<0x12345678UL>;
 template struct ValueTemplateTypeTest<(short)0x1234>;
 template struct ValueTemplateTypeTest<(char)0x12>;
+
+template<typename T>
+void test_invalid_type() {
+  __builtin_bswapg(T{}); // #invalid_type_use
+}
+
+void test_basic_errors() {
+  test_invalid_type<float>();
+  // expected-note@-1 {{in instantiation of function template specialization 'test_invalid_type<float>' requested here}}
+  // expected-error@#invalid_type_use {{1st argument must be a scalar integer type (was 'float')}}
+  
+  test_invalid_type<double>(); 
+  // expected-note@-1 {{in instantiation of function template specialization 'test_invalid_type<double>' requested here}}
+  // expected-error@#invalid_type_use {{1st argument must be a scalar integer type (was 'double')}}
+
+  test_invalid_type<void*>(); 
+  // expected-note@-1 {{in instantiation of function template specialization 'test_invalid_type<void *>' requested here}}
+  // expected-error@#invalid_type_use {{1st argument must be a scalar integer type (was 'void *')}}
+}
+
+template<typename T>
+auto test_dependent_context(T value) -> decltype(__builtin_bswapg(value)) { // #dependent_use
+  return __builtin_bswapg(value); 
+}
+
+void test_dependent_errors() {
+  test_dependent_context(1.0f); 
+  // expected-error@-1 {{no matching function for call to 'test_dependent_context'}}
+  // expected-note@#dependent_use {{candidate template ignored: substitution failure [with T = float]: 1st argument must be a scalar integer type (was 'float')}}
+  test_dependent_context(1.0l); 
+  // expected-error@-1 {{no matching function for call to 'test_dependent_context'}}
+  // expected-note@#dependent_use {{candidate template ignored: substitution failure [with T = long double]: 1st argument must be a scalar integer type (was 'long double')}}
+  test_dependent_context("hello"); 
+  // expected-error@-1 {{no matching function for call to 'test_dependent_context'}}
+  // expected-note@#dependent_use {{candidate template ignored: substitution failure [with T = const char *]: 1st argument must be a scalar integer type (was 'const char *')}}
+}
+
+void test_lambda_errors() {
+  auto lambda = [](auto x) {
+    return __builtin_bswapg(x); // #lambda_use
+  };
+  
+  lambda(1.0f);
+  // expected-error@#lambda_use {{1st argument must be a scalar integer type (was 'float')}}
+  // expected-note@-2 {{in instantiation of function template specialization 'test_lambda_errors()::(anonymous class)::operator()<float>' requested here}}
+  lambda(1.0l);
+  // expected-error@#lambda_use {{1st argument must be a scalar integer type (was 'long double')}}
+  // expected-note@-2 {{in instantiation of function template specialization 'test_lambda_errors()::(anonymous class)::operator()<long double>' requested here}}
+  lambda("hello");
+  // expected-error@#lambda_use {{1st argument must be a scalar integer type (was 'const char *')}}
+  // expected-note@-2 {{in instantiation of function template specialization 'test_lambda_errors()::(anonymous class)::operator()<const char *>' requested here}}
+}
+
+void test_argument_count_errors() {
+  int h14 = __builtin_bswapg(1, 2); // expected-error {{too many arguments to function call, expected 1, have 2}}
+}
+
+void test_lvalue_reference(int& a) {
+    auto result = __builtin_bswapg(a);
+    static_assert(__is_same(int, decltype(result)), "Should decay reference to value type");
+}
+
+void test_const_lvalue_reference(const int& a) {
+    auto result = __builtin_bswapg(a);
+    static_assert(__is_same(int, decltype(result)), "Should decay const reference to value type");
+}
+
+void test_rvalue_reference(int&& a) {
+    auto result = __builtin_bswapg(a);
+    static_assert(__is_same(int, decltype(result)), "Should decay rvalue reference to value type");
+}
+
+void test_const_rvalue_reference(const int&& a) {
+    auto result = __builtin_bswapg(a);
+    static_assert(__is_same(int, decltype(result)), "Should decay const rvalue reference to value type");
+}