[Clang] Add clang attribute `clang_builtin_alias`.

[HsiangKai]

Summary

In some cases, we want to provide the alias name for the clang builtins.
For example, the arguments must be constant integers for some RISC-V builtins.
If we use wrapper functions, we could not constrain the arguments be constant
integer. This attribute is used to achieve the purpose.

Besides this, use clang_builtin_alias is more efficient than using
wrapper functions. We use this attribute to deal with test time issue
reported in https://bugs.llvm.org/show_bug.cgi?id=49962.

clang/include/clang/Basic/Attr.td

 
 def Alias : Attr {
   let Spellings = [GCC<"alias">];
   let Args = [StringArgument<"Aliasee">];
   let Subjects = SubjectList<[Function, GlobalVar], ErrorDiag>;
   let Documentation = [Undocumented];
 }
 
+def BuiltinAlias : Attr {
+  let Spellings = [Clang<"clang_builtin_alias">];
+  let Args = [IdentifierArgument<"BuiltinName">];
+  let Subjects = SubjectList<[Function], ErrorDiag>;
+  let Documentation = [BuiltinAliasDocs];
+}
+
 def ArmBuiltinAlias : InheritableAttr, TargetSpecificAttr<TargetAnyArm> {
   let Spellings = [Clang<"__clang_arm_builtin_alias">];
   let Args = [IdentifierArgument<"BuiltinName">];
   let Subjects = SubjectList<[Function], ErrorDiag>;
   let Documentation = [ArmBuiltinAliasDocs];
 }
 
 def Aligned : InheritableAttr {
def RISCVInterrupt : InheritableAttr, TargetSpecificAttr<TargetRISCV> {
   let Args = [EnumArgument<"Interrupt", "InterruptType",
                            ["user", "supervisor", "machine"],
                            ["user", "supervisor", "machine"],
                            1>];
   let ParseKind = "Interrupt";
   let Documentation = [RISCVInterruptDocs];
 }
 
-def RISCVBuiltinAlias : InheritableAttr, TargetSpecificAttr<TargetRISCV> {
-  let Spellings = [Clang<"__clang_riscv_builtin_alias">];
-  let Subjects = SubjectList<[Function], ErrorDiag>;
-  let Args = [IdentifierArgument<"BuiltinName">];
-  let Documentation = [RISCVBuiltinAliasDocs];
-}
-
 // This is not a TargetSpecificAttr so that is silently accepted and
 // ignored on other targets as encouraged by the OpenCL spec.
 //
 // See OpenCL 1.2 6.11.5: "It is our intention that a particular
 // implementation of OpenCL be free to ignore all attributes and the
 // resulting executable binary will produce the same result."
 //
 // However, only AMD GPU targets will emit the corresponding IR

clang/include/clang/Basic/AttrDocs.td

 Refer to:
 https://gcc.gnu.org/onlinedocs/gcc/RISC-V-Function-Attributes.html
 https://riscv.org/specifications/privileged-isa/
 The RISC-V Instruction Set Manual Volume II: Privileged Architecture
 Version 1.10.
   }];
 }
 
-def RISCVBuiltinAliasDocs : Documentation {
-  let Category = DocCatFunction;
-  let Content = [{
-This attribute is used in the implementation of the RVV C intrinsics.
-It allows the C intrinsic functions to be declared using the names defined
-in RVV builtins, and still be recognized as clang builtins equivalent to the
-underlying name. For example, ``riscv_vector.h`` declares the function ``vadd``
-with ``__attribute__((__clang_riscv_builtin_alias(__builtin_rvv_vadd_vv_i8m1)))``.
-This ensures that both functions are recognized as that clang builtin,
-and in the latter case, the choice of which builtin to identify the
-function as can be deferred until after overload resolution.
-
-This attribute can only be used to set up the aliases for certain RISC-V
-C intrinsic functions; it is intended for use only inside ``riscv_*.h``
-and is not a general mechanism for declaring arbitrary aliases for
-clang builtin functions.
-  }];
-}
-
 def AVRInterruptDocs : Documentation {
   let Category = DocCatFunction;
   let Heading = "interrupt (AVR)";
   let Content = [{
 Clang supports the GNU style ``__attribute__((interrupt))`` attribute on
 AVR targets. This attribute may be attached to a function definition and instructs
 the backend to generate appropriate function entry/exit code so that it can be used
 directly as an interrupt service routine.

 with different ABI versions supported. For example, a newer version of a class
 could have a different set of data members and thus have a different size. Using
 the ``abi_tag`` attribute, it is possible to have different mangled names for
 a global variable of the class type. Therefore, the old code could keep using
 the old mangled name and the new code will use the new mangled name with tags.
   }];
 }
 
+def BuiltinAliasDocs : Documentation {
+  let Category = DocCatFunction;
+  let Content = [{
+This attribute is used in the implementation of the C intrinsics.
+It allows the C intrinsic functions to be declared using the names defined
+in target builtins, and still be recognized as clang builtins equivalent to the
+underlying name. For example, ``riscv_vector.h`` declares the function ``vadd``
+with ``__attribute__((clang_builtin_alias(__builtin_rvv_vadd_vv_i8m1)))``.
+This ensures that both functions are recognized as that clang builtin,
+and in the latter case, the choice of which builtin to identify the
+function as can be deferred until after overload resolution.
+  }];
+}
+
 def PreferredNameDocs : Documentation {
   let Category = DocCatDecl;
   let Content = [{
 The ``preferred_name`` attribute can be applied to a class template, and
 specifies a preferred way of naming a specialization of the template. The
 preferred name will be used whenever the corresponding template specialization
 would otherwise be printed in a diagnostic or similar context.
 

clang/include/clang/Basic/DiagnosticSemaKinds.td

def warn_objc_requires_super_protocol : Warning<
   InGroup<DiagGroup<"requires-super-attribute">>;
 def note_protocol_decl : Note<
   "protocol is declared here">;
 def note_protocol_decl_undefined : Note<
   "protocol %0 has no definition">;
 def err_attribute_preferred_name_arg_invalid : Error<
   "argument %0 to 'preferred_name' attribute is not a typedef for "
   "a specialization of %1">;
+def err_attribute_builtin_alias : Error<
+  "'clang_builtin_alias' attribute can only be applied to a target "
+  "builtin">;
 
 // called-once attribute diagnostics.
 def err_called_once_attribute_wrong_type : Error<
   "'called_once' attribute only applies to function-like parameters">;
 
 def warn_completion_handler_never_called : Warning<
   "%select{|captured }1completion handler is never called">,
   InGroup<CompletionHandler>, DefaultIgnore;
def err_tcb_conflicting_attributes : Error<
   "attributes '%0(\"%2\")' and '%1(\"%2\")' are mutually exclusive">;
 def warn_tcb_enforcement_violation : Warning<
   "calling %0 is a violation of trusted computing base '%1'">,
   InGroup<DiagGroup<"tcb-enforcement">>;
 
 // RISC-V builtin required extension warning
 def err_riscv_builtin_requires_extension : Error<
   "builtin requires '%0' extension support to be enabled">;
-def err_attribute_riscv_builtin_alias : Error<
-  "'__clang_riscv_builtin_alias' attribute can only be applied to a RISC-V "
-  "builtin">;
 } // end of sema component.

clang/lib/AST/Decl.cpp

 /// \param ConsiderWrapperFunctions If true, we should consider wrapper
 /// functions as their wrapped builtins. This shouldn't be done in general, but
 /// it's useful in Sema to diagnose calls to wrappers based on their semantics.
 unsigned FunctionDecl::getBuiltinID(bool ConsiderWrapperFunctions) const {
   unsigned BuiltinID = 0;
 
   if (const auto *ABAA = getAttr<ArmBuiltinAliasAttr>()) {
     BuiltinID = ABAA->getBuiltinName()->getBuiltinID();
-  } else if (const auto *RBAA = getAttr<RISCVBuiltinAliasAttr>()) {
-    BuiltinID = RBAA->getBuiltinName()->getBuiltinID();
+  } else if (const auto *BAA = getAttr<BuiltinAliasAttr>()) {
+    BuiltinID = BAA->getBuiltinName()->getBuiltinID();
   } else if (const auto *A = getAttr<BuiltinAttr>()) {
     BuiltinID = A->getID();
   }
 
   if (!BuiltinID)
     return 0;
 
   // If the function is marked "overloadable", it has a different mangled name
   // and is not the C library function.
   if (!ConsiderWrapperFunctions && hasAttr<OverloadableAttr>() &&
-      (!hasAttr<ArmBuiltinAliasAttr>() && !hasAttr<RISCVBuiltinAliasAttr>()))
+      (!hasAttr<ArmBuiltinAliasAttr>() && !hasAttr<BuiltinAliasAttr>()))
     return 0;
 
   ASTContext &Context = getASTContext();
   if (!Context.BuiltinInfo.isPredefinedLibFunction(BuiltinID))
     return BuiltinID;
 
   // This function has the name of a known C library
   // function. Determine whether it actually refers to the C library

clang/lib/Sema/SemaDeclAttr.cpp

if ((IsAArch64 && !ArmSveAliasValid(BuiltinID, AliasName)) ||
        !ArmCdeAliasValid(BuiltinID, AliasName))) {
     S.Diag(AL.getLoc(), diag::err_attribute_arm_builtin_alias);
     return;
   }
 
   D->addAttr(::new (S.Context) ArmBuiltinAliasAttr(S.Context, AL, Ident));
 }
 
-static bool RISCVVAliasValid(unsigned BuiltinID, StringRef AliasName) {
+static bool AliasValid(unsigned BuiltinID, StringRef AliasName) {
   switch (BuiltinID) {
   default:
     return false;
 #define BUILTIN(ID, TYPE, ATTRS) case RISCV::BI##ID:
 #include "clang/Basic/BuiltinsRISCV.def"
 #undef BUILTIN
     return true;
   }
 }
 
-static void handleRISCVBuiltinAliasAttr(Sema &S, Decl *D,
+static void handleBuiltinAliasAttr(Sema &S, Decl *D,
                                         const ParsedAttr &AL) {
   if (!AL.isArgIdent(0)) {
     S.Diag(AL.getLoc(), diag::err_attribute_argument_n_type)
         << AL << 1 << AANT_ArgumentIdentifier;
     return;
   }
 
   IdentifierInfo *Ident = AL.getArgAsIdent(0)->Ident;
   unsigned BuiltinID = Ident->getBuiltinID();
   StringRef AliasName = cast<FunctionDecl>(D)->getIdentifier()->getName();
 
-  if (!RISCVVAliasValid(BuiltinID, AliasName)) {
-    S.Diag(AL.getLoc(), diag::err_attribute_riscv_builtin_alias);
+  if (!AliasValid(BuiltinID, AliasName)) {
+    S.Diag(AL.getLoc(), diag::err_attribute_builtin_alias);
     return;
   }
 
-  D->addAttr(::new (S.Context) RISCVBuiltinAliasAttr(S.Context, AL, Ident));
+  D->addAttr(::new (S.Context) BuiltinAliasAttr(S.Context, AL, Ident));
 }
 
 //===----------------------------------------------------------------------===//
 // Checker-specific attribute handlers.
 //===----------------------------------------------------------------------===//
 static bool isValidSubjectOfNSReturnsRetainedAttribute(QualType QT) {
   return QT->isDependentType() || QT->isObjCRetainableType();
 }
static void ProcessDeclAttribute(Sema &S, Scope *scope, Decl *D,
   case ParsedAttr::AT_EnforceTCB:
     handleEnforceTCBAttr<EnforceTCBAttr, EnforceTCBLeafAttr>(S, D, AL);
     break;
 
   case ParsedAttr::AT_EnforceTCBLeaf:
     handleEnforceTCBAttr<EnforceTCBLeafAttr, EnforceTCBAttr>(S, D, AL);
     break;
 
-  case ParsedAttr::AT_RISCVBuiltinAlias:
-    handleRISCVBuiltinAliasAttr(S, D, AL);
+  case ParsedAttr::AT_BuiltinAlias:
+    handleBuiltinAliasAttr(S, D, AL);
     break;
   }
 }
 
 /// ProcessDeclAttributeList - Apply all the decl attributes in the specified
 /// attribute list to the specified decl, ignoring any type attributes.
 void Sema::ProcessDeclAttributeList(Scope *S, Decl *D,
                                     const ParsedAttributesView &AttrList,

clang/test/CodeGen/RISCV/riscv-attr-builtin-alias-err.c

 // REQUIRES: riscv-registered-target
 // RUN: not %clang_cc1 -triple riscv64 -fsyntax-only -verify \
 // RUN:   -target-feature +experimental-v %s 2>&1 \
 // RUN: | FileCheck %s
 
 #include <riscv_vector.h>
 
 #define __rvv_generic \
 static inline __attribute__((__always_inline__, __nodebug__))
 
 __rvv_generic
-__attribute__((__clang_riscv_builtin_alias(__builtin_rvv_vadd_vv_i8m1)))
+__attribute__((clang_builtin_alias(__builtin_rvv_vadd_vv_i8m1)))
 vint8m1_t vadd_generic (vint8m1_t op0, vint8m1_t op1, size_t op2);
 
 // CHECK: passing 'vint8m2_t' (aka '__rvv_int8m2_t') to parameter of incompatible type 'vint8m1_t'
 vint8m2_t test(vint8m2_t op0, vint8m2_t op1, size_t vl) {
   vint8m2_t ret = vadd_generic(op0, op1, vl);
   return ret;
 }

clang/test/CodeGen/RISCV/riscv-attr-builtin-alias.c

 // NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py
 // REQUIRES: riscv-registered-target
 // RUN: %clang_cc1 -triple riscv64 -emit-llvm -target-feature +experimental-v \
 // RUN:   %s -o - \
 // RUN:   | FileCheck %s
 
 #include <riscv_vector.h>
 
 #define __rvv_generic \
 static inline __attribute__((__always_inline__, __nodebug__))
 
 __rvv_generic
-__attribute__((__clang_riscv_builtin_alias(__builtin_rvv_vadd_vv_i8m1)))
+__attribute__((clang_builtin_alias(__builtin_rvv_vadd_vv_i8m1)))
 vint8m1_t vadd_generic (vint8m1_t op0, vint8m1_t op1, size_t op2);
 
 // CHECK-LABEL: @test(
 // CHECK-NEXT:  entry:
 // CHECK-NEXT:    [[OP0_ADDR:%.*]] = alloca <vscale x 8 x i8>, align 1
 // CHECK-NEXT:    [[OP1_ADDR:%.*]] = alloca <vscale x 8 x i8>, align 1
 // CHECK-NEXT:    [[VL_ADDR:%.*]] = alloca i64, align 8
 // CHECK-NEXT:    [[RET:%.*]] = alloca <vscale x 8 x i8>, align 1

clang/test/Misc/pragma-attribute-supported-attributes-list.test

 // CHECK-NEXT: OpenCLNoSVM (SubjectMatchRule_variable)
 // CHECK-NEXT: OptimizeNone (SubjectMatchRule_function, SubjectMatchRule_objc_method)
 // CHECK-NEXT: Overloadable (SubjectMatchRule_function)
 // CHECK-NEXT: Owner (SubjectMatchRule_record_not_is_union)
 // CHECK-NEXT: ParamTypestate (SubjectMatchRule_variable_is_parameter)
 // CHECK-NEXT: PassObjectSize (SubjectMatchRule_variable_is_parameter)
 // CHECK-NEXT: PatchableFunctionEntry (SubjectMatchRule_function, SubjectMatchRule_objc_method)
 // CHECK-NEXT: Pointer (SubjectMatchRule_record_not_is_union)
-// CHECK-NEXT: RISCVBuiltinAlias (SubjectMatchRule_function)
+// CHECK-NEXT: BuiltinAlias (SubjectMatchRule_function)
 // CHECK-NEXT: ReleaseHandle (SubjectMatchRule_variable_is_parameter)
 // CHECK-NEXT: RenderScriptKernel (SubjectMatchRule_function)
 // CHECK-NEXT: ReqdWorkGroupSize (SubjectMatchRule_function)
 // CHECK-NEXT: Restrict (SubjectMatchRule_function)
 // CHECK-NEXT: ReturnTypestate (SubjectMatchRule_function, SubjectMatchRule_variable_is_parameter)
 // CHECK-NEXT: ReturnsNonNull (SubjectMatchRule_objc_method, SubjectMatchRule_function)
 // CHECK-NEXT: ReturnsTwice (SubjectMatchRule_function)
 // CHECK-NEXT: ScopedLockable (SubjectMatchRule_record)

clang/utils/TableGen/RISCVVEmitter.cpp

for (unsigned i = 0; i < InputTypes.size(); ++i)
       OS << LS << "(" << InputTypes[i]->getTypeStr() << ")(op" << i << ")";
   }
   OS << ")\n";
 }
 
 void RVVIntrinsic::emitMangledFuncDef(raw_ostream &OS) const {
   bool UseAliasAttr = !isMask() && !isOperandReordered();
   if (UseAliasAttr) {
-    OS << "__attribute__((__clang_riscv_builtin_alias(";
+    OS << "__attribute__((clang_builtin_alias(";
     OS << "__builtin_rvv_" << getName() << ")))\n";
   }
   OS << OutputType->getTypeStr() << " " << getMangledName() << "(";
   // Emit function arguments
   if (getNumOperand() > 0) {
     ListSeparator LS;
     for (unsigned i = 0; i < CTypeOrder.size(); ++i)
       OS << LS << InputTypes[CTypeOrder[i]]->getTypeStr() << " op" << i;