Rename ScopStmt::contains(BB) to represents(BB). NFC.

[nandini12396]

Summary

In future, there will be no more a 1:1 correspondence between statements and basic blocks, the name contains does not correctly capture their relationship. A BB may infact comprise of multiple statements; hence we describe a statement representing a basic block.

include/polly/ScopInfo.h

   bool contains(const Loop *L) const {
     // Block statements never contain loops.
     if (isBlockStmt())
       return false;
 
     return getRegion()->contains(L);
   }
 
-  /// Return whether this statement contains @p BB.
-  bool contains(BasicBlock *BB) const {
+  /// Return whether this statement represents @p BB.
+  bool represents(BasicBlock *BB) const {
     if (isCopyStmt())
       return false;
     if (isBlockStmt())
       return BB == getBasicBlock();
     return getRegion()->contains(BB);
   }
 
   /// Return whether this statement contains @p Inst.
   bool contains(Instruction *Inst) const {
     if (!Inst)
       return false;
-    return contains(Inst->getParent());
+    return represents(Inst->getParent());
   }
 
   /// Return the closest innermost loop that contains this statement, but is not
   /// contained in it.
   ///
   /// For block statement, this is just the loop that contains the block. Region
   /// statements can contain boxed loops, so getting the loop of one of the
   /// region's BBs might return such an inner loop. For instance, the region's

lib/Analysis/ScopBuilder.cpp

 }
 
 void ScopBuilder::buildAccessFunctions(ScopStmt *Stmt, BasicBlock &BB,
                                        Region *NonAffineSubRegion,
                                        bool IsExitBlock) {
   assert(
       !Stmt == IsExitBlock &&
       "The exit BB is the only one that cannot be represented by a statement");
-  assert(IsExitBlock || Stmt->contains(&BB));
+  assert(IsExitBlock || Stmt->represents(&BB));
 
   // We do not build access functions for error blocks, as they may contain
   // instructions we can not model.
   if (isErrorBlock(BB, scop->getRegion(), LI, DT) && !IsExitBlock)
     return;
 
   for (Instruction &Inst : BB) {
     PHINode *PHI = dyn_cast<PHINode>(&Inst);

lib/CodeGen/BlockGenerators.cpp

                                       PHINode *PHICopy, BasicBlock *IncomingBB,
                                       LoopToScevMapT &LTS) {
   // If the incoming block was not yet copied mark this PHI as incomplete.
   // Once the block will be copied the incoming value will be added.
   BasicBlock *BBCopyStart = StartBlockMap[IncomingBB];
   BasicBlock *BBCopyEnd = EndBlockMap[IncomingBB];
   if (!BBCopyStart) {
     assert(!BBCopyEnd);
-    assert(Stmt.contains(IncomingBB) &&
+    assert(Stmt.represents(IncomingBB) &&
            "Bad incoming block for PHI in non-affine region");
     IncompletePHINodeMap[IncomingBB].push_back(std::make_pair(PHI, PHICopy));
     return;
   }
 
   assert(RegionMaps.count(BBCopyStart) &&
          "Incoming PHI block did not have a BBMap");
   ValueMapT &BBCopyMap = RegionMaps[BBCopyStart];
 
   Value *OpCopy = nullptr;
 
-  if (Stmt.contains(IncomingBB)) {
+  if (Stmt.represents(IncomingBB)) {
     Value *Op = PHI->getIncomingValueForBlock(IncomingBB);
 
     // If the current insert block is different from the PHIs incoming block
     // change it, otherwise do not.
     auto IP = Builder.GetInsertPoint();
     if (IP->getParent() != BBCopyEnd)
       Builder.SetInsertPoint(BBCopyEnd->getTerminator());
     OpCopy = getNewValue(Stmt, Op, BBCopyMap, LTS, getLoopForStmt(Stmt));

lib/Support/VirtualInstruction.cpp

VirtualUse VirtualUse::create(Scop *S, ScopStmt *UserStmt, Loop *UserScope,
 
   auto Inst = cast<Instruction>(Val);
   if (!S->contains(Inst))
     return VirtualUse(UserStmt, Val, ReadOnly, nullptr, InputMA);
 
   // A use is inter-statement if either it is defined in another statement, or
   // there is a MemoryAccess that reads its value that has been written by
   // another statement.
-  if (InputMA || (!Virtual && !UserStmt->contains(Inst->getParent())))
+  if (InputMA || (!Virtual && !UserStmt->represents(Inst->getParent())))
     return VirtualUse(UserStmt, Val, Inter, nullptr, InputMA);
 
   return VirtualUse(UserStmt, Val, Intra, nullptr, nullptr);
 }
 
 void VirtualUse::print(raw_ostream &OS, bool Reproducible) const {
   OS << "User: [" << User->getBaseName() << "] ";
   switch (Kind) {