[LLVM-C] Move DIBuilder Bindings For Block Scopes

[CodaFi]

Summary

Move LLVMDIBuilderCreateFunction , LLVMDIBuilderCreateLexicalBlock, and LLVMDIBuilderCreateLexicalBlockFile from Go to LLVM-C.

[whitequark]

Do you think you could add a test? (Do we have tests for DIBuilder at all?)

[CodaFi]

I'll need to move the Function scope API as well to write a coherent test.

[whitequark]

Sounds like a plan.

[whitequark]

LGTM

[harlanhaskins]

LGTM after that one small go style change.

bindings/go/llvm/dibuilder.go

210

Can you put these on the next line?

[CodaFi]

bindings/go/llvm/dibuilder.go

210

This matches the formatting in the rest of the file.

bindings/go/llvm/DIBuilderBindings.h

 #endif
 
 // FIXME: These bindings shouldn't be Go-specific and should eventually move to
 // a (somewhat) less stable collection of C APIs for use in creating bindings of
 // LLVM in other languages.
 
 typedef struct LLVMOpaqueDIBuilder *LLVMDIBuilderRef;
 
-LLVMMetadataRef LLVMDIBuilderCreateLexicalBlock(LLVMDIBuilderRef D,
-                                                LLVMMetadataRef Scope,
-                                                LLVMMetadataRef File,
-                                                unsigned Line, unsigned Column);
-
-LLVMMetadataRef LLVMDIBuilderCreateLexicalBlockFile(LLVMDIBuilderRef D,
-                                                    LLVMMetadataRef Scope,
-                                                    LLVMMetadataRef File,
-                                                    unsigned Discriminator);
-
-LLVMMetadataRef LLVMDIBuilderCreateFunction(
-    LLVMDIBuilderRef D, LLVMMetadataRef Scope, const char *Name,
-    const char *LinkageName, LLVMMetadataRef File, unsigned Line,
-    LLVMMetadataRef CompositeType, int IsLocalToUnit, int IsDefinition,
-    unsigned ScopeLine, unsigned Flags, int IsOptimized);
-
 LLVMMetadataRef LLVMDIBuilderCreateAutoVariable(
     LLVMDIBuilderRef D, LLVMMetadataRef Scope, const char *Name,
     LLVMMetadataRef File, unsigned Line, LLVMMetadataRef Ty, int AlwaysPreserve,
     unsigned Flags, uint32_t AlignInBits);
 
 LLVMMetadataRef LLVMDIBuilderCreateParameterVariable(
     LLVMDIBuilderRef D, LLVMMetadataRef Scope, const char *Name, unsigned ArgNo,
     LLVMMetadataRef File, unsigned Line, LLVMMetadataRef Ty, int AlwaysPreserve,

bindings/go/llvm/DIBuilderBindings.cpp

 #include "DIBuilderBindings.h"
 #include "IRBindings.h"
 #include "llvm/IR/DIBuilder.h"
 #include "llvm/IR/IRBuilder.h"
 #include "llvm/IR/Module.h"
 
 using namespace llvm;
 
-LLVMMetadataRef LLVMDIBuilderCreateLexicalBlock(LLVMDIBuilderRef Dref,
-                                                LLVMMetadataRef Scope,
-                                                LLVMMetadataRef File,
-                                                unsigned Line,
-                                                unsigned Column) {
-  DIBuilder *D = unwrap(Dref);
-  auto *LB = D->createLexicalBlock(unwrap<DILocalScope>(Scope),
-                                   unwrap<DIFile>(File), Line, Column);
-  return wrap(LB);
-}
-
-LLVMMetadataRef LLVMDIBuilderCreateLexicalBlockFile(LLVMDIBuilderRef Dref,
-                                                    LLVMMetadataRef Scope,
-                                                    LLVMMetadataRef File,
-                                                    unsigned Discriminator) {
-  DIBuilder *D = unwrap(Dref);
-  return wrap(D->createLexicalBlockFile(unwrap<DILocalScope>(Scope),
-                                        unwrap<DIFile>(File), Discriminator));
-}
-
-LLVMMetadataRef LLVMDIBuilderCreateFunction(
-    LLVMDIBuilderRef Dref, LLVMMetadataRef Scope, const char *Name,
-    const char *LinkageName, LLVMMetadataRef File, unsigned Line,
-    LLVMMetadataRef CompositeType, int IsLocalToUnit, int IsDefinition,
-    unsigned ScopeLine, unsigned Flags, int IsOptimized) {
-  DIBuilder *D = unwrap(Dref);
-  return wrap(D->createFunction(
-      unwrap<DIScope>(Scope), Name, LinkageName,
-      File ? unwrap<DIFile>(File) : nullptr, Line,
-      unwrap<DISubroutineType>(CompositeType), IsLocalToUnit, IsDefinition,
-      ScopeLine, static_cast<DINode::DIFlags>(Flags), IsOptimized));
-}
-
 LLVMMetadataRef LLVMDIBuilderCreateAutoVariable(
     LLVMDIBuilderRef Dref, LLVMMetadataRef Scope, const char *Name,
     LLVMMetadataRef File, unsigned Line, LLVMMetadataRef Ty, int AlwaysPreserve,
     unsigned Flags, uint32_t AlignInBits) {
   DIBuilder *D = unwrap(Dref);
   return wrap(
       D->createAutoVariable(unwrap<DIScope>(Scope), Name, unwrap<DIFile>(File),
                             Line, unwrap<DIType>(Ty), AlwaysPreserve,

bindings/go/llvm/IRBindings.h

 void LLVMMetadataReplaceAllUsesWith(LLVMMetadataRef MD, LLVMMetadataRef New);
 
 void LLVMSetCurrentDebugLocation2(LLVMBuilderRef Bref, unsigned Line,
                                   unsigned Col, LLVMMetadataRef Scope,
                                   LLVMMetadataRef InlinedAt);
 
 struct LLVMDebugLocMetadata LLVMGetCurrentDebugLocation2(LLVMBuilderRef Bref);
 
-void LLVMSetSubprogram(LLVMValueRef Fn, LLVMMetadataRef SP);
-
 #ifdef __cplusplus
 }
 
 #endif
 
 #endif

bindings/go/llvm/IRBindings.cpp

const LLVMDebugLocMetadata md{
     Loc.getLine(),
     Loc.getCol(),
     wrap(Loc.getScope()),
     InlinedAt == nullptr ? nullptr : wrap(InlinedAt->getRawInlinedAt()),
   };
   return md;
 }
 
-void LLVMSetSubprogram(LLVMValueRef Func, LLVMMetadataRef SP) {
-  unwrap<Function>(Func)->setSubprogram(unwrap<DISubprogram>(SP));
-}

bindings/go/llvm/dibuilder.go

 func (d *DIBuilder) CreateFunction(diScope Metadata, f DIFunction) Metadata {
   name := C.CString(f.Name)
   defer C.free(unsafe.Pointer(name))
   linkageName := C.CString(f.LinkageName)
   defer C.free(unsafe.Pointer(linkageName))
   result := C.LLVMDIBuilderCreateFunction(
     d.ref,
     diScope.C,
-    name,
-    linkageName,
+    name, C.size_t(len(f.Name)),
+    linkageName, C.size_t(len(f.LinkageName)),
     f.File.C,
     C.unsigned(f.Line),
     f.Type.C,
-    boolToCInt(f.LocalToUnit),
-    boolToCInt(f.IsDefinition),
+    C.LLVMBool(boolToCInt(f.LocalToUnit)),
+    C.LLVMBool(boolToCInt(f.IsDefinition)),
     C.unsigned(f.ScopeLine),
-    C.unsigned(f.Flags),
-    boolToCInt(f.Optimized),
+    C.LLVMDIFlags(f.Flags),
+    C.LLVMBool(boolToCInt(f.Optimized)),
   )
   return Metadata{C: result}
 }
 
 // DIAutoVariable holds the values for creating auto variable debug metadata.
 type DIAutoVariable struct {
   Name           string
   File           Metadata
result := C.LLVMDIBuilderCreateStructType(
     C.unsigned(t.AlignInBits),
     C.LLVMDIFlags(t.Flags),
     t.DerivedFrom.C,
     elements,
     length,
     C.unsigned(0), // Optional Objective-C runtime version.
     t.VTableHolder.C,
     uniqueID,
-    C.uint64_t(len(t.UniqueID)),
+    C.size_t(len(t.UniqueID)),
   )
   return Metadata{C: result}
 }
 
 // DIReplaceableCompositeType holds the values for creating replaceable
 // composite type debug metadata.
 type DIReplaceableCompositeType struct {
   Tag         dwarf.Tag

include/llvm-c/DebugInfo.h

  * \param DirectoryLen The length of the C string passed to \c Directory.
  */
 LLVMMetadataRef
 LLVMDIBuilderCreateFile(LLVMDIBuilderRef Builder, const char *Filename,
                         size_t FilenameLen, const char *Directory,
                         size_t DirectoryLen);
 
 /**
+ * Create a new descriptor for the specified subprogram.
+ * \param Builder         The \c DIBuilder.
+ * \param Scope           Function scope.
+ * \param Name            Function name.
+ * \param NameLen         Length of enumeration name.
+ * \param LinkageName     Mangled function name.
+ * \param LinkageNameLen  Length of linkage name.
+ * \param File            File where this variable is defined.
+ * \param LineNo          Line number.
+ * \param Ty              Function type.
+ * \param IsLocalToUnit   True if this function is not externally visible.
+ * \param IsDefinition    True if this is a function definition.
+ * \param ScopeLine       Set to the beginning of the scope this starts
+ * \param Flags           E.g.: \c LLVMDIFlagLValueReference. These flags are
+ *                        used to emit dwarf attributes.
+ * \param IsOptimized     True if optimization is ON.
+ */
+LLVMMetadataRef LLVMDIBuilderCreateFunction(
+    LLVMDIBuilderRef Builder, LLVMMetadataRef Scope, const char *Name,
+    size_t NameLen, const char *LinkageName, size_t LinkageNameLen,
+    LLVMMetadataRef File, unsigned LineNo, LLVMMetadataRef Ty,
+    LLVMBool IsLocalToUnit, LLVMBool IsDefinition,
+    unsigned ScopeLine, LLVMDIFlags Flags, LLVMBool IsOptimized);
+
+/**
+ * Create a descriptor for a lexical block with the specified parent context.
+ * \param Builder      The \c DIBuilder.
+ * \param Scope        Parent lexical block.
+ * \param File         Source file.
+ * \param Line         The line in the source file.
+ * \param Column       The column in the source file.
+ */
+LLVMMetadataRef LLVMDIBuilderCreateLexicalBlock(
+    LLVMDIBuilderRef Builder, LLVMMetadataRef Scope,
+    LLVMMetadataRef File, unsigned Line, unsigned Column);
+
+/**
+ * Create a descriptor for a lexical block with a new file attached.
+ * \param Builder        The \c DIBuilder.
+ * \param Scope          Lexical block.
+ * \param File           Source file.
+ * \param Discriminator  DWARF path discriminator value.
+ */
+LLVMMetadataRef
+LLVMDIBuilderCreateLexicalBlockFile(LLVMDIBuilderRef Builder,
+                                    LLVMMetadataRef Scope,
+                                    LLVMMetadataRef File,
+                                    unsigned Discriminator);
+
+/**
  * Creates a new DebugLocation that describes a source location.
  * \param Line The line in the source file.
  * \param Column The column in the source file.
  * \param Scope The scope in which the location resides.
  * \param InlinedAt The scope where this location was inlined, if at all.
  *                  (optional).
  * \note If the item to which this location is attached cannot be
  *       attributed to a source line, pass 0 for the line and column.

  * Create a new DIType* with "artificial" flag set.
  * \param Builder     The DIBuilder.
  * \param Type        The underlying type.
  */
 LLVMMetadataRef
 LLVMDIBuilderCreateArtificialType(LLVMDIBuilderRef Builder,
                                   LLVMMetadataRef Type);
 
+/**
+ * Get the metadata of the subprogram attached to a function.
+ *
+ * @see llvm::Function::getSubprogram()
+ */
+LLVMMetadataRef LLVMGetSubprogram(LLVMValueRef Func);
+
+/**
+ * Set the subprogram attached to a function.
+ *
+ * @see llvm::Function::setSubprogram()
+ */
+void LLVMSetSubprogram(LLVMValueRef Func, LLVMMetadataRef SP);
+
 #ifdef __cplusplus
 } /* end extern "C" */
 #endif
 
 #endif

lib/IR/DebugInfo.cpp

 LLVMMetadataRef
 LLVMDIBuilderCreateFile(LLVMDIBuilderRef Builder, const char *Filename,
                         size_t FilenameLen, const char *Directory,
                         size_t DirectoryLen) {
   return wrap(unwrap(Builder)->createFile(StringRef(Filename, FilenameLen),
                                           StringRef(Directory, DirectoryLen)));
 }
 
+LLVMMetadataRef LLVMDIBuilderCreateFunction(
+    LLVMDIBuilderRef Builder, LLVMMetadataRef Scope, const char *Name,
+    size_t NameLen, const char *LinkageName, size_t LinkageNameLen,
+    LLVMMetadataRef File, unsigned LineNo, LLVMMetadataRef Ty,
+    LLVMBool IsLocalToUnit, LLVMBool IsDefinition,
+    unsigned ScopeLine, LLVMDIFlags Flags, LLVMBool IsOptimized) {
+  return wrap(unwrap(Builder)->createFunction(
+      unwrapDI<DIScope>(Scope), {Name, NameLen}, {LinkageName, LinkageNameLen},
+      unwrapDI<DIFile>(File), LineNo, unwrapDI<DISubroutineType>(Ty),
+      IsLocalToUnit, IsDefinition, ScopeLine, map_from_llvmDIFlags(Flags),
+      IsOptimized, nullptr, nullptr, nullptr));
+}
+
+
+LLVMMetadataRef LLVMDIBuilderCreateLexicalBlock(
+    LLVMDIBuilderRef Builder, LLVMMetadataRef Scope,
+    LLVMMetadataRef File, unsigned Line, unsigned Col) {
+  return wrap(unwrap(Builder)->createLexicalBlock(unwrapDI<DIScope>(Scope),
+                                                  unwrapDI<DIFile>(File),
+                                                  Line, Col));
+}
+
+LLVMMetadataRef
+LLVMDIBuilderCreateLexicalBlockFile(LLVMDIBuilderRef Builder,
+                                    LLVMMetadataRef Scope,
+                                    LLVMMetadataRef File,
+                                    unsigned Discriminator) {
+  return wrap(unwrap(Builder)->createLexicalBlockFile(unwrapDI<DIScope>(Scope),
+                                                      unwrapDI<DIFile>(File),
+                                                      Discriminator));
+}
+
 LLVMMetadataRef
 LLVMDIBuilderCreateDebugLocation(LLVMContextRef Ctx, unsigned Line,
                                  unsigned Column, LLVMMetadataRef Scope,
                                  LLVMMetadataRef InlinedAt) {
   return wrap(DILocation::get(*unwrap(Ctx), Line, Column, unwrap(Scope),
                               unwrap(InlinedAt)));
 }
 
LLVMDIBuilderCreateSubroutineType(LLVMDIBuilderRef Builder,
                                   LLVMMetadataRef *ParameterTypes,
                                   unsigned NumParameterTypes,
                                   LLVMDIFlags Flags) {
   auto Elts = unwrap(Builder)->getOrCreateTypeArray({unwrap(ParameterTypes),
                                                      NumParameterTypes});
   return wrap(unwrap(Builder)->createSubroutineType(
     Elts, map_from_llvmDIFlags(Flags)));
 }
+
+LLVMMetadataRef LLVMGetSubprogram(LLVMValueRef Func) {
+  return wrap(unwrap<Function>(Func)->getSubprogram());
+}
+
+void LLVMSetSubprogram(LLVMValueRef Func, LLVMMetadataRef SP) {
+  unwrap<Function>(Func)->setSubprogram(unwrap<DISubprogram>(SP));
+}

test/Bindings/llvm-c/debug_info.ll

 ; RUN: llvm-c-test --test-dibuilder | FileCheck %s
 
 ; CHECK: ; ModuleID = 'debuginfo.c'
 ; CHECK-NEXT: source_filename = "debuginfo.c"
 
+; CHECK: declare !dbg !7 i64 @foo(i64, i64)
+
+; CHECK: declare !dbg !10 i64 @foo_inner_scope(i64, i64)
+
 ; CHECK: !llvm.dbg.cu = !{!0}
-; CHECK-NEXT: !FooType = !{!2}
+; CHECK-NEXT: !FooType = !{!3}
 
-; CHECK: !0 = distinct !DICompileUnit(language: DW_LANG_C, file: !1, producer: "llvm-c-test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, splitDebugInlining: false)
+; CHECK: !0 = distinct !DICompileUnit(language: DW_LANG_C, file: !1, producer: "llvm-c-test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, splitDebugInlining: false)
 ; CHECK-NEXT: !1 = !DIFile(filename: "debuginfo.c", directory: ".")
-; CHECK-NEXT: !2 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !3, size: 192, dwarfAddressSpace: 0)
-; CHECK-NEXT: !3 = !DICompositeType(tag: DW_TAG_structure_type, name: "MyStruct", file: !1, size: 192, elements: !4, runtimeLang: DW_LANG_C89, identifier: "MyStruct")
-; CHECK-NEXT: !4 = !{!5, !5, !5}
-; CHECK-NEXT: !5 = !DIBasicType(name: "Int64", size: 64)
+; CHECK-NEXT: !2 = !{}
+; CHECK-NEXT: !3 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !4, size: 192, dwarfAddressSpace: 0)
+; CHECK-NEXT: !4 = !DICompositeType(tag: DW_TAG_structure_type, name: "MyStruct", file: !1, size: 192, elements: !5, runtimeLang: DW_LANG_C89, identifier: "MyStruct")
+; CHECK-NEXT: !5 = !{!6, !6, !6}
+; CHECK-NEXT: !6 = !DIBasicType(name: "Int64", size: 64)
+; CHECK-NEXT: !7 = distinct !DISubprogram(name: "foo", linkageName: "foo", scope: !1, file: !1, line: 42, type: !8, isLocal: true, isDefinition: true, scopeLine: 42, isOptimized: false, unit: !0, variables: !2)
+; CHECK-NEXT: !8 = !DISubroutineType(types: !9)
+; CHECK-NEXT: !9 = !{!6, !6}
+; CHECK-NEXT: !10 = distinct !DISubprogram(name: "foo_inner_scope", linkageName: "foo_inner_scope", scope: !11, file: !1, line: 42, type: !8, isLocal: true, isDefinition: true, scopeLine: 42, isOptimized: false, unit: !0, variables: !2)
+; CHECK-NEXT: !11 = distinct !DILexicalBlock(scope: !7, file: !1, line: 42)

tools/llvm-c-test/debuginfo.c

LLVMMetadataRef StructDbgTy =
     LLVMDWARFSourceLanguageC, NULL, "MyStruct", 8);
 
   LLVMMetadataRef StructDbgPtrTy =
     LLVMDIBuilderCreatePointerType(DIB, StructDbgTy, 192, 0, 0, "", 0);
 
   LLVMAddNamedMetadataOperand(M, "FooType",
     LLVMMetadataAsValue(LLVMGetModuleContext(M), StructDbgPtrTy));
 
+
+  LLVMTypeRef FooParamTys[] = { LLVMInt64Type(), LLVMInt64Type() };
+  LLVMTypeRef FooFuncTy = LLVMFunctionType(LLVMInt64Type(), FooParamTys, 2, 0);
+  LLVMValueRef FooFunction = LLVMAddFunction(M, "foo", FooFuncTy);
+
+  LLVMMetadataRef ParamTypes[] = {Int64Ty, Int64Ty};
+  LLVMMetadataRef FunctionTy =
+    LLVMDIBuilderCreateSubroutineType(DIB, File, ParamTypes, 2, 0);
+  LLVMMetadataRef FunctionMetadata =
+    LLVMDIBuilderCreateFunction(DIB, File, "foo", 3, "foo", 3,
+                                File, 42, FunctionTy, true, true,
+                                42, 0, false);
+  LLVMSetSubprogram(FooFunction, FunctionMetadata);
+
+  LLVMMetadataRef FooLexicalBlock =
+    LLVMDIBuilderCreateLexicalBlock(DIB, FunctionMetadata, File, 42, 0);
+
+  LLVMValueRef InnerFooFunction =
+    LLVMAddFunction(M, "foo_inner_scope", FooFuncTy);
+  LLVMMetadataRef InnerFunctionMetadata =
+    LLVMDIBuilderCreateFunction(DIB, FooLexicalBlock, "foo_inner_scope", 15,
+                                "foo_inner_scope", 15,
+                                File, 42, FunctionTy, true, true,
+                                42, 0, false);
+  LLVMSetSubprogram(InnerFooFunction, InnerFunctionMetadata);
+
+  LLVMDIBuilderFinalize(DIB);
+
   char *MStr = LLVMPrintModuleToString(M);
   puts(MStr);
   LLVMDisposeMessage(MStr);
 
   LLVMDisposeDIBuilder(DIB);
   LLVMDisposeModule(M);
 
   return 0;
 }