LLVM C DIBuilder Creation APIs

[harlanhaskins]

Summary

This is an initial set of LLVM DIBuilder APIs that can create builders, compile units, files, and scopes, and introspect the debug info inside modules.

[harlanhaskins]

arc...picked some wrong branches here. I'll fix this diff 😅

[harlanhaskins]

Fix merge head

[harlanhaskins]

Fix 80-column limit for LLVMDWARFSourceLanguage

[harlanhaskins]

Add back remanining files (sorry for the email spam!)

[deadalnix]

Hi, you can put "HEAD^" in the file ".git/arc/default-relative-commit" , this ensure that only the comit you are currently on is sent to phabricator.

[whitequark]

lib/IR/DebugInfo.cpp

694 ↗

(On Diff #96208)

I believe our policy for all new LLVM-C code is to use pointer/length pairs for all array arguments, including strings.

[harlanhaskins]

lib/IR/DebugInfo.cpp

694 ↗

(On Diff #96208)

Ah! Yes, I had forgotten. Thanks!

[harlanhaskins]

• Fix 80-column limit for LLVMDWARFSourceLanguage
• Pass string parameters as pointer/length pairs

[deadalnix]

Ideally we'd like to have some test with this. The way it is usually done is to use the echo test: it reads a module using the C API and then recreate another identical module using the same C API. This ensure end to end testing. However this doesn't provide any reading facility so that me be more work than you are willing to put into this.

include/llvm-c/DebugInfo.h

63 ↗

(On Diff #96208)

Maybe having 2 function rather than a bool in the API that end up being a uint8_t ?

65 ↗

(On Diff #96208)

The doc should specify if it finalize or not when disposing.

90 ↗

(On Diff #96208)

DWOId yields notthing relevant on Google. Maybe this needs to be explained a bit more.

106 ↗

(On Diff #96208)

It hasn't been enforced consistently int he past, so that may not be immediately obvious, but we usually pass a pointer and a length for string in the newer API. This avoid useless calls to strlen and works even if the string isn't zero terminated which is a plus. Keep in mind that the C API is often used to bind to other languages, so while this may not be the most idiomatic thing to do in C, this ends up fitting our use case better.

lib/IR/DebugInfo.cpp

668 ↗

(On Diff #96208)

There is a facility to unwrap subclasses. You can see LLVMValueRef for how it is done. You shouldn't need to write this.

[harlanhaskins]

include/llvm-c/DebugInfo.h

65 ↗

(On Diff #96208)

This begs the question: Should it just call finalize itself?

106 ↗

(On Diff #96208)

This has been fixed in a later revision 👍

lib/IR/DebugInfo.cpp

668 ↗

(On Diff #96208)

Thanks! I was going off of the Rust implementation initially.

[harlanhaskins]

include/llvm-c/DebugInfo.h

90 ↗

(On Diff #96208)

I'll be completely honest here, this has stumped me for a while. I don't think there's even a facility within the wrappers to create a "split skeleton" compile unit...

[aprantl]

include/llvm-c/DebugInfo.h

10 ↗

(On Diff #96213)

Can you doxygenify this comment, too?

52 ↗

(On Diff #96213)

We have autobrief enabled in the doxygen configuration. Please don't use \brief any more.

[aprantl]

Could you also add some unit tests for the new interface?

[Wallbraker]

Hey cool that you are doing this work, finally!

See inline comments (also click the done tag on the comments when those are fixed, please).

Regarding the tests, only since this API is only about creating debug info I'm okay with just a creation test, this API already have a special status.

include/llvm-c/DebugInfo.h

106 ↗

(On Diff #96208)

Please use size_t for the the string sizes, no need to go to 64bit on 32bit systems.

[harlanhaskins]

• Fix 80-column limit for LLVMDWARFSourceLanguage
• Address comments

[harlanhaskins]

• uint64_t -> size_t for string lengths

[harlanhaskins]

• Add simple debuginfo tests

[harlanhaskins]

• Fix unused variable warning

[deadalnix]

This is looking good and I like where this is going. I have a few nits in comments.

Where I'm more doubtful is for the test. The way we've tested the C API in the past is by reading a module and then re-emiting a clone of it on the output. This patch doesn't have the ability to read debug infos, so that's a bit compromised. One way forward is obviously to add reading support for the elements we add emission support from. I'm not sure how much work that would be, so I'm not sure how practical this is within the scope of that diff. If that's too hard then an alternative should be chosen, like emitting a given module and checking its output. This is where this patch is going, however, it doesn't looks like this patch actually checks the output so that's a problem.

include/llvm-c/DebugInfo.h

30 ↗

(On Diff #99612)

These id needs to persist across versions, and this is not ensuring this. You can look at other enums in Core.h to see how it is done. The basic idea is to list all the enum values here, and then use the macro option to generate the mapping between exposed values and internal llvm values.

57 ↗

(On Diff #99612)

Please use LLVMBool

108 ↗

(On Diff #99612)

LLVMBool for flags.

[whitequark]

include/llvm-c/DebugInfo.h

103 ↗

(On Diff #99612)

size_t ProducerLen

104 ↗

(On Diff #99612)

LLVMBool IsOptimized

107 ↗

(On Diff #99612)

Are these last two also booleans? LLVMBool too then

128 ↗

(On Diff #99612)

What's the value for "line/column not available"?

lib/IR/DebugInfo.cpp

708 ↗

(On Diff #99612)

Ditto

709 ↗

(On Diff #99612)

LLVMBool IsOptimized

[aprantl]

(Having unit tests will avoid

include/llvm-c/DebugInfo.h

128 ↗

(On Diff #99612)

Compiler-generated locations (which are different from empty locations) are using line 0.

[harlanhaskins]

• uint8_t -> LLVMBool for flags
• ProducerLen should be size_t

[harlanhaskins]

include/llvm-c/DebugInfo.h

128 ↗

(On Diff #99612)

Should this be documented?

[harlanhaskins]

• Fix 80-column limit for LLVMDWARFSourceLanguage
• Address comments
• uint64_t -> size_t for string lengths
• Add simple debuginfo tests
• Fix unused variable warning
• uint8_t -> LLVMBool for flags
• ProducerLen should be size_t
• Add test and update CMakeLists to build debuginfo.c

[whitequark]

include/llvm-c/DebugInfo.h

50 ↗

(On Diff #101308)

Why is LLVMDebugMetadataVersion returning uint32_t and LLVMGetModuleDebugMetadataVersion returning unsigned?

[harlanhaskins]

include/llvm-c/DebugInfo.h

50 ↗

(On Diff #101308)

Just because of the types of the things they call into. Should they both be unsigned?

[deadalnix]

include/llvm-c/DebugInfo.h

50 ↗

(On Diff #101308)

I think it is better to use well defined types in the C API, so other language are not exposed to the C madness where nobody knows what an integral really is. It wasn't done consistently in the API in the past, but I think this is a good habit we should take.

[whitequark]

include/llvm-c/DebugInfo.h

50 ↗

(On Diff #101308)

That works

50 ↗

(On Diff #101308)

I disagree. Anyone building a binding already has to know what unsigned is, and using uint32_t here just makes it easier to accidentally break ABI.

[deadalnix]

include/llvm-c/DebugInfo.h

50 ↗

(On Diff #101308)

Can you elaborate ?

[whitequark]

include/llvm-c/DebugInfo.h

50 ↗

(On Diff #101308)

The C API uses unsigned practically everywhere, and that's not changing, so anything that binds to it will have to know what ABI width unsigned has. And having some functions use unsigned and some uint32_t for parameters that have the same underlying semantics is just a recipe for a footgun when going between 32 and 64-bit builds...

[deadalnix]

include/llvm-c/DebugInfo.h

50 ↗

(On Diff #101308)

This 32 bits on windows, linux and OSX both in 32bits build and 64bits builds. It is 64bits on solaris and some other obscures UNIXes. I think it's very much worth it moving everything to uint32_t (unless we have a lot of solaris 64bits users of the C API).

[whitequark]

include/llvm-c/DebugInfo.h

50 ↗

(On Diff #101308)

1. This should be done in a separate patch.
2. I am not as convinced as you that it is completely safe and I think this should be discussed on ML. This has the potential to screw binding authors quite badly if it turns out that they *do* indeed have to support those systems.

[deadalnix]

include/llvm-c/DebugInfo.h

50 ↗

(On Diff #101308)

I won't block the diff for this. unsigned it is then.

[harlanhaskins]

• Fix 80-column limit for LLVMDWARFSourceLanguage
• Address comments
• uint64_t -> size_t for string lengths
• Add simple debuginfo tests
• Fix unused variable warning
• uint8_t -> LLVMBool for flags
• ProducerLen should be size_t
• Add test and update CMakeLists to build debuginfo.c
• Fix test
• Use unsigned instead of explicitly sized unsigned integer types

[harlanhaskins]

include/llvm-c/DebugInfo.h

128 ↗

(On Diff #99612)

Really, the question is what _is_ the canonical value? Should we explicitly state 0 for line/column in the documentation or let implementers decide their sentinels?

[deadalnix]

I have one more comment. It's looking good.

include/llvm-c/DebugInfo.h

30 ↗

(On Diff #103521)

These 2 needs to have stable values. You can look in Core.h how it is done for instruction types for instance.

[harlanhaskins]

include/llvm-c/DebugInfo.h

30 ↗

(On Diff #103521)

I'm still unsure about this. Should they mirror the values defined in DINode::DIFlags? What happens if that gains or loses a case? What happens if their raw bit mask values change?

[echristo]

include/llvm-c/DebugInfo.h

128 ↗

(On Diff #99612)

From the dwarf standard:
"The compiler may emit the value 0 in cases where
an instruction cannot be attributed to any source
line."
So yes, that's the canonical "I have no idea where this is" value.

[harlanhaskins]

include/llvm-c/DebugInfo.h

128 ↗

(On Diff #99612)

Thank you! Alright, I'll add that to the comment..

[harlanhaskins]

• Add comment explaining 0 for debug locations

[deadalnix]

include/llvm-c/DebugInfo.h

30 ↗

(On Diff #103521)

The way it is done in the C API is that you make the enum in C without using macro codegen. Then you write a function that internally map the C enum value to the C++ enum value. To do so, it uses a switch which cases are generated with the macro codegen technique. The the API implementation uses this function internally.

See https://reviews.llvm.org/diffusion/L/browse/llvm/trunk/lib/IR/Core.cpp;306068$1085-1103

[CodaFi]

include/llvm-c/DebugInfo.h

30 ↗

(On Diff #103521)

Are you sure this is a good idea? For the other enums, this makes sense because they have values that aren't subject to change and have a manageable set of cases (less than 20). DWARF is going to continue to evolve over the years and LLVM's coverage of the API includes 96 tags and 200+ attributes, each of which needs to be handled by the requested mapping functions. This doesn't seem like a reasonable thing to try to maintain by hand.

[harlanhaskins]

• Added explicit enum definitions for C API DWARF values (Change made by @CodaFi)

[whitequark]

LGTM. @deadalnix?

[aprantl]

include/llvm-c/DebugInfo.h

30 ↗

(On Diff #103521)

I get that we don't want macros in the installed header files to make it easier for FFIs and other interface generators, but why can't we run the preprocessor on the file as a custom build step?

[harlanhaskins]

@whitequark Think this is good to merge in its current state? I have another patch for more functions Moreno or less ready to go once this is in.

include/llvm-c/DebugInfo.h

30 ↗

(On Diff #103521)

So I've updated this revision to explicitly lay out these enums and provide a mapping. Thoughts, @deadalnix?

[whitequark]

Sure, go ahead and commit.

[harlanhaskins]

I don't have commit access -- would you mind merging it, @whitequark?

[whitequark]

Please rebase the patch, it doesn't apply as-is.

[harlanhaskins]

wq - Fix 80-column limit for LLVMDWARFSourceLanguage

• Address comments
• uint64_t -> size_t for string lengths
• Add simple debuginfo tests
• Fix unused variable warning
• uint8_t -> LLVMBool for flags
• ProducerLen should be size_t
• Add test and update CMakeLists to build debuginfo.c
• Fix test
• Use unsigned instead of explicitly sized unsigned integer types
• Add comment explaining 0 for debug locations
• Expand enum definitions and translate to DI (#1)

[harlanhaskins]

Changes rebased on master.

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

+//===------------ DebugInfo.h - LLVM C API Debug Info API -----------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+///
+/// This file declares the C API endpoints for generating DWARF Debug Info
+///
+/// Note: This interface is experimental. It is *NOT* stable, and may be
+///       changed without warning.
+///
+//===----------------------------------------------------------------------===//
+
+#include "llvm-c/Core.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/// Debug info flags.
+typedef enum {
+  LLVMDIFlagZero = 0,
+  LLVMDIFlagPrivate = 1,
+  LLVMDIFlagProtected = 2,
+  LLVMDIFlagPublic = 3,
+  LLVMDIFlagFwdDecl = 1 << 2,
+  LLVMDIFlagAppleBlock = 1 << 3,
+  LLVMDIFlagBlockByrefStruct = 1 << 4,
+  LLVMDIFlagVirtual = 1 << 5,
+  LLVMDIFlagArtificial = 1 << 6,
+  LLVMDIFlagExplicit = 1 << 7,
+  LLVMDIFlagPrototyped = 1 << 8,
+  LLVMDIFlagObjcClassComplete = 1 << 9,
+  LLVMDIFlagObjectPointer = 1 << 10,
+  LLVMDIFlagVector = 1 << 11,
+  LLVMDIFlagStaticMember = 1 << 12,
+  LLVMDIFlagLValueReference = 1 << 13,
+  LLVMDIFlagRValueReference = 1 << 14,
+  LLVMDIFlagReserved = 1 << 15,
+  LLVMDIFlagSingleInheritance = 1 << 16,
+  LLVMDIFlagMultipleInheritance = 2 << 16,
+  LLVMDIFlagVirtualInheritance = 3 << 16,
+  LLVMDIFlagIntroducedVirtual = 1 << 18,
+  LLVMDIFlagBitField = 1 << 19,
+  LLVMDIFlagNoReturn = 1 << 20,
+  LLVMDIFlagMainSubprogram = 1 << 21,
+  LLVMDIFlagIndirectVirtualBase = (1 << 2) | (1 << 5),
+  LLVMDIFlagAccessibility = LLVMDIFlagPrivate | LLVMDIFlagProtected |
+                            LLVMDIFlagPublic,
+  LLVMDIFlagPtrToMemberRep = LLVMDIFlagSingleInheritance |
+                             LLVMDIFlagMultipleInheritance |
+                             LLVMDIFlagVirtualInheritance
+} LLVMDIFlags;
+
+/// Source languages known by DWARF.
+typedef enum {
+  LLVMDWARFSourceLanguageC89,
+  LLVMDWARFSourceLanguageC,
+  LLVMDWARFSourceLanguageAda83,
+  LLVMDWARFSourceLanguageC_plus_plus,
+  LLVMDWARFSourceLanguageCobol74,
+  LLVMDWARFSourceLanguageCobol85,
+  LLVMDWARFSourceLanguageFortran77,
+  LLVMDWARFSourceLanguageFortran90,
+  LLVMDWARFSourceLanguagePascal83,
+  LLVMDWARFSourceLanguageModula2,
+  // New in DWARF v3:
+  LLVMDWARFSourceLanguageJava,
+  LLVMDWARFSourceLanguageC99,
+  LLVMDWARFSourceLanguageAda95,
+  LLVMDWARFSourceLanguageFortran95,
+  LLVMDWARFSourceLanguagePLI,
+  LLVMDWARFSourceLanguageObjC,
+  LLVMDWARFSourceLanguageObjC_plus_plus,
+  LLVMDWARFSourceLanguageUPC,
+  LLVMDWARFSourceLanguageD,
+  // New in DWARF v4:
+  LLVMDWARFSourceLanguagePython,
+  // New in DWARF v5:
+  LLVMDWARFSourceLanguageOpenCL,
+  LLVMDWARFSourceLanguageGo,
+  LLVMDWARFSourceLanguageModula3,
+  LLVMDWARFSourceLanguageHaskell,
+  LLVMDWARFSourceLanguageC_plus_plus_03,
+  LLVMDWARFSourceLanguageC_plus_plus_11,
+  LLVMDWARFSourceLanguageOCaml,
+  LLVMDWARFSourceLanguageRust,
+  LLVMDWARFSourceLanguageC11,
+  LLVMDWARFSourceLanguageSwift,
+  LLVMDWARFSourceLanguageJulia,
+  LLVMDWARFSourceLanguageDylan,
+  LLVMDWARFSourceLanguageC_plus_plus_14,
+  LLVMDWARFSourceLanguageFortran03,
+  LLVMDWARFSourceLanguageFortran08,
+  LLVMDWARFSourceLanguageRenderScript,
+  LLVMDWARFSourceLanguageBLISS,
+  // Vendor extensions:
+  LLVMDWARFSourceLanguageMips_Assembler,
+  LLVMDWARFSourceLanguageGOOGLE_RenderScript,
+  LLVMDWARFSourceLanguageBORLAND_Delphi
+} LLVMDWARFSourceLanguage;
+
+/// The amount of debug information to emit.
+typedef enum {
+    LLVMDWARFEmissionNone = 0,
+    LLVMDWARFEmissionFull,
+    LLVMDWARFEmissionLineTablesOnly
+} LLVMDWARFEmissionKind;
+
+/// The current debug metadata version number.
+unsigned LLVMDebugMetadataVersion(void);
+
+/// The version of debug metadata that's present in the provided \c Module.
+unsigned LLVMGetModuleDebugMetadataVersion(LLVMModuleRef Module);
+
+/// Strip debug info in the module if it exists.
+///
+/// To do this, we remove all calls to the debugger intrinsics and any named
+/// metadata for debugging. We also remove debug locations for instructions.
+/// Return true if module is modified.
+LLVMBool LLVMStripModuleDebugInfo(LLVMModuleRef Module);
+
+/// Construct a builder for a module, and do not allow for unresolved nodes
+/// attached to the module.
+LLVMDIBuilderRef LLVMCreateDIBuilderDisallowUnresolved(LLVMModuleRef M);
+
+/// Construct a builder for a module and collect unresolved nodes attached
+/// to the module in order to resolve cycles during a call to
+/// \c LLVMDIBuilderFinalize.
+LLVMDIBuilderRef LLVMCreateDIBuilder(LLVMModuleRef M);
+
+/// Deallocates the DIBuilder and everything it owns.
+/// @note You must call \c LLVMDIBuilderFinalize before this
+void LLVMDisposeDIBuilder(LLVMDIBuilderRef Builder);
+
+/// Construct any deferred debug info descriptors.
+void LLVMDIBuilderFinalize(LLVMDIBuilderRef Builder);
+
+/// A CompileUnit provides an anchor for all debugging
+/// information generated during this instance of compilation.
+/// \param Lang          Source programming language, eg.
+///                      \c LLVMDWARFSourceLanguageC99
+/// \param File          File info.
+/// \param Producer      Identify the producer of debugging information
+///                      and code.  Usually this is a compiler
+///                      version string.
+/// \param ProducerLen   The length of the C string passed to \c Producer.
+/// \param isOptimized   A boolean flag which indicates whether optimization
+///                      is enabled or not.
+/// \param Flags         This string lists command line options. This
+///                      string is directly embedded in debug info
+///                      output which may be used by a tool
+///                      analyzing generated debugging information.
+/// \param FlagsLen      The length of the C string passed to \c Flags.
+/// \param RuntimeVer    This indicates runtime version for languages like
+///                      Objective-C.
+/// \param SplitName     The name of the file that we'll split debug info
+///                      out into.
+/// \param SplitNameLen  The length of the C string passed to \c SplitName.
+/// \param Kind          The kind of debug information to generate.
+/// \param DWOId         The DWOId if this is a split skeleton compile unit.
+/// \param SplitDebugInlining    Whether to emit inline debug info.
+/// \param DebugInfoForProfiling Whether to emit extra debug info for
+///                              profile collection.
+LLVMMetadataRef LLVMDIBuilderCreateCompileUnit(
+    LLVMDIBuilderRef Builder, LLVMDWARFSourceLanguage Lang,
+    LLVMMetadataRef FileRef, const char *Producer, size_t ProducerLen,
+    LLVMBool isOptimized, const char *Flags, size_t FlagsLen,
+    unsigned RuntimeVer, const char *SplitName, size_t SplitNameLen,
+    LLVMDWARFEmissionKind Kind, unsigned DWOId, LLVMBool SplitDebugInlining,
+    LLVMBool DebugInfoForProfiling);
+
+/// Create a file descriptor to hold debugging information for a file.
+/// \param Builder      The DIBuilder.
+/// \param Filename     File name.
+/// \param FilenameLen  The length of the C string passed to \c Filename.
+/// \param Directory    Directory.
+/// \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);
+
+/// 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.
+LLVMMetadataRef
+LLVMDIBuilderCreateDebugLocation(LLVMContextRef Ctx, unsigned Line,
+                                 unsigned Column, LLVMMetadataRef Scope,
+                                 LLVMMetadataRef InlinedAt);
+
+#ifdef __cplusplus
+} // end extern "C"
+#endif

llvm/trunk/lib/IR/DebugInfo.cpp

 //===- DebugInfo.cpp - Debug Information Helper Classes -------------------===//
 //
 //                     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 helper classes used to build and interpret debug
 // information in LLVM IR form.
 //
 //===----------------------------------------------------------------------===//
 
-#include "llvm/IR/DebugInfo.h"
+#include "llvm-c/DebugInfo.h"
+#include "LLVMContextImpl.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/None.h"
+#include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/IR/BasicBlock.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/DebugInfoMetadata.h"
 #include "llvm/IR/DebugLoc.h"
+#include "llvm/IR/DebugInfo.h"
+#include "llvm/IR/DIBuilder.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/GVMaterializer.h"
 #include "llvm/IR/Instruction.h"
 #include "llvm/IR/IntrinsicInst.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Metadata.h"
 #include "llvm/IR/Module.h"
 #include "llvm/Support/Casting.h"
void Instruction::applyMergedLocation(const DILocation *LocA,
   for (DILocation *L = LocB->getInlinedAt(); L; L = L->getInlinedAt()) {
     Result = L;
     if (InlinedLocationsA.count(L))
       break;
   }
   setDebugLoc(DILocation::get(
       Result->getContext(), 0, 0, Result->getScope(), Result->getInlinedAt()));
 }
+
+//===----------------------------------------------------------------------===//
+// LLVM C API implementations.
+//===----------------------------------------------------------------------===//
+
+static unsigned map_from_llvmDWARFsourcelanguage(LLVMDWARFSourceLanguage lang) {
+  switch (lang) {
+#define HANDLE_DW_LANG(ID, NAME, VERSION, VENDOR) \
+case LLVMDWARFSourceLanguage##NAME: return ID;
+#include "llvm/BinaryFormat/Dwarf.def"
+#undef HANDLE_DW_LANG
+  }
+  llvm_unreachable("Unhandled Tag");
+}
+
+unsigned LLVMDebugMetadataVersion() {
+  return DEBUG_METADATA_VERSION;
+}
+
+LLVMDIBuilderRef LLVMCreateDIBuilderDisallowUnresolved(LLVMModuleRef M) {
+  return wrap(new DIBuilder(*unwrap(M), false));
+}
+
+LLVMDIBuilderRef LLVMCreateDIBuilder(LLVMModuleRef M) {
+  return wrap(new DIBuilder(*unwrap(M)));
+}
+
+unsigned LLVMGetModuleDebugMetadataVersion(LLVMModuleRef M) {
+  return getDebugMetadataVersionFromModule(*unwrap(M));
+}
+
+LLVMBool LLVMStripModuleDebugInfo(LLVMModuleRef M) {
+  return StripDebugInfo(*unwrap(M));
+}
+
+void LLVMDisposeDIBuilder(LLVMDIBuilderRef Builder) {
+  delete unwrap(Builder);
+}
+
+void LLVMDIBuilderFinalize(LLVMDIBuilderRef Builder) {
+  unwrap(Builder)->finalize();
+}
+
+LLVMMetadataRef LLVMDIBuilderCreateCompileUnit(
+    LLVMDIBuilderRef Builder, LLVMDWARFSourceLanguage Lang,
+    LLVMMetadataRef FileRef, const char *Producer, size_t ProducerLen,
+    LLVMBool isOptimized, const char *Flags, size_t FlagsLen,
+    unsigned RuntimeVer, const char *SplitName, size_t SplitNameLen,
+    LLVMDWARFEmissionKind Kind, unsigned DWOId, LLVMBool SplitDebugInlining,
+    LLVMBool DebugInfoForProfiling) {
+  auto File = unwrap<DIFile>(FileRef);
+
+  return wrap(unwrap(Builder)->createCompileUnit(
+                 map_from_llvmDWARFsourcelanguage(Lang), File,
+                 StringRef(Producer, ProducerLen), isOptimized,
+                 StringRef(Flags, FlagsLen), RuntimeVer,
+                 StringRef(SplitName, SplitNameLen),
+                 static_cast<DICompileUnit::DebugEmissionKind>(Kind), DWOId,
+                 SplitDebugInlining, DebugInfoForProfiling));
+}
+
+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
+LLVMDIBuilderCreateDebugLocation(LLVMContextRef Ctx, unsigned Line,
+                                 unsigned Column, LLVMMetadataRef Scope,
+                                 LLVMMetadataRef InlinedAt) {
+  return wrap(DILocation::get(*unwrap(Ctx), Line, Column, unwrap(Scope),
+                              unwrap(InlinedAt)));
+}

llvm/trunk/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: !llvm.dbg.cu = !{!0}
+; CHECK: !0 = distinct !DICompileUnit(language: DW_LANG_C, file: !1, producer: "llvm-c-test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, splitDebugInlining: false)
+; CHECK-NEXT: !1 = !DIFile(filename: "debuginfo.c\00", directory: ".")

llvm/trunk/tools/llvm-c-test/CMakeLists.txt

 
 if (LLVM_COMPILER_IS_GCC_COMPATIBLE)
   set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -std=gnu99 -Wstrict-prototypes")
 endif ()
 
 add_llvm_tool(llvm-c-test
   attributes.c
   calc.c
+  debuginfo.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/debuginfo.c

+/*===-- debuginfo.c - 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.                                      *|
+|*                                                                            *|
+|*===----------------------------------------------------------------------===*|
+|*                                                                            *|
+|* Tests for the LLVM C DebugInfo API                                         *|
+|*                                                                            *|
+\*===----------------------------------------------------------------------===*/
+
+#include "llvm-c-test.h"
+#include "llvm-c/DebugInfo.h"
+#include <string.h>
+#include <stdio.h>
+
+int llvm_test_dibuilder() {
+  LLVMModuleRef M = LLVMModuleCreateWithName("debuginfo.c");
+  LLVMDIBuilderRef DIB = LLVMCreateDIBuilder(M);
+
+  LLVMMetadataRef File = LLVMDIBuilderCreateFile(DIB, "debuginfo.c", 12,
+                                                 ".", 1);
+
+  LLVMDIBuilderCreateCompileUnit(DIB,
+      LLVMDWARFSourceLanguageC, File,"llvm-c-test", 11, 0, NULL, 0, 0,
+      NULL, 0, LLVMDWARFEmissionFull, 0, 0, 0);
+
+  char *MStr = LLVMPrintModuleToString(M);
+  puts(MStr);
+  LLVMDisposeMessage(MStr);
+
+  LLVMDisposeDIBuilder(DIB);
+  LLVMDisposeModule(M);
+
+  return 0;
+}

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

 int llvm_module_list_globals(void);
 
 // calc.c
 int llvm_calc(void);
 
 // disassemble.c
 int llvm_disassemble(void);
 
+// debuginfo.c
+int llvm_test_dibuilder(void);
+
 // metadata.c
 int llvm_add_named_metadata_operand(void);
 int llvm_set_metadata(void);
 
 // object.c
 int llvm_object_list_sections(void);
 int llvm_object_list_symbols(void);
 

llvm/trunk/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-dibuilder\n");
+  fprintf(stderr,
+          "    Run tests for the DIBuilder C API - print generated module\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], "--test-function-attributes")) {
     return llvm_test_function_attributes();
   } else if (argc == 2 && !strcmp(argv[1], "--test-callsite-attributes")) {
     return llvm_test_callsite_attributes();
   } 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-dibuilder")) {
+    return llvm_test_dibuilder();
   } else {
     print_usage();
   }
 
   return 1;
 }