[MemorySSA] Make MemoryLocation unknown when phi translation cannot be performed.

[asbirlea]

Summary

When phi translation cannot be performed, be conservative and make the MemoryLocation unknown.

[george.burgess.iv]

lgtm with one nit. thanks!

llvm/include/llvm/Analysis/MemorySSA.h

1232

AIUI, generally we try to treat MemoryLocations and LocationSizes as immutable. so we can keep with that, do you think Location = Location.getWithNewSize(LocationSize::unknown()); (and reverting the changes to MemoryLocation.h) is an acceptable alternative?

[asbirlea]

Address comment.
Thank you for the review!

llvm/include/llvm/Analysis/MemoryLocation.h

public:
   }
 
   // Returns whether or not this value is precise. Note that if a value is
   // precise, it's guaranteed to not be `unknown()`.
   bool isPrecise() const {
     return (Value & ImpreciseBit) == 0;
   }
 
+  void setToUnknown() { Value = Unknown; }
+
   // Convenience method to check if this LocationSize's value is 0.
   bool isZero() const { return hasValue() && getValue() == 0; }
 
   bool operator==(const LocationSize &Other) const {
     return Value == Other.Value;
   }
 
   bool operator!=(const LocationSize &Other) const {
public:
   /// one object and into another. See
   /// http://llvm.org/docs/LangRef.html#pointeraliasing
   LocationSize Size;
 
   /// The metadata nodes which describes the aliasing of the location (each
   /// member is null if that kind of information is unavailable).
   AAMDNodes AATags;
 
+  void print(raw_ostream &OS) const { OS << *Ptr << " " << Size << "\n"; }
+
+  void setSizeToUnknown() { Size.setToUnknown(); }
+
   /// Return a location with information about the memory reference by the given
   /// instruction.
   static MemoryLocation get(const LoadInst *LI);
   static MemoryLocation get(const StoreInst *SI);
   static MemoryLocation get(const VAArgInst *VI);
   static MemoryLocation get(const AtomicCmpXchgInst *CXI);
   static MemoryLocation get(const AtomicRMWInst *RMWI);
   static MemoryLocation get(const Instruction *Inst) {

llvm/include/llvm/Analysis/MemorySSA.h

if (WalkingPhi && Location.Ptr) {
           OriginalAccess->getBlock()->getModule()->getDataLayout(), nullptr);
       if (!Translator.PHITranslateValue(OriginalAccess->getBlock(),
                                         DefIterator.getPhiArgBlock(), DT,
                                         false)) {
         if (Translator.getAddr() != Location.Ptr) {
           CurrentPair.second = Location.getWithNewPtr(Translator.getAddr());
           return;
         }
+      } else {
+        Location.setSizeToUnknown();
       }
     }
     CurrentPair.second = Location;
   }
 
   MemoryAccessPair CurrentPair;
   memoryaccess_def_iterator DefIterator;
   MemoryLocation Location;

llvm/test/Analysis/MemorySSA/phi-translation.ll

; CHECK-NEXT: store i32 %mul, i32* %arrayidx7, align 4
   br label %for.inc
 
 for.inc:                                          ; preds = %for.body, %if.then
 ; CHECK: 3 = MemoryPhi({for.body,4},{if.then,2})
 ; CHECK-NEXT: %m_i_size.1 = phi i32 [ %m_i_size.022, %if.then ], [ %mul, %for.body ]
   %m_i_size.1 = phi i32 [ %m_i_size.022, %if.then ], [ %mul, %for.body ]
   br i1 %cmp1, label %for.body, label %for.cond.cleanup
 }
+
+
+%ArrayType = type { [2 x i64] }
+%StructOverArrayType = type { %ArrayType }
+%BigStruct = type { i8, i8, i8, i8, i8, i8, i8, %ArrayType, %ArrayType}
+
+; CHECK-LABEL: define void @use_not_optimized_due_to_backedge_unknown
+define void @use_not_optimized_due_to_backedge_unknown(%BigStruct* %this) {
+entry:
+  %eval_left_dims = alloca %StructOverArrayType, align 8
+  %tmp0 = bitcast %StructOverArrayType* %eval_left_dims to i8*
+  %eval_right_dims = alloca %StructOverArrayType, align 8
+  %tmp1 = bitcast %StructOverArrayType* %eval_right_dims to i8*
+  %lhs_strides = alloca %ArrayType, align 8
+  %rhs_strides = alloca %ArrayType, align 8
+  br label %for.body.preheader
+
+for.body.preheader:                               ; preds = %entry
+  %arrayidx.i527 = getelementptr inbounds %BigStruct, %BigStruct* %this, i64 0, i32 7, i32 0, i64 0
+; CHECK: 1 = MemoryDef(liveOnEntry)
+; CHECK-NEXT: store i64 1, i64* %arrayidx.i527, align 8
+  store i64 1, i64* %arrayidx.i527, align 8
+  %arrayidx.i528 = getelementptr inbounds %BigStruct, %BigStruct* %this, i64 0, i32 8, i32 0, i64 0
+; CHECK: 2 = MemoryDef(1)
+; CHECK-NEXT: store i64 1, i64* %arrayidx.i528, align 8
+  store i64 1, i64* %arrayidx.i528, align 8
+  br label %for.main.body
+
+for.main.body:               ; preds = %if.end220.if.then185_crit_edge, %for.body.preheader
+; CHECK: 4 = MemoryPhi({for.body.preheader,2},{if.end220.if.then185_crit_edge,3})
+; CHECK-NEXT: %nocontract_idx.0656 = phi i64 [ 0, %for.body.preheader ], [ 1, %if.end220.if.then185_crit_edge ]
+  %nocontract_idx.0656 = phi i64 [ 0, %for.body.preheader ], [ 1, %if.end220.if.then185_crit_edge ]
+  %add199 = add nuw nsw i64 %nocontract_idx.0656, 1
+  %cmp200 = icmp eq i64 %nocontract_idx.0656, 0
+  %arrayidx.i559 = getelementptr inbounds %BigStruct, %BigStruct* %this, i64 0, i32 7, i32 0, i64 %nocontract_idx.0656
+; CHECK: MemoryUse(4) MayAlias
+; CHECK-NEXT: %tmp21 = load i64, i64* %arrayidx.i559, align 8
+  %tmp21 = load i64, i64* %arrayidx.i559, align 8
+  %mul206 = mul nsw i64 %tmp21, %tmp21
+  br i1 %cmp200, label %if.end220.if.then185_crit_edge, label %the.end
+
+if.end220.if.then185_crit_edge:                   ; preds = %for.main.body
+  %arrayidx.i571 = getelementptr inbounds %BigStruct, %BigStruct* %this, i64 0, i32 7, i32 0, i64 %add199
+; CHECK: 3 = MemoryDef(4)
+; CHECK-NEXT: store i64 %mul206, i64* %arrayidx.i571, align 8
+  store i64 %mul206, i64* %arrayidx.i571, align 8
+  br label %for.main.body
+
+the.end:                            ; preds = %for.main.body
+  ret void
+
+}