expose get/set tail call kind in the C api

[folkertdev]

Summary

adds LLVMGetTailCallKind and LLVMSetTailCallKind to the public C API

The C api does not currently allow us to force tail calls to be preserved. Guaranteed tail calls are essential for performance in our case. We have found that LLVM optimizations will move calls out of tail position in certain cases.

An alternative api would be to add LLVMSetMustTail and LLVMGetMustTail (and the same for notail, I guess). That would keep the TailCallKind enum members private, but is inconsistent with the internal API.

background: I am one of the main contributors to the roc programming language. We use LLVM via the inkwell crate, which in turn uses the LLVM C api to construct LLVM modules.

llvm/bindings/ocaml/llvm/llvm_ocaml.c

value llvm_num_arg_operands(value V) {
   return Val_int(LLVMGetNumArgOperands(Value_val(V)));
 }
 
 /* llvalue -> bool */
 value llvm_is_tail_call(value CallInst) {
   return Val_bool(LLVMIsTailCall(Value_val(CallInst)));
 }
 
+/* llvalue -> int */
+value llvm_get_tail_call_kind(value CallInst) {
+  return Val_int(LLVMGetTailCallKind(Value_val(CallInst)));
+}
+
 /* bool -> llvalue -> unit */
 value llvm_set_tail_call(value IsTailCall, value CallInst) {
   LLVMSetTailCall(Value_val(CallInst), Bool_val(IsTailCall));
   return Val_unit;
 }
 
+/* int -> llvalue -> unit */
+value llvm_set_tail_call_kind(value tailCallKind, value CallInst) {
+  LLVMSetTailCallKind(Value_val(CallInst), Int_val(tailCallKind));
+  return Val_unit;
+}
+
 /* llvalue -> llbasicblock */
 value llvm_get_normal_dest(value Val) {
   LLVMBasicBlockRef BB = LLVMGetNormalDest(Value_val(Val));
   return to_val(BB);
 }
 
 /* llvalue -> llbasicblock */
 value llvm_get_unwind_dest(value Val) {

llvm/include/llvm-c/Core.h

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

llvm/lib/IR/Core.cpp

 }
 
 /*--.. Operations on call instructions (only) ..............................--*/
 
 LLVMBool LLVMIsTailCall(LLVMValueRef Call) {
   return unwrap<CallInst>(Call)->isTailCall();
 }
 
+unsigned LLVMGetTailCallKind(LLVMValueRef Call) {
+  return unwrap<CallInst>(Call)->getTailCallKind();
+}
+
 void LLVMSetTailCall(LLVMValueRef Call, LLVMBool isTailCall) {
   unwrap<CallInst>(Call)->setTailCall(isTailCall);
 }
 
+void LLVMSetTailCallKind(LLVMValueRef Call, unsigned tailCallKind) {
+  unwrap<CallInst>(Call)->setTailCallKind((CallInst::TailCallKind)tailCallKind);
+}
+
 /*--.. 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/tools/llvm-c-test/echo.cpp

switch(Op) {
         SmallVector<LLVMValueRef, 8> Args;
         int ArgCount = LLVMGetNumArgOperands(Src);
         for (int i = 0; i < ArgCount; i++)
           Args.push_back(CloneValue(LLVMGetOperand(Src, i)));
         LLVMTypeRef FnTy = CloneType(LLVMGetCalledFunctionType(Src));
         LLVMValueRef Fn = CloneValue(LLVMGetCalledValue(Src));
         Dst = LLVMBuildCall2(Builder, FnTy, 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: {