rebase and fix build errors

Author: vidsinghal

llvm/lib/Transforms/IPO/AttributorAttributes.cpp

@@ -1140,13 +1140,14 @@ struct AAPointerInfoImpl
            (isValidState() ? (std::string("#") +
                               std::to_string(OffsetBins.size()) + " bins")
                            : "<invalid>") +
-           (reachesReturn()
-                ? (" (returned:" +
-                   join(map_range(ReturnedOffsets,
-                                  [](int64_t O) { return std::to_string(O); }),
-                        ", ") +
-                   ")")
-                : "");
+           (reachesReturn() ? (" (returned:" +
+                               join(map_range(ReturnedOffsets,
+                                              [](const AA::RangeTy &R) {
+                                                return std::to_string(R.Offset);
+                                              }),
+                                    ", ") +
+                               ")")
+                            : "");
   }
 
   /// See AbstractAttribute::manifest(...).
@@ -1164,14 +1165,14 @@ struct AAPointerInfoImpl
   }
   virtual void addReturnedOffsetsTo(OffsetInfo &OI) const override {
     if (ReturnedOffsets.isUnknown()) {
-      OI.setUnknown();
+      OI.setUnknown(getAssociatedValue());
       return;
     }
 
     OffsetInfo MergedOI;
-    for (auto Offset : ReturnedOffsets) {
+    for (const AA::RangeTy &OffsetRange : ReturnedOffsets) {
       OffsetInfo TmpOI = OI;
-      TmpOI.addToAll(Offset);
+      TmpOI.addToAll(OffsetRange.Offset);
       MergedOI.merge(TmpOI);
     }
     OI = std::move(MergedOI);
@@ -1181,11 +1182,15 @@ struct AAPointerInfoImpl
     if (ReturnedOffsets.isUnknown())
       return ChangeStatus::UNCHANGED;
     if (ReachedReturnedOffsets.isUnknown()) {
-      ReturnedOffsets.setUnknown();
+      ReturnedOffsets.setUnknown(getAssociatedValue());
       return ChangeStatus::CHANGED;
     }
-    if (ReturnedOffsets.merge(ReachedReturnedOffsets))
+
+    auto OldReturned = ReturnedOffsets;
+    ReturnedOffsets.merge(ReachedReturnedOffsets);
+    if (ReturnedOffsets != OldReturned)
       return ChangeStatus::CHANGED;
+
     return ChangeStatus::UNCHANGED;
   }
 
@@ -1539,8 +1544,9 @@ struct AAPointerInfoImpl
           AccessKind AK = RAcc.getKind();
           if (!IsMustAcc)
             AK = AccessKind((AK & ~AK_MUST) | AK_MAY);
-          Changed |= addAccess(A, NewRanges, CB, RAcc.getContent(), AK,
-                               RAcc.getType(), OffsetInfoMap, RAcc.getRemoteInst());
+          Changed |=
+              addAccess(A, NewRanges, CB, RAcc.getContent(), AK, RAcc.getType(),
+                        OffsetInfoMap, RAcc.getRemoteInst());
         }
       }
     }
@@ -13595,7 +13601,8 @@ struct AAAllocationInfoImpl : public AAAllocationInfo {
 
     // Set the new size of the allocation. The new size of the Allocation should
     // be the size of PrevBinEndOffset * 8 in bits.
-    auto NewAllocationSize = std::make_optional<TypeSize>(PrevBinEndOffset * 8, false);
+    auto NewAllocationSize =
+        std::make_optional<TypeSize>(PrevBinEndOffset * 8, false);
 
     if (!changeAllocationSize(NewAllocationSize))
       return ChangeStatus::UNCHANGED;
@@ -13643,7 +13650,7 @@ struct AAAllocationInfoImpl : public AAAllocationInfo {
            Instruction *LocalInst, const AA::RangeTy &OldRange,
            const AA::RangeTy &NewRange) {
           DenseMap<AA::RangeTy, AA::RangeTy> &NewBinsForInstruction =
-              Map.getOrInsertDefault(LocalInst);
+              Map.try_emplace(LocalInst).first->second;
 
           NewBinsForInstruction.insert(std::make_pair(OldRange, NewRange));
         };
@@ -13975,7 +13982,8 @@ struct AAAllocationInfoImpl : public AAAllocationInfo {
     if (OldOffset == NewComputedOffset)
       return false;
 
-    AA::RangeTy &NewRange = NewComputedOffsets.getOrInsertDefault(OldRange);
+    AA::RangeTy &NewRange =
+        NewComputedOffsets.try_emplace(OldRange).first->second;
     NewRange.Offset = NewComputedOffset;
     NewRange.Size = Size;
 

llvm/test/Transforms/Attributor/ArgumentPromotion/live_called_from_dead_2.ll

@@ -52,9 +52,9 @@ define internal i32 @caller(ptr %B) {
 ;
 ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write)
 ; CGSCC-LABEL: define {{[^@]+}}@caller
-; CGSCC-SAME: (ptr noalias nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) [[B:%.*]]) #[[ATTR0]] {
+; CGSCC-SAME: (ptr noalias nofree noundef nonnull writeonly align 4 captures(none) dereferenceable(4) [[B:%.*]]) #[[ATTR0]] {
 ; CGSCC-NEXT:    [[A1:%.*]] = alloca [0 x i8], align 1
-; CGSCC-NEXT:    [[C:%.*]] = call i32 @test(ptr noalias nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) [[B]]) #[[ATTR2:[0-9]+]]
+; CGSCC-NEXT:    [[C:%.*]] = call i32 @test(ptr noalias nofree noundef nonnull writeonly align 4 captures(none) dereferenceable(4) [[B]]) #[[ATTR2:[0-9]+]]
 ; CGSCC-NEXT:    ret i32 0
 ;
   %A = alloca i32

llvm/test/Transforms/Attributor/IPConstantProp/pthreads.ll

@@ -34,8 +34,8 @@ target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 define dso_local i32 @main() {
 ; TUNIT-LABEL: define {{[^@]+}}@main() {
 ; TUNIT-NEXT:  entry:
-; TUNIT-NEXT:    [[ALLOC11:%.*]] = alloca [0 x i8], align 1
-; TUNIT-NEXT:    [[ALLOC22:%.*]] = alloca [0 x i8], align 1
+; TUNIT-NEXT:    [[ALLOC1:%.*]] = alloca i8, align 8
+; TUNIT-NEXT:    [[ALLOC2:%.*]] = alloca i8, align 8
 ; TUNIT-NEXT:    [[THREAD:%.*]] = alloca i64, align 8
 ; TUNIT-NEXT:    [[CALL:%.*]] = call i32 @pthread_create(ptr noundef nonnull align 8 dereferenceable(8) [[THREAD]], ptr noundef null, ptr noundef nonnull @foo, ptr nofree readnone undef)
 ; TUNIT-NEXT:    [[CALL1:%.*]] = call i32 @pthread_create(ptr noundef nonnull align 8 dereferenceable(8) [[THREAD]], ptr noundef null, ptr noundef nonnull @bar, ptr noalias nofree nonnull readnone align 8 captures(none) dereferenceable(8) undef)

llvm/test/Transforms/Attributor/IPConstantProp/return-argument.ll

@@ -4,13 +4,18 @@
 
 ;; This function returns its second argument on all return statements
 define internal ptr @incdec(i1 %C, ptr %V) {
-; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write)
+; TUNIT: Function Attrs: mustprogress nofree norecurse nounwind willreturn
 ; TUNIT-LABEL: define {{[^@]+}}@incdec
-; TUNIT-SAME: (i1 noundef [[C:%.*]], ptr noalias nofree noundef nonnull returned writeonly align 4 dereferenceable(4) "no-capture-maybe-returned" [[V:%.*]]) #[[ATTR0:[0-9]+]] {
+; TUNIT-SAME: (i1 noundef [[C:%.*]], ptr nofree noundef nonnull returned align 4 dereferenceable(4) [[V:%.*]]) #[[ATTR0:[0-9]+]] {
+; TUNIT-NEXT:    [[X:%.*]] = load i32, ptr [[V]], align 4
 ; TUNIT-NEXT:    br i1 [[C]], label [[T:%.*]], label [[F:%.*]]
 ; TUNIT:       T:
+; TUNIT-NEXT:    [[X1:%.*]] = add i32 [[X]], 1
+; TUNIT-NEXT:    store i32 [[X1]], ptr [[V]], align 4
 ; TUNIT-NEXT:    ret ptr [[V]]
 ; TUNIT:       F:
+; TUNIT-NEXT:    [[X2:%.*]] = sub i32 [[X]], 1
+; TUNIT-NEXT:    store i32 [[X2]], ptr [[V]], align 4
 ; TUNIT-NEXT:    ret ptr [[V]]
 ;
 ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: readwrite)
@@ -44,13 +49,13 @@ F:              ; preds = %0
 ;; This function returns its first argument as a part of a multiple return
 ;; value
 define internal { i32, i32 } @foo(i32 %A, i32 %B) {
-; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
-; CGSCC-LABEL: define {{[^@]+}}@foo
-; CGSCC-SAME: (i32 noundef [[A:%.*]], i32 noundef [[B:%.*]]) #[[ATTR1:[0-9]+]] {
-; CGSCC-NEXT:    [[X:%.*]] = add i32 [[A]], [[B]]
-; CGSCC-NEXT:    [[Y:%.*]] = insertvalue { i32, i32 } undef, i32 [[A]], 0
-; CGSCC-NEXT:    [[Z:%.*]] = insertvalue { i32, i32 } [[Y]], i32 [[X]], 1
-; CGSCC-NEXT:    ret { i32, i32 } [[Z]]
+; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
+; CHECK-LABEL: define {{[^@]+}}@foo
+; CHECK-SAME: (i32 noundef [[A:%.*]], i32 noundef [[B:%.*]]) #[[ATTR1:[0-9]+]] {
+; CHECK-NEXT:    [[X:%.*]] = add i32 [[A]], [[B]]
+; CHECK-NEXT:    [[Y:%.*]] = insertvalue { i32, i32 } undef, i32 [[A]], 0
+; CHECK-NEXT:    [[Z:%.*]] = insertvalue { i32, i32 } [[Y]], i32 [[X]], 1
+; CHECK-NEXT:    ret { i32, i32 } [[Z]]
 ;
   %X = add i32 %A, %B
   %Y = insertvalue { i32, i32 } undef, i32 %A, 0
@@ -59,13 +64,19 @@ define internal { i32, i32 } @foo(i32 %A, i32 %B) {
 }
 
 define void @caller(i1 %C) personality ptr @__gxx_personality_v0 {
-; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
+; TUNIT: Function Attrs: norecurse
 ; TUNIT-LABEL: define {{[^@]+}}@caller
-; TUNIT-SAME: (i1 [[C:%.*]]) #[[ATTR1:[0-9]+]] personality ptr @__gxx_personality_v0 {
+; TUNIT-SAME: (i1 [[C:%.*]]) #[[ATTR2:[0-9]+]] personality ptr @__gxx_personality_v0 {
 ; TUNIT-NEXT:    [[Q:%.*]] = alloca i32, align 4
-; TUNIT-NEXT:    [[W:%.*]] = call align 4 ptr @incdec(i1 noundef [[C]], ptr noalias nofree noundef nonnull writeonly align 4 dereferenceable(4) "no-capture-maybe-returned" [[Q]]) #[[ATTR2:[0-9]+]]
+; TUNIT-NEXT:    [[W:%.*]] = call align 4 ptr @incdec(i1 noundef [[C]], ptr nofree noundef nonnull align 4 dereferenceable(4) [[Q]]) #[[ATTR3:[0-9]+]]
+; TUNIT-NEXT:    [[S1:%.*]] = call { i32, i32 } @foo(i32 noundef 1, i32 noundef 2) #[[ATTR4:[0-9]+]]
+; TUNIT-NEXT:    [[X1:%.*]] = extractvalue { i32, i32 } [[S1]], 0
+; TUNIT-NEXT:    [[S2:%.*]] = call { i32, i32 } @foo(i32 noundef 3, i32 noundef 4) #[[ATTR4]]
 ; TUNIT-NEXT:    br label [[OK:%.*]]
 ; TUNIT:       OK:
+; TUNIT-NEXT:    [[X2:%.*]] = extractvalue { i32, i32 } [[S2]], 0
+; TUNIT-NEXT:    [[Z:%.*]] = add i32 [[X1]], [[X2]]
+; TUNIT-NEXT:    store i32 [[Z]], ptr [[Q]], align 4
 ; TUNIT-NEXT:    br label [[RET:%.*]]
 ; TUNIT:       LPAD:
 ; TUNIT-NEXT:    unreachable
@@ -118,9 +129,11 @@ RET:
 
 declare i32 @__gxx_personality_v0(...)
 ;.
-; TUNIT: attributes #[[ATTR0]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write) }
+; TUNIT: attributes #[[ATTR0]] = { mustprogress nofree norecurse nounwind willreturn }
 ; TUNIT: attributes #[[ATTR1]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
-; TUNIT: attributes #[[ATTR2]] = { nofree nosync nounwind willreturn memory(write) }
+; TUNIT: attributes #[[ATTR2]] = { norecurse }
+; TUNIT: attributes #[[ATTR3]] = { nofree nounwind willreturn }
+; TUNIT: attributes #[[ATTR4]] = { nounwind memory(none) }
 ;.
 ; CGSCC: attributes #[[ATTR0]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) }
 ; CGSCC: attributes #[[ATTR1]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
@@ -129,5 +142,3 @@ declare i32 @__gxx_personality_v0(...)
 ; CGSCC: attributes #[[ATTR4]] = { nofree nosync willreturn }
 ; CGSCC: attributes #[[ATTR5]] = { nofree nosync nounwind willreturn memory(none) }
 ;.
-;; NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line:
-; CHECK: {{.*}}