[CaptureTracking] Handle capturing of launder.invariant.group

[Prazek]

Summary

launder.invariant.group has the same rules of capturing as
bitcast, gep, etc - the original value is not captured
if the returned pointer is not captured.

With this patch, we mark 40% more functions as noalias when compiling with -fstrict-vtable-pointers;
1078 vs 1778 (39.37%)

[Prazek]

ping

[Prazek]

ping

[Prazek]

ping3

[Prazek]

Is there anyone who could take a look at this small patch? I haven't got any response for almost 3 weeks.

[Prazek]

friendly ping42

[JDevlieghere]

Not a reviewer, but looks good to me!

[Prazek]

friendly ping

[Prazek]

rebase after renaming

[amharc]

Otherwise looks good to me.

llvm/test/Transforms/FunctionAttrs/nocapture.ll

224

s/nocaptureBarriers/nocaptureLaunder/

[xbolva00]

This comment was removed by xbolva00.

[xbolva00]

llvm/test/Transforms/FunctionAttrs/nocapture.ll

224

Please fix it and rerun with update_test_checks

[xbolva00]

llvm/test/Transforms/FunctionAttrs/nocapture.ll

224

Dont forget to run "ninja check-llvm"

[Prazek]

Fix test

[Prazek]

llvm/test/Transforms/FunctionAttrs/nocapture.ll

224

Yea I know, I was just rebasing in rush.

[xbolva00]

In D32673#1087535, @Prazek wrote:

Fix test

Maybe you could even regenerate test file?

./update_test_checks.py ~/LLVM/llvm/test/Transforms/FunctionAttrs/nocapture.ll

Strange, If I did it, i got "WARNING: Found conflicting asm under the same prefix: 'CHECK'!" (@spatel, maybe you can look on it why this warning happens?)

[xbolva00]

llvm/lib/Analysis/CaptureTracking.cpp

219

is lambda better here? I would prefer seperate function personally.

[Prazek]

llvm/lib/Analysis/CaptureTracking.cpp

219

I prefer lambda because it narrows function visibility to only this function, and capture of worklist and Visited set looks better than passing as a reference.

[Prazek]

In D32673#1087542, @xbolva00 wrote:

In D32673#1087535, @Prazek wrote:

Fix test

Maybe you could even regenerate test file?

./update_test_checks.py ~/LLVM/llvm/test/Transforms/FunctionAttrs/nocapture.ll

Strange, If I did it, i got "WARNING: Found conflicting asm under the same prefix: 'CHECK'!" (@spatel, maybe you can look on it why this warning happens?)

After regenerating checks I found out that the autogenerated tests does not actually test what they should. This is because labels does not check function arguments.
This is totally oposite to what this test is doing - it does not modify the actual function IR, but it adds nocapture attributes, so checking function signature is totally sufficient.

llvm/lib/Analysis/CaptureTracking.cpp

 /// a cache. Then we can move the code from BasicAliasAnalysis into
 /// that path, and remove this threshold.
 static int const Threshold = 20;
 
 void llvm::PointerMayBeCaptured(const Value *V, CaptureTracker *Tracker) {
   assert(V->getType()->isPointerTy() && "Capture is for pointers only!");
   SmallVector<const Use *, Threshold> Worklist;
   SmallSet<const Use *, Threshold> Visited;
-  int Count = 0;
 
+  auto AddUses = [&](const Value *V) {
+    int Count = 0;
     for (const Use &U : V->uses()) {
       // If there are lots of uses, conservatively say that the value
       // is captured to avoid taking too much compile time.
       if (Count++ >= Threshold)
         return Tracker->tooManyUses();
-
-    if (!Tracker->shouldExplore(&U)) continue;
-    Visited.insert(&U);
+      if (!Visited.insert(&U).second)
+        continue;
+      if (!Tracker->shouldExplore(&U))
+        continue;
       Worklist.push_back(&U);
     }
+  };
+  AddUses(V);
 
   while (!Worklist.empty()) {
     const Use *U = Worklist.pop_back_val();
     Instruction *I = cast<Instruction>(U->getUser());
     V = U->get();
 
     switch (I->getOpcode()) {
     case Instruction::Call:
     case Instruction::Invoke: {
       CallSite CS(I);
       // Not captured if the callee is readonly, doesn't return a copy through
       // its return value and doesn't unwind (a readonly function can leak bits
       // by throwing an exception or not depending on the input value).
       if (CS.onlyReadsMemory() && CS.doesNotThrow() && I->getType()->isVoidTy())
         break;
 
+      // launder.invariant.group only captures pointer by returning it,
+      // so the pointer wasn't captured if returned pointer is not captured.
+      if (CS.getIntrinsicID() == Intrinsic::launder_invariant_group) {
+        AddUses(I);
+        break;
+      }
+
       // Volatile operations effectively capture the memory location that they
       // load and store to.
       if (auto *MI = dyn_cast<MemIntrinsic>(I))
         if (MI->isVolatile())
           if (Tracker->captured(U))
             return;
 
       // Not captured if only passed via 'nocapture' arguments.  Note that
case Instruction::AtomicCmpXchg: {
       break;
     }
     case Instruction::BitCast:
     case Instruction::GetElementPtr:
     case Instruction::PHI:
     case Instruction::Select:
     case Instruction::AddrSpaceCast:
       // The original value is not captured via this if the new value isn't.
-      Count = 0;
-      for (Use &UU : I->uses()) {
-        // If there are lots of uses, conservatively say that the value
-        // is captured to avoid taking too much compile time.
-        if (Count++ >= Threshold)
-          return Tracker->tooManyUses();
-
-        if (Visited.insert(&UU).second)
-          if (Tracker->shouldExplore(&UU))
-            Worklist.push_back(&UU);
-      }
+      AddUses(I);
       break;
     case Instruction::ICmp: {
       // Don't count comparisons of a no-alias return value against null as
       // captures. This allows us to ignore comparisons of malloc results
       // with null, for example.
       if (ConstantPointerNull *CPN =
           dyn_cast<ConstantPointerNull>(I->getOperand(1)))
         if (CPN->getType()->getAddressSpace() == 0)

llvm/test/Transforms/FunctionAttrs/nocapture.ll

 
 ; CHECK: define void @test_volatile(i32* %x)
 define void @test_volatile(i32* %x) {
 entry:
   %gep = getelementptr i32, i32* %x, i64 1
   store volatile i32 0, i32* %gep, align 4
   ret void
 }
+
+; CHECK: nocaptureLaunder(i8* nocapture %p)
+define void @nocaptureLaunder(i8* %p) {
+entry:
+  %b = call i8* @llvm.launder.invariant.group.p0i8(i8* %p)
+  store i8 42, i8* %b
+  ret void
+}
+
+@g2 = global i8* null
+; CHECK: define void @captureLaunder(i8* %p)
+define void @captureLaunder(i8* %p) {
+  %b = call i8* @llvm.launder.invariant.group.p0i8(i8* %p)
+  store i8* %b, i8** @g2
+  ret void
+}
+
+declare i8* @llvm.launder.invariant.group.p0i8(i8*)