[Transforms] Write basic -place-safepoints test, fix bug

[artagnon]

Summary

Start out by documenting the minmum example of -place-safepoints
working. While doing this, improve a couple of assert errors from
PlaceSafepoints and fix a bug: deopt arguments was not accounted for,
causing a verify-failure.

[artagnon]

More work in the same direction.

Rewrite gc.statepoint, gc.result calls to use the IRBuilder API, and
write one additional test. TODO: work on CreateGCStatepoint to handle
both Call and Invoke; the invoke codepath calls gc.statepoint by hand
currently.

Should be simple enough to LGTM quickly and move forward.

[artagnon]

A quick run through clang-format.

[reames]

I approve of the general direction here but request distinct patches:

1. The bug fix
2. The style changes and asserts
3. Use of IRBuilder

As currently structured, it's hard to review because so much is mixed together.

[reames]

FYI, when preparing my own patch to add some of our out of tree tests I ran across this and one other bug. I'm going to submit a fix shortly.

Annoyingly, these bugs only existed in the upstream version. I made a mistake while separating out the patch for submission from our tree.

[artagnon]

As requested by reames, shrink the original submission to be just the
bugfix. Other changes will come as later patches.

[artagnon]

Do try to rebase onto my changes; I did spend quite a bit of time painfully splitting the patches.

[reames]

I believe this bug has been fixed in ToT. If you want to submit the test case anyways, LGTM.

Sorry for the overlapping changes here.

[artagnon]

I submitted the relevant test with 69a5c891.

lib/Transforms/Scalar/PlaceSafepoints.cpp

static Value *ReplaceWithStatepoint(const CallSite &CS, /* to replace */
   // Then go ahead and use the builder do actually do the inserts.  We insert
   // immediately before the previous instruction under the assumption that all
   // arguments will be available here.  We can't insert afterwards since we may
   // be replacing a terminator.
   Instruction *insertBefore = CS.getInstruction();
   IRBuilder<> Builder(insertBefore);
   // First, create the statepoint (with all live ptrs as arguments).
   std::vector<llvm::Value *> args;
-  // target, #args, unused, args
+  // target, #args, unused, ... args, #deopt args, ... deopt args, ... gc
+  // paramters
   Value *Target = CS.getCalledValue();
   args.push_back(Target);
   int callArgSize = CS.arg_size();
   args.push_back(
       ConstantInt::get(Type::getInt32Ty(M->getContext()), callArgSize));
-  // TODO: add a 'Needs GC-rewrite' later flag
+  // unused
   args.push_back(ConstantInt::get(Type::getInt32Ty(M->getContext()), 0));
 
   // Copy all the arguments of the original call
   args.insert(args.end(), CS.arg_begin(), CS.arg_end());
 
+  // deopt
+  args.push_back(ConstantInt::get(Type::getInt32Ty(M->getContext()), 0));
+
   // Create the statepoint given all the arguments
   Instruction *token = nullptr;
   AttributeSet return_attributes;
   if (CS.isCall()) {
     CallInst *toReplace = cast<CallInst>(CS.getInstruction());
     CallInst *call =
         Builder.CreateCall(gc_statepoint_decl, args, "safepoint_token");
     call->setTailCall(toReplace->isTailCall());

test/Transforms/Safepoint/place.ll

+; RUN: opt %s -place-safepoints -S | FileCheck %s
+
+declare zeroext i1 @void_return_i1()
+declare zeroext i1 @i1_return_i1(i1)
+
+define void @gc.safepoint_poll() {
+  ret void
+}
+
+define i1 @test_basic() gc "statepoint-example" {
+; CHECK-LABEL: test_basic
+; This is checking that a statepoint_poll + statepoint + result is
+; inserted for a function that doesn't take arguments.
+; CHECK: gc.statepoint.p0f_isVoidf
+; CHECK: gc.statepoint.p0f_i1f
+; CHECK: gc.result.int.i1
+entry:
+  %call1 = tail call i1 ()* @void_return_i1()
+  ret i1 %call1
+}
+
+define i1 @test_argument() gc "statepoint-example" {
+; CHECK-LABEL: test_argument
+; This is checking that a statepoint_poll + statepoint + result is
+; inserted for a function that takes 1 argument.
+; CHECK: gc.statepoint.p0f_isVoidf
+; CHECK: gc.statepoint.p0f_i1i1f
+; CHECK: (i1 (i1)* @i1_return_i1, i32 1, i32 0, i1 false, i32 0)
+; CHECK: gc.result.int.i1
+entry:
+  %call1 = tail call i1 (i1)* @i1_return_i1(i1 false)
+  ret i1 %call1
+}
 No newline at end of file