[Attributor][IPConstantProp] Run the Attributor on IPConstantProp tests

[jdoerfert]

Summary

The Attributor can, to some degree, do what IPConstantProp does. We can
consequently use the corner cases already collected and tested for in
the IPConstantProp tests to improve Attributor test coverage.

This exposed various bugs fixed in previous Attributor patches.

Not all functionality of IPConstantProp is available in AAValueSimplify
and AAIsDead so some tests show that we cannot perform the expected
constant propagation.

[fhahn]

As mentioned in D69747 already, I am not too happy with the tests here to mix testing IPSCCP and IPConstantPropagation; I think it's valuable to just have a single target to run the relevant tests. Would it make sense to group the attributor tests together in a directory?

Also, unfortunately I did not have time to followd the attributor development closely lately, I am just curious: is there a benefit of doing some value simplifications in attributor directly?

[jdoerfert]

In D69748#1731344, @fhahn wrote:

As mentioned in D69747 already, I am not too happy with the tests here to mix testing IPSCCP and IPConstantPropagation; I think it's valuable to just have a single target to run the relevant tests. Would it make sense to group the attributor tests together in a directory?

I do not disagree but it is not as simple. I want to reuse existing test without copying them while the Attributor is still under development and needs to coexists with what we have. (It probably will stay that way for some passes we want to "share tests with", see below.) If we could use softlinks that would be great, otherwise I will probably ignore this minor issue and continue to run: llvm/test/Transforms/{IPConstantProp,FunctionAttrs,InferFunctionAttrs,ArgumentPromotion}

Also, unfortunately I did not have time to followd the attributor development closely lately, I am just curious: is there a benefit of doing some value simplifications in attributor directly?

TL;DR, I think so yes, at least in the short term. How we want to go forward once the Attributor matured fully is an open question.

There are reasons, but, as always, it is not a clear win. So perfect world, we have a single place with "IP-SCCP-like" logic that can make use of all "optimistic in-flight information" during a fixpoint iteration.
For now, we will have some IP-SCCP like logic rewritten in the Attributor framework, see for example D69605 for liveness improvements. The conditional folding logic needs cleanup before I put them here but that should happen in the coming days as well. Now we want this because we want/need liveness information during the deduction and we can use other information that is deduced to improve the value simplification part (think constant propagation) and thereby liveness. One example would be capture information and memory access information based on liveness information which feeds back into the rest.

As an actually unrelated example, this code (https://godbolt.org/z/vP-vvM) works with the Attributor while IP-SCCP for some reason dislikes the dead unknown(&X) call. In the Attributor framework, it doesn't matter because the use of X is simply never shown to the relevant AAValueSimplify class as long as we assume it is dead. (All Attributor::checkForAllXXXX(Predicate, ...) methods simply "hide" dead code. XXXX can be CallSites, ReturnValues, Uses,....)

static int X = 0;
void unknown(int *);

int foo(void) {
  if (X == 1)
    X = 2;  
  if (X == 2)
    unknown(&X);
  return X;
}

[jdoerfert]

What did we decide here? Can this go forward and we move tests after?

[jdoerfert]

ping :)

[efriedma]

I don't think would be a big deal to just copy the tests: if you're using the test to check the behavior of a different pass, it isn't really the same test, even if the IR is identical.

[jdoerfert]

In D69748#1739174, @efriedma wrote:

I don't think would be a big deal to just copy the tests: if you're using the test to check the behavior of a different pass, it isn't really the same test, even if the IR is identical.

I'm fine with that but I'd prefer to invest the time only if I have confidence I get it in then.
@fhahn, @davide Is this OK with you or would you object?

[fhahn]

Also, unfortunately I did not have time to followd the attributor development closely lately, I am just curious: is there a benefit of doing some value simplifications in attributor directly?

TL;DR, I think so yes, at least in the short term. How we want to go forward once the Attributor matured fully is an open question.

There are reasons, but, as always, it is not a clear win. So perfect world, we have a single place with "IP-SCCP-like" logic that can make use of all "optimistic in-flight information" during a fixpoint iteration.
For now, we will have some IP-SCCP like logic rewritten in the Attributor framework, see for example D69605 for liveness improvements. The conditional folding logic needs cleanup before I put them here but that should happen in the coming days as well. Now we want this because we want/need liveness information during the deduction and we can use other information that is deduced to improve the value simplification part (think constant propagation) and thereby liveness. One example would be capture information and memory access information based on liveness information which feeds back into the rest.

Would it be sufficient to have IPSCCP simplify the module before running the Attributor? Ideally it should apply the simplifications based on liveness (module cases it misses) and the attributor would not have to worry about them. I think it would be good try to avoid splitting development effort and keeping Attributor focused should simplify the way towards enabling it.

As an actually unrelated example, this code (https://godbolt.org/z/vP-vvM) works with the Attributor while IP-SCCP for some reason dislikes the dead unknown(&X) call. In the Attributor framework, it doesn't matter because the use of X is simply never shown to the relevant AAValueSimplify class as long as we assume it is dead. (All Attributor::checkForAllXXXX(Predicate, ...) methods simply "hide" dead code. XXXX can be CallSites, ReturnValues, Uses,....)

static int X = 0;
void unknown(int *);

int foo(void) {
  if (X == 1)
    X = 2;  
  if (X == 2)
    unknown(&X);
  return X;
}

This is interesting. I'll check what's going on with IPSCCP here. It might miss some global initializer facts.

With respect to the tests in this patch, I'd slightly prefer copying them to an attributor directory (this might avoid confusion on the future and makes it easier to ensure new tests added to the directory check the right thing), but it's also fine as is.

[jdoerfert]

In D69748#1739315, @fhahn wrote:

Also, unfortunately I did not have time to followd the attributor development closely lately, I am just curious: is there a benefit of doing some value simplifications in attributor directly?

TL;DR, I think so yes, at least in the short term. How we want to go forward once the Attributor matured fully is an open question.

There are reasons, but, as always, it is not a clear win. So perfect world, we have a single place with "IP-SCCP-like" logic that can make use of all "optimistic in-flight information" during a fixpoint iteration.
For now, we will have some IP-SCCP like logic rewritten in the Attributor framework, see for example D69605 for liveness improvements. The conditional folding logic needs cleanup before I put them here but that should happen in the coming days as well. Now we want this because we want/need liveness information during the deduction and we can use other information that is deduced to improve the value simplification part (think constant propagation) and thereby liveness. One example would be capture information and memory access information based on liveness information which feeds back into the rest.

Would it be sufficient to have IPSCCP simplify the module before running the Attributor? Ideally it should apply the simplifications based on liveness (module cases it misses) and the attributor would not have to worry about them. I think it would be good try to avoid splitting development effort and keeping Attributor focused should simplify the way towards enabling it.

My point is that liveness and other attributes are connected in known (and yet unknown) ways.

As an actually unrelated example, this code (https://godbolt.org/z/vP-vvM) works with the Attributor while IP-SCCP for some reason dislikes the dead unknown(&X) call. In the Attributor framework, it doesn't matter because the use of X is simply never shown to the relevant AAValueSimplify class as long as we assume it is dead. (All Attributor::checkForAllXXXX(Predicate, ...) methods simply "hide" dead code. XXXX can be CallSites, ReturnValues, Uses,....)

static int X = 0;
void unknown(int *);

int foo(void) {
  if (X == 1)
    X = 2;  
  if (X == 2)
    unknown(&X);
  return X;
}

This is interesting. I'll check what's going on with IPSCCP here. It might miss some global initializer facts.

With respect to the tests in this patch, I'd slightly prefer copying them to an attributor directory (this might avoid confusion on the future and makes it easier to ensure new tests added to the directory check the right thing), but it's also fine as is.

It seems copying is the favorite solution.
I'll create a new Attributor test directory and copy/move all relevant tests in there.
I will, if I do not hear complaints, do this without waiting for reviews as it will not impact anyone else.
Please let me know if you wish to have a pre-commit review for the test directory.

[jdoerfert]

Copy the tests into the Attributor test directory

[jdoerfert]

Fix the run and check lines

[merge_guards_bot]

Build result: fail - 60619 tests passed, 9 failed and 726 were skipped.

failed: LLVM.Transforms/Attributor/IPConstantProp/2009-09-24-byval-ptr.ll
failed: LLVM.Transforms/Attributor/IPConstantProp/PR26044.ll
failed: LLVM.Transforms/Attributor/IPConstantProp/arg-count-mismatch.ll
failed: LLVM.Transforms/Attributor/IPConstantProp/musttail-call.ll
failed: LLVM.Transforms/Attributor/IPConstantProp/openmp_parallel_for.ll
failed: LLVM.Transforms/Attributor/IPConstantProp/remove-call-inst.ll
failed: LLVM.Transforms/Attributor/IPConstantProp/return-argument.ll
failed: LLVM.Transforms/Attributor/IPConstantProp/solve-after-each-resolving-undefs-for-function.ll
failed: LLVM.Transforms/Attributor/IPConstantProp/user-with-multiple-uses.ll

Log files: console-log.txt, CMakeCache.txt

[merge_guards_bot]

Build result: fail - 60619 tests passed, 9 failed and 726 were skipped.

failed: LLVM.Transforms/Attributor/IPConstantProp/2009-09-24-byval-ptr.ll
failed: LLVM.Transforms/Attributor/IPConstantProp/PR26044.ll
failed: LLVM.Transforms/Attributor/IPConstantProp/arg-count-mismatch.ll
failed: LLVM.Transforms/Attributor/IPConstantProp/musttail-call.ll
failed: LLVM.Transforms/Attributor/IPConstantProp/openmp_parallel_for.ll
failed: LLVM.Transforms/Attributor/IPConstantProp/remove-call-inst.ll
failed: LLVM.Transforms/Attributor/IPConstantProp/return-argument.ll
failed: LLVM.Transforms/Attributor/IPConstantProp/solve-after-each-resolving-undefs-for-function.ll
failed: LLVM.Transforms/Attributor/IPConstantProp/user-with-multiple-uses.ll

Log files: console-log.txt, CMakeCache.txt

[jdoerfert]

Properly rebase the tests

[merge_guards_bot]

Build result: pass - 60628 tests passed, 0 failed and 726 were skipped.

Log files: console-log.txt, CMakeCache.txt

[jdoerfert]

@fhahn @efriedma I copied the tests as discussed, can one of you accept?

[efriedma]

Looks generally fine.

llvm/test/Transforms/Attributor/IPConstantProp/2009-09-24-byval-ptr.ll

24 ↗

(On Diff #232762)

This is technically a legal optimization given the test as written, but I don't think you're proving it correctly. readonly on a function does not imply readonly on its byval arguments. Try the following variation:

define internal i32 @vfu2(%struct.MYstr* byval align 4 %u) nounwind readonly {
entry:
  %z = getelementptr %struct.MYstr, %struct.MYstr* %u, i32 0, i32 1
  store i32 99, i32* %z, align 4
  %0 = getelementptr %struct.MYstr, %struct.MYstr* %u, i32 0, i32 1 ; <i32*> [#uses=1]
  %1 = load i32, i32* %0
  %2 = getelementptr %struct.MYstr, %struct.MYstr* %u, i32 0, i32 0 ; <i8*> [#uses=1]
  %3 = load i8, i8* %2
  %4 = zext i8 %3 to i32
  %5 = add i32 %4, %1
  ret i32 %5
}

llvm/test/Transforms/Attributor/IPConstantProp/musttail-call.ll

48 ↗

(On Diff #232762)

Comment isn't consistent with CHECK?

llvm/test/Transforms/Attributor/IPConstantProp/user-with-multiple-uses.ll

5 ↗

(On Diff #232762)

This is the same test as remove-call-inst.ll?

[jdoerfert]

Some context:
I did not write these tests but copied them and changed the run line. Given that was not the plan initially when we started the review I didn't want to just go ahead.
The plan now is to copy them, this patch, then run update_check on them, then use them to improve coverage once IPCP features trickle into the Attributor.

llvm/test/Transforms/Attributor/IPConstantProp/2009-09-24-byval-ptr.ll

24 ↗

(On Diff #232762)

The Attributor doesn't really do anything on this test yet. Only after pointer privatization goes in. I'll add your test case though.

llvm/test/Transforms/Attributor/IPConstantProp/musttail-call.ll

48 ↗

(On Diff #232762)

I'll get rid of the comment.

llvm/test/Transforms/Attributor/IPConstantProp/user-with-multiple-uses.ll

5 ↗

(On Diff #232762)

It seem that way, I'll remove it.

[efriedma]

llvm/test/Transforms/Attributor/IPConstantProp/2009-09-24-byval-ptr.ll

24 ↗

(On Diff #232762)

I probably should have posted a complete testcase. I meant taking this testcase, and replacing the vfu2 definition with my function. It looks like attributor transforms it. (Unless I messed up somehow.)

[jdoerfert]

llvm/test/Transforms/Attributor/IPConstantProp/2009-09-24-byval-ptr.ll

24 ↗

(On Diff #232762)

Here is the test, original and your version (_2), https://godbolt.org/z/A6L--T

What transformation do you mean and do you think it is wrong?

[efriedma]

llvm/test/Transforms/Attributor/IPConstantProp/2009-09-24-byval-ptr.ll

24 ↗

(On Diff #232762)

The transform of the GEP from %z = getelementptr %struct.MYstr, %struct.MYstr* %u, i32 0, i32 1 to %z = getelementptr %struct.MYstr, %struct.MYstr* @mystr, i32 0, i32 1.

[jdoerfert]

llvm/test/Transforms/Attributor/IPConstantProp/2009-09-24-byval-ptr.ll

24 ↗

(On Diff #232762)

Sorry, I must have been blind.

The readonly on the function should not imply readonly on the byval argument because it is copied. Agreed. I'll fix that.

[jdoerfert]

llvm/test/Transforms/Attributor/IPConstantProp/2009-09-24-byval-ptr.ll

24 ↗

(On Diff #232762)

This should be fixed with rG6abd01e4624a2c9f8f76e11cc5d57cc7551b5d2a. I'll rerun the check scripts before I commit and verify the diff (if that is OK with you)

[efriedma]

LGTM

llvm/test/Transforms/Attributor/IPConstantProp/2009-09-24-byval-ptr.ll

24 ↗

(On Diff #232762)

Okay.

llvm/test/Transforms/IPConstantProp/2008-06-09-WeakProp.ll

 ; RUN: opt < %s -ipconstprop -S | FileCheck %s
+; RUN: opt < %s -passes=attributor -S | FileCheck %s
 ; Should not propagate the result of a weak function.
 ; PR2411
 
 ; CHECK: ret i32 %r
 
 define weak i32 @foo() nounwind  {
 entry:
         ret i32 1
 }
 
 define i32 @main() nounwind  {
 entry:
         %r = call i32 @foo( ) nounwind
         ret i32 %r
 }
 

llvm/test/Transforms/IPConstantProp/2009-09-24-byval-ptr.ll

 ; RUN: opt < %s -ipsccp -S | FileCheck %s
+; RUN: opt -S -passes=attributor -aa-pipeline='basic-aa' -attributor-disable=false -attributor-max-iterations-verify -attributor-max-iterations=3 < %s | FileCheck %s
 ; Don't constant-propagate byval pointers, since they are not pointers!
 ; PR5038
 %struct.MYstr = type { i8, i32 }
 @mystr = internal global %struct.MYstr zeroinitializer ; <%struct.MYstr*> [#uses=3]
 define internal void @vfu1(%struct.MYstr* byval align 4 %u) nounwind {
 entry:
   %0 = getelementptr %struct.MYstr, %struct.MYstr* %u, i32 0, i32 1 ; <i32*> [#uses=1]
   store i32 99, i32* %0, align 4

llvm/test/Transforms/IPConstantProp/PR16052.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --scrub-attributes 
 ; RUN: opt < %s -S -ipsccp | FileCheck %s
+; RUN: opt -S -passes=attributor -aa-pipeline='basic-aa' -attributor-disable=false -attributor-max-iterations-verify -attributor-max-iterations=3 < %s | FileCheck %s --check-prefix=ATTRIBUTOR
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 define i64 @fn2() {
 ; CHECK-LABEL: define {{[^@]+}}@fn2()
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[CALL2:%.*]] = call i64 @fn1(i64 undef)
 ; CHECK-NEXT:    ret i64 [[CALL2]]
 ;
+; ATTRIBUTOR-LABEL: define {{[^@]+}}@fn2()
+; ATTRIBUTOR-NEXT:  entry:
+; ATTRIBUTOR-NEXT:    [[CONV:%.*]] = sext i32 undef to i64
+; ATTRIBUTOR-NEXT:    [[DIV:%.*]] = sdiv i64 8, [[CONV]]
+; ATTRIBUTOR-NEXT:    [[CALL2:%.*]] = call i64 @fn1(i64 [[DIV]])
+; ATTRIBUTOR-NEXT:    ret i64 [[CALL2]]
+;
 entry:
   %conv = sext i32 undef to i64
   %div = sdiv i64 8, %conv
   %call2 = call i64 @fn1(i64 %div)
   ret i64 %call2
 }
 
 define internal i64 @fn1(i64 %p1) {
 ; CHECK-LABEL: define {{[^@]+}}@fn1
 ; CHECK-SAME: (i64 [[P1:%.*]])
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[COND:%.*]] = select i1 undef, i64 undef, i64 undef
 ; CHECK-NEXT:    ret i64 [[COND]]
 ;
+; ATTRIBUTOR-LABEL: define {{[^@]+}}@fn1
+; ATTRIBUTOR-SAME: (i64 returned [[P1:%.*]])
+; ATTRIBUTOR-NEXT:  entry:
+; ATTRIBUTOR-NEXT:    [[TOBOOL:%.*]] = icmp ne i64 [[P1]], 0
+; ATTRIBUTOR-NEXT:    [[COND:%.*]] = select i1 [[TOBOOL]], i64 [[P1]], i64 [[P1]]
+; ATTRIBUTOR-NEXT:    ret i64 [[COND]]
+;
 entry:
   %tobool = icmp ne i64 %p1, 0
   %cond = select i1 %tobool, i64 %p1, i64 %p1
   ret i64 %cond
 }

llvm/test/Transforms/IPConstantProp/PR26044.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --scrub-attributes
-; RUN: opt < %s -S -ipsccp | FileCheck %s --check-prefixes=IPSCCP
+; RUN: opt < %s -S -ipsccp | FileCheck %s --check-prefixes=ALL,IPSCCP
+; RUN: opt -S -passes=attributor -aa-pipeline='basic-aa' -attributor-disable=false -attributor-max-iterations-verify -attributor-max-iterations=1 < %s | FileCheck %s --check-prefixes=ALL,ATTRIBUTOR
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 define void @fn2(i32* %P) {
 ; IPSCCP-LABEL: define {{[^@]+}}@fn2
 ; IPSCCP-SAME: (i32* [[P:%.*]])
 ; IPSCCP-NEXT:  entry:
 ; IPSCCP-NEXT:    br label [[IF_END:%.*]]
 ; IPSCCP:       for.cond1:
 ; IPSCCP-NEXT:    br i1 false, label [[IF_END]], label [[IF_END]]
 ; IPSCCP:       if.end:
 ; IPSCCP-NEXT:    [[CALL:%.*]] = call i32 @fn1(i32 undef)
 ; IPSCCP-NEXT:    store i32 [[CALL]], i32* [[P]]
 ; IPSCCP-NEXT:    br label [[FOR_COND1:%.*]]
 ;
+; ATTRIBUTOR-LABEL: define {{[^@]+}}@fn2
+; ATTRIBUTOR-SAME: (i32* nocapture writeonly [[P:%.*]])
+; ATTRIBUTOR-NEXT:  entry:
+; ATTRIBUTOR-NEXT:    br label [[IF_END:%.*]]
+; ATTRIBUTOR:       for.cond1:
+; ATTRIBUTOR-NEXT:    br i1 undef, label [[IF_END]], label [[IF_END]]
+; ATTRIBUTOR:       if.end:
+; ATTRIBUTOR-NEXT:    [[E_2:%.*]] = phi i32* [ undef, [[ENTRY:%.*]] ], [ null, [[FOR_COND1:%.*]] ], [ null, [[FOR_COND1]] ]
+; ATTRIBUTOR-NEXT:    [[TMP0:%.*]] = load i32, i32* [[E_2]], align 4
+; ATTRIBUTOR-NEXT:    [[CALL:%.*]] = call i32 @fn1(i32 [[TMP0]])
+; ATTRIBUTOR-NEXT:    store i32 [[CALL]], i32* [[P]]
+; ATTRIBUTOR-NEXT:    br label [[FOR_COND1]]
+;
 entry:
   br label %if.end
 
 for.cond1:                                        ; preds = %if.end, %for.end
   br i1 undef, label %if.end, label %if.end
 
 if.end:                                           ; preds = %lbl, %for.cond1
   %e.2 = phi i32* [ undef, %entry ], [ null, %for.cond1 ], [ null, %for.cond1 ]
   %0 = load i32, i32* %e.2, align 4
   %call = call i32 @fn1(i32 %0)
   store i32 %call, i32* %P
   br label %for.cond1
 }
 
 define internal i32 @fn1(i32 %p1) {
 ; IPSCCP-LABEL: define {{[^@]+}}@fn1
 ; IPSCCP-SAME: (i32 [[P1:%.*]])
 ; IPSCCP-NEXT:  entry:
 ; IPSCCP-NEXT:    [[COND:%.*]] = select i1 undef, i32 undef, i32 undef
 ; IPSCCP-NEXT:    ret i32 [[COND]]
 ;
+; ATTRIBUTOR-LABEL: define {{[^@]+}}@fn1
+; ATTRIBUTOR-SAME: (i32 returned [[P1:%.*]])
+; ATTRIBUTOR-NEXT:  entry:
+; ATTRIBUTOR-NEXT:    [[TOBOOL:%.*]] = icmp ne i32 [[P1]], 0
+; ATTRIBUTOR-NEXT:    [[COND:%.*]] = select i1 [[TOBOOL]], i32 [[P1]], i32 [[P1]]
+; ATTRIBUTOR-NEXT:    ret i32 [[COND]]
+;
 entry:
   %tobool = icmp ne i32 %p1, 0
   %cond = select i1 %tobool, i32 %p1, i32 %p1
   ret i32 %cond
 }
 
 define void @fn_no_null_opt(i32* %P) #0 {
 ; IPSCCP-LABEL: define {{[^@]+}}@fn_no_null_opt
 ; IPSCCP-SAME: (i32* [[P:%.*]])
 ; IPSCCP-NEXT:  entry:
 ; IPSCCP-NEXT:    br label [[IF_END:%.*]]
 ; IPSCCP:       for.cond1:
 ; IPSCCP-NEXT:    br i1 false, label [[IF_END]], label [[IF_END]]
 ; IPSCCP:       if.end:
 ; IPSCCP-NEXT:    [[TMP0:%.*]] = load i32, i32* null, align 4
 ; IPSCCP-NEXT:    [[CALL:%.*]] = call i32 @fn0(i32 [[TMP0]])
 ; IPSCCP-NEXT:    store i32 [[CALL]], i32* [[P]]
 ; IPSCCP-NEXT:    br label [[FOR_COND1:%.*]]
 ;
+; ATTRIBUTOR-LABEL: define {{[^@]+}}@fn_no_null_opt
+; ATTRIBUTOR-SAME: (i32* nocapture writeonly [[P:%.*]])
+; ATTRIBUTOR-NEXT:  entry:
+; ATTRIBUTOR-NEXT:    br label [[IF_END:%.*]]
+; ATTRIBUTOR:       for.cond1:
+; ATTRIBUTOR-NEXT:    br i1 undef, label [[IF_END]], label [[IF_END]]
+; ATTRIBUTOR:       if.end:
+; ATTRIBUTOR-NEXT:    [[E_2:%.*]] = phi i32* [ undef, [[ENTRY:%.*]] ], [ null, [[FOR_COND1:%.*]] ], [ null, [[FOR_COND1]] ]
+; ATTRIBUTOR-NEXT:    [[TMP0:%.*]] = load i32, i32* [[E_2]], align 4
+; ATTRIBUTOR-NEXT:    [[CALL:%.*]] = call i32 @fn0(i32 [[TMP0]])
+; ATTRIBUTOR-NEXT:    store i32 [[CALL]], i32* [[P]]
+; ATTRIBUTOR-NEXT:    br label [[FOR_COND1]]
+;
 entry:
   br label %if.end
 
 for.cond1:                                        ; preds = %if.end, %for.end
   br i1 undef, label %if.end, label %if.end
 
 if.end:                                           ; preds = %lbl, %for.cond1
   %e.2 = phi i32* [ undef, %entry ], [ null, %for.cond1 ], [ null, %for.cond1 ]
   %0 = load i32, i32* %e.2, align 4
   %call = call i32 @fn0(i32 %0)
   store i32 %call, i32* %P
   br label %for.cond1
 }
 
 define internal i32 @fn0(i32 %p1) {
 ; IPSCCP-LABEL: define {{[^@]+}}@fn0
 ; IPSCCP-SAME: (i32 [[P1:%.*]])
 ; IPSCCP-NEXT:  entry:
 ; IPSCCP-NEXT:    [[TOBOOL:%.*]] = icmp ne i32 [[P1]], 0
 ; IPSCCP-NEXT:    [[COND:%.*]] = select i1 [[TOBOOL]], i32 [[P1]], i32 [[P1]]
 ; IPSCCP-NEXT:    ret i32 [[COND]]
 ;
+; ATTRIBUTOR-LABEL: define {{[^@]+}}@fn0
+; ATTRIBUTOR-SAME: (i32 returned [[P1:%.*]])
+; ATTRIBUTOR-NEXT:  entry:
+; ATTRIBUTOR-NEXT:    [[TOBOOL:%.*]] = icmp ne i32 [[P1]], 0
+; ATTRIBUTOR-NEXT:    [[COND:%.*]] = select i1 [[TOBOOL]], i32 [[P1]], i32 [[P1]]
+; ATTRIBUTOR-NEXT:    ret i32 [[COND]]
+;
 entry:
   %tobool = icmp ne i32 %p1, 0
   %cond = select i1 %tobool, i32 %p1, i32 %p1
   ret i32 %cond
 }
 
 attributes #0 = { "null-pointer-is-valid"="true" }

llvm/test/Transforms/IPConstantProp/arg-count-mismatch.ll

 ; RUN: opt < %s -ipconstprop -S -o - | FileCheck %s
+; RUN: opt -S -passes=attributor -aa-pipeline='basic-aa' -attributor-disable=false -attributor-max-iterations-verify -attributor-max-iterations=5 < %s | FileCheck %s
 
 ; The original C source looked like this:
 ;
 ;   long long a101, b101, e101;
 ;   volatile long c101;
 ;   int d101;
 ;
 ;   static inline int bar(p1, p2)

llvm/test/Transforms/IPConstantProp/arg-type-mismatch.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt < %s -ipconstprop -S -o - | FileCheck %s
+; RUN: opt -S -passes=attributor -aa-pipeline='basic-aa' -attributor-disable=false -attributor-max-iterations-verify -attributor-max-iterations=1 < %s | FileCheck %s
 
 ; This test is just to verify that we do not crash/assert due to mismatch in
 ; argument type between the caller and callee.
 
 define dso_local void @foo(i16 %a) {
 ; CHECK-LABEL: @foo(
 ; CHECK-NEXT:    [[CALL:%.*]] = call i16 bitcast (i16 (i16, i16)* @bar to i16 (i16, i32)*)(i16 [[A:%.*]], i32 7)
 ; CHECK-NEXT:    ret void

llvm/test/Transforms/IPConstantProp/comdat-ipo.ll

 ; RUN: opt < %s -ipconstprop -S | FileCheck %s
+; RUN: opt -S -passes=attributor -aa-pipeline='basic-aa' -attributor-disable=false -attributor-max-iterations-verify -attributor-max-iterations=1 < %s | FileCheck %s
 
 ; See PR26774
 
 define i32 @baz() {
   ret i32 10
 }
 
 ; We can const-prop @baz's return value *into* @foo, but cannot

llvm/test/Transforms/IPConstantProp/dangling-block-address.ll

 ; RUN: opt < %s -internalize -ipsccp -S | FileCheck %s
+; RUN: opt -S -passes='internalize,attributor' -aa-pipeline='basic-aa' -attributor-disable=false -attributor-max-iterations-verify -attributor-max-iterations=1 < %s | FileCheck %s
 ; PR5569
 
 ; IPSCCP should prove that the blocks are dead and delete them, and
 ; properly handle the dangling blockaddress constants.
 
 ; CHECK: @bar.l = internal constant [2 x i8*] [i8* inttoptr (i32 1 to i8*), i8* inttoptr (i32 1 to i8*)]
 
 @code = global [5 x i32] [i32 0, i32 0, i32 0, i32 0, i32 1], align 4 ; <[5 x i32]*> [#uses=0]

llvm/test/Transforms/IPConstantProp/deadarg.ll

 ; RUN: opt < %s -ipconstprop -disable-output
+; RUN: opt -passes=attributor -aa-pipeline='basic-aa' -attributor-disable=false -attributor-max-iterations-verify -attributor-max-iterations=1 -disable-output < %s
 define internal void @foo(i32 %X) {
         call void @foo( i32 %X )
         ret void
 }
 

llvm/test/Transforms/IPConstantProp/fp-bc-icmp-const-fold.ll

 ; RUN: opt -S -ipsccp < %s | FileCheck %s
+; RUN: opt -S -passes=attributor -aa-pipeline='basic-aa' -attributor-disable=false -attributor-max-iterations-verify -attributor-max-iterations=1 < %s | FileCheck %s
 target datalayout = "E-m:e-i64:64-n32:64"
 target triple = "powerpc64-bgq-linux"
 
 define void @test(i32 signext %n) {
 
 ; CHECK-LABEL: @test
 
 entry:

llvm/test/Transforms/IPConstantProp/global.ll

 ; RUN: opt < %s -S -passes=ipsccp | FileCheck %s
 ; RUN: opt < %s -S -ipsccp | FileCheck %s
+; RUN: opt -S -passes=attributor -aa-pipeline='basic-aa' -attributor-disable=false -attributor-max-iterations-verify -attributor-max-iterations=1 < %s | FileCheck %s --check-prefix=ATTRIBUTOR
 
 @_ZL6test1g = internal global i32 42, align 4
 
 define void @_Z7test1f1v() nounwind {
 entry:
   %tmp = load i32, i32* @_ZL6test1g, align 4
   %cmp = icmp eq i32 %tmp, 0
   br i1 %cmp, label %if.then, label %if.end
 
 if.then:                                          ; preds = %entry
   store i32 0, i32* @_ZL6test1g, align 4
   br label %if.end
 
 if.end:                                           ; preds = %if.then, %entry
   ret void
 }
 
 ; CHECK: @_Z7test1f2v()
 ; CHECK: entry:
 ; CHECK-NEXT: ret i32 42
+
+; ATTRIBUTOR: @_Z7test1f2v()
+; ATTRIBUTOR: entry:
+; ATTRIBUTOR-NEXT: %tmp = load i32, i32* @_ZL6test1g, align 4
+; ATTRIBUTOR-NEXT: ret i32 %tmp
 define i32 @_Z7test1f2v() nounwind {
 entry:
   %tmp = load i32, i32* @_ZL6test1g, align 4
   ret i32 %tmp
 }

llvm/test/Transforms/IPConstantProp/musttail-call.ll

 ; RUN: opt < %s -ipsccp -S | FileCheck %s
+; RUN: opt -S -passes=attributor -aa-pipeline='basic-aa' -attributor-disable=false -attributor-max-iterations-verify -attributor-max-iterations=5 < %s | FileCheck %s --check-prefix=ATTRIBUTOR
 ; PR36485
 ; musttail call result can\'t be replaced with a constant, unless the call
 ; can be removed
 
 declare i32 @external()
 
 define i8* @start(i8 %v) {
   %c1 = icmp eq i8 %v, 0
   br i1 %c1, label %true, label %false
 true:
   ; CHECK: %ca = musttail call i8* @side_effects(i8 0)
   ; CHECK: ret i8* %ca
+  ; FIXME: propagate the value information for %v
+  ; ATTRIBUTOR: %ca = musttail call i8* @side_effects(i8 %v)
+  ; ATTRIBUTOR: ret i8* %ca
   %ca = musttail call i8* @side_effects(i8 %v)
   ret i8* %ca
 false:
   %c2 = icmp eq i8 %v, 1
   br i1 %c2, label %c2_true, label %c2_false
 c2_true:
   %ca1 = musttail call i8* @no_side_effects(i8 %v)
   ; CHECK: ret i8* null
+  ; FIXME: zap this call
+  ; ATTRIBUTOR: ret i8* %ca1
   ret i8* %ca1
 c2_false:
   ; CHECK: %ca2 = musttail call i8* @dont_zap_me(i8 %v)
   ; CHECK: ret i8* %ca2
+  ; ATTRIBUTOR: %ca2 = musttail call i8* @dont_zap_me(i8 undef)
+  ; ATTRIBUTOR: ret i8* %ca2
   %ca2 = musttail call i8* @dont_zap_me(i8 %v)
   ret i8* %ca2
 }
 
 define internal i8* @side_effects(i8 %v) {
   %i1 = call i32 @external()
 
   ; since this goes back to `start` the SCPP should be see that the return value
   ; is always `null`.
   ; The call can't be removed due to `external` call above, though.
 
   ; CHECK: %ca = musttail call i8* @start(i8 0)
+  ; ATTRIBUTOR: %ca = musttail call i8* @start(i8 %v)
   %ca = musttail call i8* @start(i8 %v)
 
   ; Thus the result must be returned anyway
   ; CHECK: ret i8* %ca
+  ; ATTRIBUTOR: ret i8* %ca
   ret i8* %ca
 }
 
 define internal i8* @no_side_effects(i8 %v) readonly nounwind {
   ; The call to this function is removed, so the return value must be zapped
   ; CHECK: ret i8* undef
+  ; ATTRIBUTOR: ret i8* null
   ret i8* null
 }
 
 define internal i8* @dont_zap_me(i8 %v) {
   %i1 = call i32 @external()
 
   ; The call to this function cannot be removed due to side effects. Thus the
   ; return value should stay as it is, and should not be zapped.
   ; CHECK: ret i8* null
+  ; ATTRIBUTOR: ret i8* null
   ret i8* null
 }

llvm/test/Transforms/IPConstantProp/naked-return.ll

 ; RUN: opt -ipsccp -S %s | FileCheck %s
 ; RUN: opt -ipconstprop -S %s | FileCheck %s
+; RUN: opt -S -passes=attributor -aa-pipeline='basic-aa' -attributor-disable=false -attributor-max-iterations-verify -attributor-max-iterations=1 < %s | FileCheck %s
 
 target datalayout = "e-m:x-p:32:32-i64:64-f80:32-n8:16:32-a:0:32-S32"
 target triple = "i686-pc-windows-msvc19.0.24215"
 
 define i32 @dipsy(i32, i32) local_unnamed_addr #0 {
 BasicBlock0:
   call void asm "\0D\0Apushl %ebp\0D\0Amovl 8(%esp),%eax\0D\0Amovl 12(%esp), %ebp\0D\0Acalll *%eax\0D\0Apopl %ebp\0D\0Aretl\0D\0A", ""()
   ret i32 0

llvm/test/Transforms/IPConstantProp/openmp_parallel_for.ll

 ; RUN: opt -S -ipconstprop < %s | FileCheck %s
+; RUN: opt -S -passes=attributor -aa-pipeline='basic-aa' -attributor-disable=false -attributor-max-iterations-verify -attributor-max-iterations=1 < %s | FileCheck %s
 ;
 ;    void bar(int, float, double);
 ;
 ;    void foo(int N) {
 ;      float p = 3;
 ;      double q = 5;
 ;      N = 7;
 ;

llvm/test/Transforms/IPConstantProp/pthreads.ll

 ; RUN: opt -ipconstprop -S < %s | FileCheck %s
+; RUN: opt -S -passes=attributor -aa-pipeline='basic-aa' -attributor-disable=false -attributor-max-iterations-verify -attributor-max-iterations=1 < %s | FileCheck %s
 ;
 ;    #include <pthread.h>
 ;
 ;    void *GlobalVPtr;
 ;
 ;    static void *foo(void *arg) { return arg; }
 ;    static void *bar(void *arg) { return arg; }
 ;

llvm/test/Transforms/IPConstantProp/recursion.ll

 ; RUN: opt < %s -ipconstprop -deadargelim -S | FileCheck %s
+; RUN: opt -S -passes=attributor -aa-pipeline='basic-aa' -attributor-disable=false -attributor-max-iterations-verify -attributor-max-iterations=2 < %s | FileCheck %s
 
 ; CHECK-NOT: %X
 
 define internal i32 @foo(i32 %X) {
         %Y = call i32 @foo( i32 %X )            ; <i32> [#uses=1]
         %Z = add i32 %Y, 1              ; <i32> [#uses=1]
         ret i32 %Z
 }
 
 define void @bar() {
         call i32 @foo( i32 17 )         ; <i32>:1 [#uses=0]
         ret void
 }
 

llvm/test/Transforms/IPConstantProp/remove-call-inst.ll

 ; RUN: opt < %s -S -ipsccp | FileCheck %s
+; RUN: opt -S -passes=attributor -aa-pipeline='basic-aa' -attributor-disable=false -attributor-max-iterations-verify -attributor-max-iterations=3 < %s | FileCheck %s --check-prefix=ATTRIBUTOR
 ; PR5596
 
 ; IPSCCP should propagate the 0 argument, eliminate the switch, and propagate
 ; the result.
 
 ; CHECK: define i32 @main() #0 {
 ; CHECK-NEXT: entry:
 ; CHECK-NOT: call
 ; CHECK-NEXT: ret i32 123
 
+; FIXME: Remove obsolete calls/instructions
+; ATTRIBUTOR: define i32 @main() #0 {
+; ATTRIBUTOR-NEXT: entry:
+; ATTRIBUTOR-NEXT: call
+; ATTRIBUTOR-NEXT: ret i32 123
+
 define i32 @main() noreturn nounwind {
 entry:
   %call2 = tail call i32 @wwrite(i64 0) nounwind
   ret i32 %call2
 }
 
 define internal i32 @wwrite(i64 %i) nounwind readnone {
 entry:

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

 ; RUN: opt < %s -ipconstprop -S | FileCheck %s
+; RUN: opt -S -passes=attributor -aa-pipeline='basic-aa' -attributor-disable=false -attributor-max-iterations-verify -attributor-max-iterations=10 < %s | FileCheck %s --check-prefix=ATTRIBUTOR
 
 ; CHECK: add i32 1, 3
 ; CHECK: store i32 %Z, i32* %Q
+; ATTRIBUTOR:  %Z = add i32 %X1, %X2
+; ATTRIBUTOR:  store i32 %Z, i32* %W
 
 ;; This function returns its second argument on all return statements
 define internal i32* @incdec(i1 %C, i32* %V) {
         %X = load i32, i32* %V
         br i1 %C, label %T, label %F
 
 T:              ; preds = %0
         %X1 = add i32 %X, 1

llvm/test/Transforms/IPConstantProp/return-constant.ll

 ; RUN: opt < %s -ipconstprop -instcombine -S | FileCheck %s
+; RUN: opt -S -passes=attributor -aa-pipeline='basic-aa' -attributor-disable=false -attributor-max-iterations-verify -attributor-max-iterations=1 < %s | FileCheck %s --check-prefix=ATTRIBUTOR
 
 ; CHECK: ret i1 true
 ; CHECK: ret i1 true
 ; CHECK-NOT: ret i1 true
 
+; FIXME: icmp folding is missing
+; ATTRIBUTOR: ret i1 %Y
+; ATTRIBUTOR: ret i1 %Y
+
 define internal i32 @foo(i1 %C) {
         br i1 %C, label %T, label %F
 
 T:              ; preds = %0
         ret i32 52
 
 F:              ; preds = %0
         ret i32 52

llvm/test/Transforms/IPConstantProp/return-constants.ll

 ; RUN: opt < %s -ipconstprop -S | FileCheck %s
+; RUN: opt -S -passes=attributor -aa-pipeline='basic-aa' -attributor-disable=false -attributor-max-iterations-verify -attributor-max-iterations=7 < %s | FileCheck %s --check-prefix=ATTRIBUTOR
 
 ;; Check that the 21 constants got propagated properly
 ; CHECK: %M = add i32 21, 21
 ;; Check that the second return values didn't get propagated
 ; CHECK: %N = add i32 %B, %D
 
+;; FIXME: support for extractvalue and insertvalue missing.
+; ATTRIBUTOR: %M = add i32 %A, %C
+;; Check that the second return values didn't get propagated
+; ATTRIBUTOR: %N = add i32 %B, %D
+
 %0 = type { i32, i32 }
 
 define internal %0 @foo(i1 %Q) {
   br i1 %Q, label %T, label %F
 
 T:                                                ; preds = %0
   %mrv = insertvalue %0 undef, i32 21, 0
   %mrv1 = insertvalue %0 %mrv, i32 22, 1

llvm/test/Transforms/IPConstantProp/solve-after-each-resolving-undefs-for-function.ll

 ; RUN: opt < %s -ipsccp -S | FileCheck %s
+; RUN: opt -S -passes=attributor -aa-pipeline='basic-aa' -attributor-disable=false -attributor-max-iterations-verify -attributor-max-iterations=3 < %s | FileCheck %s --check-prefix=ATTRIBUTOR
 
 ; CHECK-LABEL: @testf(
 ; CHECK:         ret i32 undef
+; ATTRIBUTOR-LABEL: @testf(
+; ATTRIBUTOR-NOT:     ret i32
+; ATTRIBUTOR:         ret i32 10
+; ATTRIBUTOR-NOT:     ret i32
 ;
 define internal i32 @testf(i1 %c) {
 entry:
   br i1 %c, label %if.cond, label %if.end
 
 if.cond:
   br i1 undef, label %if.then, label %if.end
 
 if.then:                                          ; preds = %entry, %if.then
   ret i32 11
 
 if.end:                                          ; preds = %if.then1, %entry
   ret i32 10
 }
 
 ; CHECK-LABEL: @test1(
 ; CHECK:         ret i32 undef
+; FIXME: Fold the conditional
+; ATTRIBUTOR-LABEL: @test1(
+; ATTRIBUTOR:         %res = icmp eq i32 10, 10
+; ATTRIBUTOR:         br i1 %res, label %ret1, label %ret2
+; ATTRIBUTOR:         ret i32 99
+; ATTRIBUTOR:         ret i32 0
 ;
 define internal i32 @test1(i1 %c) {
 entry:
   br label %if.then
 
 if.then:                                          ; preds = %entry, %if.then
   %call = call i32 @testf(i1 %c)
   %res = icmp eq i32 %call, 10
   br i1 %res, label %ret1, label %ret2
 
 ret1:                                           ; preds = %if.then, %entry
   ret i32 99
 
 ret2:                                           ; preds = %if.then, %entry
   ret i32 0
 }
 
 ; CHECK-LABEL: @main(
 ; CHECK-NEXT:    %res = call i32 @test1(
 ; CHECK-NEXT:    ret i32 99
+; ATTRIBUTOR-LABEL: @main(
+; ATTRIBUTOR-NEXT:    %res = call i32 @test1(
+; ATTRIBUTOR-NEXT:    ret i32 %res
 ;
 define i32 @main(i1 %c) {
   %res = call i32 @test1(i1 %c)
   ret i32 %res
 }

llvm/test/Transforms/IPConstantProp/user-with-multiple-uses.ll

 ; RUN: opt < %s -S -ipsccp | FileCheck %s
+; RUN: opt -S -passes=attributor -aa-pipeline='basic-aa' -attributor-disable=false -attributor-max-iterations-verify -attributor-max-iterations=3 < %s | FileCheck %s
 ; PR5596
 
 ; IPSCCP should propagate the 0 argument, eliminate the switch, and propagate
 ; the result.
 
 ; CHECK: define i32 @main() #0 {
 ; CHECK-NEXT: entry:
 ; CHECK-NEXT: %call2 = tail call i32 @wwrite(i64 0) [[NUW:#[0-9]+]]