[LLVM-C] Move DIBuilder Bindings For Temporary MDNodes

[CodaFi]

Summary

Move LLVMTemporaryMDNode and LLVMMetadataReplaceAllUsesWith to the C bindings and add LLVMDeleteTemporaryMDNode for deleting non-RAUW'ed temporary nodes.

[whitequark]

include/llvm-c/DebugInfo.h

851

I think this should be called LLVMDisposeTemporaryMDNode, by analogy with every other destructor.

858

Is this really necessary? If this function remains, it should at least be documented that it is exactly the same as calling LLVMReplaceAllUsesWith and then LLVMDisposeTemporaryMDNode, but I'm not convinced that it has much value.

[CodaFi]

llvm::Value::replaceAllUsesWith and llvm::MDNode::replaceAllUsesWith are distinct operations. The former assumes the source and replacement values are the same type, the latter assumes that you're trying to build up a graph of dummy metadata for an incomplete or recursive definition that you will eventually finalize by replacing it with real nodes.

I do agree with the name change for dispose - and it is actually a useful operation to have. We're handing ownership of temporary metadata nodes to the caller and if they don't RAUW they will leak.

[whitequark]

llvm::Value::replaceAllUsesWith and llvm::MDNode::replaceAllUsesWith are distinct operations.

Ah, I haven't realized the MDNode function is different. LGTM.

bindings/go/llvm/IRBindings.h

struct LLVMDebugLocMetadata{
     LLVMMetadataRef InlinedAt;
 };
 
 LLVMMetadataRef LLVMConstantAsMetadata(LLVMValueRef Val);
 
 LLVMMetadataRef LLVMMDString2(LLVMContextRef C, const char *Str, unsigned SLen);
 LLVMMetadataRef LLVMMDNode2(LLVMContextRef C, LLVMMetadataRef *MDs,
                             unsigned Count);
-LLVMMetadataRef LLVMTemporaryMDNode(LLVMContextRef C, LLVMMetadataRef *MDs,
-                                    unsigned Count);
 
 void LLVMAddNamedMetadataOperand2(LLVMModuleRef M, const char *name,
                                   LLVMMetadataRef Val);
 void LLVMSetMetadata2(LLVMValueRef Inst, unsigned KindID, LLVMMetadataRef MD);
 
-void LLVMMetadataReplaceAllUsesWith(LLVMMetadataRef MD, LLVMMetadataRef New);
-
 void LLVMSetCurrentDebugLocation2(LLVMBuilderRef Bref, unsigned Line,
                                   unsigned Col, LLVMMetadataRef Scope,
                                   LLVMMetadataRef InlinedAt);
 
 struct LLVMDebugLocMetadata LLVMGetCurrentDebugLocation2(LLVMBuilderRef Bref);
 
 #ifdef __cplusplus
 }
 
 #endif
 
 #endif

bindings/go/llvm/IRBindings.cpp

 }
 
 LLVMMetadataRef LLVMMDNode2(LLVMContextRef C, LLVMMetadataRef *MDs,
                             unsigned Count) {
   return wrap(
       MDNode::get(*unwrap(C), ArrayRef<Metadata *>(unwrap(MDs), Count)));
 }
 
-LLVMMetadataRef LLVMTemporaryMDNode(LLVMContextRef C, LLVMMetadataRef *MDs,
-                                    unsigned Count) {
-  return wrap(MDTuple::getTemporary(*unwrap(C),
-                                    ArrayRef<Metadata *>(unwrap(MDs), Count))
-                  .release());
-}
-
 void LLVMAddNamedMetadataOperand2(LLVMModuleRef M, const char *name,
                                   LLVMMetadataRef Val) {
   NamedMDNode *N = unwrap(M)->getOrInsertNamedMetadata(name);
   if (!N)
     return;
   if (!Val)
     return;
   N->addOperand(unwrap<MDNode>(Val));
 }
 
 void LLVMSetMetadata2(LLVMValueRef Inst, unsigned KindID, LLVMMetadataRef MD) {
   MDNode *N = MD ? unwrap<MDNode>(MD) : nullptr;
   unwrap<Instruction>(Inst)->setMetadata(KindID, N);
 }
 
-void LLVMMetadataReplaceAllUsesWith(LLVMMetadataRef MD, LLVMMetadataRef New) {
-  auto *Node = unwrap<MDNode>(MD);
-  Node->replaceAllUsesWith(unwrap<Metadata>(New));
-  MDNode::deleteTemporary(Node);
-}
-
 void LLVMSetCurrentDebugLocation2(LLVMBuilderRef Bref, unsigned Line,
                                   unsigned Col, LLVMMetadataRef Scope,
                                   LLVMMetadataRef InlinedAt) {
   unwrap(Bref)->SetCurrentDebugLocation(
       DebugLoc::get(Line, Col, Scope ? unwrap<MDNode>(Scope) : nullptr,
                     InlinedAt ? unwrap<MDNode>(InlinedAt) : nullptr));
 }
 

bindings/go/llvm/dibuilder.go

 }
 
 func boolToCInt(v bool) C.int {
   if v {
     return 1
   }
   return 0
 }
+
+//-------------------------------------------------------------------------
+// llvm.Metadata
+//-------------------------------------------------------------------------
+
+func (c Context) TemporaryMDNode(mds []Metadata) (md Metadata) {
+  ptr, nvals := llvmMetadataRefs(mds)
+  md.C = C.LLVMTemporaryMDNode(c.C, ptr, C.size_t(nvals))
+  return
+}
+
+func (md Metadata) ReplaceAllUsesWith(new Metadata) {
+  C.LLVMMetadataReplaceAllUsesWith(md.C, new.C)
+}

bindings/go/llvm/ir.go

func (c Context) MDString(str string) (md Metadata) {
   md.C = C.LLVMMDString2(c.C, cstr, C.unsigned(len(str)))
   return
 }
 func (c Context) MDNode(mds []Metadata) (md Metadata) {
   ptr, nvals := llvmMetadataRefs(mds)
   md.C = C.LLVMMDNode2(c.C, ptr, nvals)
   return
 }
-func (c Context) TemporaryMDNode(mds []Metadata) (md Metadata) {
-  ptr, nvals := llvmMetadataRefs(mds)
-  md.C = C.LLVMTemporaryMDNode(c.C, ptr, nvals)
-  return
-}
 func (v Value) ConstantAsMetadata() (md Metadata) {
   md.C = C.LLVMConstantAsMetadata(v.C)
   return
 }
 
 // Operations on scalar constants
 func ConstInt(t Type, n uint64, signExtend bool) (v Value) {
   v.C = C.LLVMConstInt(t.C,

 // manager. Returns 1 if any of the passes modified the module, 0 otherwise.
 // See llvm::FunctionPassManager::doFinalization.
 func (pm PassManager) FinalizeFunc() bool { return C.LLVMFinalizeFunctionPassManager(pm.C) != 0 }
 
 // Frees the memory of a pass pipeline. For function pipelines, does not free
 // the module provider.
 // See llvm::PassManagerBase::~PassManagerBase.
 func (pm PassManager) Dispose() { C.LLVMDisposePassManager(pm.C) }
-
-//-------------------------------------------------------------------------
-// llvm.Metadata
-//-------------------------------------------------------------------------
-
-func (md Metadata) ReplaceAllUsesWith(new Metadata) {
-  C.LLVMMetadataReplaceAllUsesWith(md.C, new.C)
-}

include/llvm-c/DebugInfo.h

LLVMDIBuilderCreateGlobalVariableExpression(LLVMDIBuilderRef Builder,
                                             const char *Linkage, size_t LinkLen,
                                             LLVMMetadataRef File,
                                             unsigned LineNo,
                                             LLVMMetadataRef Ty,
                                             LLVMBool LocalToUnit,
                                             LLVMMetadataRef Expr,
                                             LLVMMetadataRef Decl,
                                             uint32_t AlignInBits);
+/**
+ * Create a new temporary \c MDNode.  Suitable for use in constructing cyclic
+ * \c MDNode structures. A temporary \c MDNode is not uniqued, may be RAUW'd,
+ * and must be manually deleted with \c LLVMDeleteTemporaryMDNode.
+ * \param Ctx            The context in which to construct the temporary node.
+ * \param Data           The metadata elements.
+ * \param NumElements    Number of metadata elements.
+ */
+LLVMMetadataRef LLVMTemporaryMDNode(LLVMContextRef Ctx, LLVMMetadataRef *Data,
+                                    size_t NumElements);
+
+/**
+ * Deallocate a temporary node.
+ *
+ * Calls \c replaceAllUsesWith(nullptr) before deleting, so any remaining
+ * references will be reset.
+ * \param TempNode    The temporary metadata node.
+ */
+void LLVMDeleteTemporaryMDNode(LLVMMetadataRef TempNode);
+
+/**
+ * Replace all uses of temporary metadata.
+ * \param TempTargetMetadata    The temporary metadata node.
+ * \param Replacement           The replacement metadata node.
+ */
+void LLVMMetadataReplaceAllUsesWith(LLVMMetadataRef TempTargetMetadata,
+                                    LLVMMetadataRef Replacement);
 
 /**
  * Create a new descriptor for the specified global variable that is temporary
  * and meant to be RAUWed.
  * \param Scope       Variable scope.
  * \param Name        Name of the variable.
  * \param NameLen     The length of the C string passed to \c Name.
  * \param Linkage     Mangled  name of the variable.

lib/IR/DebugInfo.cpp

LLVMDIBuilderCreateGlobalVariableExpression(LLVMDIBuilderRef Builder,
                                             uint32_t AlignInBits) {
   return wrap(unwrap(Builder)->createGlobalVariableExpression(
                   unwrapDI<DIScope>(Scope), {Name, NameLen}, {Linkage, LinkLen},
                   unwrapDI<DIFile>(File), LineNo, unwrapDI<DIType>(Ty),
                   LocalToUnit, unwrap<DIExpression>(Expr),
                   unwrapDI<MDNode>(Decl), AlignInBits));
 }
 
+LLVMMetadataRef LLVMTemporaryMDNode(LLVMContextRef Ctx, LLVMMetadataRef *Data,
+                                    size_t Count) {
+  return wrap(
+      MDTuple::getTemporary(*unwrap(Ctx), {unwrap(Data), Count}).release());
+}
+
+void LLVMDeleteTemporaryMDNode(LLVMMetadataRef TempNode) {
+  MDNode::deleteTemporary(unwrapDI<MDNode>(TempNode));
+}
+
+void LLVMMetadataReplaceAllUsesWith(LLVMMetadataRef TargetMetadata,
+                                    LLVMMetadataRef Replacement) {
+  auto *Node = unwrapDI<MDNode>(TargetMetadata);
+  Node->replaceAllUsesWith(unwrap<Metadata>(Replacement));
+  MDNode::deleteTemporary(Node);
+}
+
 LLVMMetadataRef
 LLVMDIBuilderCreateTempGlobalVariableFwdDecl(LLVMDIBuilderRef Builder,
                                              LLVMMetadataRef Scope,
                                              const char *Name, size_t NameLen,
                                              const char *Linkage, size_t LnkLen,
                                              LLVMMetadataRef File,
                                              unsigned LineNo,
                                              LLVMMetadataRef Ty,

tools/llvm-c-test/debuginfo.c

int llvm_test_dibuilder(void) {
   LLVMMetadataRef VectorTy =
     LLVMDIBuilderCreateVectorType(DIB, 64 * 10, 0,
                                   Int64Ty, Subscripts, 1);
 
 
   LLVMMetadataRef ParamTypes[] = {Int64Ty, Int64Ty, VectorTy};
   LLVMMetadataRef FunctionTy =
     LLVMDIBuilderCreateSubroutineType(DIB, File, ParamTypes, 3, 0);
+
+  LLVMMetadataRef ReplaceableFunctionMetadata =
+    LLVMDIBuilderCreateReplaceableCompositeType(DIB, 0x15, "foo", 3,
+                                                File, File, 42,
+                                                0, 0, 0,
+                                                LLVMDIFlagFwdDecl,
+                                                "", 0);
+
+  LLVMMetadataRef FooParamLocation =
+    LLVMDIBuilderCreateDebugLocation(LLVMGetGlobalContext(), 42, 0,
+                                     ReplaceableFunctionMetadata, NULL);
   LLVMMetadataRef FunctionMetadata =
     LLVMDIBuilderCreateFunction(DIB, File, "foo", 3, "foo", 3,
                                 File, 42, FunctionTy, true, true,
                                 42, 0, false);
+  LLVMMetadataReplaceAllUsesWith(ReplaceableFunctionMetadata, FunctionMetadata);
 
-  LLVMMetadataRef FooParamLocation =
-    LLVMDIBuilderCreateDebugLocation(LLVMGetGlobalContext(), 42, 0,
-                                     FunctionMetadata, NULL);
   LLVMMetadataRef FooParamExpression =
     LLVMDIBuilderCreateExpression(DIB, NULL, 0);
   LLVMMetadataRef FooParamVar1 =
     LLVMDIBuilderCreateParameterVariable(DIB, FunctionMetadata, "a", 1, 1, File,
                                          42, Int64Ty, true, 0);
   LLVMDIBuilderInsertDeclareAtEnd(DIB, LLVMConstInt(LLVMInt64Type(), 0, false),
                                   FooParamVar1, FooParamExpression,
                                   FooParamLocation, FooEntryBlock);