[di] Add an accessor for NumElements and use that instead of accessing the field directly.

Author: gottesmm

lib/SILOptimizer/Mandatory/DIMemoryUseCollector.cpp

@@ -561,7 +561,8 @@ class ElementUseCollector {
 
   void trackDestroy(SILInstruction *Destroy) { UseInfo.trackDestroy(Destroy); }
 
-  unsigned getNumMemoryElements() const { return TheMemory.NumElements; }
+  /// Return the raw number of elements including the 'super.init' value.
+  unsigned getNumMemoryElements() const { return TheMemory.getNumElements(); }
 
   SILInstruction *getMemoryInst() const { return TheMemory.MemoryInst; }
 
@@ -588,7 +589,8 @@ void ElementUseCollector::addElementUses(unsigned BaseEltNo, SILType UseTy,
   // If we're in a subelement of a struct or enum, just mark the struct, not
   // things that come after it in a parent tuple.
   unsigned NumElements = 1;
-  if (TheMemory.NumElements != 1 && !InStructSubElement && !InEnumSubElement)
+  if (TheMemory.getNumElements() != 1 && !InStructSubElement &&
+      !InEnumSubElement)
     NumElements =
         getElementCountRec(TypeExpansionContext(*User->getFunction()), Module,
                            UseTy, IsSelfOfNonDelegatingInitializer);
@@ -843,14 +845,14 @@ void ElementUseCollector::collectUses(SILValue Pointer, unsigned BaseEltNo) {
         // by the callee, and this is enforced by sema, so we can consider it
         // a nonmutating use.
         bool isLet = true;
-        
-        for (unsigned i = 0; i < TheMemory.NumElements; ++i) {
+
+        for (unsigned i = 0; i < TheMemory.getNumElements(); ++i) {
           if (!TheMemory.isElementLetProperty(i)) {
             isLet = false;
             break;
           }
         }
-        
+
         if (isLet) {
           addElementUses(BaseEltNo, PointeeType, User, DIUseKind::IndirectIn);
           continue;
@@ -1186,7 +1188,7 @@ void ElementUseCollector::collectClassSelfUses() {
     // We can safely handle anything else as an escape.  They should all happen
     // after super.init is invoked.  As such, all elements must be initialized
     // and super.init must be called.
-    trackUse(DIMemoryUse(User, DIUseKind::Load, 0, TheMemory.NumElements));
+    trackUse(DIMemoryUse(User, DIUseKind::Load, 0, TheMemory.getNumElements()));
   }
 
   assert(StoresOfArgumentToSelf == 1 &&
@@ -1461,7 +1463,7 @@ void ElementUseCollector::collectClassSelfUses(
       Kind = DIUseKind::Escape;
     }
 
-    trackUse(DIMemoryUse(User, Kind, 0, TheMemory.NumElements));
+    trackUse(DIMemoryUse(User, Kind, 0, TheMemory.getNumElements()));
   }
 }
 
@@ -1593,7 +1595,7 @@ void ClassInitElementUseCollector::collectClassInitSelfUses() {
   // When we're analyzing a delegating constructor, we aren't field sensitive at
   // all.  Just treat all members of self as uses of the single
   // non-field-sensitive value.
-  assert(TheMemory.NumElements == 1 && "delegating inits only have 1 bit");
+  assert(TheMemory.getNumElements() == 1 && "delegating inits only have 1 bit");
   auto *MUI = TheMemory.MemoryInst;
 
   // The number of stores of the initial 'self' argument into the self box
@@ -1827,7 +1829,8 @@ void swift::ownership::collectDIElementUsesFrom(
     // When we're analyzing a delegating constructor, we aren't field sensitive
     // at all. Just treat all members of self as uses of the single
     // non-field-sensitive value.
-    assert(MemoryInfo.NumElements == 1 && "delegating inits only have 1 bit");
+    assert(MemoryInfo.getNumElements() == 1 &&
+           "delegating inits only have 1 bit");
     collectDelegatingInitUses(MemoryInfo, UseInfo, MemoryInfo.MemoryInst);
     return;
   }

lib/SILOptimizer/Mandatory/DIMemoryUseCollector.h

@@ -60,7 +60,6 @@ class DIMemoryObjectInfo {
   /// This is the base type of the memory allocation.
   SILType MemorySILType;
 
-public:
   /// This is the count of elements being analyzed.  For memory objects that are
   /// tuples, this is the flattened element count.  For 'self' members in init
   /// methods, this is the local field count (+1 for super/self classes were
@@ -103,6 +102,13 @@ class DIMemoryObjectInfo {
     return NumElements - (unsigned)isDerivedClassSelf();
   }
 
+  /// Return the number of elements, including the extra "super.init" tracker in
+  /// initializers of derived classes.
+  ///
+  /// \see getNumMemoryElements() for the number of elements, excluding the
+  /// extra "super.init" tracker in the initializers of derived classes.
+  unsigned getNumElements() const { return NumElements; }
+
   /// Return true if this is 'self' in any kind of initializer.
   bool isAnyInitSelf() const { return !MemoryInst->isVar(); }
 

lib/SILOptimizer/Mandatory/DefiniteInitialization.cpp

@@ -435,8 +435,9 @@ namespace {
     void emitSelfConsumedDiagnostic(SILInstruction *Inst);
 
     LiveOutBlockState &getBlockInfo(SILBasicBlock *BB) {
-      return PerBlockInfo.insert({BB,
-                     LiveOutBlockState(TheMemory.NumElements)}).first->second;
+      return PerBlockInfo
+          .insert({BB, LiveOutBlockState(TheMemory.getNumElements())})
+          .first->second;
     }
 
     AvailabilitySet getLivenessAtInst(SILInstruction *Inst, unsigned FirstElt,
@@ -640,7 +641,7 @@ void LifetimeChecker::noteUninitializedMembers(const DIMemoryUse &Use) {
     if (Liveness.get(i) == DIKind::Yes) continue;
 
     // Ignore a failed super.init requirement.
-    if (i == TheMemory.NumElements-1 && TheMemory.isDerivedClassSelf())
+    if (i == TheMemory.getNumElements() - 1 && TheMemory.isDerivedClassSelf())
       continue;
 
     std::string Name;
@@ -672,7 +673,7 @@ std::string LifetimeChecker::getUninitElementName(const DIMemoryUse &Use) {
   // Verify that it isn't the super.init marker that failed.  The client should
   // handle this, not pass it down to diagnoseInitError.
   assert((!TheMemory.isDerivedClassSelf() ||
-          firstUndefElement != TheMemory.NumElements-1) &&
+          firstUndefElement != TheMemory.getNumElements() - 1) &&
          "super.init failure not handled in the right place");
 
   // If the definition is a declaration, try to reconstruct a name and
@@ -938,8 +939,8 @@ void LifetimeChecker::handleStoreUse(unsigned UseID) {
 
   if (TheMemory.isNonRootClassSelf()) {
     if (getSelfInitializedAtInst(Use.Inst) != DIKind::Yes) {
-      auto SelfLiveness = getLivenessAtInst(Use.Inst,
-                                            0, TheMemory.NumElements);
+      auto SelfLiveness =
+          getLivenessAtInst(Use.Inst, 0, TheMemory.getNumElements());
       if (SelfLiveness.isAllYes()) {
         emitSelfConsumedDiagnostic(Use.Inst);
         return;
@@ -1816,11 +1817,12 @@ void LifetimeChecker::handleSelfInitUse(unsigned UseID) {
 
   // Determine the liveness states of the memory object, including the
   // self/super.init state.
-  AvailabilitySet Liveness = getLivenessAtInst(Inst, 0, TheMemory.NumElements);
+  AvailabilitySet Liveness =
+      getLivenessAtInst(Inst, 0, TheMemory.getNumElements());
 
   // self/super.init() calls require that self/super.init has not already
   // been called. If it has, reject the program.
-  switch (Liveness.get(TheMemory.NumElements-1)) {
+  switch (Liveness.get(TheMemory.getNumElements() - 1)) {
   case DIKind::No:  // This is good! Keep going.
     break;
   case DIKind::Yes:
@@ -1838,15 +1840,16 @@ void LifetimeChecker::handleSelfInitUse(unsigned UseID) {
   }
 
   if (TheMemory.isDelegatingInit()) {
-    assert(TheMemory.NumElements == 1 && "delegating inits have a single elt");
+    assert(TheMemory.getNumElements() == 1 &&
+           "delegating inits have a single elt");
 
     // Lower Assign instructions if needed.
     if (isa<AssignInst>(Use.Inst) || isa<AssignByWrapperInst>(Use.Inst))
       NeedsUpdateForInitState.push_back(UseID);
   } else {
     // super.init also requires that all ivars are initialized before the
     // superclass initializer runs.
-    for (unsigned i = 0, e = TheMemory.NumElements-1; i != e; ++i) {
+    for (unsigned i = 0, e = TheMemory.getNumElements() - 1; i != e; ++i) {
       if (Liveness.get(i) == DIKind::Yes) continue;
 
       // If the super.init call is implicit generated, produce a specific
@@ -2045,7 +2048,7 @@ void LifetimeChecker::processNonTrivialRelease(unsigned ReleaseID) {
   assert(isa<StrongReleaseInst>(Release) || isa<DestroyValueInst>(Release) ||
          isa<DestroyAddrInst>(Release));
 
-  auto Availability = getLivenessAtInst(Release, 0, TheMemory.NumElements);
+  auto Availability = getLivenessAtInst(Release, 0, TheMemory.getNumElements());
   DIKind SelfInitialized = DIKind::Yes;
 
   if (TheMemory.isNonRootClassSelf()) {
@@ -2188,7 +2191,7 @@ SILValue LifetimeChecker::handleConditionalInitAssign() {
   SILLocation Loc = TheMemory.getLoc();
   Loc.markAutoGenerated();
 
-  unsigned NumMemoryElements = TheMemory.NumElements;
+  unsigned NumMemoryElements = TheMemory.getNumElements();
 
   // We might need an extra bit to check if self was consumed.
   if (HasConditionalSelfInitialized)
@@ -2338,10 +2341,10 @@ handleConditionalDestroys(SILValue ControlVariableAddr) {
   SILBuilderWithScope B(TheMemory.MemoryInst);
   Identifier ShiftRightFn, TruncateFn;
 
-  unsigned NumMemoryElements = TheMemory.NumElements;
-  
-  unsigned SelfInitializedElt = TheMemory.NumElements;
-  unsigned SuperInitElt = TheMemory.NumElements - 1;
+  unsigned NumMemoryElements = TheMemory.getNumElements();
+
+  unsigned SelfInitializedElt = TheMemory.getNumElements();
+  unsigned SuperInitElt = TheMemory.getNumElements() - 1;
 
   // We might need an extra bit to check if self was consumed.
   if (HasConditionalSelfInitialized)
@@ -2698,7 +2701,7 @@ AvailabilitySet LifetimeChecker::getLivenessAtInst(SILInstruction *Inst,
   LLVM_DEBUG(llvm::dbgs() << "Get liveness " << FirstElt << ", #" << NumElts
                           << " at " << *Inst);
 
-  AvailabilitySet Result(TheMemory.NumElements);
+  AvailabilitySet Result(TheMemory.getNumElements());
 
   // Empty tuple queries return a completely "unknown" vector, since they don't
   // care about any of the elements.
@@ -2709,13 +2712,13 @@ AvailabilitySet LifetimeChecker::getLivenessAtInst(SILInstruction *Inst,
 
   // The vastly most common case is memory allocations that are not tuples,
   // so special case this with a more efficient algorithm.
-  if (TheMemory.NumElements == 1) {
+  if (TheMemory.getNumElements() == 1) {
     return getLivenessAtNonTupleInst(Inst, InstBB, Result);
   }
 
   // Check locally to see if any elements are satisfied within the block, and
   // keep track of which ones are still needed in the NeededElements set.
-  SmallBitVector NeededElements(TheMemory.NumElements);
+  SmallBitVector NeededElements(TheMemory.getNumElements());
   NeededElements.set(FirstElt, FirstElt+NumElts);
 
   // If there is a store in the current block, scan the block to see if the
@@ -2842,9 +2845,9 @@ bool LifetimeChecker::isInitializedAtUse(const DIMemoryUse &Use,
 
   // If the client wants to know about super.init, check to see if we failed
   // it or some other element.
-  if (Use.FirstElement+Use.NumElements == TheMemory.NumElements &&
+  if (Use.FirstElement + Use.NumElements == TheMemory.getNumElements() &&
       TheMemory.isAnyDerivedClassSelf() &&
-      Liveness.get(Liveness.size()-1) != DIKind::Yes) {
+      Liveness.get(Liveness.size() - 1) != DIKind::Yes) {
     if (SuperInitDone) *SuperInitDone = false;
   }
 
@@ -2864,8 +2867,8 @@ bool LifetimeChecker::isInitializedAtUse(const DIMemoryUse &Use,
   // we caught it, self is no longer available.
   if (TheMemory.isNonRootClassSelf()) {
     if (getSelfInitializedAtInst(Use.Inst) != DIKind::Yes) {
-      auto SelfLiveness = getLivenessAtInst(Use.Inst,
-                                            0, TheMemory.NumElements);
+      auto SelfLiveness =
+          getLivenessAtInst(Use.Inst, 0, TheMemory.getNumElements());
       if (SelfLiveness.isAllYes()) {
         if (FailedSelfUse) *FailedSelfUse = true;
         return false;