Introducing LLVMMetadataRef

[deadalnix]

Summary

This seems like an uncontroversial first step toward providing access to the metadata hierarchy that now exists in LLVM. This should allow for good debug info support from C.

Future plans are to deprecate API that take mixed bags of values and metadata (mainly the LLVMMDNode family of functions) and migrate the rest toward the use of LLVMMetadataRef.

Once this is in place, mapping of DIBuilder will be able to start.

[Wallbraker]

So they are completely redoing[1] the debug info interface which this is a precursor for, so I dunno how much benefit this will give us right now.

I do like this commit otherwise, some small nitpicks.

[1] http://lists.llvm.org/pipermail/llvm-dev/2016-March/097773.html

include/llvm/IR/Value.h

793 ↗

(On Diff #54754)

Unrelated NFC.

lib/IR/Core.cpp

770 ↗

(On Diff #54754)

Unrelated NFC.

818 ↗

(On Diff #54754)

Shouldn't we do a similar smart unwrap that we do with ValueAsMetadata, turning constants into real constants?

[deadalnix]

lib/IR/Core.cpp

818 ↗

(On Diff #54754)

This is unwrapping constants internally already.

[deadalnix]

Remove NFC changes.

[Wallbraker]

Looks good to me!

[Eugene.Zelenko]

Looks like patch was not committed.

[deadalnix]

No because what comes next was unclear. The good new is that I'll have more time to work on that soon, so you should see progress again.

[deadalnix]

Rebase

llvm/trunk/bindings/go/llvm/IRBindings.h

 #endif
 
 #include <stdint.h>
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-typedef struct LLVMOpaqueMetadata *LLVMMetadataRef;
 struct LLVMDebugLocMetadata{
     unsigned Line;
     unsigned Col;
     LLVMMetadataRef Scope;
     LLVMMetadataRef InlinedAt;
 };
 
 LLVMMetadataRef LLVMConstantAsMetadata(LLVMValueRef Val);

 
 struct LLVMDebugLocMetadata LLVMGetCurrentDebugLocation2(LLVMBuilderRef Bref);
 
 void LLVMSetSubprogram(LLVMValueRef Fn, LLVMMetadataRef SP);
 
 #ifdef __cplusplus
 }
 
-namespace llvm {
-
-DEFINE_ISA_CONVERSION_FUNCTIONS(Metadata, LLVMMetadataRef)
-
-inline Metadata **unwrap(LLVMMetadataRef *Vals) {
-  return reinterpret_cast<Metadata**>(Vals);
-}
-
-}
-
 #endif
 
 #endif

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

LLVMValueRef LLVMMDNodeInContext(LLVMContextRef C, LLVMValueRef *Vals,
                                  unsigned Count);
 
 /**
  * Obtain a MDNode value from the global context.
  */
 LLVMValueRef LLVMMDNode(LLVMValueRef *Vals, unsigned Count);
 
 /**
+ * Obtain a Metadata as a Value.
+ */
+LLVMValueRef LLVMMetadataAsValue(LLVMContextRef C, LLVMMetadataRef MD);
+
+/**
+ * Obtain a Value as a Metadata.
+ */
+LLVMMetadataRef LLVMValueAsMetadata(LLVMValueRef Val);
+
+/**
  * Obtain the underlying string from a MDString value.
  *
  * @param V Instance to obtain string from.
  * @param Length Memory address which will hold length of returned string.
  * @return String data in MDString.
  */
 const char *LLVMGetMDString(LLVMValueRef V, unsigned *Length);
 

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

 /**
  * Represents a basic block of instructions in LLVM IR.
  *
  * This models llvm::BasicBlock.
  */
 typedef struct LLVMOpaqueBasicBlock *LLVMBasicBlockRef;
 
 /**
+ * Represents an LLVM Metadata.
+ *
+ * This models llvm::Metadata.
+ */
+typedef struct LLVMOpaqueMetadata *LLVMMetadataRef;
+
+/**
  * Represents an LLVM basic block builder.
  *
  * This models llvm::IRBuilder.
  */
 typedef struct LLVMOpaqueBuilder *LLVMBuilderRef;
 
 /**
  * Interface used to provide a module to JIT or interpreter.

llvm/trunk/include/llvm/IR/Metadata.h

 #include "llvm/ADT/PointerUnion.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/IR/Constant.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Value.h"
 #include "llvm/Support/Casting.h"
+#include "llvm/Support/CBindingWrapping.h"
 #include "llvm/Support/ErrorHandling.h"
 #include <cassert>
 #include <cstddef>
 #include <cstdint>
 #include <iterator>
 #include <memory>
 #include <string>
 #include <type_traits>
public:
   /// otherwise, pointer addresses are substituted.
   /// @{
   void printAsOperand(raw_ostream &OS, const Module *M = nullptr) const;
   void printAsOperand(raw_ostream &OS, ModuleSlotTracker &MST,
                       const Module *M = nullptr) const;
   /// @}
 };
 
+// Create wrappers for C Binding types (see CBindingWrapping.h).
+DEFINE_ISA_CONVERSION_FUNCTIONS(Metadata, LLVMMetadataRef)
+
+// Specialized opaque metadata conversions.
+inline Metadata **unwrap(LLVMMetadataRef *MDs) {
+  return reinterpret_cast<Metadata**>(MDs);
+}
+
 #define HANDLE_METADATA(CLASS) class CLASS;
 #include "llvm/IR/Metadata.def"
 
 // Provide specializations of isa so that we don't need definitions of
 // subclasses to see if the metadata is a subclass.
 #define HANDLE_METADATA_LEAF(CLASS)                                            \
   template <> struct isa_impl<CLASS, Metadata> {                               \
     static inline bool doit(const Metadata &MD) {                              \

llvm/trunk/lib/IR/Core.cpp

LLVMValueRef LLVMMDNodeInContext(LLVMContextRef C, LLVMValueRef *Vals,
   }
   return wrap(MetadataAsValue::get(Context, MDNode::get(Context, MDs)));
 }
 
 LLVMValueRef LLVMMDNode(LLVMValueRef *Vals, unsigned Count) {
   return LLVMMDNodeInContext(LLVMGetGlobalContext(), Vals, Count);
 }
 
+LLVMValueRef LLVMMetadataAsValue(LLVMContextRef C, LLVMMetadataRef MD) {
+  return wrap(MetadataAsValue::get(*unwrap(C), unwrap(MD)));
+}
+
+LLVMMetadataRef LLVMValueAsMetadata(LLVMValueRef Val) {
+  auto *V = unwrap(Val);
+  if (auto *C = dyn_cast<Constant>(V))
+    return wrap(ConstantAsMetadata::get(C));
+  if (auto *MAV = dyn_cast<MetadataAsValue>(V))
+    return wrap(MAV->getMetadata());
+  return wrap(ValueAsMetadata::get(V));
+}
+
 const char *LLVMGetMDString(LLVMValueRef V, unsigned *Length) {
   if (const auto *MD = dyn_cast<MetadataAsValue>(unwrap(V)))
     if (const MDString *S = dyn_cast<MDString>(MD->getMetadata())) {
       *Length = S->getString().size();
       return S->getString().data();
     }
   *Length = 0;
   return nullptr;