Add support for attribute for call and invoke instruction in the C API

[deadalnix]

Summary

As per title.

[Wallbraker]

Can we please have one release with the new and old functions. Removing and adding replacement functions in the same release makes the upgrade path much harder. I can not upgrade the LLVM version I use because it breaks my build (build bots, other users and so on). And I can not change my code without breaking anything that still uses the old version (build bots, other users and so on). This is all made worse that the symbols are still there but their semantics have change, so it will just be hard to debug black magic errors.

So adding LLVMAddInstrAttribute2 and LLVMRemoveInstrAttribute2 and keeping the old functions but mark them as deprecated, removing them the release after that (3.10).

Maybe we should add a way to get the number of attribute a function has and be able to get a list of them?

size_t LLVMInstrGetNumAttribute(LLVMValueRef val);
LLVMBool LLVMInstrGetNumAttribute(LLVMValueRef val, size_t index, unsigned int *KindID);

...


auto num = LLVMInstrGetNumAttribute(val);
uint[] arr;
arr.length = num;
foreach (i, ref e; arr) {
    LLVMInstrGetAttributeAtIndex(val, i, &e);
}

[deadalnix]

This is not relevent anymore.

bindings/go/llvm/ir.go

func llvmMetadataRefs(mds []Metadata) (*C.LLVMMetadataRef, C.unsigned) {
   ptlen := C.unsigned(len(mds))
   if ptlen > 0 {
     pt = llvmMetadataRefPtr(&mds[0])
   }
   return pt, ptlen
 }
 
 //-------------------------------------------------------------------------
-// llvm.Attribute
-//-------------------------------------------------------------------------
-
-const (
-  NoneAttribute               Attribute = 0
-  ZExtAttribute               Attribute = C.LLVMZExtAttribute
-  SExtAttribute               Attribute = C.LLVMSExtAttribute
-  NoReturnAttribute           Attribute = C.LLVMNoReturnAttribute
-  InRegAttribute              Attribute = C.LLVMInRegAttribute
-  StructRetAttribute          Attribute = C.LLVMStructRetAttribute
-  NoUnwindAttribute           Attribute = C.LLVMNoUnwindAttribute
-  NoAliasAttribute            Attribute = C.LLVMNoAliasAttribute
-  ByValAttribute              Attribute = C.LLVMByValAttribute
-  NestAttribute               Attribute = C.LLVMNestAttribute
-  ReadNoneAttribute           Attribute = C.LLVMReadNoneAttribute
-  ReadOnlyAttribute           Attribute = C.LLVMReadOnlyAttribute
-  NoInlineAttribute           Attribute = C.LLVMNoInlineAttribute
-  AlwaysInlineAttribute       Attribute = C.LLVMAlwaysInlineAttribute
-  OptimizeForSizeAttribute    Attribute = C.LLVMOptimizeForSizeAttribute
-  StackProtectAttribute       Attribute = C.LLVMStackProtectAttribute
-  StackProtectReqAttribute    Attribute = C.LLVMStackProtectReqAttribute
-  Alignment                   Attribute = C.LLVMAlignment
-  NoCaptureAttribute          Attribute = C.LLVMNoCaptureAttribute
-  NoRedZoneAttribute          Attribute = C.LLVMNoRedZoneAttribute
-  NoImplicitFloatAttribute    Attribute = C.LLVMNoImplicitFloatAttribute
-  NakedAttribute              Attribute = C.LLVMNakedAttribute
-  InlineHintAttribute         Attribute = C.LLVMInlineHintAttribute
-  StackAlignment              Attribute = C.LLVMStackAlignment
-  ReturnsTwiceAttribute       Attribute = C.LLVMReturnsTwice
-  UWTableAttribute            Attribute = C.LLVMUWTable
-  NonLazyBindAttribute        Attribute = 1 << 31
-  SanitizeAddressAttribute    Attribute = 1 << 32
-  MinSizeAttribute            Attribute = 1 << 33
-  NoDuplicateAttribute        Attribute = 1 << 34
-  StackProtectStrongAttribute Attribute = 1 << 35
-  SanitizeThreadAttribute     Attribute = 1 << 36
-  SanitizeMemoryAttribute     Attribute = 1 << 37
-  NoBuiltinAttribute          Attribute = 1 << 38
-  ReturnedAttribute           Attribute = 1 << 39
-  ColdAttribute               Attribute = 1 << 40
-  BuiltinAttribute            Attribute = 1 << 41
-  OptimizeNoneAttribute       Attribute = 1 << 42
-  InAllocaAttribute           Attribute = 1 << 43
-  NonNullAttribute            Attribute = 1 << 44
-  JumpTableAttribute          Attribute = 1 << 45
-  ConvergentAttribute         Attribute = 1 << 46
-  SafeStackAttribute          Attribute = 1 << 47
-)
-
-//-------------------------------------------------------------------------
 // llvm.Opcode
 //-------------------------------------------------------------------------
 
 const (
   Ret         Opcode = C.LLVMRet
   Br          Opcode = C.LLVMBr
   Switch      Opcode = C.LLVMSwitch
   IndirectBr  Opcode = C.LLVMIndirectBr

 
 // Operations on call sites
 func (v Value) SetInstructionCallConv(cc CallConv) {
   C.LLVMSetInstructionCallConv(v.C, C.unsigned(cc))
 }
 func (v Value) InstructionCallConv() CallConv {
   return CallConv(C.LLVMCallConv(C.LLVMGetInstructionCallConv(v.C)))
 }
-func (v Value) AddInstrAttribute(i int, a Attribute) {
-  if a >= 1<<32 {
-    panic("attribute value currently unsupported")
-  }
-  C.LLVMAddInstrAttribute(v.C, C.unsigned(i), C.LLVMAttribute(a))
-}
-func (v Value) RemoveInstrAttribute(i int, a Attribute) {
-  if a >= 1<<32 {
-    panic("attribute value currently unsupported")
-  }
-  C.LLVMRemoveInstrAttribute(v.C, C.unsigned(i), C.LLVMAttribute(a))
+func (v Value) AddInstrAttribute(i int, KindID uint) {
+  C.LLVMAddInstrAttribute(v.C, C.unsigned(i), C.uint(KindID))
+func (v Value) RemoveInstrAttribute(i int, KindID uint) {
+  C.LLVMRemoveInstrAttribute(v.C, C.unsigned(i), C.uint(KindID))
 }
 func (v Value) SetInstrParamAlignment(i int, align int) {
   C.LLVMSetInstrParamAlignment(v.C, C.unsigned(i), C.unsigned(align))
 }
 
 // Operations on call instructions (only)
 func (v Value) IsTailCall() bool    { return C.LLVMIsTailCall(v.C) != 0 }
 func (v Value) SetTailCall(is bool) { C.LLVMSetTailCall(v.C, boolToLLVMBool(is)) }

include/llvm-c/Core.h

 
 /**
  * @defgroup LLVMCCoreTypes Types and Enumerations
  *
  * @{
  */
 
 typedef enum {
-    LLVMZExtAttribute       = 1<<0,
-    LLVMSExtAttribute       = 1<<1,
-    LLVMNoReturnAttribute   = 1<<2,
-    LLVMInRegAttribute      = 1<<3,
-    LLVMStructRetAttribute  = 1<<4,
-    LLVMNoUnwindAttribute   = 1<<5,
-    LLVMNoAliasAttribute    = 1<<6,
-    LLVMByValAttribute      = 1<<7,
-    LLVMNestAttribute       = 1<<8,
-    LLVMReadNoneAttribute   = 1<<9,
-    LLVMReadOnlyAttribute   = 1<<10,
-    LLVMNoInlineAttribute   = 1<<11,
-    LLVMAlwaysInlineAttribute    = 1<<12,
-    LLVMOptimizeForSizeAttribute = 1<<13,
-    LLVMStackProtectAttribute    = 1<<14,
-    LLVMStackProtectReqAttribute = 1<<15,
-    LLVMAlignment = 31<<16,
-    LLVMNoCaptureAttribute  = 1<<21,
-    LLVMNoRedZoneAttribute  = 1<<22,
-    LLVMNoImplicitFloatAttribute = 1<<23,
-    LLVMNakedAttribute      = 1<<24,
-    LLVMInlineHintAttribute = 1<<25,
-    LLVMStackAlignment = 7<<26,
-    LLVMReturnsTwice = 1 << 29,
-    LLVMUWTable = 1 << 30,
-    LLVMNonLazyBind = 1 << 31
-
-    /* FIXME: These attributes are currently not included in the C API as
-       a temporary measure until the API/ABI impact to the C API is understood
-       and the path forward agreed upon.
-    LLVMSanitizeAddressAttribute = 1ULL << 32,
-    LLVMStackProtectStrongAttribute = 1ULL<<35,
-    LLVMColdAttribute = 1ULL << 40,
-    LLVMOptimizeNoneAttribute = 1ULL << 42,
-    LLVMInAllocaAttribute = 1ULL << 43,
-    LLVMNonNullAttribute = 1ULL << 44,
-    LLVMJumpTableAttribute = 1ULL << 45,
-    LLVMConvergentAttribute = 1ULL << 46,
-    LLVMSafeStackAttribute = 1ULL << 47,
-    LLVMSwiftSelfAttribute = 1ULL << 48,
-    LLVMSwiftErrorAttribute = 1ULL << 49,
-    */
-} LLVMAttribute;
-
-typedef enum {
   /* Terminator Instructions */
   LLVMRet            = 1,
   LLVMBr             = 2,
   LLVMSwitch         = 3,
   LLVMIndirectBr     = 4,
   LLVMInvoke         = 5,
   /* removed 6 due to API changes */
   LLVMUnreachable    = 7,

  * This is the opposite of LLVMSetInstructionCallConv(). Reads its
  * usage.
  *
  * @see LLVMSetInstructionCallConv()
  */
 unsigned LLVMGetInstructionCallConv(LLVMValueRef Instr);
 
 
-void LLVMAddInstrAttribute(LLVMValueRef Instr, unsigned index, LLVMAttribute);
+void LLVMAddInstrAttribute(LLVMValueRef Instr, unsigned index,
+                           unsigned KindID);
 void LLVMRemoveInstrAttribute(LLVMValueRef Instr, unsigned index,
-                              LLVMAttribute);
+                              unsigned KindID);
 void LLVMSetInstrParamAlignment(LLVMValueRef Instr, unsigned index,
                                 unsigned align);
+LLVMBool LLVMHasInstrAttribute(LLVMValueRef Instr, unsigned index,
+                               unsigned KindID);
 
 /**
  * Obtain the pointer to the function invoked by this instruction.
  *
  * This expects an LLVMValueRef that corresponds to a llvm::CallInst or
  * llvm::InvokeInst.
  *
  * @see llvm::CallInst::getCalledValue()

include/llvm/IR/CallSite.h

#define CALLSITE_DELEGATE_SETTER(METHOD) \
   /// the call.
   const AttributeSet &getAttributes() const {
     CALLSITE_DELEGATE_GETTER(getAttributes());
   }
   void setAttributes(const AttributeSet &PAL) {
     CALLSITE_DELEGATE_SETTER(setAttributes(PAL));
   }
 
+  void addAttribute(unsigned i, Attribute::AttrKind attr) {
+    CALLSITE_DELEGATE_SETTER(addAttribute(i, attr));
+  }
+
+  void addAttribute(unsigned i, StringRef Kind, StringRef Value) {
+    CALLSITE_DELEGATE_SETTER(addAttribute(i, Kind, Value));
+  }
+
+  void removeAttribute(unsigned i, Attribute::AttrKind attr) {
+    CALLSITE_DELEGATE_SETTER(removeAttribute(i, attr));
+  }
+
+  void removeAttribute(unsigned i, Attribute attr) {
+    CALLSITE_DELEGATE_SETTER(removeAttribute(i, attr));
+  }
+
   /// \brief Return true if this function has the given attribute.
   bool hasFnAttr(Attribute::AttrKind A) const {
     CALLSITE_DELEGATE_GETTER(hasFnAttr(A));
   }
 
   /// \brief Return true if this function has the given attribute.
   bool hasFnAttr(StringRef A) const {
     CALLSITE_DELEGATE_GETTER(hasFnAttr(A));

include/llvm/IR/Instructions.h

public:
 
   /// addAttribute - adds the attribute to the list of attributes.
   void addAttribute(unsigned i, Attribute::AttrKind attr);
 
   /// addAttribute - adds the attribute to the list of attributes.
   void addAttribute(unsigned i, StringRef Kind, StringRef Value);
 
   /// removeAttribute - removes the attribute from the list of attributes.
+  void removeAttribute(unsigned i, Attribute::AttrKind attr);
+
+  /// removeAttribute - removes the attribute from the list of attributes.
   void removeAttribute(unsigned i, Attribute attr);
 
   /// \brief adds the dereferenceable attribute to the list of attributes.
   void addDereferenceableAttr(unsigned i, uint64_t Bytes);
 
   /// \brief adds the dereferenceable_or_null attribute to the list of
   /// attributes.
   void addDereferenceableOrNullAttr(unsigned i, uint64_t Bytes);
public:
   /// setAttributes - Set the parameter attributes for this invoke.
   ///
   void setAttributes(const AttributeSet &Attrs) { AttributeList = Attrs; }
 
   /// addAttribute - adds the attribute to the list of attributes.
   void addAttribute(unsigned i, Attribute::AttrKind attr);
 
   /// removeAttribute - removes the attribute from the list of attributes.
+  void removeAttribute(unsigned i, Attribute::AttrKind attr);
+
+  /// removeAttribute - removes the attribute from the list of attributes.
   void removeAttribute(unsigned i, Attribute attr);
 
   /// \brief adds the dereferenceable attribute to the list of attributes.
   void addDereferenceableAttr(unsigned i, uint64_t Bytes);
 
   /// \brief adds the dereferenceable_or_null attribute to the list of
   /// attributes.
   void addDereferenceableOrNullAttr(unsigned i, uint64_t Bytes);

lib/IR/Core.cpp

 }
 
 void LLVMSetInstructionCallConv(LLVMValueRef Instr, unsigned CC) {
   return CallSite(unwrap<Instruction>(Instr))
     .setCallingConv(static_cast<CallingConv::ID>(CC));
 }
 
 void LLVMAddInstrAttribute(LLVMValueRef Instr, unsigned index,
-                           LLVMAttribute PA) {
+                           unsigned KindID) {
   CallSite Call = CallSite(unwrap<Instruction>(Instr));
-  AttrBuilder B(PA);
-  Call.setAttributes(
-    Call.getAttributes().addAttributes(Call->getContext(), index,
-                                       AttributeSet::get(Call->getContext(),
-                                                         index, B)));
+  Call.addAttribute(index, (Attribute::AttrKind)KindID);
 }
 
 void LLVMRemoveInstrAttribute(LLVMValueRef Instr, unsigned index,
-                              LLVMAttribute PA) {
+                              unsigned KindID) {
   CallSite Call = CallSite(unwrap<Instruction>(Instr));
-  AttrBuilder B(PA);
-  Call.setAttributes(Call.getAttributes()
-                       .removeAttributes(Call->getContext(), index,
-                                         AttributeSet::get(Call->getContext(),
-                                                           index, B)));
+  Call.removeAttribute(index, (Attribute::AttrKind)KindID);
+}
+
+LLVMBool LLVMHasInstrAttribute(LLVMValueRef Instr, unsigned index,
+                               unsigned KindID) {
+  CallSite Call = CallSite(unwrap<Instruction>(Instr));
+  return Call.paramHasAttr(index, (Attribute::AttrKind)KindID);
 }
 
 void LLVMSetInstrParamAlignment(LLVMValueRef Instr, unsigned index,
                                 unsigned align) {
   CallSite Call = CallSite(unwrap<Instruction>(Instr));
   AttrBuilder B;
   B.addAlignmentAttr(align);
   Call.setAttributes(Call.getAttributes()

lib/IR/Instructions.cpp

 }
 
 void CallInst::addAttribute(unsigned i, StringRef Kind, StringRef Value) {
   AttributeSet PAL = getAttributes();
   PAL = PAL.addAttribute(getContext(), i, Kind, Value);
   setAttributes(PAL);
 }
 
+void CallInst::removeAttribute(unsigned i, Attribute::AttrKind attr) {
+  AttributeSet PAL = getAttributes();
+  PAL = PAL.removeAttribute(getContext(), i, attr);
+  setAttributes(PAL);
+}
+
 void CallInst::removeAttribute(unsigned i, Attribute attr) {
   AttributeSet PAL = getAttributes();
   AttrBuilder B(attr);
   LLVMContext &Context = getContext();
   PAL = PAL.removeAttributes(Context, i,
                              AttributeSet::get(Context, i, B));
   setAttributes(PAL);
 }

 }
 
 void InvokeInst::addAttribute(unsigned i, Attribute::AttrKind attr) {
   AttributeSet PAL = getAttributes();
   PAL = PAL.addAttribute(getContext(), i, attr);
   setAttributes(PAL);
 }
 
+void InvokeInst::removeAttribute(unsigned i, Attribute::AttrKind attr) {
+  AttributeSet PAL = getAttributes();
+  PAL = PAL.removeAttribute(getContext(), i, attr);
+  setAttributes(PAL);
+}
+
 void InvokeInst::removeAttribute(unsigned i, Attribute attr) {
   AttributeSet PAL = getAttributes();
   AttrBuilder B(attr);
   PAL = PAL.removeAttributes(getContext(), i,
                              AttributeSet::get(getContext(), i, B));
   setAttributes(PAL);
 }
 

test/Bindings/llvm-c/invoke.ll

 @C6object6Object__ClassInfo = linkonce_odr constant %C6object9ClassInfo { %C6object9ClassInfo__vtbl* @C6object9ClassInfo__vtblZ, %C6object9ClassInfo* @C6object6Object__ClassInfo }
 @C6object9Throwable__ClassInfo = linkonce_odr constant %C6object9ClassInfo { %C6object9ClassInfo__vtbl* @C6object9ClassInfo__vtblZ, %C6object9ClassInfo* @C6object6Object__ClassInfo }
 @C6object9Exception__ClassInfo = linkonce_odr constant %C6object9ClassInfo { %C6object9ClassInfo__vtbl* @C6object9ClassInfo__vtblZ, %C6object9ClassInfo* @C6object9Throwable__ClassInfo }
 @C6object9Exception__vtblZ = linkonce_odr constant %C6object9Exception__vtbl { %C6object9ClassInfo* @C6object9Exception__ClassInfo }
 @C6object5Error__ClassInfo = linkonce_odr constant %C6object9ClassInfo { %C6object9ClassInfo__vtbl* @C6object9ClassInfo__vtblZ, %C6object9ClassInfo* @C6object9Throwable__ClassInfo }
 
 define i32 @_D8test01494mainFMZi() personality i32 (i32, i32, i64, i8*, i8*)* @__sd_eh_personality {
 body:
-  %0 = invoke i8* @_d_allocmemory(i64 8)
+  %0 = invoke noalias i8* @_d_allocmemory(i64 8)
           to label %then unwind label %landingPad
 
 then:                                             ; preds = %body
   %1 = bitcast i8* %0 to i8**
   store i8* bitcast (%C6object9Exception__vtbl* @C6object9Exception__vtblZ to i8*), i8** %1, align 8
   %2 = bitcast i8* %0 to %C6object6Object*
   invoke void @_D6object6Object6__ctorFMC6object6ObjectZv(%C6object6Object* %2)
           to label %then1 unwind label %landingPad
 
 then1:                                            ; preds = %then
   %3 = bitcast i8* %0 to %C6object9Throwable*
-  invoke void @__sd_eh_throw(%C6object9Throwable* %3)
+  invoke void @__sd_eh_throw(%C6object9Throwable* nonnull %3)
           to label %then2 unwind label %landingPad
 
 then2:                                            ; preds = %then1
   unreachable
 
 landingPad:                                       ; preds = %then1, %then, %body
   %4 = landingpad { i8*, i32 }
           cleanup
           catch %C6object9ClassInfo* @C6object5Error__ClassInfo
           catch %C6object9ClassInfo* @C6object9Exception__ClassInfo
           catch %C6object9ClassInfo* @C6object9Throwable__ClassInfo
   %5 = extractvalue { i8*, i32 } %4, 1
-  %6 = tail call i32 @llvm.eh.typeid.for(i8* bitcast (%C6object9ClassInfo* @C6object5Error__ClassInfo to i8*))
+  %6 = tail call i32 @llvm.eh.typeid.for(i8* nonnull bitcast (%C6object9ClassInfo* @C6object5Error__ClassInfo to i8*))
   %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* bitcast (%C6object9ClassInfo* @C6object9Exception__ClassInfo to i8*))
+  %8 = tail 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* bitcast (%C6object9ClassInfo* @C6object9Throwable__ClassInfo to i8*))
+  %10 = tail 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

tools/llvm-c-test/echo.cpp

LLVMValueRef CloneValue(LLVMValueRef Src) {
     auto Builder = LLVMCreateBuilderInContext(Ctx);
     auto BB = DeclareBB(LLVMGetInstructionParent(Src));
     LLVMPositionBuilderAtEnd(Builder, BB);
     auto Dst = CloneInstruction(Src, Builder);
     LLVMDisposeBuilder(Builder);
     return Dst;
   }
 
+  void CloneAttrs(LLVMValueRef Src, LLVMValueRef Dst) {
+    int ArgCount = LLVMGetNumArgOperands(Src);
+    for (unsigned k = 0, e = LLVMGetEndAttrKind(); k < e; ++k) {
+      // NB: 0 is the return value attribute. Arguments are 1 - ArgCount.
+      for (int i = 0; i <= ArgCount; i++) {
+        if (LLVMHasInstrAttribute(Src, i, k))
+          LLVMAddInstrAttribute(Dst, i, k);
+      }
+    }
+  }
+
   LLVMValueRef CloneInstruction(LLVMValueRef Src, LLVMBuilderRef Builder) {
     const char *Name = LLVMGetValueName(Src);
     if (!LLVMIsAInstruction(Src))
       report_fatal_error("Expected an instruction");
 
     // Check if this is something we already computed.
     {
       auto i = VMap.find(Src);
switch(Op) {
         int ArgCount = LLVMGetNumArgOperands(Src);
         for (int i = 0; i < ArgCount; i++)
           Args.push_back(CloneValue(LLVMGetOperand(Src, i)));
         LLVMValueRef Fn = CloneValue(LLVMGetCalledValue(Src));
         LLVMBasicBlockRef Then = DeclareBB(LLVMGetNormalDest(Src));
         LLVMBasicBlockRef Unwind = DeclareBB(LLVMGetUnwindDest(Src));
         Dst = LLVMBuildInvoke(Builder, Fn, Args.data(), ArgCount,
                               Then, Unwind, Name);
+        CloneAttrs(Src, Dst);
         break;
       }
       case LLVMUnreachable:
         Dst = LLVMBuildUnreachable(Builder);
         break;
       case LLVMAdd: {
         LLVMValueRef LHS = CloneValue(LLVMGetOperand(Src, 0));
         LLVMValueRef RHS = CloneValue(LLVMGetOperand(Src, 1));
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));
+        CloneAttrs(Src, Dst);
         break;
       }
       case LLVMResume: {
         Dst = LLVMBuildResume(Builder, CloneValue(LLVMGetOperand(Src, 0)));
         break;
       }
       case LLVMLandingPad: {
         // The landing pad API is a bit screwed up for historical reasons.