Rename 'kcfi_salt' to 'cfi_salt' to indicate that it's not just for the kernel.

bwendling · bwendling · commit cec156a5c16e · 2025-07-23T14:42:09.000-07:00
diff --git a/clang/include/clang/AST/Type.h b/clang/include/clang/AST/Type.h
@@ -4676,11 +4676,11 @@ class FunctionType : public Type {
   /// \p AttributedType.
   struct alignas(void *) FunctionTypeExtraAttributeInfo {
     /// A CFI "salt" that differentiates functions with the same prototype.
-    StringRef KCFISalt;
+    StringRef CFISalt;
 
-    operator bool() const { return !KCFISalt.empty(); }
+    operator bool() const { return !CFISalt.empty(); }
 
-    void Profile(llvm::FoldingSetNodeID &ID) const { ID.AddString(KCFISalt); }
+    void Profile(llvm::FoldingSetNodeID &ID) const { ID.AddString(CFISalt); }
   };
 
   /// The AArch64 SME ACLE (Arm C/C++ Language Extensions) define a number
diff --git a/clang/include/clang/Basic/Attr.td b/clang/include/clang/Basic/Attr.td
@@ -3929,11 +3929,11 @@ def CFICanonicalJumpTable : InheritableAttr {
   let SimpleHandler = 1;
 }
 
-def KCFISalt : DeclOrTypeAttr {
-  let Spellings = [Clang<"kcfi_salt">];
+def CFISalt : DeclOrTypeAttr {
+  let Spellings = [Clang<"cfi_salt">];
   let Args = [StringArgument<"Salt">];
   let Subjects = SubjectList<[Function, Field, Var, TypedefName], ErrorDiag>;
-  let Documentation = [KCFISaltDocs];
+  let Documentation = [CFISaltDocs];
   let LangOpts = [COnly];
 }
 
diff --git a/clang/include/clang/Basic/AttrDocs.td b/clang/include/clang/Basic/AttrDocs.td
@@ -3643,12 +3643,12 @@ make the function's CFI jump table canonical. See :ref:`the CFI documentation
   }];
 }
 
-def KCFISaltDocs : Documentation {
+def CFISaltDocs : Documentation {
   let Category = DocCatFunction;
-  let Heading = "kcfi_salt";
-  let Label = "langext-kcfi_salt";
+  let Heading = "cfi_salt";
+  let Label = "langext-cfi_salt";
   let Content = [{
-Use ``__attribute__((kcfi_salt("<salt>")))`` on a function declaration, function
+Use ``__attribute__((cfi_salt("<salt>")))`` on a function declaration, function
 definition, or typedef to help distinguish CFI hashes between functions with
 the same type signature.
 
@@ -3657,11 +3657,11 @@ Example use:
 .. code-block:: c
 
   // .h file:
-  #define __kcfi_salt __attribute__((kcfi_salt("pepper")))
+  #define __cfi_salt __attribute__((cfi_salt("pepper")))
 
   // Convenient typedefs to avoid nested declarator syntax.
   typedef int (*fptr_t)(void); // Non-salted function call.
-  typedef int (*fptr_salted_t)(void) __kcfi_salt;
+  typedef int (*fptr_salted_t)(void) __cfi_salt;
 
   struct widget_generator {
     fptr_t init;
@@ -3671,7 +3671,7 @@ Example use:
 
   // 1st .c file:
   static int internal_init(void) { /* ... */ }
-  static int internal_salted_exec(void) __kcfi_salt { /* ... */ }
+  static int internal_salted_exec(void) __cfi_salt { /* ... */ }
   static int internal_teardown(void) { /* ... */ }
 
   static struct widget_generator _generator = {
diff --git a/clang/lib/AST/Type.cpp b/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.KCFISalt = epi.ExtraAttributeInfo.KCFISalt;
+    ExtraAttrInfo.CFISalt = epi.ExtraAttributeInfo.CFISalt;
 
     // Also set the bit in FunctionTypeExtraBitfields.
     auto &ExtraBits = *getTrailingObjects<FunctionTypeExtraBitfields>();
diff --git a/clang/lib/AST/TypePrinter.cpp b/clang/lib/AST/TypePrinter.cpp
@@ -2129,9 +2129,8 @@ void TypePrinter::printAttributedAfter(const AttributedType *T,
   case attr::ExtVectorType:
     OS << "ext_vector_type";
     break;
-  case attr::KCFISalt:
-    OS << "kcfi_salt(\"" << cast<KCFISaltAttr>(T->getAttr())->getSalt()
-       << "\")";
+  case attr::CFISalt:
+    OS << "cfi_salt(\"" << cast<CFISaltAttr>(T->getAttr())->getSalt() << "\")";
     break;
   }
   OS << "))";
diff --git a/clang/lib/CodeGen/CodeGenFunction.cpp b/clang/lib/CodeGen/CodeGenFunction.cpp
@@ -2912,7 +2912,7 @@ void CodeGenFunction::EmitKCFIOperandBundle(
 
   StringRef Salt;
   if (const auto &Info = FP->getExtraAttributeInfo())
-    Salt = Info.KCFISalt;
+    Salt = Info.CFISalt;
 
   Bundles.emplace_back("kcfi", CGM.CreateKCFITypeId(FP->desugar(), Salt));
 }
diff --git a/clang/lib/CodeGen/CodeGenModule.cpp b/clang/lib/CodeGen/CodeGenModule.cpp
@@ -3019,7 +3019,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.KCFISalt;
+      Salt = Info.CFISalt;
 
   F->setMetadata(llvm::LLVMContext::MD_kcfi_type,
                  llvm::MDNode::get(Ctx, MDB.createConstant(CreateKCFITypeId(
diff --git a/clang/lib/Sema/SemaType.cpp b/clang/lib/Sema/SemaType.cpp
@@ -156,8 +156,8 @@ static void diagnoseBadTypeAttribute(Sema &S, const ParsedAttr &attr,
   case ParsedAttr::AT_Allocating:                                              \
   case ParsedAttr::AT_Regparm:                                                 \
   case ParsedAttr::AT_CFIUncheckedCallee:                                      \
+  case ParsedAttr::AT_CFISalt:                                                 \
   case ParsedAttr::AT_CmseNSCall:                                              \
-  case ParsedAttr::AT_KCFISalt:                                                \
   case ParsedAttr::AT_ArmStreaming:                                            \
   case ParsedAttr::AT_ArmStreamingCompatible:                                  \
   case ParsedAttr::AT_ArmPreserves:                                            \
@@ -7942,14 +7942,14 @@ static bool handleFunctionTypeAttr(TypeProcessingState &state, ParsedAttr &attr,
     return true;
   }
 
-  if (attr.getKind() == ParsedAttr::AT_KCFISalt) {
+  if (attr.getKind() == ParsedAttr::AT_CFISalt) {
     StringRef Argument;
     if (!S.checkStringLiteralArgumentAttr(attr, 0, Argument))
       return false;
 
     const auto *FnTy = unwrapped.get()->getAs<FunctionProtoType>();
     FunctionProtoType::ExtProtoInfo EPI = FnTy->getExtProtoInfo();
-    EPI.ExtraAttributeInfo.KCFISalt = Argument;
+    EPI.ExtraAttributeInfo.CFISalt = Argument;
 
     QualType newtype = S.Context.getFunctionType(FnTy->getReturnType(),
                                                  FnTy->getParamTypes(), EPI);
diff --git a/clang/test/CodeGen/cfi-salt.c b/clang/test/CodeGen/cfi-salt.c
@@ -8,13 +8,13 @@
 #error Missing kcfi?
 #endif
 
-#define __kcfi_salt __attribute__((kcfi_salt("pepper")))
+#define __cfi_salt __attribute__((cfi_salt("pepper")))
 
 typedef int (*fn_t)(void);
-typedef int __kcfi_salt (*fn_salt_t)(void);
+typedef int __cfi_salt (*fn_salt_t)(void);
 
 typedef unsigned int (*ufn_t)(void);
-typedef unsigned int __kcfi_salt (*ufn_salt_t)(void);
+typedef unsigned int __cfi_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_]+]]"
@@ -26,25 +26,25 @@ typedef unsigned int __kcfi_salt (*ufn_salt_t)(void);
 // CHECK-NOT: module asm ".weak __kcfi_typeid_{{f6|_Z2f6v}}"
 
 int f1(void);
-int f1_salt(void) __kcfi_salt;
+int f1_salt(void) __cfi_salt;
 
 unsigned int f2(void);
-unsigned int f2_salt(void) __kcfi_salt;
+unsigned int f2_salt(void) __cfi_salt;
 
 static int f3(void);
-static int f3_salt(void) __kcfi_salt;
+static int f3_salt(void) __cfi_salt;
 
 extern int f4(void);
-extern int f4_salt(void) __kcfi_salt;
+extern int f4_salt(void) __cfi_salt;
 
 static int f5(void);
-static int f5_salt(void) __kcfi_salt;
+static int f5_salt(void) __cfi_salt;
 
 extern int f6(void);
-extern int f6_salt(void) __kcfi_salt;
+extern int f6_salt(void) __cfi_salt;
 
 struct cfi_struct {
-  fn_t __kcfi_salt fptr;
+  fn_t __cfi_salt fptr;
   fn_salt_t td_fptr;
 };
 
@@ -66,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 __kcfi_salt f) { return f(); }
+int call_salt(fn_t __cfi_salt f) { return f(); }
 int call_salt_ty(fn_salt_t f) { return f(); }
 
 // CHECK-LABEL: @{{ucall|_Z5ucallPFjvE}}
@@ -76,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 __kcfi_salt f) { return f(); }
+unsigned int ucall_salt(ufn_t __cfi_salt f) { return f(); }
 unsigned int ucall_salt_ty(ufn_salt_t f) { return f(); }
 
 int test1(struct cfi_struct *ptr) {
@@ -114,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) __kcfi_salt { return 0; }
+int f1_salt(void) __cfi_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) __kcfi_salt { return 2; }
+unsigned int f2_salt(void) __cfi_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) __kcfi_salt { return 1; }
+static int f3_salt(void) __cfi_salt { return 1; }
 
 // CHECK: declare !kcfi_type ![[#LOW_SODIUM_TYPE]]{{.*}} i32 @[[F4]]()
 // CHECK: declare !kcfi_type ![[#SALTY_TYPE]]{{.*}} i32 @[[F4_SALT]]()
@@ -141,7 +141,7 @@ static int f3_salt(void) __kcfi_salt { return 1; }
 // CHECK-NOT:   !kcfi_type
 // CHECK-SAME:  {
 static int f5(void) { return 2; }
-static int f5_salt(void) __kcfi_salt { return 2; }
+static int f5_salt(void) __cfi_salt { return 2; }
 
 // CHECK: declare !kcfi_type ![[#LOW_SODIUM_TYPE]]{{.*}} i32 @{{f6|_Z2f6v}}()
 // CHECK: declare !kcfi_type ![[#SALTY_TYPE]]{{.*}} i32 @{{f6_salt|_Z7f6_saltv}}()
@@ -153,6 +153,29 @@ static int f5_salt(void) __kcfi_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}
 //
@@ -161,3 +184,6 @@ int f7_typedef_salt(struct cfi_struct *ptr) { return ptr->td_fptr(); }
 //
 // 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]]}
diff --git a/clang/test/Misc/pragma-attribute-supported-attributes-list.test b/clang/test/Misc/pragma-attribute-supported-attributes-list.test
@@ -31,6 +31,7 @@
 // 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)
@@ -92,7 +93,6 @@
 // CHECK-NEXT: IFunc (SubjectMatchRule_function)
 // CHECK-NEXT: InitPriority (SubjectMatchRule_variable)
 // CHECK-NEXT: InternalLinkage (SubjectMatchRule_variable, SubjectMatchRule_function, SubjectMatchRule_record)
-// CHECK-NEXT: KCFISalt (SubjectMatchRule_function, SubjectMatchRule_field, SubjectMatchRule_variable, SubjectMatchRule_type_alias)
 // CHECK-NEXT: LTOVisibilityPublic (SubjectMatchRule_record)
 // CHECK-NEXT: Leaf (SubjectMatchRule_function)
 // CHECK-NEXT: LoaderUninitialized (SubjectMatchRule_variable_is_global)

Original file line number	Diff line number	Diff line change
`@@ -3929,11 +3929,11 @@ def CFICanonicalJumpTable : InheritableAttr {`
`3929`	`3929`	`let SimpleHandler = 1;`
`3930`	`3930`	`}`
`3931`	`3931`
`3932`		`-def KCFISalt : DeclOrTypeAttr {`
`3933`		`- let Spellings = [Clang<"kcfi_salt">];`
	`3932`	`+def CFISalt : DeclOrTypeAttr {`
	`3933`	`+ let Spellings = [Clang<"cfi_salt">];`
`3934`	`3934`	`let Args = [StringArgument<"Salt">];`
`3935`	`3935`	`let Subjects = SubjectList<[Function, Field, Var, TypedefName], ErrorDiag>;`
`3936`		`- let Documentation = [KCFISaltDocs];`
	`3936`	`+ let Documentation = [CFISaltDocs];`
`3937`	`3937`	`let LangOpts = [COnly];`
`3938`	`3938`	`}`
`3939`	`3939`
Original file line number	Diff line number	Diff line change
`@@ -2912,7 +2912,7 @@ void CodeGenFunction::EmitKCFIOperandBundle(`
`2912`	`2912`
`2913`	`2913`	`StringRef Salt;`
`2914`	`2914`	`if (const auto &Info = FP->getExtraAttributeInfo())`
`2915`		`- Salt = Info.KCFISalt;`
	`2915`	`+ Salt = Info.CFISalt;`
`2916`	`2916`
`2917`	`2917`	`Bundles.emplace_back("kcfi", CGM.CreateKCFITypeId(FP->desugar(), Salt));`
`2918`	`2918`	`}`