Handle may/parital alias and clean up code

Author: haopliu

llvm/include/llvm/Analysis/AliasAnalysis.h

@@ -667,6 +667,11 @@ class BatchAAResults {
                  MemoryLocation(V2, LocationSize::precise(1))) ==
            AliasResult::MustAlias;
   }
+  bool isNoAlias(const Value *V1, const Value *V2) {
+    return alias(MemoryLocation(V1, LocationSize::precise(1)),
+                 MemoryLocation(V2, LocationSize::precise(1))) ==
+           AliasResult::NoAlias;
+  }
   ModRefInfo callCapturesBefore(const Instruction *I,
                                 const MemoryLocation &MemLoc,
                                 DominatorTree *DT) {

llvm/lib/Transforms/Scalar/DeadStoreElimination.cpp

@@ -834,9 +834,8 @@ struct MemoryLocationWrapper {
 // A memory def wrapper that represents a MemoryDef and the MemoryLocation(s)
 // defined by this MemoryDef.
 struct MemoryDefWrapper {
-  MemoryDefWrapper(
-      MemoryDef *MemDef,
-      const SmallVectorImpl<std::pair<MemoryLocation, bool>> &MemLocations) {
+  MemoryDefWrapper(MemoryDef *MemDef,
+                   ArrayRef<std::pair<MemoryLocation, bool>> MemLocations) {
     DefInst = MemDef->getMemoryInst();
     for (auto &[MemLoc, DefByInitializesAttr] : MemLocations)
       DefinedLocations.push_back(
@@ -866,17 +865,16 @@ struct ArgumentInitInfo {
 // Return the intersected range list of the initializes attributes of "Args".
 // "Args" are call arguments that alias to each other.
 // If any argument in "Args" doesn't have dead_on_unwind attr and
-// "FuncHasNoUnwindAttr" is false, return empty.
-ConstantRangeList
-getIntersectedInitRangeList(const SmallVectorImpl<ArgumentInitInfo> &Args,
-                            bool FuncHasNoUnwindAttr) {
+// "CallHasNoUnwindAttr" is false, return empty.
+ConstantRangeList getIntersectedInitRangeList(ArrayRef<ArgumentInitInfo> Args,
+                                              bool CallHasNoUnwindAttr) {
   if (Args.empty())
     return {};
 
   // To address unwind, the function should have nounwind attribute or the
   // arguments have dead_on_unwind attribute. Otherwise, return empty.
   for (const auto &Arg : Args) {
-    if (!FuncHasNoUnwindAttr && !Arg.HasDeadOnUnwindAttr)
+    if (!CallHasNoUnwindAttr && !Arg.HasDeadOnUnwindAttr)
       return {};
     if (Arg.Inits.empty())
       return {};
@@ -885,14 +883,14 @@ getIntersectedInitRangeList(const SmallVectorImpl<ArgumentInitInfo> &Args,
   if (Args.size() == 1)
     return Args[0].Inits;
 
-  ConstantRangeList IntersectedIntervals = Args[0].Inits;
-  for (size_t I = 1, Count = Args.size(); I < Count; ++I)
-    IntersectedIntervals = IntersectedIntervals.intersectWith(Args[I].Inits);
+  ConstantRangeList IntersectedIntervals = Args.front().Inits;
+  for (auto &Arg : Args.drop_front())
+    IntersectedIntervals = IntersectedIntervals.intersectWith(Arg.Inits);
 
   return IntersectedIntervals;
 }
 
-// Return the locations wrote by the initializes attribute.
+// Return the locations written by the initializes attribute.
 // Note that this function considers:
 // 1. Unwind edge: apply "initializes" attribute only if the callee has
 //    "nounwind" attribute or the argument has "dead_on_unwind" attribute.
@@ -908,19 +906,20 @@ getInitializesArgMemLoc(const Instruction *I, BatchAAResults &BatchAA) {
   SmallMapVector<Value *, SmallVector<ArgumentInitInfo, 2>, 2> Arguments;
   for (unsigned Idx = 0, Count = CB->arg_size(); Idx < Count; ++Idx) {
     ConstantRangeList Inits;
-    if (CB->paramHasAttr(Idx, Attribute::Initializes))
-      Inits = CB->getParamAttr(Idx, Attribute::Initializes)
-                  .getValueAsConstantRangeList();
+    Attribute InitializesAttr = CB->getParamAttr(Idx, Attribute::Initializes);
+    if (InitializesAttr.isValid())
+      Inits = InitializesAttr.getValueAsConstantRangeList();
 
     bool HasDeadOnUnwindAttr = CB->paramHasAttr(Idx, Attribute::DeadOnUnwind);
     ArgumentInitInfo InitInfo{Idx, HasDeadOnUnwindAttr, Inits};
     Value *CurArg = CB->getArgOperand(Idx);
     bool FoundAliasing = false;
     for (auto &[Arg, AliasList] : Arguments) {
-      if (BatchAA.isMustAlias(Arg, CurArg)) {
-        FoundAliasing = true;
-        AliasList.push_back(InitInfo);
-      }
+      if (BatchAA.isNoAlias(Arg, CurArg))
+        continue;
+      // Conservatively consider must/may/partial-alias as aliasing.
+      FoundAliasing = true;
+      AliasList.push_back(InitInfo);
     }
     if (!FoundAliasing)
       Arguments[CurArg] = {InitInfo};
@@ -929,7 +928,7 @@ getInitializesArgMemLoc(const Instruction *I, BatchAAResults &BatchAA) {
   SmallVector<MemoryLocation, 1> Locations;
   for (const auto &[_, Args] : Arguments) {
     auto IntersectedRanges =
-        getIntersectedInitRangeList(Args, CB->hasFnAttr(Attribute::NoUnwind));
+        getIntersectedInitRangeList(Args, CB->doesNotThrow());
     if (IntersectedRanges.empty())
       continue;
 
@@ -1736,9 +1735,8 @@ struct DSEState {
       bool IsKillingDefFromInitAttr = false;
       if (IsInitializesAttrMemLoc) {
         if (KillingI == UseInst &&
-            KillingUndObj == getUnderlyingObject(MaybeDeadLoc.Ptr)) {
+            KillingUndObj == getUnderlyingObject(MaybeDeadLoc.Ptr))
           IsKillingDefFromInitAttr = true;
-        }
       }
 
       if (isReadClobber(MaybeDeadLoc, UseInst) && !IsKillingDefFromInitAttr) {

llvm/test/Transforms/DeadStoreElimination/inter-procedural.ll

@@ -3,6 +3,7 @@
 
 declare void @p1_write_only(ptr nocapture noundef writeonly initializes((0, 2)) dead_on_unwind)
 declare void @p1_write_then_read(ptr nocapture noundef initializes((0, 2)) dead_on_unwind)
+declare void @p1_clobber(ptr nocapture noundef)
 declare void @p2_same_range(ptr nocapture noundef initializes((0, 2)) dead_on_unwind, ptr nocapture noundef initializes((0, 2)) dead_on_unwind)
 declare void @p2_no_init(ptr nocapture noundef initializes((0, 2)) dead_on_unwind, ptr nocapture noundef dead_on_unwind)
 declare void @p2_no_dead_on_unwind(ptr nocapture noundef initializes((0, 2)) dead_on_unwind, ptr nocapture noundef initializes((0, 2)))
@@ -38,6 +39,24 @@ define i16 @p1_write_then_read_caller() {
   ret i16 %l
 }
 
+; Function Attrs: mustprogress nounwind uwtable
+define i16 @p1_write_then_read_caller_with_clobber() {
+; CHECK-LABEL: @p1_write_then_read_caller_with_clobber(
+; CHECK-NEXT:    %ptr = alloca i16, align 2
+; CHECK-NEXT:    store i16 0, ptr %ptr
+; CHECK-NEXT:    call void @p1_clobber(ptr %ptr)
+; CHECK-NEXT:    call void @p1_write_then_read(ptr %ptr)
+; CHECK-NEXT:    %l = load i16, ptr %ptr
+; CHECK-NEXT:    ret i16 %l
+;
+  %ptr = alloca i16
+  store i16 0, ptr %ptr
+  call void @p1_clobber(ptr %ptr)
+  call void @p1_write_then_read(ptr %ptr)
+  %l = load i16, ptr %ptr
+  ret i16 %l
+}
+
 ; Function Attrs: mustprogress nounwind uwtable
 define i16 @p2_same_range_nonalias_caller() {
 ; CHECK-LABEL: @p2_same_range_nonalias_caller(