Reserve attribute to C-only and rename to 'kcfi_salt', indicating that it's specifically for the kernel.

Author: bwendling

clang/include/clang/AST/Type.h

@@ -4651,11 +4651,11 @@ class FunctionType : public Type {
   /// \p AttributedType.
   struct alignas(void *) FunctionTypeExtraAttributeInfo {
     /// A CFI "salt" that differentiates functions with the same prototype.
-    StringRef CFISalt;
+    StringRef KCFISalt;
 
-    operator bool() const { return !CFISalt.empty(); }
+    operator bool() const { return !KCFISalt.empty(); }
 
-    void Profile(llvm::FoldingSetNodeID &ID) const { ID.AddString(CFISalt); }
+    void Profile(llvm::FoldingSetNodeID &ID) const { ID.AddString(KCFISalt); }
   };
 
   /// The AArch64 SME ACLE (Arm C/C++ Language Extensions) define a number

clang/include/clang/Basic/Attr.td

@@ -3896,11 +3896,12 @@ def CFICanonicalJumpTable : InheritableAttr {
   let SimpleHandler = 1;
 }
 
-def CFISalt : DeclOrTypeAttr {
-  let Spellings = [Clang<"cfi_salt">];
+def KCFISalt : DeclOrTypeAttr {
+  let Spellings = [Clang<"kcfi_salt">];
   let Args = [StringArgument<"Salt">];
   let Subjects = SubjectList<[Function, Field, Var, TypedefName], ErrorDiag>;
-  let Documentation = [CFISaltDocs];
+  let Documentation = [KCFISaltDocs];
+  let LangOpts = [COnly];
 }
 
 // C/C++ Thread safety attributes (e.g. for deadlock, data race checking)

clang/include/clang/Basic/AttrDocs.td

@@ -3643,10 +3643,10 @@ make the function's CFI jump table canonical. See :ref:`the CFI documentation
   }];
 }
 
-def CFISaltDocs : Documentation {
+def KCFISaltDocs : Documentation {
   let Category = DocCatFunction;
   let Content = [{
-Use ``__attribute__((cfi_salt("<salt>")))`` on a function declaration, function
+Use ``__attribute__((kcfi_salt("<salt>")))`` on a function declaration, function
 definition, or typedef to help distinguish CFI hashes between functions with
 the same type signature.
 
@@ -3655,11 +3655,11 @@ Example use:
 .. code-block:: c
 
   // .h file:
-  #define __cfi_salt __attribute__((cfi_salt("vogon")))
+  #define __kcfi_salt __attribute__((kcfi_salt("vogon")))
 
   // Convenient typedefs to avoid nested declarator syntax.
   typedef int (*fptr_t)(void); // Non-salted function call.
-  typedef int (*fptr_salted_t)(void) __cfi_salt;
+  typedef int (*fptr_salted_t)(void) __kcfi_salt;
 
   struct widget_generator {
     fptr_t init;
@@ -3669,7 +3669,7 @@ Example use:
 
   // 1st .c file:
   static int internal_init(void) { /* ... */ }
-  static int internal_salted_exec(void) __cfi_salt { /* ... */ }
+  static int internal_salted_exec(void) __kcfi_salt { /* ... */ }
   static int internal_teardown(void) { /* ... */ }
 
   static struct widget_generator _generator = {

clang/lib/AST/Type.cpp

@@ -3680,7 +3680,7 @@ FunctionProtoType::FunctionProtoType(QualType result, ArrayRef<QualType> params,
   // Propagate any extra attribute information.
   if (epi.requiresFunctionProtoTypeExtraAttributeInfo()) {
     auto &ExtraAttrInfo = *getTrailingObjects<FunctionTypeExtraAttributeInfo>();
-    ExtraAttrInfo.CFISalt = epi.ExtraAttributeInfo.CFISalt;
+    ExtraAttrInfo.KCFISalt = epi.ExtraAttributeInfo.KCFISalt;
 
     // Also set the bit in FunctionTypeExtraBitfields.
     auto &ExtraBits = *getTrailingObjects<FunctionTypeExtraBitfields>();

clang/lib/AST/TypePrinter.cpp

@@ -2106,8 +2106,8 @@ void TypePrinter::printAttributedAfter(const AttributedType *T,
   case attr::ExtVectorType:
     OS << "ext_vector_type";
     break;
-  case attr::CFISalt:
-    OS << "cfi_salt(\"" << cast<CFISaltAttr>(T->getAttr())->getSalt() << "\")";
+  case attr::KCFISalt:
+    OS << "kcfi_salt(\"" << cast<KCFISaltAttr>(T->getAttr())->getSalt() << "\")";
     break;
   }
   OS << "))";

clang/lib/CodeGen/CodeGenFunction.cpp

@@ -2912,7 +2912,7 @@ void CodeGenFunction::EmitKCFIOperandBundle(
 
   StringRef Salt;
   if (const auto &Info = FP->getExtraAttributeInfo())
-    Salt = Info.CFISalt;
+    Salt = Info.KCFISalt;
 
   Bundles.emplace_back("kcfi", CGM.CreateKCFITypeId(FP->desugar(), Salt));
 }

clang/lib/CodeGen/CodeGenModule.cpp

@@ -3022,7 +3022,7 @@ void CodeGenModule::setKCFIType(const FunctionDecl *FD, llvm::Function *F) {
 
   if (const auto *FP = FD->getType()->getAs<FunctionProtoType>())
     if (const auto &Info = FP->getExtraAttributeInfo())
-      Salt = Info.CFISalt;
+      Salt = Info.KCFISalt;
 
   F->setMetadata(llvm::LLVMContext::MD_kcfi_type,
                  llvm::MDNode::get(Ctx, MDB.createConstant(CreateKCFITypeId(

clang/lib/Sema/SemaType.cpp

@@ -157,14 +157,14 @@ static void diagnoseBadTypeAttribute(Sema &S, const ParsedAttr &attr,
   case ParsedAttr::AT_Regparm:                                                 \
   case ParsedAttr::AT_CFIUncheckedCallee:                                      \
   case ParsedAttr::AT_CmseNSCall:                                              \
+  case ParsedAttr::AT_KCFISalt:                                                \
   case ParsedAttr::AT_ArmStreaming:                                            \
   case ParsedAttr::AT_ArmStreamingCompatible:                                  \
   case ParsedAttr::AT_ArmPreserves:                                            \
   case ParsedAttr::AT_ArmIn:                                                   \
   case ParsedAttr::AT_ArmOut:                                                  \
   case ParsedAttr::AT_ArmInOut:                                                \
   case ParsedAttr::AT_ArmAgnostic:                                             \
-  case ParsedAttr::AT_CFISalt:                                                 \
   case ParsedAttr::AT_AnyX86NoCallerSavedRegisters:                            \
   case ParsedAttr::AT_AnyX86NoCfCheck:                                         \
     CALLING_CONV_ATTRS_CASELIST
@@ -7940,14 +7940,14 @@ static bool handleFunctionTypeAttr(TypeProcessingState &state, ParsedAttr &attr,
     return true;
   }
 
-  if (attr.getKind() == ParsedAttr::AT_CFISalt) {
+  if (attr.getKind() == ParsedAttr::AT_KCFISalt) {
     StringRef Argument;
     if (!S.checkStringLiteralArgumentAttr(attr, 0, Argument))
       return false;
 
     const auto *FnTy = unwrapped.get()->getAs<FunctionProtoType>();
     FunctionProtoType::ExtProtoInfo EPI = FnTy->getExtProtoInfo();
-    EPI.ExtraAttributeInfo.CFISalt = Argument;
+    EPI.ExtraAttributeInfo.KCFISalt = Argument;
 
     QualType newtype = S.Context.getFunctionType(FnTy->getReturnType(),
                                                  FnTy->getParamTypes(), EPI);

clang/test/CodeGen/kcfi-salt.c

@@ -1,5 +1,4 @@
 // RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -emit-llvm -fsanitize=kcfi -o - %s | FileCheck %s
-// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -emit-llvm -fsanitize=kcfi -x c++ -o - %s | FileCheck %s --check-prefixes=CHECK,MEMBER
 // RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -emit-llvm -fsanitize=kcfi -fpatchable-function-entry-offset=3 -o - %s | FileCheck %s --check-prefixes=CHECK,OFFSET
 
 // Note that the interleving of functions, which normally would be in sequence,
@@ -9,13 +8,13 @@
 #error Missing kcfi?
 #endif
 
-#define __cfi_salt __attribute__((cfi_salt("pepper")))
+#define __kcfi_salt __attribute__((kcfi_salt("pepper")))
 
 typedef int (*fn_t)(void);
-typedef int __cfi_salt (*fn_salt_t)(void);
+typedef int __kcfi_salt (*fn_salt_t)(void);
 
 typedef unsigned int (*ufn_t)(void);
-typedef unsigned int __cfi_salt (*ufn_salt_t)(void);
+typedef unsigned int __kcfi_salt (*ufn_salt_t)(void);
 
 /// Must emit __kcfi_typeid symbols for address-taken function declarations
 // CHECK: module asm ".weak __kcfi_typeid_[[F4:[a-zA-Z0-9_]+]]"
@@ -27,25 +26,25 @@ typedef unsigned int __cfi_salt (*ufn_salt_t)(void);
 // CHECK-NOT: module asm ".weak __kcfi_typeid_{{f6|_Z2f6v}}"
 
 int f1(void);
-int f1_salt(void) __cfi_salt;
+int f1_salt(void) __kcfi_salt;
 
 unsigned int f2(void);
-unsigned int f2_salt(void) __cfi_salt;
+unsigned int f2_salt(void) __kcfi_salt;
 
 static int f3(void);
-static int f3_salt(void) __cfi_salt;
+static int f3_salt(void) __kcfi_salt;
 
 extern int f4(void);
-extern int f4_salt(void) __cfi_salt;
+extern int f4_salt(void) __kcfi_salt;
 
 static int f5(void);
-static int f5_salt(void) __cfi_salt;
+static int f5_salt(void) __kcfi_salt;
 
 extern int f6(void);
-extern int f6_salt(void) __cfi_salt;
+extern int f6_salt(void) __kcfi_salt;
 
 struct cfi_struct {
-  fn_t __cfi_salt fptr;
+  fn_t __kcfi_salt fptr;
   fn_salt_t td_fptr;
 };
 
@@ -67,7 +66,7 @@ int __call(fn_t f) __attribute__((__no_sanitize__("kcfi"))) {
 // CHECK-LABEL: @{{call_salt_ty|_Z12call_salt_tyPFivE}}
 // CHECK:         call{{.*}} i32 %{{.}}(){{.*}} [ "kcfi"(i32 [[#SALTY_HASH]]) ]
 int call(fn_t f) { return f(); }
-int call_salt(fn_t __cfi_salt f) { return f(); }
+int call_salt(fn_t __kcfi_salt f) { return f(); }
 int call_salt_ty(fn_salt_t f) { return f(); }
 
 // CHECK-LABEL: @{{ucall|_Z5ucallPFjvE}}
@@ -77,7 +76,7 @@ int call_salt_ty(fn_salt_t f) { return f(); }
 // CHECK-LABEL: @{{ucall_salt_ty|_Z13ucall_salt_tyPFjvE}}
 // CHECK:         call{{.*}} i32 %{{.}}(){{.*}} [ "kcfi"(i32 [[#SALTY_UHASH]]) ]
 unsigned int ucall(ufn_t f) { return f(); }
-unsigned int ucall_salt(ufn_t __cfi_salt f) { return f(); }
+unsigned int ucall_salt(ufn_t __kcfi_salt f) { return f(); }
 unsigned int ucall_salt_ty(ufn_salt_t f) { return f(); }
 
 int test1(struct cfi_struct *ptr) {
@@ -115,21 +114,21 @@ int test1(struct cfi_struct *ptr) {
 // CHECK-LABEL: define dso_local{{.*}} i32 @{{f1_salt|_Z7f1_saltv}}(){{.*}} !kcfi_type
 // CHECK-SAME:  ![[#SALTY_TYPE:]]
 int f1(void) { return 0; }
-int f1_salt(void) __cfi_salt { return 0; }
+int f1_salt(void) __kcfi_salt { return 0; }
 
 // CHECK-LABEL: define dso_local{{.*}} i32 @{{f2|_Z2f2v}}(){{.*}} !kcfi_type
 // CHECK-SAME:  ![[#LOW_SODIUM_UTYPE:]]
 // CHECK: define dso_local{{.*}} i32 @{{f2_salt|_Z7f2_saltv}}(){{.*}} !kcfi_type
 // CHECK-SAME:  ![[#SALTY_UTYPE:]]
 unsigned int f2(void) { return 2; }
-unsigned int f2_salt(void) __cfi_salt { return 2; }
+unsigned int f2_salt(void) __kcfi_salt { return 2; }
 
 // CHECK-LABEL: define internal{{.*}} i32 @{{f3|_ZL2f3v}}(){{.*}} !kcfi_type
 // CHECK-SAME:  ![[#LOW_SODIUM_TYPE]]
 // CHECK-LABEL: define internal{{.*}} i32 @{{f3_salt|_ZL7f3_saltv}}(){{.*}} !kcfi_type
 // CHECK-SAME:  ![[#SALTY_TYPE]]
 static int f3(void) { return 1; }
-static int f3_salt(void) __cfi_salt { return 1; }
+static int f3_salt(void) __kcfi_salt { return 1; }
 
 // CHECK: declare !kcfi_type ![[#LOW_SODIUM_TYPE]]{{.*}} i32 @[[F4]]()
 // CHECK: declare !kcfi_type ![[#SALTY_TYPE]]{{.*}} i32 @[[F4_SALT]]()
@@ -142,7 +141,7 @@ static int f3_salt(void) __cfi_salt { return 1; }
 // CHECK-NOT:   !kcfi_type
 // CHECK-SAME:  {
 static int f5(void) { return 2; }
-static int f5_salt(void) __cfi_salt { return 2; }
+static int f5_salt(void) __kcfi_salt { return 2; }
 
 // CHECK: declare !kcfi_type ![[#LOW_SODIUM_TYPE]]{{.*}} i32 @{{f6|_Z2f6v}}()
 // CHECK: declare !kcfi_type ![[#SALTY_TYPE]]{{.*}} i32 @{{f6_salt|_Z7f6_saltv}}()
@@ -154,29 +153,6 @@ static int f5_salt(void) __cfi_salt { return 2; }
 int f7_salt(struct cfi_struct *ptr) { return ptr->fptr(); }
 int f7_typedef_salt(struct cfi_struct *ptr) { return ptr->td_fptr(); }
 
-#ifdef __cplusplus
-// MEMBER-LABEL: define dso_local void @_Z16test_member_callv() #0 !kcfi_type
-// MEMBER:         call void %[[#]](ptr{{.*}} [ "kcfi"(i32 [[#%d,MEMBER_LOW_SODIUM_HASH:]]) ]
-// MEMBER:         call void %[[#]](ptr{{.*}} [ "kcfi"(i32 [[#%d,MEMBER_SALT_HASH:]]) ]
-
-// MEMBER-LABEL: define{{.*}} void @_ZN1A1fEv(ptr{{.*}} %this){{.*}} !kcfi_type
-// MEMBER-SAME:  [[#MEMBER_LOW_SODIUM_TYPE:]]
-// MEMBER-LABEL: define{{.*}} void @_ZN1A1gEv(ptr{{.*}} %this){{.*}} !kcfi_type
-// MEMBER-SAME:  [[#MEMBER_SALT_TYPE:]]
-struct A {
-  void f() {}
-  void __cfi_salt g() {}
-};
-
-void test_member_call(void) {
-  void (A::* p)() = &A::f;
-  (A().*p)();
-
-  void __cfi_salt (A::* q)() = &A::g;
-  (A().*q)();
-}
-#endif
-
 // CHECK:  ![[#]] = !{i32 4, !"kcfi", i32 1}
 // OFFSET: ![[#]] = !{i32 4, !"kcfi-offset", i32 3}
 //
@@ -185,6 +161,3 @@ void test_member_call(void) {
 //
 // CHECK:  ![[#LOW_SODIUM_UTYPE]] = !{i32 [[#LOW_SODIUM_UHASH]]}
 // CHECK:  ![[#SALTY_UTYPE]] = !{i32 [[#SALTY_UHASH]]}
-//
-// MEMBER: ![[#MEMBER_LOW_SODIUM_TYPE]] = !{i32 [[#MEMBER_LOW_SODIUM_HASH]]}
-// MEMBER: ![[#MEMBER_SALT_TYPE]] = !{i32 [[#MEMBER_SALT_HASH]]}

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

@@ -31,7 +31,6 @@
 // CHECK-NEXT: CFConsumed (SubjectMatchRule_variable_is_parameter)
 // CHECK-NEXT: CFGuard (SubjectMatchRule_function)
 // CHECK-NEXT: CFICanonicalJumpTable (SubjectMatchRule_function)
-// CHECK-NEXT: CFISalt (SubjectMatchRule_function, SubjectMatchRule_field, SubjectMatchRule_variable, SubjectMatchRule_type_alias)
 // CHECK-NEXT: CFUnknownTransfer (SubjectMatchRule_function)
 // CHECK-NEXT: CPUDispatch (SubjectMatchRule_function)
 // CHECK-NEXT: CPUSpecific (SubjectMatchRule_function)
@@ -97,6 +96,7 @@
 // CHECK-NEXT: Leaf (SubjectMatchRule_function)
 // CHECK-NEXT: LoaderUninitialized (SubjectMatchRule_variable_is_global)
 // CHECK-NEXT: Lockable (SubjectMatchRule_record)
+// CHECK-NEXT: KCFISalt (SubjectMatchRule_function, SubjectMatchRule_field, SubjectMatchRule_variable, SubjectMatchRule_type_alias)
 // CHECK-NEXT: MIGServerRoutine (SubjectMatchRule_function, SubjectMatchRule_objc_method, SubjectMatchRule_block)
 // CHECK-NEXT: MSConstexpr (SubjectMatchRule_function)
 // CHECK-NEXT: MSStruct (SubjectMatchRule_record)