[CIR] Fix SymbolUserOpInterface::getUserSymbol

[CIR] Clean up CIRLinkerInterface

[CIR] Remove stray include

Author: frabert

clang/include/clang/CIR/Dialect/IR/CIRAttrs.td

@@ -972,7 +972,7 @@ def CIR_AddressSpaceAttr :  CIR_EnumAttr<CIR_AddressSpace, "address_space"> {
   ];
 
   let assemblyFormat = [{
-    `<` custom<AddressSpaceValue>($value) `>`
+    `` custom<AddressSpaceValue>($value)
   }];
 
   let defaultValue = "cir::AddressSpace::Default";

clang/include/clang/CIR/Dialect/IR/CIROps.td

@@ -2557,7 +2557,8 @@ def CIR_GlobalOp : CIR_Op<"global", [
 //===----------------------------------------------------------------------===//
 
 def CIR_GetGlobalOp : CIR_Op<"get_global", [
-  Pure, DeclareOpInterfaceMethods<SymbolUserOpInterface>
+  Pure, SymbolUserOpInterface,
+  DeclareOpInterfaceMethods<SymbolUserOpInterface, ["getUserSymbol"]>
 ]> {
   let summary = "Get the address of a global variable";
   let description = [{
@@ -2595,7 +2596,8 @@ def CIR_GetGlobalOp : CIR_Op<"get_global", [
 //===----------------------------------------------------------------------===//
 
 def CIR_VTableAddrPointOp : CIR_Op<"vtable.address_point", [
-  Pure, DeclareOpInterfaceMethods<SymbolUserOpInterface>
+  Pure, SymbolUserOpInterface,
+  DeclareOpInterfaceMethods<SymbolUserOpInterface, ["getUserSymbol"]>
 ]> {
   let summary = "Get the vtable (global variable) address point";
   let description = [{
@@ -2873,7 +2875,8 @@ def CIR_VTableGetVirtualFnAddrOp : CIR_Op<"vtable.get_virtual_fn_addr", [
 //===----------------------------------------------------------------------===//
 
 def CIR_VTTAddrPointOp : CIR_Op<"vtt.address_point", [
-  Pure, DeclareOpInterfaceMethods<SymbolUserOpInterface>
+  Pure, SymbolUserOpInterface,
+  DeclareOpInterfaceMethods<SymbolUserOpInterface, ["getUserSymbol"]>
 ]> {
   let summary = "Get the VTT address point";
   let description = [{
@@ -4201,8 +4204,9 @@ def CIR_SideEffect : CIR_I32EnumAttr<
 
 class CIR_CallOp<string mnemonic, list<Trait> extra_traits = []>
     : CIR_Op<mnemonic, !listconcat(extra_traits, [
+        SymbolUserOpInterface,
         DeclareOpInterfaceMethods<CIRCallOpInterface>,
-        DeclareOpInterfaceMethods<SymbolUserOpInterface>
+        DeclareOpInterfaceMethods<SymbolUserOpInterface, ["getUserSymbol"]>
       ])>
 {
   let extraClassDeclaration = [{
@@ -4682,8 +4686,10 @@ def CIR_EhInflightOp : CIR_Op<"eh.inflight_exception"> {
   }];
 }
 
-def CIR_EhTypeIdOp : CIR_Op<"eh.typeid",
-  [Pure, DeclareOpInterfaceMethods<SymbolUserOpInterface>]> {
+def CIR_EhTypeIdOp : CIR_Op<"eh.typeid", [
+  Pure, SymbolUserOpInterface,
+  DeclareOpInterfaceMethods<SymbolUserOpInterface, ["getUserSymbol"]>
+]> {
   let summary = "Compute exception type id from it's global type symbol";
   let description = [{
     Returns the exception type id for a given global symbol representing

clang/include/clang/CIR/Interfaces/CIRLinkerInterface.h

@@ -12,9 +12,9 @@
 
 #ifndef CLANG_INTERFACES_CIR_CIRLINKINTERFACE_H_
 #define CLANG_INTERFACES_CIR_CIRLINKINTERFACE_H_
+#include "clang/CIR/Dialect/IR/CIROpsEnums.h"
 #include "mlir/Linker/LLVMLinkerMixin.h"
-#include "mlir/Linker/LinkerInterface.h"
-#include "clang/CIR/Dialect/IR/CIRDialect.h"
+
 #include <optional>
 
 namespace mlir {
@@ -35,183 +35,44 @@ class CIRSymbolLinkerInterface
   CIRSymbolLinkerInterface(Dialect *dialect)
       : SymbolAttrLLVMLinkerInterface(dialect) {}
 
-  bool canBeLinked(Operation *op) const override {
-    return isa<cir::GlobalOp>(op) || isa<cir::FuncOp>(op);
-  }
+  bool canBeLinked(Operation *op) const override;
 
   //===--------------------------------------------------------------------===//
   // LLVMLinkerMixin required methods from derived linker interface
   //===--------------------------------------------------------------------===//
 
-  // TODO: expose convertLinkage from LowerToLLVM.cpp
-  static Linkage toLLVMLinkage(cir::GlobalLinkageKind linkage) {
-    using CIR = cir::GlobalLinkageKind;
-    using LLVM = mlir::LLVM::Linkage;
-
-    switch (linkage) {
-    case CIR::AvailableExternallyLinkage:
-      return LLVM::AvailableExternally;
-    case CIR::CommonLinkage:
-      return LLVM::Common;
-    case CIR::ExternalLinkage:
-      return LLVM::External;
-    case CIR::ExternalWeakLinkage:
-      return LLVM::ExternWeak;
-    case CIR::InternalLinkage:
-      return LLVM::Internal;
-    case CIR::LinkOnceAnyLinkage:
-      return LLVM::Linkonce;
-    case CIR::LinkOnceODRLinkage:
-      return LLVM::LinkonceODR;
-    case CIR::PrivateLinkage:
-      return LLVM::Private;
-    case CIR::WeakAnyLinkage:
-      return LLVM::Weak;
-    case CIR::WeakODRLinkage:
-      return LLVM::WeakODR;
-    };
-  }
-
-  static Linkage getLinkage(Operation *op) {
-    if (auto gv = dyn_cast<cir::GlobalOp>(op))
-      return toLLVMLinkage(gv.getLinkage());
-    if (auto fn = dyn_cast<cir::FuncOp>(op))
-      return toLLVMLinkage(fn.getLinkage());
-    llvm_unreachable("unexpected operation");
-  }
-
-  static bool isComdat(Operation *op) {
-    // TODO(frabert): Extracting comdat info from CIR is not implemented yet
-    return false;
-  }
+  static Linkage getLinkage(Operation *op);
+
+  static bool isComdat(Operation *op);
 
   static std::optional<mlir::link::ComdatSelector>
-  getComdatSelector(Operation *op) {
-    // TODO(frabert): Extracting comdat info from CIR is not implemented yet
-    return std::nullopt;
-  }
-
-  // TODO: expose lowerCIRVisibilityToLLVMVisibility from LowerToLLVM.cpp
-  static Visibility toLLVMVisibility(cir::VisibilityAttr visibility) {
-    return toLLVMVisibility(visibility.getValue());
-  }
-
-  static Visibility toLLVMVisibility(cir::VisibilityKind visibility) {
-    using CIR = cir::VisibilityKind;
-    using LLVM = mlir::LLVM::Visibility;
-
-    switch (visibility) {
-    case CIR::Default:
-      return LLVM::Default;
-    case CIR::Hidden:
-      return LLVM::Hidden;
-    case CIR::Protected:
-      return LLVM::Protected;
-    };
-  }
-
-  static cir::VisibilityKind toCIRVisibility(Visibility visibility) {
-    using CIR = cir::VisibilityKind;
-    using LLVM = mlir::LLVM::Visibility;
-
-    switch (visibility) {
-    case LLVM::Default:
-      return CIR::Default;
-    case LLVM::Hidden:
-      return CIR::Hidden;
-    case LLVM::Protected:
-      return CIR::Protected;
-    };
-  }
-
-  static cir::VisibilityAttr toCIRVisibilityAttr(Visibility visibility,
-                                                 MLIRContext *mlirContext) {
-    return cir::VisibilityAttr::get(mlirContext, toCIRVisibility(visibility));
-  }
-
-  static Visibility getVisibility(Operation *op) {
-    if (auto gv = dyn_cast<cir::GlobalOp>(op))
-      return toLLVMVisibility(gv.getGlobalVisibility());
-    if (auto fn = dyn_cast<cir::FuncOp>(op))
-      return toLLVMVisibility(fn.getGlobalVisibility());
-    llvm_unreachable("unexpected operation");
-  }
-
-  static void setVisibility(Operation *op, Visibility visibility) {
-    if (auto gv = dyn_cast<cir::GlobalOp>(op))
-      return gv.setGlobalVisibilityAttr(
-          toCIRVisibilityAttr(visibility, op->getContext()));
-    if (auto fn = dyn_cast<cir::FuncOp>(op))
-      return fn.setGlobalVisibilityAttr(
-          toCIRVisibilityAttr(visibility, op->getContext()));
-    llvm_unreachable("unexpected operation");
-  }
-
-  static bool isDeclaration(Operation *op) {
-    if (auto gv = dyn_cast<cir::GlobalOp>(op))
-      return gv.isDeclaration();
-    if (auto fn = dyn_cast<cir::FuncOp>(op))
-      return fn.isDeclaration();
-    llvm_unreachable("unexpected operation");
-  }
-
-  static unsigned getBitWidth(Operation *op) { llvm_unreachable("NYI"); }
-
-  // FIXME: CIR does not yet have UnnamedAddr attribute
-  static UnnamedAddr getUnnamedAddr(Operation * /* op*/) {
-    return UnnamedAddr::Global;
-  }
-
-  // FIXME: CIR does not yet have UnnamedAddr attribute
-  static void setUnnamedAddr(Operation * /* op*/, UnnamedAddr addr) {}
-
-  static std::optional<uint64_t> getAlignment(Operation *op) {
-    if (auto gv = dyn_cast<cir::GlobalOp>(op))
-      return gv.getAlignment();
-    // FIXME: CIR does not (yet?) have alignment for functions
-    llvm_unreachable("unexpected operation");
-  }
-
-  static void setAlignment(Operation *op, std::optional<uint64_t> align) {
-    if (auto gv = dyn_cast<cir::GlobalOp>(op))
-      return gv.setAlignment(align);
-    // FIXME: CIR does not (yet?) have alignment for functions
-    llvm_unreachable("unexpected operation");
-  }
-
-  static bool isConstant(Operation *op) {
-    if (auto gv = dyn_cast<cir::GlobalOp>(op))
-      return gv.getConstant();
-    llvm_unreachable("unexpected operation");
-  }
-
-  static void setIsConstant(Operation *op, bool value) {
-    if (auto gv = dyn_cast<cir::GlobalOp>(op))
-      return gv.setConstant(value);
-    llvm_unreachable("constness setting allowed only for globals");
-  }
-
-  static bool isGlobalVar(Operation *op) { return isa<cir::GlobalOp>(op); }
-
-  static llvm::StringRef getSection(Operation *op) {
-    if (auto gv = dyn_cast<cir::GlobalOp>(op)) {
-      auto section = gv.getSection();
-      return section ? section.value() : llvm::StringRef();
-    }
-    // FIXME: CIR func does not yet have section attribute
-    llvm_unreachable("unexpected operation");
-  }
-
-  static std::optional<cir::AddressSpaceAttr> getAddressSpace(Operation *op) {
-    if (auto gv = dyn_cast<cir::GlobalOp>(op)) {
-      if (auto addrSpace = gv.getAddrSpaceAttr()) {
-        return addrSpace;
-      }
-      return std::nullopt;
-    }
-
-    llvm_unreachable("unexpected operation");
-  }
+  getComdatSelector(Operation *op);
+
+  static Visibility getVisibility(Operation *op);
+
+  static void setVisibility(Operation *op, Visibility visibility);
+
+  static bool isDeclaration(Operation *op);
+
+  static unsigned getBitWidth(Operation *op);
+
+  static UnnamedAddr getUnnamedAddr(Operation *op);
+
+  static void setUnnamedAddr(Operation *op, UnnamedAddr addr);
+
+  static std::optional<uint64_t> getAlignment(Operation *op);
+
+  static void setAlignment(Operation *op, std::optional<uint64_t> align);
+
+  static bool isConstant(Operation *op);
+
+  static void setIsConstant(Operation *op, bool value);
+
+  static bool isGlobalVar(Operation *op);
+
+  static llvm::StringRef getSection(Operation *op);
+
+  static std::optional<cir::AddressSpace> getAddressSpace(Operation *op);
 };
 
 void registerLinkerInterface(mlir::DialectRegistry &registry);