[RS4GC] Handle call/invoke instructions as base defining values of vectors

[dneilson]

Summary

There's an asymmetry in the definitions of findBaseDefiningValueOfVector() and
findBaseDefiningValue() of RS4GC. The later handles call and invoke instructions,
and the former does not. This appears to be simple oversight. This patch remedies
the oversight by adding the call and invoke cases to findBaseDefiningValueOfVector().

[DaniilSuchkov]

I wonder is it possible to handle this two instructions, GEPs, bitcasts, loads, and other in findBaseDefiningValue to avoid code duplication and such oversights?

[anna]

In D42653#991536, @DaniilSuchkov wrote:

I wonder is it possible to handle this two instructions, GEPs, bitcasts, loads, and other in findBaseDefiningValue to avoid code duplication and such oversights?

We could, but I guess the idea is to explicitly think about vector and scalar code separately.

[anna]

lgtm w/ comment addressed.

test/Transforms/RewriteStatepointsForGC/base-vector.ll

267

please add a testcase for invoke as well. We should exercise that code path (there's a testcase in invokes.ll for the scalar version).

[dneilson]

Adding vector invoke test

lib/Transforms/Scalar/RewriteStatepointsForGC.cpp

findBaseDefiningValueOfVector(Value *I) {
   if (auto *GEP = dyn_cast<GetElementPtrInst>(I))
     return findBaseDefiningValue(GEP->getPointerOperand());
 
   // If the pointer comes through a bitcast of a vector of pointers to
   // a vector of another type of pointer, then look through the bitcast
   if (auto *BC = dyn_cast<BitCastInst>(I))
     return findBaseDefiningValue(BC->getOperand(0));
 
+  // We assume that functions in the source language only return base
+  // pointers.  This should probably be generalized via attributes to support
+  // both source language and internal functions.
+  if (isa<CallInst>(I) || isa<InvokeInst>(I))
+    return BaseDefiningValueResult(I, true);
+
   // A PHI or Select is a base defining value.  The outer findBasePointer
   // algorithm is responsible for constructing a base value for this BDV.
   assert((isa<SelectInst>(I) || isa<PHINode>(I)) &&
          "unknown vector instruction - no base found for vector element");
   return BaseDefiningValueResult(I, false);
 }
 
 /// Helper function for findBasePointer - Will return a value which either a)

test/Transforms/RewriteStatepointsForGC/base-vector.ll

 ; CHECK: %vec2.remat = getelementptr i64, <4 x i64 addrspace(1)*> %vec1.relocated.casted, i32 1024
 ; CHECK: call void @use_vec(<4 x i64 addrspace(1)*> %vec2.remat)
 entry:
   %vec2 = getelementptr i64, <4 x i64 addrspace(1)*> %vec1, i32 1024
   call void @do_safepoint() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
   call void @use_vec(<4 x i64 addrspace(1) *> %vec2)
   ret void
 }
+
+declare <4 x i64 addrspace(1)*> @def_vec() "gc-leaf-function"
+
+define void @test12(<4 x i64 addrspace(1)*> %vec1) gc "statepoint-example" {
+; CHECK-LABEL: @test12(
+; CHECK: @llvm.experimental.gc.statepoint.p0f_isVoidf{{.*}}<4 x i64 addrspace(1)*> %vec)
+; CHECK-NEXT: %vec.relocated = call coldcc <4 x i8 addrspace(1)*> @llvm.experimental.gc.relocate.v4p1i8(
+; CHECK-NEXT: %vec.relocated.casted = bitcast <4 x i8 addrspace(1)*> %vec.relocated to <4 x i64 addrspace(1)*>
+; CHECK-NEXT: call void @use_vec(<4 x i64 addrspace(1)*> %vec.relocated.casted)
+; CHECK-NEXT: ret void
+entry:
+  %vec = call <4 x i64 addrspace(1)*> @def_vec()
+  call void @do_safepoint() [ "deopt"() ]
+  call void @use_vec(<4 x i64 addrspace(1)*> %vec)
+  ret void
+}

test/Transforms/RewriteStatepointsForGC/invokes.ll

 ; CHECK: ret i64
 
 exceptional_return:
   %landing_pad4 = landingpad token
           cleanup
   ret i64 addrspace(1)* %obj1
 }
 
+declare <4 x i64 addrspace(1)*> @some_vector_call(<4 x i64 addrspace(1)*>)
+
+define <4 x i64 addrspace(1)*> @test_basic_vector(<4 x i64 addrspace(1)*> %objs, <4 x i64 addrspace(1)*> %objs1) gc "statepoint-example" personality i32 ()* @personality_function {
+; CHECK-LABEL: @test_basic_vector
+entry:
+; CHECK: invoke{{.*}}llvm.experimental.gc.statepoint{{.*}}some_vector_call
+  %ret_val = invoke <4 x i64 addrspace(1)*> @some_vector_call(<4 x i64 addrspace(1)*> %objs)
+               to label %normal_return unwind label %exceptional_return
+
+; CHECK-LABEL: normal_return:
+; CHECK: gc.result
+; CHECK: ret <4 x i64 addrspace(1)*>
+
+normal_return:
+  ret <4 x i64 addrspace(1)*> %ret_val
+
+; CHECK-LABEL: exceptional_return:
+; CHECK: landingpad
+; CHECK: ret <4 x i64 addrspace(1)*>
+
+exceptional_return:
+  %landing_pad4 = landingpad token
+          cleanup
+  ret <4 x i64 addrspace(1)*> %objs1
+}
+
 define i64 addrspace(1)* @test_two_invokes(i64 addrspace(1)* %obj, i64 addrspace(1)* %obj1) gc "statepoint-example" personality i32 ()* @personality_function {
 ; CHECK-LABEL: entry:
 entry:
   ; CHECK: invoke 
   ; CHECK: statepoint
   ; CHECK: some_call
   %ret_val1 = invoke i64 addrspace(1)* @some_call(i64 addrspace(1)* %obj)
                to label %second_invoke unwind label %exceptional_return