[llvm-c] Expose LLVMContextGetDiagnostic{Handler,Context}

[whitequark]

LGTM

[whitequark]

Actually, can you please add a test? The main function of llvm-c-test/echo.cpp seems to be a suitable place to set and then retrieve a diagnostic handler.

[jketema]

I was wondering what a suitable place for a test was. Thanks for the pointer, I'll update. Once this is in I should have a first version of a patch for the OCaml bindings exposing the diagnostic handler.

[jketema]

Added test for diagnostic handler

[whitequark]

deadalnix, does the test look OK to you?

[deadalnix]

Overall I'm good with it. I'm not sure test belongs in the echo thing. I would add a new flag to llvm-c-test and just create a new kind of test. That way it would be possible to actually trigger the handler and see if it does what is expected.

[jketema]

I've split out the diagnostic testing and improved it a bit as suggested. Let me know what you think.

While here, I also fixed some issues with the help text printed by llvm-c-test. I hope that's fine.

[jketema]

Remove some unnecessary duplication introduced in the previous version of this patch.

[deadalnix]

Small nits, but looks good overall.

tools/llvm-c-test/diagnostic.c

40 ↗

(On Diff #52894)

Remove empty line

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

53 ↗

(On Diff #52894)

The name is a bit confusing, because this isn't the handler. Maybe llvm_test_diagnostic_handler or something alike.

[jketema]

Addressed the little nitpicks.

@whitequark Is this ok with you?

llvm/trunk/include/llvm-c/Core.h

 /**
  * Set the diagnostic handler for this context.
  */
 void LLVMContextSetDiagnosticHandler(LLVMContextRef C,
                                      LLVMDiagnosticHandler Handler,
                                      void *DiagnosticContext);
 
 /**
+ * Get the diagnostic handler of this context.
+ */
+LLVMDiagnosticHandler LLVMContextGetDiagnosticHandler(LLVMContextRef C);
+
+/**
+ * Get the diagnostic context of this context.
+ */
+void *LLVMContextGetDiagnosticContext(LLVMContextRef C);
+
+/**
  * Set the yield callback function for this context.
  *
  * @see LLVMContext::setYieldCallback()
  */
 void LLVMContextSetYieldCallback(LLVMContextRef C, LLVMYieldCallback Callback,
                                  void *OpaqueHandle);
 
 /**

llvm/trunk/lib/IR/Core.cpp

 LLVMContextRef LLVMGetGlobalContext() {
   return wrap(&getGlobalContext());
 }
 
 void LLVMContextSetDiagnosticHandler(LLVMContextRef C,
                                      LLVMDiagnosticHandler Handler,
                                      void *DiagnosticContext) {
   unwrap(C)->setDiagnosticHandler(
-      LLVM_EXTENSION reinterpret_cast<LLVMContext::DiagnosticHandlerTy>(Handler),
+      LLVM_EXTENSION reinterpret_cast<LLVMContext::DiagnosticHandlerTy>(
+          Handler),
       DiagnosticContext);
 }
 
+LLVMDiagnosticHandler LLVMContextGetDiagnosticHandler(LLVMContextRef C) {
+  return LLVM_EXTENSION reinterpret_cast<LLVMDiagnosticHandler>(
+      unwrap(C)->getDiagnosticHandler());
+}
+
+void *LLVMContextGetDiagnosticContext(LLVMContextRef C) {
+  return unwrap(C)->getDiagnosticContext();
+}
+
 void LLVMContextSetYieldCallback(LLVMContextRef C, LLVMYieldCallback Callback,
                                  void *OpaqueHandle) {
   auto YieldCallback =
     LLVM_EXTENSION reinterpret_cast<LLVMContext::YieldCallbackTy>(Callback);
   unwrap(C)->setYieldCallback(YieldCallback, OpaqueHandle);
 }
 
 void LLVMContextDispose(LLVMContextRef C) {

llvm/trunk/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

llvm/trunk/test/Bindings/llvm-c/invalid-bitcode.test

 ; RUN: not llvm-c-test --module-dump < %S/Inputs/invalid.ll.bc 2>&1 | FileCheck %s
 ; RUN: not llvm-c-test --lazy-module-dump < %S/Inputs/invalid.ll.bc 2>&1 | FileCheck %s
 
 CHECK: Error parsing bitcode: Unknown attribute kind (52)
 
 
 ; RUN: not llvm-c-test --new-module-dump < %S/Inputs/invalid.ll.bc 2>&1 | FileCheck --check-prefix=NEW %s
 ; RUN: not llvm-c-test --lazy-new-module-dump < %S/Inputs/invalid.ll.bc 2>&1 | FileCheck --check-prefix=NEW %s
 
 NEW: Error with new bitcode parser: Unknown attribute kind (52)
+
+; RUN: llvm-c-test --test-diagnostic-handler < %S/Inputs/invalid.ll.bc 2>&1 | FileCheck --check-prefix=DIAGNOSTIC %s
+
+DIAGNOSTIC: Executing diagnostic handler
+DIAGNOSTIC: Diagnostic severity is of type error
+DIAGNOSTIC: Diagnostic handler was called while loading module

llvm/trunk/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
+  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()

llvm/trunk/tools/llvm-c-test/diagnostic.c

+//===-- diagnostic.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-diagnostic-handler command in llvm-c-test.
+//
+// This command uses the C API to read a module with a custom diagnostic
+// handler set to test the diagnostic handler functionality.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm-c-test.h"
+#include "llvm-c/BitReader.h"
+#include "llvm-c/Core.h"
+
+#include <stdio.h>
+
+static void diagnosticHandler(LLVMDiagnosticInfoRef DI, void *C) {
+  fprintf(stderr, "Executing diagnostic handler\n");
+
+  fprintf(stderr, "Diagnostic severity is of type ");
+  switch (LLVMGetDiagInfoSeverity(DI)) {
+  case LLVMDSError:
+    fprintf(stderr, "error");
+    break;
+  case LLVMDSWarning:
+    fprintf(stderr, "warning");
+    break;
+  case LLVMDSRemark:
+    fprintf(stderr, "remark");
+    break;
+  case LLVMDSNote:
+    fprintf(stderr, "note");
+    break;
+  }
+  fprintf(stderr, "\n");
+
+  (*(int *)C) = 1;
+}
+
+static int handlerCalled = 0;
+
+int llvm_test_diagnostic_handler(void) {
+  LLVMContextRef C = LLVMGetGlobalContext();
+  LLVMContextSetDiagnosticHandler(C, diagnosticHandler, &handlerCalled);
+
+  if (LLVMContextGetDiagnosticHandler(C) != diagnosticHandler) {
+    fprintf(stderr, "LLVMContext{Set,Get}DiagnosticHandler failed\n");
+    return 1;
+  }
+
+  int *DC = (int *)LLVMContextGetDiagnosticContext(C);
+  if (DC != &handlerCalled || *DC) {
+    fprintf(stderr, "LLVMContextGetDiagnosticContext failed\n");
+    return 1;
+  }
+
+  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);
+  }
+
+  LLVMDisposeMemoryBuffer(MB);
+
+  if (handlerCalled) {
+    fprintf(stderr, "Diagnostic handler was called while loading module\n");
+  } else {
+    fprintf(stderr, "Diagnostic handler was not called while loading module\n");
+  }
+
+  return 0;
+}

llvm/trunk/tools/llvm-c-test/echo.cpp

 //===-- echo.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 --echo commands in llvm-c-test.
+// This file implements the --echo command in llvm-c-test.
 //
 // This command uses the C API to read a module and output an exact copy of it
 // as output. It is used to check that the resulting module matches the input
 // to validate that the C API can read and write modules properly.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm-c-test.h"

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

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

llvm/trunk/tools/llvm-c-test/main.c

 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
 static void print_usage(void) {
   fprintf(stderr, "llvm-c-test command\n\n");
   fprintf(stderr, " Commands:\n");
   fprintf(stderr, "  * --module-dump\n");
-  fprintf(stderr, "    Read bytecode from stdin - print disassembly\n\n");
+  fprintf(stderr, "    Read bitcode from stdin - print disassembly\n\n");
   fprintf(stderr, "  * --lazy-module-dump\n");
   fprintf(stderr,
-          "    Lazily read bytecode from stdin - print disassembly\n\n");
+          "    Lazily read bitcode from stdin - print disassembly\n\n");
   fprintf(stderr, "  * --new-module-dump\n");
-  fprintf(stderr, "    Read bytecode from stdin - print disassembly\n\n");
+  fprintf(stderr, "    Read bitcode from stdin - print disassembly\n\n");
   fprintf(stderr, "  * --lazy-new-module-dump\n");
   fprintf(stderr,
-          "    Lazily read bytecode from stdin - print disassembly\n\n");
+          "    Lazily read bitcode from stdin - print disassembly\n\n");
   fprintf(stderr, "  * --module-list-functions\n");
   fprintf(stderr,
-          "    Read bytecode from stdin - list summary of functions\n\n");
+          "    Read bitcode from stdin - list summary of functions\n\n");
   fprintf(stderr, "  * --module-list-globals\n");
-  fprintf(stderr, "    Read bytecode from stdin - list summary of globals\n\n");
+  fprintf(stderr, "    Read bitcode from stdin - list summary of globals\n\n");
   fprintf(stderr, "  * --targets-list\n");
   fprintf(stderr, "    List available targets\n\n");
   fprintf(stderr, "  * --object-list-sections\n");
   fprintf(stderr, "    Read object file form stdin - list sections\n\n");
   fprintf(stderr, "  * --object-list-symbols\n");
   fprintf(stderr,
           "    Read object file form stdin - list symbols (like nm)\n\n");
   fprintf(stderr, "  * --disassemble\n");
   fprintf(stderr, "    Read lines of triple, hex ascii machine code from stdin "
                   "- print disassembly\n\n");
   fprintf(stderr, "  * --calc\n");
-  fprintf(stderr, "  * --echo\n");
-  fprintf(stderr,
-          "    Read object file form stdin - and print it back out\n\n");
   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");
 }
 
 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], "--calc")) {
     return llvm_calc();
   } 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 {
     print_usage();
   }
 
   return 1;
 }