[LLVM-C] [bindings/go] Add C and Golang bindings for COMDAT

[chandlerc]

Adding Peter who is probably in a good position to review here.

[rnk]

One issue, looks good otherwise. I don't know Go but it seems straightforward.

include/llvm-c/Comdat.h

24

These should probably have explicit enumerator values so that they do not change over time.

[ben-clayton]

include/llvm-c/Comdat.h

24

Happy to change, but I'd like to understand the reasoning for keeping the enum values immutable. In Comdat.cpp we map these values to the C++ equivalents, so from at least the LLVM perspective there's no problem with the values changing over time. Are we expecting other languages to hardcode the constants instead of using this C enum?

[rnk]

include/llvm-c/Comdat.h

24

I guess we could leave it alone. llvm-c/Core.h uses both numbered and unnumbered enums. It looks like when enumerators are removed, in practice people do transition the enum to something explicitly numbered. I guess the lesson is that maybe we can trust people to be careful when editing these enums, in which case, unnumbered is fine.

[ben-clayton]

Ack.
Thank you for your review!

[ben-clayton]

I do not have privileges to commit the patch myself.
Would someone be so kind?

bindings/go/llvm/ir.go

 // This file defines bindings for the ir component.
 //
 //===----------------------------------------------------------------------===//
 
 package llvm
 
 /*
 #include "llvm-c/Core.h"
+#include "llvm-c/Comdat.h"
 #include "IRBindings.h"
 #include <stdlib.h>
 */
 import "C"
 import "unsafe"
 import "errors"
 
 type (
   // We use these weird structs here because *Ref types are pointers and
   // Go's spec says that a pointer cannot be used as a receiver base type.
   Context struct {
     C C.LLVMContextRef
   }
   Module struct {
     C C.LLVMModuleRef
   }
   Type struct {
     C C.LLVMTypeRef
   }
   Value struct {
     C C.LLVMValueRef
   }
+  Comdat struct {
+    C C.LLVMComdatRef
+  }
   BasicBlock struct {
     C C.LLVMBasicBlockRef
   }
   Builder struct {
     C C.LLVMBuilderRef
   }
   ModuleProvider struct {
     C C.LLVMModuleProviderRef
   }
   MemoryBuffer struct {
     C C.LLVMMemoryBufferRef
   }
   PassManager struct {
     C C.LLVMPassManagerRef
   }
   Use struct {
     C C.LLVMUseRef
   }
   Metadata struct {
     C C.LLVMMetadataRef
   }
   Attribute struct {
     C C.LLVMAttributeRef
   }
-  Opcode           C.LLVMOpcode
-  TypeKind         C.LLVMTypeKind
-  Linkage          C.LLVMLinkage
-  Visibility       C.LLVMVisibility
-  CallConv         C.LLVMCallConv
-  IntPredicate     C.LLVMIntPredicate
-  FloatPredicate   C.LLVMRealPredicate
-  LandingPadClause C.LLVMLandingPadClauseTy
+  Opcode              C.LLVMOpcode
+  TypeKind            C.LLVMTypeKind
+  Linkage             C.LLVMLinkage
+  Visibility          C.LLVMVisibility
+  CallConv            C.LLVMCallConv
+  ComdatSelectionKind C.LLVMComdatSelectionKind
+  IntPredicate        C.LLVMIntPredicate
+  FloatPredicate      C.LLVMRealPredicate
+  LandingPadClause    C.LLVMLandingPadClauseTy
 )
 
 func (c Context) IsNil() bool        { return c.C == nil }
 func (c Module) IsNil() bool         { return c.C == nil }
 func (c Type) IsNil() bool           { return c.C == nil }
 func (c Value) IsNil() bool          { return c.C == nil }
 func (c BasicBlock) IsNil() bool     { return c.C == nil }
 func (c Builder) IsNil() bool        { return c.C == nil }
const (
   CCallConv           CallConv = C.LLVMCCallConv
   FastCallConv        CallConv = C.LLVMFastCallConv
   ColdCallConv        CallConv = C.LLVMColdCallConv
   X86StdcallCallConv  CallConv = C.LLVMX86StdcallCallConv
   X86FastcallCallConv CallConv = C.LLVMX86FastcallCallConv
 )
 
 //-------------------------------------------------------------------------
+// llvm.ComdatSelectionKind
+//-------------------------------------------------------------------------
+
+const (
+  AnyComdatSelectionKind          ComdatSelectionKind = C.LLVMAnyComdatSelectionKind
+  ExactMatchComdatSelectionKind   ComdatSelectionKind = C.LLVMExactMatchComdatSelectionKind
+  LargestComdatSelectionKind      ComdatSelectionKind = C.LLVMLargestComdatSelectionKind
+  NoDuplicatesComdatSelectionKind ComdatSelectionKind = C.LLVMNoDuplicatesComdatSelectionKind
+  SameSizeComdatSelectionKind     ComdatSelectionKind = C.LLVMSameSizeComdatSelectionKind
+)
+
+//-------------------------------------------------------------------------
 // llvm.IntPredicate
 //-------------------------------------------------------------------------
 
 const (
   IntEQ  IntPredicate = C.LLVMIntEQ
   IntNE  IntPredicate = C.LLVMIntNE
   IntUGT IntPredicate = C.LLVMIntUGT
   IntUGE IntPredicate = C.LLVMIntUGE

 // Operations on aliases
 func AddAlias(m Module, t Type, aliasee Value, name string) (v Value) {
   cname := C.CString(name)
   defer C.free(unsafe.Pointer(cname))
   v.C = C.LLVMAddAlias(m.C, t.C, aliasee.C, cname)
   return
 }
 
+// Operations on comdat
+func (m Module) Comdat(name string) (c Comdat) {
+  cname := C.CString(name)
+  defer C.free(unsafe.Pointer(cname))
+  c.C = C.LLVMGetOrInsertComdat(m.C, cname)
+  return
+}
+
+func (v Value) Comdat() (c Comdat) { c.C = C.LLVMGetComdat(v.C); return }
+func (v Value) SetComdat(c Comdat) { C.LLVMSetComdat(v.C, c.C) }
+
+func (c Comdat) SelectionKind() ComdatSelectionKind {
+  return ComdatSelectionKind(C.LLVMGetComdatSelectionKind(c.C))
+}
+
+func (c Comdat) SetSelectionKind(k ComdatSelectionKind) {
+  C.LLVMSetComdatSelectionKind(c.C, (C.LLVMComdatSelectionKind)(k))
+}
+
 // Operations on functions
 func AddFunction(m Module, name string, ft Type) (v Value) {
   cname := C.CString(name)
   defer C.free(unsafe.Pointer(cname))
   v.C = C.LLVMAddFunction(m.C, cname, ft.C)
   return
 }
 

include/llvm-c/Comdat.h

+/*===-- llvm-c/Comdat.h - Module Comdat C Interface -------------*- C++ -*-===*\
+|*                                                                            *|
+|*                     The LLVM Compiler Infrastructure                       *|
+|*                                                                            *|
+|* This file is distributed under the University of Illinois Open Source      *|
+|* License. See LICENSE.TXT for details.                                      *|
+|*                                                                            *|
+|*===----------------------------------------------------------------------===*|
+|*                                                                            *|
+|* This file defines the C interface to COMDAT.                               *|
+|*                                                                            *|
+\*===----------------------------------------------------------------------===*/
+
+#ifndef LLVM_C_COMDAT_H
+#define LLVM_C_COMDAT_H
+
+#include "llvm-c/Types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef enum {
+  LLVMAnyComdatSelectionKind,        ///< The linker may choose any COMDAT.
+  LLVMExactMatchComdatSelectionKind, ///< The data referenced by the COMDAT must
+                                     ///< be the same.
+  LLVMLargestComdatSelectionKind,    ///< The linker will choose the largest
+                                     ///< COMDAT.
+  LLVMNoDuplicatesComdatSelectionKind, ///< No other Module may specify this
+                                       ///< COMDAT.
+  LLVMSameSizeComdatSelectionKind ///< The data referenced by the COMDAT must be
+                                  ///< the same size.
+} LLVMComdatSelectionKind;
+
+/**
+ * Return the Comdat in the module with the specified name. It is created
+ * if it didn't already exist.
+ *
+ * @see llvm::Module::getOrInsertComdat()
+ */
+LLVMComdatRef LLVMGetOrInsertComdat(LLVMModuleRef M, const char *Name);
+
+/**
+ * Get the Comdat assigned to the given global object.
+ *
+ * @see llvm::GlobalObject::getComdat()
+ */
+LLVMComdatRef LLVMGetComdat(LLVMValueRef V);
+
+/**
+ * Assign the Comdat to the given global object.
+ *
+ * @see llvm::GlobalObject::setComdat()
+ */
+void LLVMSetComdat(LLVMValueRef V, LLVMComdatRef C);
+
+/*
+ * Get the conflict resolution selection kind for the Comdat.
+ *
+ * @see llvm::Comdat::getSelectionKind()
+ */
+LLVMComdatSelectionKind LLVMGetComdatSelectionKind(LLVMComdatRef C);
+
+/*
+ * Set the conflict resolution selection kind for the Comdat.
+ *
+ * @see llvm::Comdat::setSelectionKind()
+ */
+void LLVMSetComdatSelectionKind(LLVMComdatRef C, LLVMComdatSelectionKind Kind);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

include/llvm-c/Types.h

 typedef struct LLVMOpaqueAttributeRef *LLVMAttributeRef;
 
 /**
  * @see llvm::DiagnosticInfo
  */
 typedef struct LLVMOpaqueDiagnosticInfo *LLVMDiagnosticInfoRef;
 
 /**
+ * @see llvm::Comdat
+ */
+typedef struct LLVMComdat *LLVMComdatRef;
+
+/**
  * @}
  */
 
 #ifdef __cplusplus
 }
 #endif
 
 #endif

include/llvm/IR/Comdat.h

 /// This file contains the declaration of the Comdat class, which represents a
 /// single COMDAT in LLVM.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_IR_COMDAT_H
 #define LLVM_IR_COMDAT_H
 
+#include "llvm-c/Types.h"
+#include "llvm/Support/CBindingWrapping.h"
+
 namespace llvm {
 
 class raw_ostream;
 class StringRef;
 template <typename ValueTy> class StringMapEntry;
 
 // This is a Name X SelectionKind pair. The reason for having this be an
 // independent object instead of just adding the name and the SelectionKind
private:
 
   Comdat();
 
   // Points to the map in Module.
   StringMapEntry<Comdat> *Name = nullptr;
   SelectionKind SK = Any;
 };
 
+// Create wrappers for C Binding types (see CBindingWrapping.h).
+DEFINE_SIMPLE_CONVERSION_FUNCTIONS(Comdat, LLVMComdatRef)
+
 inline raw_ostream &operator<<(raw_ostream &OS, const Comdat &C) {
   C.print(OS);
   return OS;
 }
 
 } // end namespace llvm
 
 #endif // LLVM_IR_COMDAT_H

lib/IR/Comdat.cpp

 //===- Comdat.cpp - Implement Metadata 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 Comdat class.
+// This file implements the Comdat class (including the C bindings).
 //
 //===----------------------------------------------------------------------===//
 
-#include "llvm/IR/Comdat.h"
+#include "llvm-c/Comdat.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringRef.h"
+#include "llvm/IR/Comdat.h"
+#include "llvm/IR/GlobalObject.h"
+#include "llvm/IR/Module.h"
 
 using namespace llvm;
 
 Comdat::Comdat(Comdat &&C) : Name(C.Name), SK(C.SK) {}
 
 Comdat::Comdat() = default;
 
 StringRef Comdat::getName() const { return Name->first(); }
+
+LLVMComdatRef LLVMGetOrInsertComdat(LLVMModuleRef M, const char *Name) {
+  return wrap(unwrap(M)->getOrInsertComdat(Name));
+}
+
+LLVMComdatRef LLVMGetComdat(LLVMValueRef V) {
+  GlobalObject *G = unwrap<GlobalObject>(V);
+  return wrap(G->getComdat());
+}
+
+void LLVMSetComdat(LLVMValueRef V, LLVMComdatRef C) {
+  GlobalObject *G = unwrap<GlobalObject>(V);
+  G->setComdat(unwrap(C));
+}
+
+LLVMComdatSelectionKind LLVMGetComdatSelectionKind(LLVMComdatRef C) {
+  switch (unwrap(C)->getSelectionKind()) {
+  case Comdat::Any:
+    return LLVMAnyComdatSelectionKind;
+  case Comdat::ExactMatch:
+    return LLVMExactMatchComdatSelectionKind;
+  case Comdat::Largest:
+    return LLVMLargestComdatSelectionKind;
+  case Comdat::NoDuplicates:
+    return LLVMNoDuplicatesComdatSelectionKind;
+  case Comdat::SameSize:
+    return LLVMSameSizeComdatSelectionKind;
+  }
+  llvm_unreachable("Invalid Comdat SelectionKind!");
+}
+
+void LLVMSetComdatSelectionKind(LLVMComdatRef C, LLVMComdatSelectionKind kind) {
+  Comdat *Cd = unwrap(C);
+  switch (kind) {
+  case LLVMAnyComdatSelectionKind:
+    Cd->setSelectionKind(Comdat::Any);
+    break;
+  case LLVMExactMatchComdatSelectionKind:
+    Cd->setSelectionKind(Comdat::ExactMatch);
+    break;
+  case LLVMLargestComdatSelectionKind:
+    Cd->setSelectionKind(Comdat::Largest);
+    break;
+  case LLVMNoDuplicatesComdatSelectionKind:
+    Cd->setSelectionKind(Comdat::NoDuplicates);
+    break;
+  case LLVMSameSizeComdatSelectionKind:
+    Cd->setSelectionKind(Comdat::SameSize);
+    break;
+  }
+}