[bindings/go] Implement API for adding debug info to global variables

[aykevl]

Summary

I implemented what seems like the most generic API possible. For example, there is also GlobalVariable->addDebugInfo but that is basically just a helper for GlobalObject->addMetadata.

[aykevl]

@whitequark can you take a look?

[whitequark]

@aykevl No. I'm no longer maintaining any LLVM bindings. I suggest you step up and discuss becoming a maintainer of the Go bindings on the mailing list.

llvm/bindings/go/llvm/dibuilder.go

result := C.LLVMDIBuilderCreateFunction(
     C.LLVMBool(boolToCInt(f.IsDefinition)),
     C.unsigned(f.ScopeLine),
     C.LLVMDIFlags(f.Flags),
     C.LLVMBool(boolToCInt(f.Optimized)),
   )
   return Metadata{C: result}
 }
 
+// DIGlobalVariableExpression holds the values for creating global variable
+// debug metadata.
+type DIGlobalVariableExpression struct {
+  Name        string   // Name of the variable.
+  LinkageName string   // Mangled name of the variable
+  File        Metadata // File where this variable is defined.
+  Line        int      // Line number.
+  Type        Metadata // Variable Type.
+  LocalToUnit bool     // Flag indicating whether this variable is externally visible or not.
+  Expr        Metadata // The location of the global relative to the attached GlobalVariable.
+  Decl        Metadata // Reference to the corresponding declaration.
+  AlignInBits uint32   // Variable alignment(or 0 if no alignment attr was specified).
+}
+
+// CreateGlobalVariableExpression creates a new descriptor for the specified
+// global variable.
+func (d *DIBuilder) CreateGlobalVariableExpression(diScope Metadata, g DIGlobalVariableExpression) Metadata {
+  name := C.CString(g.Name)
+  defer C.free(unsafe.Pointer(name))
+  linkageName := C.CString(g.LinkageName)
+  defer C.free(unsafe.Pointer(linkageName))
+  result := C.LLVMDIBuilderCreateGlobalVariableExpression(
+    d.ref,                       // Builder
+    diScope.C,                   // Scope
+    name, C.size_t(len(g.Name)), // Name, NameLen
+    linkageName, C.size_t(len(g.LinkageName)), // Linkage, LinkLen
+    g.File.C,                              // File
+    C.unsigned(g.Line),                    // LineNo
+    g.Type.C,                              // Ty
+    C.LLVMBool(boolToCInt(g.LocalToUnit)), // LocalToUnit
+    g.Expr.C,                              // Expr
+    g.Decl.C,                              // Decl
+    C.uint32_t(g.AlignInBits),             // AlignInBits
+  )
+  return Metadata{C: result}
+}
+
 // DIAutoVariable holds the values for creating auto variable debug metadata.
 type DIAutoVariable struct {
   Name           string
   File           Metadata
   Line           int
   Type           Metadata
   AlwaysPreserve bool
   Flags          int
func (v Value) SetSubprogram(sp Metadata) {
   C.LLVMSetSubprogram(v.C, sp.C)
 }
 
 func (v Value) Subprogram() (md Metadata) {
   md.C = C.LLVMGetSubprogram(v.C)
   return
 }
 
+// AddMetadata adds a metadata entry of the given kind to a global object.
+func (v Value) AddMetadata(kind int, md Metadata) {
+  C.LLVMGlobalObjectAddMetadata(v.C, C.unsigned(kind), md.C)
+}
+
 func boolToCInt(v bool) C.int {
   if v {
     return 1
   }
   return 0
 }
 
 //-------------------------------------------------------------------------

llvm/include/llvm-c/Core.h

  */
 LLVMValueRef LLVMGetMetadata(LLVMValueRef Val, unsigned KindID);
 
 /**
  * Set metadata associated with an instruction value.
  */
 void LLVMSetMetadata(LLVMValueRef Val, unsigned KindID, LLVMValueRef Node);
 
+/**
+ * Add metadata to a global object.
+ */
+void LLVMGlobalObjectAddMetadata(LLVMValueRef Global, unsigned KindID, LLVMMetadataRef MD);
+
 /**
  * Returns the metadata associated with an instruction value, but filters out
  * all the debug locations.
  *
  * @see llvm::Instruction::getAllMetadataOtherThanDebugLoc()
  */
 LLVMValueMetadataEntry *
 LLVMInstructionGetAllMetadataOtherThanDebugLoc(LLVMValueRef Instr,

llvm/lib/IR/Core.cpp

 }
 
 void LLVMSetMetadata(LLVMValueRef Inst, unsigned KindID, LLVMValueRef Val) {
   MDNode *N = Val ? extractMDNode(unwrap<MetadataAsValue>(Val)) : nullptr;
 
   unwrap<Instruction>(Inst)->setMetadata(KindID, N);
 }
 
+void LLVMGlobalObjectAddMetadata(LLVMValueRef Global, unsigned KindID, LLVMMetadataRef MD) {
+  MDNode *N = MD ? unwrap<MDNode>(MD) : nullptr;
+  GlobalObject *O = unwrap<GlobalObject>(Global);
+  O->addMetadata(KindID, *N);
+}
+
 struct LLVMOpaqueValueMetadataEntry {
   unsigned Kind;
   LLVMMetadataRef Metadata;
 };
 
 using MetadataEntries = SmallVectorImpl<std::pair<unsigned, MDNode *>>;
 static LLVMValueMetadataEntry *
 llvm_getMetadata(size_t *NumEntries,