IR: Remove Value::intersectOptionalDataWith, replace all calls with calls to Instruction::andIRFlags. NFCI.

[pcc]

Summary

The two functions are intended to be functionally equivalent.

[pcc]

Ping.

[majnemer]

LGTM

include/llvm/IR/Value.h

void clearSubclassOptionalData() {
     SubclassOptionalData = 0;
   }
 
   /// \brief Check the optional flags for equality.
   bool hasSameSubclassOptionalData(const Value *V) const {
     return SubclassOptionalData == V->SubclassOptionalData;
   }
 
-  /// \brief Clear any optional flags not set in the given Value.
-  void intersectOptionalDataWith(const Value *V) {
-    SubclassOptionalData &= V->SubclassOptionalData;
-  }
-
   /// \brief Return true if there is a value handle associated with this value.
   bool hasValueHandle() const { return HasValueHandle; }
 
   /// \brief Return true if there is metadata referencing this value.
   bool isUsedByMetadata() const { return IsUsedByMD; }
 
   /// \brief Strip off pointer casts, all-zero GEPs, and aliases.
   ///

lib/Transforms/Scalar/GVNHoist.cpp

bool makeOperandsAvailable(Instruction *Repl, BasicBlock *HoistPt,
     // other paths.
     for (Instruction *OtherInst : InstructionsToHoist) {
       GetElementPtrInst *OtherGep;
       if (auto *OtherLd = dyn_cast<LoadInst>(OtherInst))
         OtherGep = cast<GetElementPtrInst>(OtherLd->getPointerOperand());
       else
         OtherGep = cast<GetElementPtrInst>(
             cast<StoreInst>(OtherInst)->getPointerOperand());
-      ClonedGep->intersectOptionalDataWith(OtherGep);
+      ClonedGep->andIRFlags(OtherGep);
       combineKnownMetadata(ClonedGep, OtherGep);
     }
     Repl->replaceUsesOfWith(Gep, ClonedGep);
 
     // Also copy Val when it is a GEP.
     if (Val && isa<GetElementPtrInst>(Val)) {
       Instruction *ClonedVal = Val->clone();
       ClonedVal->insertBefore(HoistPt->getTerminator());
       // Conservatively discard any optimization hints, they may differ on the
       // other paths.
       for (Instruction *OtherInst : InstructionsToHoist) {
         auto *OtherVal =
             cast<Instruction>(cast<StoreInst>(OtherInst)->getValueOperand());
-        ClonedVal->intersectOptionalDataWith(OtherVal);
+        ClonedVal->andIRFlags(OtherVal);
         combineKnownMetadata(ClonedVal, OtherVal);
       }
       Repl->replaceUsesOfWith(Val, ClonedVal);
     }
 
     return true;
   }
 
for (const HoistingPointInfo &HP : HPL) {
             ++NumStoresRemoved;
           } else if (auto *ReplacementAlloca = dyn_cast<AllocaInst>(Repl)) {
             ReplacementAlloca->setAlignment(
                 std::max(ReplacementAlloca->getAlignment(),
                          cast<AllocaInst>(I)->getAlignment()));
           } else if (isa<CallInst>(Repl)) {
             ++NumCallsRemoved;
           }
-          Repl->intersectOptionalDataWith(I);
+          Repl->andIRFlags(I);
           combineKnownMetadata(Repl, I);
           I->replaceAllUsesWith(Repl);
           I->eraseFromParent();
         }
     }
 
     NumHoisted += NL + NS + NC + NI;
     NumRemoved += NR;

lib/Transforms/Scalar/MergedLoadStoreMotion.cpp

void MergedLoadStoreMotion::hoistInstruction(BasicBlock *BB,
                                              Instruction *ElseInst) {
   DEBUG(dbgs() << " Hoist Instruction into BB \n"; BB->dump();
         dbgs() << "Instruction Left\n"; HoistCand->dump(); dbgs() << "\n";
         dbgs() << "Instruction Right\n"; ElseInst->dump(); dbgs() << "\n");
   // Hoist the instruction.
   assert(HoistCand->getParent() != BB);
 
   // Intersect optional metadata.
-  HoistCand->intersectOptionalDataWith(ElseInst);
+  HoistCand->andIRFlags(ElseInst);
   HoistCand->dropUnknownNonDebugMetadata();
 
   // Prepend point for instruction insert
   Instruction *HoistPt = BB->getTerminator();
 
   // Merged instruction
   Instruction *HoistedInst = HoistCand->clone();
 
if (A0 && A1 && A0->isIdenticalTo(A1) && A0->hasOneUse() &&
       (A0->getParent() == S0->getParent()) && A1->hasOneUse() &&
       (A1->getParent() == S1->getParent()) && isa<GetElementPtrInst>(A0)) {
     DEBUG(dbgs() << "Sink Instruction into BB \n"; BB->dump();
           dbgs() << "Instruction Left\n"; S0->dump(); dbgs() << "\n";
           dbgs() << "Instruction Right\n"; S1->dump(); dbgs() << "\n");
     // Hoist the instruction.
     BasicBlock::iterator InsertPt = BB->getFirstInsertionPt();
     // Intersect optional metadata.
-    S0->intersectOptionalDataWith(S1);
+    S0->andIRFlags(S1);
     S0->dropUnknownNonDebugMetadata();
 
     // Create the new store to be inserted at the join point.
     StoreInst *SNew = cast<StoreInst>(S0->clone());
     Instruction *ANew = A0->clone();
     SNew->insertBefore(&*InsertPt);
     ANew->insertBefore(SNew);
 

lib/Transforms/Utils/SimplifyCFG.cpp

if (!TTI.isProfitableToHoist(I1) || !TTI.isProfitableToHoist(I2))
       return Changed;
 
     // For a normal instruction, we just move one to right before the branch,
     // then replace all uses of the other with the first.  Finally, we remove
     // the now redundant second instruction.
     BIParent->getInstList().splice(BI->getIterator(), BB1->getInstList(), I1);
     if (!I2->use_empty())
       I2->replaceAllUsesWith(I1);
-    I1->intersectOptionalDataWith(I2);
+    I1->andIRFlags(I2);
     unsigned KnownIDs[] = {LLVMContext::MD_tbaa,
                            LLVMContext::MD_range,
                            LLVMContext::MD_fpmath,
                            LLVMContext::MD_invariant_load,
                            LLVMContext::MD_nonnull,
                            LLVMContext::MD_invariant_group,
                            LLVMContext::MD_align,
                            LLVMContext::MD_dereferenceable,
while (RI1 != RE1 && RI2 != RE2) {
     BBEnd->getInstList().splice(FirstNonPhiInBBEnd->getIterator(),
                                 BB1->getInstList(), I1);
     if (!OldPN->use_empty())
       OldPN->replaceAllUsesWith(I1);
     OldPN->eraseFromParent();
 
     if (!I2->use_empty())
       I2->replaceAllUsesWith(I1);
-    I1->intersectOptionalDataWith(I2);
+    I1->andIRFlags(I2);
     // TODO: Use combineMetadata here to preserve what metadata we can
     // (analogous to the hoisting case above).
     I2->eraseFromParent();
 
     if (UpdateRE1)
       RE1 = BB1->getInstList().rend();
     if (UpdateRE2)
       RE2 = BB2->getInstList().rend();

lib/Transforms/Vectorize/BBVectorize.cpp

for (BasicBlock::iterator PI = BB.getFirstInsertionPt(); PI != BB.end();) {
                               Tys, Old->isVarArg()));
       } else if (!isa<StoreInst>(K))
         K->mutateType(getVecTypeForPair(L->getType(), H->getType()));
 
       unsigned KnownIDs[] = {LLVMContext::MD_tbaa, LLVMContext::MD_alias_scope,
                              LLVMContext::MD_noalias, LLVMContext::MD_fpmath,
                              LLVMContext::MD_invariant_group};
       combineMetadata(K, H, KnownIDs);
-      K->intersectOptionalDataWith(H);
+      K->andIRFlags(H);
 
       for (unsigned o = 0; o < NumOperands; ++o)
         K->setOperand(o, ReplacedOperands[o]);
 
       K->insertAfter(J);
 
       // Instruction insertion point:
       Instruction *InsertionPt = K;