[mlir] Add a `GlobalSymbol` trait.

[fmorac]

Summary

Currently there's no mechanism to indicate that a particular symbol should be
treated as a global symbol, this patch adds this trait and modifies the LLVM
translation mechanism to be aware of the trait and convert the operation
alongside all the other LLVM globals.

[fmorac]

Duplicate of D154098

mlir/include/mlir/IR/SymbolInterfaces.td

let methods = [
     >,
   ];
 }
 
 //===----------------------------------------------------------------------===//
 // Symbol Traits
 //===----------------------------------------------------------------------===//
 
+// Op defines a global symbol.
+def GlobalSymbol : NativeOpTrait<"GlobalSymbol", [Symbol]>;
+
 // Op defines a symbol table.
 def SymbolTable : NativeOpTrait<"SymbolTable">;
 
 #endif // MLIR_IR_SYMBOLINTERFACES

mlir/include/mlir/IR/SymbolTable.h

ParseResult parseOptionalVisibilityKeyword(OpAsmParser &parser,
                                            NamedAttrList &attrs);
 } // namespace impl
 
 } // namespace mlir
 
 /// Include the generated symbol interfaces.
 #include "mlir/IR/SymbolInterfaces.h.inc"
 
+namespace mlir {
+namespace OpTrait {
+/// A trait used to indicate that a symbol has a global scope. Operations using
+/// this trait must also adhere to the constraints defined by the `Symbol`
+/// trait.
+template <typename ConcreteType>
+class GlobalSymbol : public TraitBase<ConcreteType, GlobalSymbol> {
+  static LogicalResult verifyTrait(Operation *op) {
+    static_assert(ConcreteType::template hasTrait<ZeroResults>(),
+                  "expected operation must have zero results");
+    static_assert(ConcreteType::template hasTrait<SymbolOpInterface::Trait>(),
+                  "expected operation must inherit the `Symbol` trait");
+    return success();
+  }
+};
+} // namespace OpTrait
+} // namespace mlir
+
 #endif // MLIR_IR_SYMBOLTABLE_H

mlir/lib/Target/LLVMIR/ModuleTranslation.cpp

 /// `dsoLocalRequested` is true, otherwise it is left unchanged.
 static void addRuntimePreemptionSpecifier(bool dsoLocalRequested,
                                           llvm::GlobalValue *gv) {
   if (dsoLocalRequested)
     gv->setDSOLocal(true);
 }
 
 /// Create named global variables that correspond to llvm.mlir.global
-/// definitions. Convert llvm.global_ctors and global_dtors ops.
+/// definitions. Convert llvm.global_ctors and global_dtors ops. Finally convert
+/// operations with the `GlobalSymbol` trait.
 LogicalResult ModuleTranslation::convertGlobals() {
   for (auto op : getModuleBody(mlirModule).getOps<LLVM::GlobalOp>()) {
     llvm::Type *type = convertType(op.getType());
     llvm::Constant *cst = nullptr;
     if (op.getValueOrNull()) {
       // String attributes are treated separately because they cannot appear as
       // in-function constants and are thus not supported by getLLVMConstant.
       if (auto strAttr = dyn_cast_or_null<StringAttr>(op.getValueOrNull())) {
for (auto symbolAndPriority : range) {
                      /*Data=*/nullptr);
     }
   }
 
   for (auto op : getModuleBody(mlirModule).getOps<LLVM::GlobalOp>())
     if (failed(convertDialectAttributes(op)))
       return failure();
 
+  // Convert operations having the `GlobalSymbol` trait.
+  {
+    llvm::IRBuilder<> llvmBuilder(llvmModule->getContext());
+    for (Operation &op : getModuleBody(mlirModule).getOperations()) {
+      if (!isa<LLVM::GlobalOp, LLVM::GlobalCtorsOp, LLVM::GlobalDtorsOp>(&op) &&
+          op.hasTrait<OpTrait::GlobalSymbol>() &&
+          failed(convertOperation(op, llvmBuilder))) {
+        return failure();
+      }
+    }
+  }
+
   return success();
 }
 
 /// Attempts to add an attribute identified by `key`, optionally with the given
 /// `value` to LLVM function `llvmFunc`. Reports errors at `loc` if any. If the
 /// attribute has a kind known to LLVM IR, create the attribute of this kind,
 /// otherwise keep it as a string attribute. Performs additional checks for
 /// attributes known to have or not have a value in order to avoid assertions
if (failed(translator.convertFunctions()))
     return nullptr;
 
   // Convert other top-level operations if possible.
   llvm::IRBuilder<> llvmBuilder(llvmContext);
   for (Operation &o : getModuleBody(module).getOperations()) {
     if (!isa<LLVM::LLVMFuncOp, LLVM::GlobalOp, LLVM::GlobalCtorsOp,
              LLVM::GlobalDtorsOp, LLVM::MetadataOp, LLVM::ComdatOp>(&o) &&
         !o.hasTrait<OpTrait::IsTerminator>() &&
+        !o.hasTrait<OpTrait::GlobalSymbol>() &&
         failed(translator.convertOperation(o, llvmBuilder))) {
       return nullptr;
     }
   }
 
   // Convert module itself.
   if (failed(translator.convertOperation(*module, llvmBuilder)))
     return nullptr;
 
   if (llvm::verifyModule(*translator.llvmModule, &llvm::errs()))
     return nullptr;
 
   return std::move(translator.llvmModule);
 }