[llvm-c] Add the ability to create debug locations

[jketema]

Summary

This ability was implicitly removed when debug information got its own specialized meta-data nodes.

[AlexDenisov]

include/llvm-c/Core.h

2790

Would not it be better to name it LLVMCreateDILocation?
This way other methods from the DI family can be imported consistently.
Just a side note though :)

[jketema]

include/llvm-c/Core.h

2790

I was trying to match the set and get functions below.

[whitequark]

include/llvm-c/Core.h

2790

I second LLVMCreateDILocation suggestion

lib/IR/Core.cpp

2315

Factor out this cast, perhaps? I can see it happenning a lot.

[echristo]

I'd be really surprised if this debug information worked. To make it work you need DISubprogram metadata which I don't think we want to put in the C API right now - at least not without serious stability caveats.

[whitequark]

@echristo What about exposing the bare key-value metadata interface? It itself can be stable, and frontends could use it before anything more specific is stabilized.

[jketema]

@echristo Indeed this doesn't quite work: the generated bitcode is parsable, but invalid, because a DIScope cannot be generated. I was planning to expose DIBuilder as a follow up patch, which should resolve this, but given your comment, you think this is not the right time to do this?

[deadalnix]

Various things here :

• Typically, there is a LOT of DILoc generated in any non toy module. Wrapping them all in a Value is going to be VERY wasteful. I would vote to add a LLVMMetadataRef type and use it.
• There is no need to create a new C test for that IMO. The echo test should be extended and a module with lcoation information should be fed to it.
• How is the scope created using that API ? If the plan is to use the old way to scope instead of DIScope, then I'm not sure where this is going. This allow to mix the old debug API with the new one, while not being able to get the largest benefit in the name a reduced resource requirement.

On a side note I have a patch that wrap the whole DIBuilder thing in the C API, that i did not submitted yet as testing was lacking.

[jketema]

@deadalnix

How is the scope created using that API ?

"I was planning to expose DIBuilder as a follow up patch"

[deadalnix]

Sorry, missed that bit. OK, let's discuss about how to proceed with this, as it obviously has an impact on this patch.

It seems to me that mapping the new DI API is a good opportunity to introduce LLVMMetadataRef and the MD class hierarchy. Wrapping everything in MetadataAsValue is going to create a tremendous amount of waste. I submitted D19088 , which isn't a a state where it is ready to be merged, but that should help the discussion here.

include/llvm-c/Core.h

 LLVMBasicBlockRef LLVMGetInsertBlock(LLVMBuilderRef Builder);
 void LLVMClearInsertionPosition(LLVMBuilderRef Builder);
 void LLVMInsertIntoBuilder(LLVMBuilderRef Builder, LLVMValueRef Instr);
 void LLVMInsertIntoBuilderWithName(LLVMBuilderRef Builder, LLVMValueRef Instr,
                                    const char *Name);
 void LLVMDisposeBuilder(LLVMBuilderRef Builder);
 
 /* Metadata */
+LLVMValueRef LLVMCreateDebugLocation(LLVMContextRef C, unsigned Line,
+                                     unsigned Col, const LLVMValueRef Scope,
+                                     const LLVMValueRef InlinedAt);
 void LLVMSetCurrentDebugLocation(LLVMBuilderRef Builder, LLVMValueRef L);
 LLVMValueRef LLVMGetCurrentDebugLocation(LLVMBuilderRef Builder);
 void LLVMSetInstDebugLocation(LLVMBuilderRef Builder, LLVMValueRef Inst);
 
 /* Terminators */
 LLVMValueRef LLVMBuildRetVoid(LLVMBuilderRef);
 LLVMValueRef LLVMBuildRet(LLVMBuilderRef, LLVMValueRef V);
 LLVMValueRef LLVMBuildAggregateRet(LLVMBuilderRef, LLVMValueRef *RetVals,

lib/IR/Core.cpp

 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm-c/Core.h"
 #include "llvm/Bitcode/ReaderWriter.h"
 #include "llvm/IR/Attributes.h"
 #include "llvm/IR/CallSite.h"
 #include "llvm/IR/Constants.h"
+#include "llvm/IR/DebugInfoMetadata.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/DiagnosticInfo.h"
 #include "llvm/IR/DiagnosticPrinter.h"
 #include "llvm/IR/GlobalAlias.h"
 #include "llvm/IR/GlobalVariable.h"
 #include "llvm/IR/IRBuilder.h"
 #include "llvm/IR/InlineAsm.h"
 #include "llvm/IR/IntrinsicInst.h"

 }
 
 void LLVMDisposeBuilder(LLVMBuilderRef Builder) {
   delete unwrap(Builder);
 }
 
 /*--.. Metadata builders ...................................................--*/
 
+LLVMValueRef LLVMCreateDebugLocation(LLVMContextRef C, unsigned Line,
+                                     unsigned Col, const LLVMValueRef Scope,
+                                     const LLVMValueRef InlinedAt) {
+  MDNode *SNode =
+      Scope ? cast<MDNode>(unwrap<MetadataAsValue>(Scope)->getMetadata())
+            : nullptr;
+  MDNode *INode =
+      InlinedAt
+          ? cast<MDNode>(unwrap<MetadataAsValue>(InlinedAt)->getMetadata())
+          : nullptr;
+  return wrap(MetadataAsValue::get(
+      *unwrap(C), DebugLoc::get(Line, Col, SNode, INode).get()));
+}
+
 void LLVMSetCurrentDebugLocation(LLVMBuilderRef Builder, LLVMValueRef L) {
   MDNode *Loc =
       L ? cast<MDNode>(unwrap<MetadataAsValue>(L)->getMetadata()) : nullptr;
   unwrap(Builder)->SetCurrentDebugLocation(DebugLoc(Loc));
 }
 
 LLVMValueRef LLVMGetCurrentDebugLocation(LLVMBuilderRef Builder) {
   LLVMContext &Context = unwrap(Builder)->getContext();

test/Bindings/llvm-c/empty.ll

 ; RUN: llvm-as < %s | llvm-dis > %t.orig
 ; RUN: llvm-as < %s | llvm-c-test --echo > %t.echo
 ; RUN: diff -w %t.orig %t.echo
+
 ; RUN: llvm-as < %s | llvm-c-test --test-diagnostic-handler 2>&1 | FileCheck %s
 ; CHECK: Diagnostic handler was not called while loading module
+
+; RUN: llvm-c-test --test-debug-information | FileCheck %s --check-prefix DBG
+; DBG: ret i32 %{{.*}}, !dbg !{{.*}}
+; DBG: !{{.*}} = !{i32 1, !"Debug Info Version", i32 3}
+; DBG: !{{.*}} = !DILocation(line: 1, column: 2, scope: !{{.*}})

tools/llvm-c-test/CMakeLists.txt

 endif()
 
 if (LLVM_COMPILER_IS_GCC_COMPATIBLE)
   set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -std=gnu99 -Wstrict-prototypes")
 endif ()
 
 add_llvm_tool(llvm-c-test
   calc.c
+  debug.c
   diagnostic.c
   disassemble.c
   echo.cpp
   helpers.c
   include-all.c
   main.c
   module.c
   metadata.c
   object.c
   targets.c
   )
 
 if(USE_LLVM_DYLIB)
   target_link_libraries(llvm-c-test LLVM)
 endif()

tools/llvm-c-test/debug.c

+//===-- debug.cpp - tool for testing libLLVM and llvm-c API ---------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file implements the --test-debug-information command in llvm-c-test.
+//
+// This command uses the C API to create a module that includes debug
+// information.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm-c-test.h"
+#include "llvm-c/Core.h"
+
+#include <stdio.h>
+#include <string.h>
+
+enum { NumFnParams = 1 };
+
+int llvm_test_debug_information(void) {
+
+  LLVMContextRef C = LLVMGetGlobalContext();
+  LLVMModuleRef M = LLVMModuleCreateWithNameInContext("Debug test module", C);
+
+  LLVMTypeRef Int32Ty = LLVMInt32TypeInContext(C);
+
+  // Create debug version.
+  const char *DebugStr = "Debug Info Version";
+  LLVMValueRef DbgVer[3];
+  DbgVer[0] = LLVMConstInt(Int32Ty, 1, 0);
+  DbgVer[1] = LLVMMDStringInContext(C, DebugStr, strlen(DebugStr));
+  DbgVer[2] = LLVMConstInt(Int32Ty, 3, 0);
+  LLVMAddNamedMetadataOperand(M, "llvm.module.flags",
+                              LLVMMDNodeInContext(C, DbgVer, 3));
+
+  // Build function declaration.
+  LLVMTypeRef ParamTys[NumFnParams];
+  ParamTys[0] = Int32Ty;
+  LLVMTypeRef FTy = LLVMFunctionType(Int32Ty, ParamTys,
+                                     NumFnParams, 0);
+
+  // Build basic block.
+  LLVMValueRef Fn = LLVMAddFunction(M, "foo", FTy);
+  LLVMBasicBlockRef BB = LLVMAppendBasicBlockInContext(C, Fn, "entry");
+  LLVMBuilderRef B = LLVMCreateBuilderInContext(C);
+  LLVMPositionBuilderAtEnd(B, BB);
+
+  // Create and set debug location.
+  LLVMValueRef Scope = LLVMMDNodeInContext(C, NULL, 0);
+  LLVMValueRef Loc = LLVMCreateDebugLocation(C, 1, 2, Scope, NULL);
+  LLVMSetCurrentDebugLocation(B, Loc);
+
+  // Create return instruction.
+  LLVMValueRef Params[NumFnParams];
+  LLVMGetParams(Fn, Params);
+  LLVMBuildRet(B, Params[0]);
+
+  // Print the module.
+  char *irstr = LLVMPrintModuleToString(M);
+  puts(irstr);
+  LLVMDisposeMessage(irstr);
+
+  return 0;
+}

tools/llvm-c-test/diagnostic.c

int llvm_test_diagnostic_handler(void) {
   LLVMMemoryBufferRef MB;
   char *msg = NULL;
   if (LLVMCreateMemoryBufferWithSTDIN(&MB, &msg)) {
     fprintf(stderr, "Error reading file: %s\n", msg);
     LLVMDisposeMessage(msg);
     return 1;
   }
 
-
   LLVMModuleRef M;
   int Ret = LLVMGetBitcodeModule2(MB, &M);
   if (Ret) {
     // We do not return if the bitcode was invalid, as we want to test whether
     // the diagnostic handler was executed.
     fprintf(stderr, "Error parsing bitcode: %s\n", msg);
   }
 

tools/llvm-c-test/llvm-c-test.h

 int llvm_targets_list(void);
 
 // echo.c
 int llvm_echo(void);
 
 // diagnostic.c
 int llvm_test_diagnostic_handler(void);
 
+// debug.c
+int llvm_test_debug_information(void);
+
 #ifdef __cplusplus
 }
 #endif /* !defined(__cplusplus) */
 
 #endif

tools/llvm-c-test/main.c

fprintf(
       stderr,
       "    Read lines of name, rpn from stdin - print generated module\n\n");
   fprintf(stderr, "  * --echo\n");
   fprintf(stderr,
           "    Read bitcode file form stdin - print it back out\n\n");
   fprintf(stderr, "  * --test-diagnostic-handler\n");
   fprintf(stderr,
           "    Read bitcode file form stdin with a diagnostic handler set\n\n");
+  fprintf(stderr, "  * --test-debug-information\n");
+  fprintf(stderr,
+          "    Create a bitcode file that includes debug information\n\n");
 }
 
 int main(int argc, char **argv) {
   LLVMPassRegistryRef pr = LLVMGetGlobalPassRegistry();
 
   LLVMInitializeCore(pr);
 
   if (argc == 2 && !strcmp(argv[1], "--lazy-new-module-dump")) {
int main(int argc, char **argv) {
   } else if (argc == 2 && !strcmp(argv[1], "--add-named-metadata-operand")) {
     return llvm_add_named_metadata_operand();
   } else if (argc == 2 && !strcmp(argv[1], "--set-metadata")) {
     return llvm_set_metadata();
   } else if (argc == 2 && !strcmp(argv[1], "--echo")) {
     return llvm_echo();
   } else if (argc == 2 && !strcmp(argv[1], "--test-diagnostic-handler")) {
     return llvm_test_diagnostic_handler();
+  } else if (argc == 2 && !strcmp(argv[1], "--test-debug-information")) {
+    return llvm_test_debug_information();
   } else {
     print_usage();
   }
 
   return 1;
 }