[𝘀𝗽𝗿] changes introduced through rebase

Created using spr 1.3.6-beta.1

[skip ci]

Author: pcc

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;
         }
       }

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

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

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()));
     }

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) {

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

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.

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.