[flang] Add support for linkonce_odr in FIR

[jeanPerier]

Summary

Add support for parsing and converting linkonce_odr in FIR.

[clementval]

LGTM

flang/include/flang/Optimizer/Builder/FIRBuilder.h

public:
   //===--------------------------------------------------------------------===//
 
   mlir::StringAttr createCommonLinkage() { return getStringAttr("common"); }
 
   mlir::StringAttr createInternalLinkage() { return getStringAttr("internal"); }
 
   mlir::StringAttr createLinkOnceLinkage() { return getStringAttr("linkonce"); }
 
+  mlir::StringAttr createLinkOnceODRLinkage() {
+    return getStringAttr("linkonce_odr");
+  }
+
   mlir::StringAttr createWeakLinkage() { return getStringAttr("weak"); }
 
   /// Get a function by name. If the function exists in the current module, it
   /// is returned. Otherwise, a null FuncOp is returned.
   mlir::FuncOp getNamedFunction(llvm::StringRef name) {
     return getNamedFunction(getModule(), name);
   }
 

flang/lib/Optimizer/CodeGen/CodeGen.cpp

struct GlobalOpConversion : public FIROpConversion<fir::GlobalOp> {
   // enumeration.
   mlir::LLVM::Linkage convertLinkage(Optional<StringRef> optLinkage) const {
     if (optLinkage.hasValue()) {
       auto name = optLinkage.getValue();
       if (name == "internal")
         return mlir::LLVM::Linkage::Internal;
       if (name == "linkonce")
         return mlir::LLVM::Linkage::Linkonce;
+      if (name == "linkonce_odr")
+        return mlir::LLVM::Linkage::LinkonceODR;
       if (name == "common")
         return mlir::LLVM::Linkage::Common;
       if (name == "weak")
         return mlir::LLVM::Linkage::Weak;
     }
     return mlir::LLVM::Linkage::External;
   }
 };

flang/lib/Optimizer/Dialect/FIROps.cpp

 void fir::GlobalOp::build(mlir::OpBuilder &builder, OperationState &result,
                           StringRef name, Type type,
                           ArrayRef<NamedAttribute> attrs) {
   build(builder, result, name, /*isConstant=*/false, type, attrs);
 }
 
 mlir::ParseResult fir::GlobalOp::verifyValidLinkage(StringRef linkage) {
   // Supporting only a subset of the LLVM linkage types for now
-  static const char *validNames[] = {"common", "internal", "linkonce", "weak"};
+  static const char *validNames[] = {"common", "internal", "linkonce",
+                                     "linkonce_odr", "weak"};
   return mlir::success(llvm::is_contained(validNames, linkage));
 }
 
 //===----------------------------------------------------------------------===//
 // GlobalLenOp
 //===----------------------------------------------------------------------===//
 
 mlir::ParseResult GlobalLenOp::parse(mlir::OpAsmParser &parser,

flang/test/Fir/fir-ops.fir

 // CHECK: fir.has_value [[VAL_132]] : !fir.type<minez(f:i32)>
 // CHECK: }
 fir.global @global_derived : !fir.type<minez(f:i32)> {
   fir.global_len f, 1 : i32
   %0 = fir.undefined !fir.type<minez>
   fir.has_value %0 : !fir.type<minez>
 }
 
+// CHECK-LABEL: fir.global linkonce_odr @global_linkonce_odr : i32 {
+// CHECK: [[VAL_130:%.*]] = arith.constant 1 : i32
+// CHECK: fir.has_value [[VAL_130]] : i32
+// CHECK: }
+fir.global linkonce_odr @global_linkonce_odr : i32 {
+  %0 = arith.constant 1 : i32
+  fir.has_value %0 : i32
+}
+
 // CHECK-LABEL: fir.dispatch_table @dispatch_tbl {
 // CHECK: fir.dt_entry "method", @method_impl
 // CHECK: }
 fir.dispatch_table @dispatch_tbl {
   fir.dt_entry "method", @method_impl
 }
 
 // CHECK-LABEL: func @compare_complex(