[CaptureTracking] Allow non-void `noalias` return funcs to be non-capturing

[goldstein.w.n]

Summary

This only applies for readonly/nounwind functions from which capturing
can only happen via the return value. If the return is noalias, its
guranteed to not be based on any incoming pointer argument so is safe
to be assumed not to be capturing.

[goldstein.w.n]

Rebase

[goldstein.w.n]

ping.

[nikic]

I don't think this is correct. noalias is a provenance concept, while nocapture is also about address identity.

For example, realloc-style functions usually also have noalias return, even though they might return the same pointer as their argument. After such a realloc, it is no longer legal to make accesses through the old pointer, even though it has the same address as the new one.

Lets say you have a special realloc function that guarantees that it returns the original pointer (with fresh provenance) if the allocation size does not change. In that case realloc(p, old_size) == p must return true, so realloc captures the pointer.

There are some confounding factors here, because we do have at least one optimization that tries to assign address unpredictabliity properties to noalias returns, but I believe the general consensus is that that optimization is buggy, and this should be represented using a separate allocator property instead.

Anyway, what's the motivation for this? I can't come up with an example where you would run into a function that is both noalias and readonly in practice.

[goldstein.w.n]

In D156841#4584404, @nikic wrote:

I don't think this is correct. noalias is a provenance concept, while nocapture is also about address identity.

For example, realloc-style functions usually also have noalias return, even though they might return the same pointer as their argument. After such a realloc, it is no longer legal to make accesses through the old pointer, even though it has the same address as the new one.

Lets say you have a special realloc function that guarantees that it returns the original pointer (with fresh provenance) if the allocation size does not change. In that case realloc(p, old_size) == p must return true, so realloc captures the pointer.

Ah thats a good point.

There are some confounding factors here, because we do have at least one optimization that tries to assign address unpredictabliity properties to noalias returns, but I believe the general consensus is that that optimization is buggy, and this should be represented using a separate allocator property instead.

Anyway, what's the motivation for this? I can't come up with an example where you would run into a function that is both noalias and readonly in practice.

Same as my other nocapture patch. I really want a way to be able nocapture to some inline syscalls and realized I can get it with noalias.
But fine dropping this. I'm waiting on the light attributor codes to get into upstream then will hopefully integrate the callsite tracking patch
I have.

llvm/lib/Analysis/CaptureTracking.cpp

UseCaptureKind llvm::DetermineUseCaptureKind(
   switch (I->getOpcode()) {
   case Instruction::Call:
   case Instruction::Invoke: {
     auto *Call = cast<CallBase>(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 (Call->onlyReadsMemory() && Call->doesNotThrow() &&
-        Call->getType()->isVoidTy())
+        (Call->getType()->isVoidTy() || Call->returnDoesNotAlias()))
         return UseCaptureKind::NO_CAPTURE;
 
     // The pointer is not captured if returned pointer is not captured.
     // NOTE: CaptureTracking users should not assume that only functions
     // marked with nocapture do not capture. This means that places like
     // getUnderlyingObject in ValueTracking or DecomposeGEPExpression
     // in BasicAA also need to know about this property.
     if (isIntrinsicReturningPointerAliasingArgumentWithoutCapturing(Call, true))
       return UseCaptureKind::PASSTHROUGH;

llvm/test/Transforms/FunctionAttrs/nocapture.ll

 ; CHECK-NEXT:    ret void
 ;
   call void %f(ptr %p) readnone
   ret void
 }
 
 define ptr @noalias_ret(ptr %f, ptr %p) {
 ; CHECK-LABEL: define ptr @noalias_ret
-; CHECK-SAME: (ptr nocapture readonly [[F:%.*]], ptr readonly [[P:%.*]]) #[[ATTR5]] {
+; CHECK-SAME: (ptr nocapture readonly [[F:%.*]], ptr nocapture readonly [[P:%.*]]) #[[ATTR5]] {
 ; CHECK-NEXT:    [[R:%.*]] = call noalias ptr [[F]](ptr [[P]]) #[[ATTR8]]
 ; CHECK-NEXT:    ret ptr [[R]]
 ;
   %r = call noalias ptr %f(ptr %p) readonly nounwind
   ret ptr %r
 }
 
 define ptr @noalias_ret_fail(ptr %f, ptr %p) {