[Statepoint] Use default attributes for some GC intrinsics

[nikic]

Summary

This adds the default intrinsic attributes (nosync, nofree, nocallback, willreturn) to the gc.result, gc.relocate, gc.pointer.base and gc.pointer.offset intrinsics. As far as I understand, all of these are supposed to be pure. Some quotes from LangRef:

A gc.result is modeled as a ‘readnone’ pure function. It has no side effects since it is just a projection of the return value of the previous call represented by the gc.statepoint.

A gc.relocate is modeled as a readnone pure function. It has no side effects since it is just a way to extract information about work done during the actual call modeled by the gc.statepoint.

Having willreturn in particular will be important to avoid optimization regressions in the future.

[mkazantsev]

I'm not sure about nosync. I'd rather expect that gc.relocate does communicate with other threads. @apilipenko @anna WDYT?

[mkazantsev]

willreturn definitely looks fine, nocallback not sure what is it (not in https://llvm.org/docs/LangRef.html?), nofree must be fine... But nosync is less than obvious for me, I'd rather expect it not to be present at least in gc.relocate.

[anna]

Most attributes added here look right to me for the proposed intrinsics (and cannot be added for gc.statepoint). What is nocallback ?

The nosync is a bit tricky.
nosync from langref:

This function attribute indicates that the function does not communicate (synchronize) with another thread through memory or other well-defined means.

gc.relocates are a way to make sure that past a gc.statepoint, we do not use the original pointers, we use the relocated pointers. There is no ordering requirement w.r.t. other threads (that is already provided for through the statepoint intrinsic).
So, nosync looks right as well.

[reames]

Just to comment, gc.result, and gc.relocate are explicitly projections from the result tuple. They're basically weirdly spelled extractvalues from an implicit tuple tied together by the token result. So, nosync is definitely correct for them.

[nikic]

For nocallback, see https://github.com/llvm/llvm-project/issues/58683. There are open questions about the semantics, but as far as intrinsics are concerned, it means that it will not call any functions visible to LLVM. This is probably a problem for gc.statepoint, but as @reames mentions, the gc.result/gc.relocate intrinsics are just projections, so it should be fine there.

[nikic]

Rebase to resolve a test conflict

[apilipenko]

Looks good to me.

llvm/include/llvm/IR/Intrinsics.td

 def int_experimental_gc_statepoint : Intrinsic<[llvm_token_ty],
                                [llvm_i64_ty, llvm_i32_ty,
                                 llvm_anyptr_ty, llvm_i32_ty,
                                 llvm_i32_ty, llvm_vararg_ty],
                                [Throws, ImmArg<ArgIndex<0>>,
                                 ImmArg<ArgIndex<1>>, ImmArg<ArgIndex<3>>,
                                 ImmArg<ArgIndex<4>>]>;
 
-def int_experimental_gc_result   : Intrinsic<[llvm_any_ty], [llvm_token_ty],
-                                             [IntrNoMem]>;
-def int_experimental_gc_relocate : Intrinsic<[llvm_any_ty],
-                                             [llvm_token_ty, llvm_i32_ty,
-                                              llvm_i32_ty],
-                                             [IntrNoMem, ImmArg<ArgIndex<1>>,
-                                              ImmArg<ArgIndex<2>>]>;
+def int_experimental_gc_result : DefaultAttrsIntrinsic<
+    [llvm_any_ty], [llvm_token_ty], [IntrNoMem]>;
 
-def int_experimental_gc_get_pointer_base : Intrinsic<[llvm_anyptr_ty],
-                 [llvm_anyptr_ty], [IntrNoMem, IntrWillReturn,
-                 ReadNone<ArgIndex<0>>, NoCapture<ArgIndex<0>>]>;
-
-def int_experimental_gc_get_pointer_offset : Intrinsic<[llvm_i64_ty],
-                 [llvm_anyptr_ty], [IntrNoMem, IntrWillReturn,
-                 ReadNone<ArgIndex<0>>, NoCapture<ArgIndex<0>>]>;
+def int_experimental_gc_relocate : DefaultAttrsIntrinsic<
+    [llvm_any_ty], [llvm_token_ty, llvm_i32_ty, llvm_i32_ty],
+    [IntrNoMem, ImmArg<ArgIndex<1>>, ImmArg<ArgIndex<2>>]>;
+
+def int_experimental_gc_get_pointer_base : DefaultAttrsIntrinsic<
+    [llvm_anyptr_ty], [llvm_anyptr_ty],
+    [IntrNoMem, IntrWillReturn, ReadNone<ArgIndex<0>>, NoCapture<ArgIndex<0>>]>;
+
+def int_experimental_gc_get_pointer_offset : DefaultAttrsIntrinsic<
+    [llvm_i64_ty], [llvm_anyptr_ty],
+    [IntrNoMem, IntrWillReturn, ReadNone<ArgIndex<0>>, NoCapture<ArgIndex<0>>]>;
 
 //===------------------------ Coroutine Intrinsics ---------------===//
 // These are documented in docs/Coroutines.rst
 
 // Coroutine Structure Intrinsics.
 
 def int_coro_id : DefaultAttrsIntrinsic<[llvm_token_ty],
     [llvm_i32_ty, llvm_ptr_ty, llvm_ptr_ty, llvm_ptr_ty],

llvm/test/Transforms/RewriteStatepointsForGC/statepoint-attrs.ll

;
 
   call void @f(i8 addrspace(1)* %arg) #1
   ret void
 }
 
 
 attributes #1 = { norecurse noimplicitfloat }
 ;.
-; CHECK: attributes #[[ATTR0:[0-9]+]] = { nounwind memory(none) }
+; CHECK: attributes #[[ATTR0:[0-9]+]] = { nocallback nofree nosync nounwind willreturn memory(none) }
 ; CHECK: attributes #[[ATTR1]] = { noimplicitfloat norecurse }
 ;.