Switch to EXTENSION

pcc · pcc · commit 7dace4385198 · 2025-08-01T17:30:27.000-07:00
Created using spr 1.3.6-beta.1
diff --git a/clang/include/clang/Basic/Features.def b/clang/include/clang/Basic/Features.def
@@ -312,9 +312,9 @@ FEATURE(shadow_call_stack,
 FEATURE(tls, PP.getTargetInfo().isTLSSupported())
 FEATURE(underlying_type, LangOpts.CPlusPlus)
 FEATURE(experimental_library, LangOpts.ExperimentalLibrary)
-FEATURE(pointer_field_protection,
-        LangOpts.getPointerFieldProtection() !=
-        LangOptions::PointerFieldProtectionKind::None)
+EXTENSION(pointer_field_protection,
+          LangOpts.getPointerFieldProtection() !=
+          LangOptions::PointerFieldProtectionKind::None)
 
 // C11 features supported by other languages as extensions.
 EXTENSION(c_alignas, true)
diff --git a/libcxx/include/__config b/libcxx/include/__config
@@ -490,7 +490,7 @@ typedef __char32_t char32_t;
 #    define _LIBCPP_EXCEPTIONS_SIG e
 #  endif
 
-#  if __has_feature(pointer_field_protection)
+#  if __has_extension(pointer_field_protection)
 #    define _LIBCPP_PFP_SIG p
 #  else
 #    define _LIBCPP_PFP_SIG
@@ -1275,7 +1275,7 @@ typedef __char32_t char32_t;
 #    define _LIBCPP_HAS_EXPLICIT_THIS_PARAMETER 0
 #  endif
 
-#  if __has_feature(pointer_field_protection)
+#  if __has_extension(pointer_field_protection)
 #    define _LIBCPP_NO_PFP [[clang::no_field_protection]]
 #  else
 #    define _LIBCPP_NO_PFP
diff --git a/libcxx/include/__force_nonstandard_layout b/libcxx/include/__force_nonstandard_layout
@@ -32,7 +32,7 @@ class __force_nonstandard_layout_base2 : __force_nonstandard_layout_base1 {};
 class __force_nonstandard_layout : __force_nonstandard_layout_base1, __force_nonstandard_layout_base2 {};
 _LIBCPP_DIAGNOSTIC_POP
 
-#if __has_feature(pointer_field_protection)
+#if __has_extension(pointer_field_protection)
 #  define _LIBCPP_MAYBE_FORCE_NONSTANDARD_LAYOUT : __force_nonstandard_layout
 #else
 #  define _LIBCPP_MAYBE_FORCE_NONSTANDARD_LAYOUT
diff --git a/libcxx/test/libcxx/gdb/gdb_pretty_printer_test.sh.cpp b/libcxx/test/libcxx/gdb/gdb_pretty_printer_test.sh.cpp
@@ -256,7 +256,7 @@ void unique_ptr_test() {
   ComparePrettyPrintToRegex(std::move(forty_two),
       R"(std::unique_ptr<int> containing = {__ptr_ = 0x[a-f0-9]+})");
 
-#if !__has_feature(pointer_field_protection)
+#if !__has_extension(pointer_field_protection)
   // GDB doesn't know how to read PFP fields correctly yet.
   std::unique_ptr<int> this_is_null;
   ComparePrettyPrintToChars(std::move(this_is_null),
@@ -479,7 +479,7 @@ void vector_test() {
                             "std::vector of length "
                             "3, capacity 3 = {5, 6, 7}");
 
-#if !__has_feature(pointer_field_protection)
+#if !__has_extension(pointer_field_protection)
   // GDB doesn't know how to read PFP fields correctly yet.
   std::vector<int, UncompressibleAllocator<int>> test3({7, 8});
   ComparePrettyPrintToChars(std::move(test3),
@@ -656,7 +656,7 @@ void shared_ptr_test() {
       test0,
       R"(std::shared_ptr<int> count [3\?], weak [0\?]( \(libc\+\+ missing debug info\))? containing = {__ptr_ = 0x[a-f0-9]+})");
 
-#if !__has_feature(pointer_field_protection)
+#if !__has_extension(pointer_field_protection)
   // GDB doesn't know how to read PFP fields correctly yet.
   std::shared_ptr<const int> test3;
   ComparePrettyPrintToChars(test3, "std::shared_ptr is nullptr");
diff --git a/libcxx/test/libcxx/type_traits/is_trivially_relocatable.compile.pass.cpp b/libcxx/test/libcxx/type_traits/is_trivially_relocatable.compile.pass.cpp
@@ -28,7 +28,7 @@
 #  include <locale>
 #endif
 
-#if __has_feature(pointer_field_protection)
+#if __has_extension(pointer_field_protection)
 constexpr bool pfp_disabled = false;
 #else
 constexpr bool pfp_disabled = true;
diff --git a/libcxxabi/include/__cxxabi_config.h b/libcxxabi/include/__cxxabi_config.h
@@ -110,7 +110,7 @@
 #endif
 
 #if defined(_LIBCXXABI_COMPILER_CLANG)
-#  if __has_feature(pointer_field_protection)
+#  if __has_extension(pointer_field_protection)
 #    define _LIBCXXABI_NO_PFP [[clang::no_field_protection]]
 #  else
 #    define _LIBCXXABI_NO_PFP
diff --git a/lld/ELF/Relocations.cpp b/lld/ELF/Relocations.cpp
@@ -1175,9 +1175,8 @@ void RelocationScanner::processAux(RelExpr expr, RelType type, uint64_t offset,
                << " cannot be used against ifunc symbol '" << &sym << "'";
           printLocation(diag, *sec, sym, offset);
         } else {
-          part.relaDyn->addReloc({ctx.target->iRelativeRel, sec, offset,
-                                  DynamicReloc::AddendOnlyWithTargetVA, sym,
-                                  addend, R_ABS});
+          part.relaDyn->addReloc({ctx.target->iRelativeRel, sec, offset, false,
+                                  sym, addend, R_ABS});
           return;
         }
       }
diff --git a/llvm/docs/LangRef.rst b/llvm/docs/LangRef.rst
@@ -31200,14 +31200,14 @@ third argument is 1). When loading from the pointer, the inverse operation
 is done on the loaded pointer after it is loaded. Specifically, when the
 third argument is 1, the pointer is signed (using pointer authentication
 instructions or emulated PAC if not supported by the hardware) using
-the struct address before being stored, and authenticated after being
+the discriminator before being stored, and authenticated after being
 loaded. Note that it is currently unsupported to have the third argument
 be 1 on targets other than AArch64. When the third argument is 0, it is
 rotated left by 16 bits and the discriminator is subtracted before being
 stored, and the discriminator is added and the pointer is rotated right
 by 16 bits after being loaded.
 
-If the pointer is used otherwise than for loading or storing (e.g. its
+If the pointer is used other than for loading or storing (e.g. its
 address escapes), that will disable all blending operations using
 the deactivation symbol specified in the intrinsic's operand bundle.
 The deactivation symbol operand bundle is copied onto any sign and auth
diff --git a/llvm/include/llvm/Transforms/Utils/Local.h b/llvm/include/llvm/Transforms/Utils/Local.h
@@ -182,9 +182,10 @@ LLVM_ABI bool EliminateDuplicatePHINodes(BasicBlock *BB);
 LLVM_ABI bool EliminateDuplicatePHINodes(BasicBlock *BB,
                                          SmallPtrSetImpl<PHINode *> &ToRemove);
 
-/// Returns whether it is allowed and beneficial for optimizations to transform
-/// phi(load(ptr)) into load(phi(ptr)) or a similar transformation for stores.
-bool shouldFoldLoadStoreWithPointerOperandThroughPhi(const Value *Ptr);
+/// Returns whether it is allowed and beneficial for optimizations to fold this
+/// operand through a phi, for example when transforming phi(load(ptr)) into
+/// load(phi(ptr)).
+bool shouldFoldOperandThroughPhi(const Value *Ptr);
 
 /// This function is used to do simplification of a CFG.  For example, it
 /// adjusts branches to branches to eliminate the extra hop, it eliminates
diff --git a/llvm/lib/CodeGen/PreISelIntrinsicLowering.cpp b/llvm/lib/CodeGen/PreISelIntrinsicLowering.cpp
@@ -39,8 +39,6 @@
 #include "llvm/Transforms/Utils/LowerMemIntrinsics.h"
 #include "llvm/Transforms/Utils/LowerVectorIntrinsics.h"
 
-#include <set>
-
 using namespace llvm;
 
 /// Threshold to leave statically sized memory intrinsic calls. Calls of known
@@ -476,8 +474,8 @@ enum class PointerEncoding {
 bool expandProtectedFieldPtr(Function &Intr) {
   Module &M = *Intr.getParent();
 
-  std::set<GlobalValue *> DSsToDeactivate;
-  std::set<Instruction *> LoadsStores;
+  SmallPtrSet<GlobalValue *, 2> DSsToDeactivate;
+  SmallPtrSet<Instruction *, 2> LoadsStores;
 
   Type *Int8Ty = Type::getInt8Ty(M.getContext());
   Type *Int64Ty = Type::getInt64Ty(M.getContext());
@@ -520,111 +518,75 @@ bool expandProtectedFieldPtr(Function &Intr) {
   for (User *U : Intr.users()) {
     auto *Call = cast<CallInst>(U);
     auto *DS = GetDeactivationSymbol(Call);
-    std::set<PHINode *> VisitedPhis;
-
-    std::function<void(Instruction *)> FindLoadsStores;
-    FindLoadsStores = [&](Instruction *I) {
-      for (Use &U : I->uses()) {
-        if (auto *LI = dyn_cast<LoadInst>(U.getUser())) {
-          if (isa<PointerType>(LI->getType())) {
-            LoadsStores.insert(LI);
-            continue;
-          }
-        }
-        if (auto *SI = dyn_cast<StoreInst>(U.getUser())) {
-          if (U.getOperandNo() == 1 &&
-              isa<PointerType>(SI->getValueOperand()->getType())) {
-            LoadsStores.insert(SI);
-            continue;
-          }
-        }
-        if (auto *P = dyn_cast<PHINode>(U.getUser())) {
-          if (VisitedPhis.insert(P).second)
-            FindLoadsStores(P);
+
+    for (Use &U : Call->uses()) {
+      if (auto *LI = dyn_cast<LoadInst>(U.getUser())) {
+        if (isa<PointerType>(LI->getType())) {
+          LoadsStores.insert(LI);
           continue;
         }
-        // Comparisons against null cannot be used to recover the original
-        // pointer so we allow them.
-        if (auto *CI = dyn_cast<ICmpInst>(U.getUser())) {
-          if (auto *Op = dyn_cast<Constant>(CI->getOperand(0)))
-            if (Op->isNullValue())
-              continue;
-          if (auto *Op = dyn_cast<Constant>(CI->getOperand(1)))
-            if (Op->isNullValue())
-              continue;
-        }
-        if (DS)
-          DSsToDeactivate.insert(DS);
       }
-    };
-
-    FindLoadsStores(Call);
-  }
-
-  for (Instruction *I : LoadsStores) {
-    std::set<Value *> Pointers;
-    std::set<Value *> Discs;
-    std::set<GlobalValue *> DSs;
-    std::set<PHINode *> VisitedPhis;
-    bool UseHWEncoding = false;
-
-    std::function<void(Value *)> FindFields;
-    FindFields = [&](Value *V) {
-      if (auto *Call = dyn_cast<CallInst>(V)) {
-        if (Call->getCalledOperand() == &Intr) {
-          Pointers.insert(Call->getArgOperand(0));
-          Discs.insert(Call->getArgOperand(1));
-          if (cast<ConstantInt>(Call->getArgOperand(2))->getZExtValue())
-            UseHWEncoding = true;
-          DSs.insert(GetDeactivationSymbol(Call));
-          return;
+      if (auto *SI = dyn_cast<StoreInst>(U.getUser())) {
+        if (U.getOperandNo() == 1 &&
+            isa<PointerType>(SI->getValueOperand()->getType())) {
+          LoadsStores.insert(SI);
+          continue;
         }
       }
-      if (auto *P = dyn_cast<PHINode>(V)) {
-        if (VisitedPhis.insert(P).second)
-          for (Value *V : P->incoming_values())
-            FindFields(V);
-        return;
+      // Comparisons against null cannot be used to recover the original
+      // pointer so we allow them.
+      if (auto *CI = dyn_cast<ICmpInst>(U.getUser())) {
+        if (auto *Op = dyn_cast<Constant>(CI->getOperand(0)))
+          if (Op->isNullValue())
+            continue;
+        if (auto *Op = dyn_cast<Constant>(CI->getOperand(1)))
+          if (Op->isNullValue())
+            continue;
       }
-      Pointers.insert(nullptr);
-    };
-    FindFields(isa<StoreInst>(I) ? cast<StoreInst>(I)->getPointerOperand()
-                                 : cast<LoadInst>(I)->getPointerOperand());
-    if (Pointers.size() != 1 || Discs.size() != 1 || DSs.size() != 1) {
-      for (GlobalValue *DS : DSs)
-        if (DS)
-          DSsToDeactivate.insert(DS);
-      continue;
+      if (DS)
+        DSsToDeactivate.insert(DS);
     }
+  }
+
+  for (Instruction *I : LoadsStores) {
+    auto *PointerOperand = isa<StoreInst>(I)
+                               ? cast<StoreInst>(I)->getPointerOperand()
+                               : cast<LoadInst>(I)->getPointerOperand();
+    auto *Call = cast<CallInst>(PointerOperand);
+
+    auto *Disc = Call->getArgOperand(1);
+    bool UseHWEncoding = cast<ConstantInt>(Call->getArgOperand(2))->getZExtValue();
 
-    GlobalValue *DS = *DSs.begin();
+    GlobalValue *DS = GetDeactivationSymbol(Call);
     OperandBundleDef DSBundle("deactivation-symbol", DS);
 
     if (auto *LI = dyn_cast<LoadInst>(I)) {
       IRBuilder<> B(LI->getNextNode());
       auto *LIInt = cast<Instruction>(B.CreatePtrToInt(LI, B.getInt64Ty()));
       Value *Auth;
       if (UseHWEncoding) {
-        Auth = CreateAuth(B, LIInt, *Discs.begin(), DSBundle);
+        Auth = CreateAuth(B, LIInt, Disc, DSBundle);
       } else {
-        Auth = B.CreateAdd(LIInt, *Discs.begin());
+        Auth = B.CreateAdd(LIInt, Disc);
         Auth = B.CreateIntrinsic(
             Auth->getType(), Intrinsic::fshr,
             {Auth, Auth, ConstantInt::get(Auth->getType(), 16)});
       }
       LI->replaceAllUsesWith(B.CreateIntToPtr(Auth, B.getPtrTy()));
       LIInt->setOperand(0, LI);
-    } else if (auto *SI = dyn_cast<StoreInst>(I)) {
+    } else {
+      auto *SI = cast<StoreInst>(I);
       IRBuilder<> B(SI);
       auto *SIValInt =
           B.CreatePtrToInt(SI->getValueOperand(), B.getInt64Ty());
       Value *Sign;
       if (UseHWEncoding) {
-        Sign = CreateSign(B, SIValInt, *Discs.begin(), DSBundle);
+        Sign = CreateSign(B, SIValInt, Disc, DSBundle);
       } else {
         Sign = B.CreateIntrinsic(
             SIValInt->getType(), Intrinsic::fshl,
             {SIValInt, SIValInt, ConstantInt::get(SIValInt->getType(), 16)});
+        Sign = B.CreateSub(Sign, Disc);
       }
       SI->setOperand(0, B.CreateIntToPtr(Sign, B.getPtrTy()));
     }
diff --git a/llvm/lib/IR/Verifier.cpp b/llvm/lib/IR/Verifier.cpp
@@ -2627,6 +2627,11 @@ void Verifier::visitConstantPtrAuth(const ConstantPtrAuth *CPA) {
 
   Check(CPA->getDiscriminator()->getBitWidth() == 64,
         "signed ptrauth constant discriminator must be i64 constant integer");
+
+  Check(isa<GlobalValue>(CPA->getDeactivationSymbol()) ||
+            CPA->getDeactivationSymbol()->isNullValue(),
+        "signed ptrauth constant deactivation symbol must be a global value "
+        "or null");
 }
 
 bool Verifier::verifyAttributeCount(AttributeList Attrs, unsigned Params) {
diff --git a/llvm/lib/Transforms/InstCombine/InstCombinePHI.cpp b/llvm/lib/Transforms/InstCombine/InstCombinePHI.cpp
@@ -697,7 +697,7 @@ static bool isSafeAndProfitableToSinkLoad(LoadInst *L) {
 Instruction *InstCombinerImpl::foldPHIArgLoadIntoPHI(PHINode &PN) {
   LoadInst *FirstLI = cast<LoadInst>(PN.getIncomingValue(0));
 
-  if (!shouldFoldLoadStoreWithPointerOperandThroughPhi(FirstLI->getOperand(0)))
+  if (!shouldFoldOperandThroughPhi(FirstLI->getOperand(0)))
     return nullptr;
 
   // FIXME: This is overconservative; this transform is allowed in some cases
@@ -736,7 +736,7 @@ Instruction *InstCombinerImpl::foldPHIArgLoadIntoPHI(PHINode &PN) {
         LI->getPointerAddressSpace() != LoadAddrSpace)
       return nullptr;
 
-    if (!shouldFoldLoadStoreWithPointerOperandThroughPhi(LI->getOperand(0)))
+    if (!shouldFoldOperandThroughPhi(LI->getOperand(0)))
       return nullptr;
 
     // We can't sink the load if the loaded value could be modified between
diff --git a/llvm/lib/Transforms/Utils/Local.cpp b/llvm/lib/Transforms/Utils/Local.cpp
@@ -3846,7 +3846,7 @@ bool llvm::canReplaceOperandWithVariable(const Instruction *I, unsigned OpIdx) {
   if (Op->getType()->isMetadataTy())
     return false;
 
-  if (!shouldFoldLoadStoreWithPointerOperandThroughPhi(Op))
+  if (!shouldFoldOperandThroughPhi(Op))
     return false;
 
   // Cannot replace alloca argument with phi/select.
diff --git a/llvm/lib/Transforms/Utils/SimplifyCFG.cpp b/llvm/lib/Transforms/Utils/SimplifyCFG.cpp
@@ -2134,7 +2134,7 @@ static bool replacingOperandWithVariableIsCheap(const Instruction *I,
   return !isa<IntrinsicInst>(I);
 }
 
-bool llvm::shouldFoldLoadStoreWithPointerOperandThroughPhi(const Value *Ptr) {
+bool llvm::shouldFoldOperandThroughPhi(const Value *Ptr) {
   // swifterror pointers can only be used by a load or store; sinking a load
   // or store would require introducing a select for the pointer operand,
   // which isn't allowed for swifterror pointers.
diff --git a/llvm/test/Transforms/PreISelIntrinsicLowering/protected-field-pointer.ll b/llvm/test/Transforms/PreISelIntrinsicLowering/protected-field-pointer.ll
diff --git a/llvm/test/Transforms/SROA/protected-field-pointer.ll b/llvm/test/Transforms/SROA/protected-field-pointer.ll
diff --git a/llvm/test/Transforms/Util/phi-protected-field-ptr.ll b/llvm/test/Transforms/Util/phi-protected-field-ptr.ll
diff --git a/llvm/test/Verifier/ptrauth-constant.ll b/llvm/test/Verifier/ptrauth-constant.ll

Original file line number	Diff line number	Diff line change
`@@ -1175,9 +1175,8 @@ void RelocationScanner::processAux(RelExpr expr, RelType type, uint64_t offset,`
`1175`	`1175`	`<< " cannot be used against ifunc symbol '" << &sym << "'";`
`1176`	`1176`	`printLocation(diag, *sec, sym, offset);`
`1177`	`1177`	`} else {`
`1178`		`- part.relaDyn->addReloc({ctx.target->iRelativeRel, sec, offset,`
`1179`		`- DynamicReloc::AddendOnlyWithTargetVA, sym,`
`1180`		`- addend, R_ABS});`
	`1178`	`+ part.relaDyn->addReloc({ctx.target->iRelativeRel, sec, offset, false,`
	`1179`	`+ sym, addend, R_ABS});`
`1181`	`1180`	`return;`
`1182`	`1181`	`}`
`1183`	`1182`	`}`