The result of a function with noundef return attribute must be well defined

[reames]

Summary

This does for readability of returns within said function as what we do for the caller side when reasoning about what might be poison.

Couldn't figure out a small test. I'm working on this from SCEV, but that's blocked by other things as well.

[nikic]

If nothing else you could add a unit test, see programUndefinedIfPoison/isGuaranteedNotToBePoison tests in ValueTrackingTest.

llvm/lib/Analysis/ValueTracking.cpp

5423

This should guard against void returns, in which case getOperand(0) would assert.

[nikic]

llvm/lib/Analysis/ValueTracking.cpp

5423

Hm, I guess this is not strictly necessary thanks to https://github.com/llvm/llvm-project/blob/7d541eb4d49aaaab6a51a3568b9214fd8691e2d3/llvm/lib/IR/Attributes.cpp#L1840. Having noundef implies that the return type cannot be void.

[reames]

Added D111186 as a dependency. Will rebase over updated tests once I can exercise this from SCEV.

[reames]

Add tests - key detail is that removing udiv no-longer has any effect as noimplicit defs serves as a immediate UB root.

[nikic]

LG

llvm/lib/Analysis/ValueTracking.cpp

case Instruction::Invoke: {
         Operands.insert(CB->getCalledOperand());
       for (unsigned i = 0; i < CB->arg_size(); ++i) {
         if (CB->paramHasAttr(i, Attribute::NoUndef) ||
             CB->paramHasAttr(i, Attribute::Dereferenceable))
           Operands.insert(CB->getArgOperand(i));
       }
       break;
     }
-
+    case Instruction::Ret:
+      if (I->getFunction()->hasRetAttribute(Attribute::NoUndef))
+        Operands.insert(I->getOperand(0));
+      break;
     default:
       break;
   }
 }
 
 void llvm::getGuaranteedNonPoisonOps(const Instruction *I,
                                      SmallPtrSetImpl<const Value *> &Operands) {
   getGuaranteedWellDefinedOps(I, Operands);

llvm/test/Analysis/ScalarEvolution/flags-from-poison.ll

cont1:                                            ; preds = %if.else
   br label %cont6
 
 cont6:                                            ; preds = %cont1, %if.then
   %ph = phi %struct.anon* [ %9, %cont1 ], [ %1, %if.then ]
   store i32 %3, i32* @b, align 4
   br label %for.cond
 }
 
-; TODO: once D111180 lands, remove the udiv from these *-basic tests.
-; noundef really should be enough
-
 define noundef i32 @add-basic(i32 %a, i32 %b) {
 ; CHECK-LABEL: 'add-basic'
 ; CHECK-NEXT:  Classifying expressions for: @add-basic
 ; CHECK-NEXT:    %res = add nuw nsw i32 %a, %b
 ; CHECK-NEXT:    --> (%a + %b)<nuw><nsw> U: full-set S: full-set
-; CHECK-NEXT:    %res2 = udiv i32 255, %res
-; CHECK-NEXT:    --> (255 /u (%a + %b)<nuw><nsw>) U: [0,256) S: [0,256)
 ; CHECK-NEXT:  Determining loop execution counts for: @add-basic
 ;
   %res = add nuw nsw i32 %a, %b
-  %res2 = udiv i32 255, %res
-  ret i32 %res2
+  ret i32 %res
 }
 
 define noundef i32 @sub-basic(i32 %a, i32 %b) {
 ; CHECK-LABEL: 'sub-basic'
 ; CHECK-NEXT:  Classifying expressions for: @sub-basic
 ; CHECK-NEXT:    %res = sub nuw nsw i32 %a, %b
 ; CHECK-NEXT:    --> ((-1 * %b) + %a) U: full-set S: full-set
-; CHECK-NEXT:    %res2 = udiv i32 255, %res
-; CHECK-NEXT:    --> (255 /u ((-1 * %b) + %a)) U: [0,256) S: [0,256)
 ; CHECK-NEXT:  Determining loop execution counts for: @sub-basic
 ;
   %res = sub nuw nsw i32 %a, %b
-  %res2 = udiv i32 255, %res
-  ret i32 %res2
+  ret i32 %res
 }
 
 define noundef i32 @mul-basic(i32 %a, i32 %b) {
 ; CHECK-LABEL: 'mul-basic'
 ; CHECK-NEXT:  Classifying expressions for: @mul-basic
 ; CHECK-NEXT:    %res = mul nuw nsw i32 %a, %b
 ; CHECK-NEXT:    --> (%a * %b)<nuw><nsw> U: full-set S: full-set
-; CHECK-NEXT:    %res2 = udiv i32 255, %res
-; CHECK-NEXT:    --> (255 /u (%a * %b)<nuw><nsw>) U: [0,256) S: [0,256)
 ; CHECK-NEXT:  Determining loop execution counts for: @mul-basic
 ;
   %res = mul nuw nsw i32 %a, %b
-  %res2 = udiv i32 255, %res
-  ret i32 %res2
+  ret i32 %res
 }
 
 @gA = external global i32
 @gB = external global i32
 @gC = external global i32
 @gD = external global i32
 
 

 ; CHECK-NEXT:    --> %a U: full-set S: full-set
 ; CHECK-NEXT:    %b = load i32, i32* @gB, align 4
 ; CHECK-NEXT:    --> %b U: full-set S: full-set
 ; CHECK-NEXT:    %c = load i32, i32* @gC, align 4
 ; CHECK-NEXT:    --> %c U: full-set S: full-set
 ; CHECK-NEXT:    %d = load i32, i32* @gD, align 4
 ; CHECK-NEXT:    --> %d U: full-set S: full-set
 ; CHECK-NEXT:    %x = mul nuw i32 %a, %b
-; CHECK-NEXT:    --> (%a * %b) U: full-set S: full-set
+; CHECK-NEXT:    --> (%a * %b)<nuw> U: full-set S: full-set
 ; CHECK-NEXT:    %y = mul nuw i32 %c, %d
-; CHECK-NEXT:    --> (%c * %d) U: full-set S: full-set
+; CHECK-NEXT:    --> (%c * %d)<nuw> U: full-set S: full-set
 ; CHECK-NEXT:    %res = mul nuw i32 %x, %y
 ; CHECK-NEXT:    --> (%a * %b * %c * %d) U: full-set S: full-set
 ; CHECK-NEXT:  Determining loop execution counts for: @mul-recurse
 ;
   call void @foo()
   %a = load i32, i32* @gA
   %b = load i32, i32* @gB
   %c = load i32, i32* @gC