Expose TailCallKind via the LLVM C API

[etaoins]

Summary

This exposes CallInst's tail call kind via new LLVMGetTailCallKind and LLVMSetTailCallKind functions. The motivation for this is to be able to see musttail for languages that require mandatory tail calls for correctness. Today only the weaker LLVMSetTail is exposed and there is no way to set GuaranteedTailCallOpt via the C API.

[etaoins]

Thanks for the quick review! I don't have commit access so it'd be great if someone could land this for me.

[JDevlieghere]

This test seems to be failing pretty much everywhere. Can you please have a look or should we revert it?

[CodaFi]

Y’all can revert it. I’ll resubmit the patch with updated tests tomorrow.

[JDevlieghere]

In D66061#1630825, @CodaFi wrote:

Y’all can revert it. I’ll resubmit the patch with updated tests tomorrow.

Will do. Thanks!

[Jim]

llvm/trunk/lib/IR/Core.cpp

2848

This switch should have default case. You can add that look like.

default: 
  llvm_unreachable("Unexpected TailCallKind");

llvm/trunk/include/llvm-c/Core.h

enum {
   // ISO C restricts enumerator values to range of 'int'
   // (4294967295 is too large)
   // LLVMAttributeFunctionIndex = ~0U,
   LLVMAttributeFunctionIndex = -1,
 };
 
 typedef unsigned LLVMAttributeIndex;
 
+typedef enum {
+  LLVMTailCallKindNone,
+  LLVMTailCallKindTail,
+  LLVMTailCallKindMustTail,
+  LLVMTailCallKindNoTail
+} LLVMTailCallKind;
+
 /**
  * @}
  */
 
 void LLVMInitializeCore(LLVMPassRegistryRef R);
 
 /** Deallocate and destroy all ManagedStatic variables.
     @see llvm::llvm_shutdown

  *
  * This only works on llvm::CallInst instructions.
  *
  * @see llvm::CallInst::setTailCall()
  */
 void LLVMSetTailCall(LLVMValueRef CallInst, LLVMBool IsTailCall);
 
 /**
+ * Obtains the kind of tail call for a call instruction.
+ *
+ * This only works on llvm::CallInst instructions.
+ *
+ * @see llvm::CallInst::getTailCallKind()
+ */
+LLVMTailCallKind LLVMGetTailCallKind(LLVMValueRef CallInst);
+
+/**
+ * Set the kind of tail call for a call instruction.
+ *
+ * This only works on llvm::CallInst instructions.
+ *
+ * @see llvm::CallInst::setTailCallKind()
+ */
+void LLVMSetTailCallKind(LLVMValueRef CallInst, LLVMTailCallKind TCK);
+
+/**
  * Return the normal destination basic block.
  *
  * This only works on llvm::InvokeInst instructions.
  *
  * @see llvm::InvokeInst::getNormalDest()
  */
 LLVMBasicBlockRef LLVMGetNormalDest(LLVMValueRef InvokeInst);
 

llvm/trunk/lib/IR/Core.cpp

 LLVMBool LLVMIsTailCall(LLVMValueRef Call) {
   return unwrap<CallInst>(Call)->isTailCall();
 }
 
 void LLVMSetTailCall(LLVMValueRef Call, LLVMBool isTailCall) {
   unwrap<CallInst>(Call)->setTailCall(isTailCall);
 }
 
+LLVMTailCallKind LLVMGetTailCallKind(LLVMValueRef Call) {
+  switch (unwrap<CallInst>(Call)->getTailCallKind()) {
+  case CallInst::TailCallKind::TCK_None:
+    return LLVMTailCallKindNone;
+  case CallInst::TailCallKind::TCK_Tail:
+    return LLVMTailCallKindTail;
+  case CallInst::TailCallKind::TCK_MustTail:
+    return LLVMTailCallKindMustTail;
+  case CallInst::TailCallKind::TCK_NoTail:
+    return LLVMTailCallKindNoTail;
+  }
+}
+
+void LLVMSetTailCallKind(LLVMValueRef Call, LLVMTailCallKind TCK) {
+  CallInst::TailCallKind kind;
+  switch (TCK) {
+  case LLVMTailCallKindNone:
+    kind = CallInst::TailCallKind::TCK_None;
+    break;
+  case LLVMTailCallKindTail:
+    kind = CallInst::TailCallKind::TCK_Tail;
+    break;
+  case LLVMTailCallKindMustTail:
+    kind = CallInst::TailCallKind::TCK_MustTail;
+    break;
+  case LLVMTailCallKindNoTail:
+    kind = CallInst::TailCallKind::TCK_NoTail;
+    break;
+  }
+
+  unwrap<CallInst>(Call)->setTailCallKind(kind);
+}
+
 /*--.. Operations on invoke instructions (only) ............................--*/
 
 LLVMBasicBlockRef LLVMGetNormalDest(LLVMValueRef Invoke) {
   return wrap(unwrap<InvokeInst>(Invoke)->getNormalDest());
 }
 
 LLVMBasicBlockRef LLVMGetUnwindDest(LLVMValueRef Invoke) {
   if (CleanupReturnInst *CRI = dyn_cast<CleanupReturnInst>(unwrap(Invoke))) {

llvm/trunk/test/Bindings/llvm-c/invoke.ll

landingPad:                                       ; preds = %then1, %then, %body
   %7 = icmp eq i32 %6, %5
   br i1 %7, label %catch, label %unwind3
 
 catch:                                            ; preds = %unwind5, %unwind3, %landingPad
   %merge = phi i32 [ 23, %landingPad ], [ 19, %unwind3 ], [ 13, %unwind5 ]
   ret i32 %merge
 
 unwind3:                                          ; preds = %landingPad
-  %8 = tail call i32 @llvm.eh.typeid.for(i8* nonnull bitcast (%C6object9ClassInfo* @C6object9Exception__ClassInfo to i8*))
+  %8 = musttail call i32 @llvm.eh.typeid.for(i8* nonnull bitcast (%C6object9ClassInfo* @C6object9Exception__ClassInfo to i8*))
   %9 = icmp eq i32 %8, %5
   br i1 %9, label %catch, label %unwind5
 
 unwind5:                                          ; preds = %unwind3
-  %10 = tail call i32 @llvm.eh.typeid.for(i8* nonnull bitcast (%C6object9ClassInfo* @C6object9Throwable__ClassInfo to i8*))
+  %10 = notail call i32 @llvm.eh.typeid.for(i8* nonnull bitcast (%C6object9ClassInfo* @C6object9Throwable__ClassInfo to i8*))
   %11 = icmp eq i32 %10, %5
   br i1 %11, label %catch, label %unwind7
 
 unwind7:                                          ; preds = %unwind5
   resume { i8*, i32 } %4
 }
 
 declare void @_D6object6Object6__ctorFMC6object6ObjectZv(%C6object6Object*)
 
 declare noalias i8* @_d_allocmemory(i64)
 
 declare i32 @__sd_eh_personality(i32, i32, i64, i8*, i8*)
 
 declare void @__sd_eh_throw(%C6object9Throwable* nonnull) #0
 
 ; Function Attrs: nounwind readnone
 declare i32 @llvm.eh.typeid.for(i8*) #1
 
 attributes #0 = { noreturn }
 attributes #1 = { nounwind readnone }
 No newline at end of file

llvm/trunk/tools/llvm-c-test/echo.cpp

switch(Op) {
       }
       case LLVMCall: {
         SmallVector<LLVMValueRef, 8> Args;
         int ArgCount = LLVMGetNumArgOperands(Src);
         for (int i = 0; i < ArgCount; i++)
           Args.push_back(CloneValue(LLVMGetOperand(Src, i)));
         LLVMValueRef Fn = CloneValue(LLVMGetCalledValue(Src));
         Dst = LLVMBuildCall(Builder, Fn, Args.data(), ArgCount, Name);
-        LLVMSetTailCall(Dst, LLVMIsTailCall(Src));
+        LLVMSetTailCallKind(Dst, LLVMGetTailCallKind(Src));
         CloneAttrs(Src, Dst);
         break;
       }
       case LLVMResume: {
         Dst = LLVMBuildResume(Builder, CloneValue(LLVMGetOperand(Src, 0)));
         break;
       }
       case LLVMLandingPad: {