[mlir] Add support for LLVMIR comdat operation

[DavidTruby]

Summary

The LLVM comdat operation specifies how to deduplicate globals with the
same key in two different object files. This is necessary on Windows
where e.g. two object files with linkonce globals will not link unless
a comdat for those globals is specified. It is also supported in the ELF
format.

[DavidTruby]

I'm not 100% sure I've done this correctly as my understanding of comdats is somewhat limited. We need this for flang where we have some linkonce and linkonce_odr globals that we can't link on Windows without comdats.
I originally wanted to have a separate symbol table for comdats so that they could share the same symbol with the global they are defining the comdat for, as this is how it works in LLVM, but I couldn't quite get that to work. If we'd prefer it to work that way then any pointers on how to do that would be much appreciated!

[gysit]

I'm not 100% sure I've done this correctly as my understanding of comdats is somewhat limited. We need this for flang where we have some linkonce and linkonce_odr globals that we can't link on Windows without comdats. I originally wanted to have a separate symbol table for comdats so that they could share the same symbol with the global they are defining the comdat for, as this is how it works in LLVM, but I couldn't quite get that to work. If we'd prefer it to work that way then any pointers on how to do that would be much appreciated!

I would recommend to have a look at how the alias analysis metadata is handled in LLVM dialect:

llvm.metadata @__llvm_global_metadata {
  llvm.alias_scope_domain @domain_0 {  description = "copy" }
  llvm.alias_scope @scope_1 { description = "copy: argument 0", domain = @domain_0 }
}

llvm.load %arg0 { alias_scopes = [@__llvm_global_metadata::@scope_1] }

It uses a global llvm.metadata operation that has a region which contains the individual metadata nodes. The llvm.metadata operation itself serves as a symbol table for the individual alias metadata operations. I.e., you could introduce an llvm.comdat operation that defines one global symbol under which you nest the comdat symbols for the individual global variables. Is this roughly what your separate symbol table approach looks like? I think having one global operation that nests all comdat information is cleaner than your current solution since there is only one symbol (the one of the llvm.comdat operation) that pollutes the global namespace.

mlir/include/mlir/Dialect/LLVMIR/LLVMEnums.td

617

Is the DialectAttr wrapper needed?

If the enum is only used as an operation attribute then the DialectAttr may not be necessary. AtomicOrdering is an example for an enum that does not need DialectAttr.

If you plan to use the attribute as a discardable attribute outside of the LLVM dialect, then the DialectAttr wrapper may be needed.

mlir/include/mlir/Dialect/LLVMIR/LLVMOps.td

1324

Please use a SymbolRef / FlatSymbolRef attribute when referencing symbols.

1433

Could you use CArg<"StringRef", StringRef()> here and use the empty string reference instead of nullopt?

mlir/lib/Dialect/LLVMIR/IR/LLVMDialect.cpp

41

nit: This looks like a leftover?

[DavidTruby]

Thanks for the review! This is probably more like what I was looking for yes, I'll rework the patch to use something similar to the metadata op. Thanks for the pointer! I assume it's possible with llvm.metadata to add to it at multiple points, rather than the entire op having to be created at one place?

mlir/include/mlir/Dialect/LLVMIR/LLVMOps.td

1433

Ah, yes probably. This was a holdover from an initial prototype where I allowed to specify just that there was a comdat and that it would look up one with the same name as the function (as LLVM allows this) but I don't think that's really necessary and complicates things a bit. If anything we could just add a function to create a comdat with the same name anyway, but in the printed IR form have it always be explicit.

[gysit]

Thanks for the review! This is probably more like what I was looking for yes, I'll rework the patch to use something similar to the metadata op. Thanks for the pointer! I assume it's possible with llvm.metadata to add to it at multiple points, rather than the entire op having to be created at one place?

Yes you can have multiple llvm.metadata operations. The import from LLVM IR currently generates only one llvm.metadata operation since every metadata operation you introduce somewhat pollutes the global namespace. We thus went for creating just one metadata operation with a long name that will not conflict with any other symbol. However, you can also generate IR with multiple such operations and it should lower correctly to LLVM IR. The same can be implemented for a possible new llvm.comdat operation.

You may also consider renaming llvm.metadata and make it multi-purpose so that it can contain metadata and comdat information. I currently have a slight preference for a separate llvm.comdat operation since this seem to be different things and since we may refactor metadata to be purely attribute based sometime in the future. However, I do not have a strong opinion and you are for sure deeper in the comdat topic than me :). Maybe comdat can be consider as some sort of metadata?

mlir/include/mlir/Dialect/LLVMIR/LLVMOps.td

1433

Ah, yes probably. This was a holdover from an initial prototype where I allowed to specify just that there was a comdat and that it would look up one with the same name as the function

Ah right I have seen this LLVM feature. I would probably prefer to make things explicit to avoid such special case handling.

[DavidTruby]

As another thought, one thing I am unclear on is what value there is, if any, in having multiple COMDAT sections with the same selection type. If it makes no difference, we could just have this be an attribute on global just like linkage is, and just give all any comdat globals the same LLVM comdat when lowering to LLVM IR. I suspect there's a reason that isn't how it works in LLVM though, but I'm not clear what it is

[Dinistro]

In D150796#4364871, @DavidTruby wrote:

As another thought, one thing I am unclear on is what value there is, if any, in having multiple COMDAT sections with the same selection type. If it makes no difference, we could just have this be an attribute on global just like linkage is, and just give all any comdat globals the same LLVM comdat when lowering to LLVM IR. I suspect there's a reason that isn't how it works in LLVM though, but I'm not clear what it is

COMDAT has a key associated with it. Only when the key is the same, the linker will attempt deduplication.
While there might not be an immediate use case for this behaviour, not modelling the key will potentially break the LLVM to MLIR import.

[gysit]

COMDAT has a key associated with it. Only when the key is the same, the linker will attempt deduplication.

Yes that makes sense! Also note that deduplication kinds such as "exactmatch" or "largets" actually indicate that the grouping of different symbols into comdat sections matters.

[DavidTruby]

Add comdat region to contain comdat selection operations

[rnk]

Here are some interesting examples of C++ code that generate interesting comdats:
https://gcc.godbolt.org/z/EjGMxMcra -- uses the largest selection for the vtable in the MS C++ ABI (The symbol starting with "?_7" is the vtable)
https://gcc.godbolt.org/z/ETv9oPK95 -- Use of the D5 comdat group so that we can alias the D1 destructor to D2 to save code size

That should give you some real world examples of interesting comdats in LLVM IR that you might want to translate. I think there may be another use in PGO data, but I'm not sure.

mlir/lib/Target/LLVMIR/ModuleTranslation.cpp

734

I don't understand why you are appending the name of the selector here. The name of the LLVM comdat is significant and typically should exactly match some other global symbol.

[DavidTruby]

mlir/lib/Target/LLVMIR/ModuleTranslation.cpp

734

This isn't appending the name of the selector, it's appending the name of the symbol corresponding to the selector. Or, using an example:

llvm.comdat @__comdat_region {
  llvm.comdat_selector @foo any
}

comes out in LLVM IR as

comdat $__comdat_region_foo any

we discussed above doing it this way so that both in the case of importing from LLVM IR, or generating from another language, can just make a single MLIR llvm.comdat region and put all the comdat symbols in there, to avoid polluting the global namespace. This is somewhat emulating the idea that in LLVM comdat symbols are in a separate symbol table with symbols prefixed by $ instead of @, but without making significant changes to MLIR to actually do that.

We also discussed whether we should emulate the behaviour where they match the global symbol that they are specifying the comdat for and decided to be explicit here instead. Is there a specific reason that they should match the symbol or is that just the convention in LLVM?

I may have fully misunderstood comdats, my knowledge is basically only driven by what we require for flang, so any more context would be really useful!

[gysit]

Thanks for updating and thanks @rnk for the examples.

I think implementing the import of comdat's in ModuleImport.cpp could be a great opportunity to roundtrip the examples through MLIR back to LLVM IR. Ideally we should obtain more or less the same LLVM IR after the roundtrip.

mlir/include/mlir/Dialect/LLVMIR/LLVMOps.td

1538–1539

I think after the update description and summary should be update to reflect the new approach.

1557

Similarly, the description and summary need to be updated here.

mlir/lib/Dialect/LLVMIR/IR/LLVMDialect.cpp

1621

Please add a test to invalid.mlir that verifies the error message is produced as expected.

Additionally, the operations that have comdat's attached should also verify that the symbol references point to a valid comdat selector operation. I expect the implementation would be similar to verifySymbolRefsPointTo in LLVMInterfaces.cpp, which is used to verify the symbol references that point to metadata.

1622

nit: the braces can be dropped here.

1935

nit: the llvm:: prefix is most likely not needed here?

mlir/lib/Target/LLVMIR/ModuleTranslation.cpp

734

if I understand @rnk's comment correctly the exported comdat should not have the comdat region prefix. That makes sense to me. We should probably drop the __comdat_region prefix when translating to LLVM IR. For your example, we thus would obtain the following MLIR:

comdat $foo any

The __comdat_region operation mainly exists to prevent naming conflicts between global symbols and comdat names since MLIR does not have a separate mechanism to model comdat names. The only drawback in doing so is that we should verify this does not produce conflicting comdat names since there could be multiple comdat operations containing the same name. We may want to introduce a verifier to prevent this and/or check there are no conflicts when translating to LLVM IR.

1419

ComdatSelectorOp should not be a top-level operation?

mlir/test/Dialect/LLVMIR/comdat.mlir

16

ultra nit: please add the missing newline.

[DavidTruby]

Add LLVM IR import

mlir/lib/Dialect/LLVMIR/IR/LLVMDialect.cpp

1621

Is what I have on line 1890 in this file not sufficient to check that?

[gysit]

mlir/lib/Dialect/LLVMIR/IR/LLVMDialect.cpp

1621

Is what I have on line 1890 in this file not sufficient to check that?

I think that is sufficient. I would have expected two lookups are needed but I guess here one is ok since global op a module level thing.

Adding a test will make sure it really works.

Also if there are other operations, such as llvm.func, that can have comdat it may make to factor this out into an independent function?

[DavidTruby]

Add test for invalid comdat reference

[gysit]

Thanks!

Can you add a test for the import as well? E.g. in a new /llvm-project/mlir/test/Target/LLVMIR/Import/comdat.ll file.

There are some older comments from ealier reviews that still need clarification. I tried to mark them. It also makes sense to resolve all the comments that have been addressed to make sure everything is catched.

Also two general coding guideline comments:

• please use camelBack naming for variables, for example cdop should be renamed to comdatOp.
• auto should be avoided except the type is explicit on the rhs of the expression or if the type is very long.

Can you make a pass to fix these. I think I marked most but not all instances.

mlir/include/mlir/Dialect/LLVMIR/LLVMEnums.td

617

Any updates on this?

mlir/include/mlir/Dialect/LLVMIR/LLVMOps.td

1433

Can you address to comment or is the optional still needed?

mlir/lib/Dialect/LLVMIR/IR/LLVMDialect.cpp

1695

nit: please rename to comdat or comdatAttr.

1766

Can you rename to 'verifyComdat' to and hand in the comdat attribute directly? I would also move in

`emitOpError() << "expected comdat symbol"

into the function itself since the error message is not specific to GlobalOp.

1768

nit: please rename to comdatOp

mlir/lib/Target/LLVMIR/ModuleImport.cpp

85

nit: can you add a comment similar to the one above

561

nit: rename to comdatOp or similar here and further below.

569

Can you put

OpBuilder::InsertionGuard guard(builder);

before builder.setInsertionPointToEnd(&cdregion.getBody().back());.

892

nit: please rename to comdat or similar.

mlir/lib/Target/LLVMIR/ModuleTranslation.cpp

729

Can you spell out the type here and below if the type is not overly complex.

732

nit: please rename llcomdat to llvmComdat.

mlir/test/Dialect/LLVMIR/invalid.mlir

1439

ultra nit: please add a newline at the end of the file.

mlir/test/Target/LLVMIR/llvmir-invalid.mlir

256

ultra nit: please add a newline at the end of the file.

[DavidTruby]

Address misc review comments.

[DavidTruby]

Also two general coding guideline comments:

• please use camelBack naming for variables, for example cdop should be renamed to comdatOp.
• auto should be avoided except the type is explicit on the rhs of the expression or if the type is very long.

Can you make a pass to fix these. I think I marked most but not all instances.

Sorry about that, I'm used to working on flang where the style is different.. I think I've caught all these now!

mlir/include/mlir/Dialect/LLVMIR/LLVMOps.td

1433

I couldn't get this to be representable as a StringRef when the SymbolRef must contain a nested symbol. That's why I reverted to optional here

[gysit]

Thanks!

I have a few last comments.

mlir/include/mlir/Dialect/LLVMIR/LLVMOps.td

1433

I was thinking of

CArg<"SymbolRefAttr", "{}">:$comdat,

The implementation of the builder would then have to check if the comdat argument is non-null.

mlir/lib/Dialect/LLVMIR/IR/LLVMDialect.cpp

26

nit: I suspect that got added by the IDE and is probably not necessary.

1767–1769

If you want to keep the comment braces are required. Comments should start upper case and end with a dot. However, in this case the comment seems not necessary.

1933–1934

Please shorten to:

if (failed(verifyComdat(getOperation(), getComdat()))
  return failure();

mlir/lib/Target/LLVMIR/ModuleImport.cpp

569

Sorry for not being precise enough. You can now delete:

builder.setInsertionPointAfter(comdat);

since the insertion guard should make it redundant.

[DavidTruby]

Remove std::optional from SymbolRefAttr and address other comments

[DavidTruby]

mlir/include/mlir/Dialect/LLVMIR/LLVMOps.td

1433

Ah, I didn't realise that would just work. Thanks!

[gysit]

LGTM!

I marked two more things that possibly can be deleted. One seems to be a leftover from the more complicated attribute definition. I am 90% sure it can go away :). Please give it a try before landing.

mlir/include/mlir/Dialect/LLVMIR/LLVMAttrs.h

69 ↗

(On Diff #532147)

nit: I believe this can be dropped now?

mlir/test/Dialect/LLVMIR/invalid.mlir

1425

nit: this change seems unrelated?

[DavidTruby]

In D150796#4428299, @gysit wrote:

LGTM!

Thanks for all the help on this review! I made both changes you suggested above before landing

mlir/include/mlir/Dialect/LLVMIR/LLVMAttrDefs.td

 //===----------------------------------------------------------------------===//
 
 def CConvAttr : LLVM_Attr<"CConv", "cconv"> {
   let parameters = (ins "CConv":$CallingConv);
   let assemblyFormat = "`<` $CallingConv `>`";
 }
 
 //===----------------------------------------------------------------------===//
+// ComdatAttr
+//===----------------------------------------------------------------------===//
+
+def ComdatAttr : LLVM_Attr<"Comdat", "comdat"> {
+  let parameters = (ins "comdat::Comdat":$comdat);
+  let assemblyFormat = "$comdat";
+}
+
+//===----------------------------------------------------------------------===//
 // LinkageAttr
 //===----------------------------------------------------------------------===//
 
 def LinkageAttr : LLVM_Attr<"Linkage", "linkage"> {
   let parameters = (ins "linkage::Linkage":$linkage);
   let assemblyFormat = "`<` $linkage `>`";
 }
 

mlir/include/mlir/Dialect/LLVMIR/LLVMEnums.td

def Linkage : DialectAttr<
     "LLVM Linkage specification"> {
   let storageType = "::mlir::LLVM::LinkageAttr";
   let returnType = "::mlir::LLVM::Linkage";
   let convertFromStorage = "$_self.getLinkage()";
   let constBuilderCall =
           "::mlir::LLVM::LinkageAttr::get($_builder.getContext(), $0)";
 }
 
+
+//===----------------------------------------------------------------------===//
+// Comdat
+//===----------------------------------------------------------------------===//
+
+def ComdatAny
+    : LLVM_EnumAttrCase<"Any", "any", "Any", 0>;
+def ComdatExactMatch
+    : LLVM_EnumAttrCase<"ExactMatch", "exactmatch", "ExactMatch", 1>;
+def ComdatLargest
+    : LLVM_EnumAttrCase<"Largest", "largest", "Largest", 2>;
+def ComdatNoDeduplicate
+    : LLVM_EnumAttrCase<"NoDeduplicate", "nodeduplicate", "NoDeduplicate", 3>;
+def ComdatSameSize
+    : LLVM_EnumAttrCase<"SameSize", "samesize", "SameSize", 4>;
+
+def Comdat : LLVM_EnumAttr<
+  "Comdat",
+  "::llvm::Comdat::SelectionKind",
+  "LLVM Comdat Types",
+  [ComdatAny, ComdatExactMatch, ComdatLargest,
+   ComdatNoDeduplicate, ComdatSameSize]> {
+  let cppNamespace = "::mlir::LLVM::comdat";
+}
+
 //===----------------------------------------------------------------------===//
 // UnnamedAddr
 //===----------------------------------------------------------------------===//
 
 def UnnamedAddrNone : LLVM_EnumAttrCase<"None", "", "None", 0>;
 def UnnamedAddrLocal : LLVM_EnumAttrCase<"Local", "local_unnamed_addr", "Local", 1>;
 def UnnamedAddrGlobal : LLVM_EnumAttrCase<"Global", "unnamed_addr", "Global", 2>;
 
 def UnnamedAddr : LLVM_EnumAttr<

mlir/include/mlir/Dialect/LLVMIR/LLVMOps.td

let arguments = (ins
     Linkage:$linkage,
     UnitAttr:$dso_local,
     UnitAttr:$thread_local_,
     OptionalAttr<AnyAttr>:$value,
     OptionalAttr<I64Attr>:$alignment,
     DefaultValuedAttr<ConfinedAttr<I32Attr, [IntNonNegative]>, "0">:$addr_space,
     OptionalAttr<UnnamedAddr>:$unnamed_addr,
     OptionalAttr<StrAttr>:$section,
+    OptionalAttr<SymbolRefAttr>:$comdat,
     DefaultValuedAttr<Visibility, "mlir::LLVM::Visibility::Default">:$visibility_
   );
   let summary = "LLVM dialect global.";
   let description = [{
     Since MLIR allows for arbitrary operations to be present at the top level,
     global variables are defined using the `llvm.mlir.global` operation. Both
     global constants and variables can be defined, and the value may also be
     initialized in both cases.
def LLVM_GlobalOp : LLVM_Op<"mlir.global",
 
   let builders = [
     OpBuilder<(ins "Type":$type, "bool":$isConstant, "Linkage":$linkage,
       "StringRef":$name, "Attribute":$value,
       CArg<"uint64_t", "0">:$alignment,
       CArg<"unsigned", "0">:$addrSpace,
       CArg<"bool", "false">:$dsoLocal,
       CArg<"bool", "false">:$thread_local_,
+      CArg<"SymbolRefAttr", "{}">:$comdat,
       CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>
   ];
 
   let extraClassDeclaration = [{
     /// Return the LLVM type of the global.
     Type getType() {
       return getGlobalType();
     }
let description = [{
     llvm.mlir.global_dtors {@dtor}
     ```
 
   }];
   let assemblyFormat = "attr-dict";
   let hasVerifier = 1;
 }
 
+def LLVM_ComdatSelectorOp : LLVM_Op<"comdat_selector", [Symbol]> {
+  let arguments = (ins
+    SymbolNameAttr:$sym_name,
+    Comdat:$comdat
+  );
+
+  let summary = "LLVM dialect comdat selector declaration";
+
+  let description = [{
+    Provides access to object file COMDAT section/group functionality.
+
+    Examples:
+    ```mlir
+    llvm.comdat @__llvm_comdat {
+      llvm.comdat_selector @any any
+    }
+    llvm.mlir.global internal constant @has_any_comdat(1 : i64) comdat(@__llvm_comdat::@any) : i64
+    ```
+  }];
+  let assemblyFormat = "$sym_name $comdat attr-dict";
+}
+
+def LLVM_ComdatOp : LLVM_Op<"comdat", [NoTerminator, NoRegionArguments, SymbolTable, Symbol]> {
+  let arguments = (ins
+    SymbolNameAttr:$sym_name
+  );
+  let summary = "LLVM dialect comdat region";
+
+  let description = [{
+    Provides access to object file COMDAT section/group functionality.
+
+    Examples:
+    ```mlir
+    llvm.comdat @__llvm_comdat {
+      llvm.comdat_selector @any any
+    }
+    llvm.mlir.global internal constant @has_any_comdat(1 : i64) comdat(@__llvm_comdat::@any) : i64
+    ```
+  }];
+  let regions = (region SizedRegion<1>:$body);
+
+
+  let skipDefaultBuilders = 1;
+  let builders = [OpBuilder<(ins "StringRef":$symName)>];
+
+  let assemblyFormat = "$sym_name $body attr-dict";
+  let hasRegionVerifier = 1;
+}
+
 def LLVM_LLVMFuncOp : LLVM_Op<"func", [
     AutomaticAllocationScope, IsolatedFromAbove, FunctionOpInterface,
     CallableOpInterface
   ]> {
   let summary = "LLVM dialect function.";
 
   let description = [{
     MLIR functions are defined by an operation that is not built into the IR

mlir/include/mlir/Target/LLVMIR/ModuleImport.h

public:
   /// dialect interfaces for the supported LLVM IR intrinsics and metadata kinds
   /// and builds the dispatch tables. Returns failure if multiple dialect
   /// interfaces translate the same LLVM IR intrinsic.
   LogicalResult initializeImportInterface() { return iface.initializeImport(); }
 
   /// Converts all functions of the LLVM module to MLIR functions.
   LogicalResult convertFunctions();
 
+  /// Converts all comdat selectors of the LLVM module to MLIR comdat
+  /// operations.
+  LogicalResult convertComdats();
+
   /// Converts all global variables of the LLVM module to MLIR global variables.
   LogicalResult convertGlobals();
 
   /// Converts the data layout of the LLVM module to an MLIR data layout
   /// specification.
   LogicalResult convertDataLayout();
 
   /// Stores the mapping between an LLVM value and its MLIR counterpart.
private:
   /// `convertConstant` method, or returns failure if the conversion of any of
   /// them fails. All operations are inserted at the start of the current
   /// function entry block.
   FailureOr<Value> convertConstantExpr(llvm::Constant *constant);
   /// Returns a global metadata operation that serves as a container for LLVM
   /// metadata that converts to MLIR operations. Creates the global metadata
   /// operation on the first invocation.
   MetadataOp getGlobalMetadataOp();
+  /// Returns a global comdat operation that serves as a container for LLVM
+  /// comdat selectors. Creates the global comdat operation on the first
+  /// invocation.
+  ComdatOp getGlobalComdatOp();
   /// Performs conversion of LLVM TBAA metadata starting from
   /// `node`. On exit from this function all nodes reachable
   /// from `node` are converted, and tbaaMapping map is updated
   /// (unless all dependencies have been converted by a previous
   /// invocation of this function).
   LogicalResult processTBAAMetadata(const llvm::MDNode *node);
   /// Converts all LLVM access groups starting from `node` to MLIR access group
   /// operations and stores a mapping from every nested access group node to the
private:
   /// Block to insert the next constant into.
   Block *constantInsertionBlock = nullptr;
   /// Operation to insert the next constant after.
   Operation *constantInsertionOp = nullptr;
   /// Operation to insert the next global after.
   Operation *globalInsertionOp = nullptr;
   /// Operation to insert metadata operations into.
   MetadataOp globalMetadataOp = nullptr;
+  /// Operation to insert comdat selector operations into.
+  ComdatOp globalComdatOp = nullptr;
   /// The current context.
   MLIRContext *context;
   /// The MLIR module being created.
   ModuleOp mlirModule;
   /// The LLVM module being imported.
   std::unique_ptr<llvm::Module> llvmModule;
 
   /// A dialect interface collection used for dispatching the import to specific

mlir/include/mlir/Target/LLVMIR/ModuleTranslation.h

private:
   ModuleTranslation(Operation *module,
                     std::unique_ptr<llvm::Module> llvmModule);
   ~ModuleTranslation();
 
   /// Converts individual components.
   LogicalResult convertOperation(Operation &op, llvm::IRBuilderBase &builder);
   LogicalResult convertFunctionSignatures();
   LogicalResult convertFunctions();
+  LogicalResult convertComdats();
   LogicalResult convertGlobals();
   LogicalResult convertOneFunction(LLVMFuncOp func);
 
   /// Process access_group LLVM Metadata operations and create LLVM
   /// metadata nodes.
   LogicalResult createAccessGroupMetadata();
 
   /// Process alias.scope LLVM Metadata operations and create LLVM

mlir/lib/Dialect/LLVMIR/IR/LLVMDialect.cpp

 #include "mlir/Dialect/LLVMIR/LLVMTypes.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/BuiltinOps.h"
 #include "mlir/IR/BuiltinTypes.h"
 #include "mlir/IR/DialectImplementation.h"
 #include "mlir/IR/FunctionImplementation.h"
 #include "mlir/IR/MLIRContext.h"
 #include "mlir/IR/Matchers.h"
 
 #include "llvm/ADT/SCCIterator.h"
 #include "llvm/ADT/TypeSwitch.h"
 #include "llvm/AsmParser/Parser.h"
 #include "llvm/Bitcode/BitcodeReader.h"
 #include "llvm/Bitcode/BitcodeWriter.h"
 #include "llvm/IR/Attributes.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/Type.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/Mutex.h"
 #include "llvm/Support/SourceMgr.h"
 
 #include <numeric>
 #include <optional>
 
 using namespace mlir;
 using namespace mlir::LLVM;
 using mlir::LLVM::cconv::getMaxEnumValForCConv;
 using mlir::LLVM::linkage::getMaxEnumValForLinkage;
 
 #include "mlir/Dialect/LLVMIR/LLVMOpsDialect.cpp.inc"
 
 static constexpr const char kElemTypeAttrName[] = "elem_type";
AddressOfOp::verifySymbolUses(SymbolTableCollection &symbolTable) {
   if (function && type.getElementType() != function.getFunctionType())
     return emitOpError(
         "the type must be a pointer to the type of the referenced function");
 
   return success();
 }
 
 //===----------------------------------------------------------------------===//
+// Verifier for LLVM::ComdatOp.
+//===----------------------------------------------------------------------===//
+
+void ComdatOp::build(OpBuilder &builder, OperationState &result,
+                     StringRef symName) {
+  result.addAttribute(getSymNameAttrName(result.name),
+                      builder.getStringAttr(symName));
+  Region *body = result.addRegion();
+  body->emplaceBlock();
+}
+
+LogicalResult ComdatOp::verifyRegions() {
+  Region &body = getBody();
+  for (Operation &op : body.getOps())
+    if (!isa<ComdatSelectorOp>(op))
+      return op.emitError(
+          "only comdat selector symbols can appear in a comdat region");
+
+  return success();
+}
+
+//===----------------------------------------------------------------------===//
 // Builder, printer and verifier for LLVM::GlobalOp.
 //===----------------------------------------------------------------------===//
 
 void GlobalOp::build(OpBuilder &builder, OperationState &result, Type type,
                      bool isConstant, Linkage linkage, StringRef name,
                      Attribute value, uint64_t alignment, unsigned addrSpace,
-                     bool dsoLocal, bool threadLocal,
+                     bool dsoLocal, bool threadLocal, SymbolRefAttr comdat,
                      ArrayRef<NamedAttribute> attrs) {
   result.addAttribute(getSymNameAttrName(result.name),
                       builder.getStringAttr(name));
   result.addAttribute(getGlobalTypeAttrName(result.name), TypeAttr::get(type));
   if (isConstant)
     result.addAttribute(getConstantAttrName(result.name),
                         builder.getUnitAttr());
   if (value)
     result.addAttribute(getValueAttrName(result.name), value);
   if (dsoLocal)
     result.addAttribute(getDsoLocalAttrName(result.name),
                         builder.getUnitAttr());
   if (threadLocal)
     result.addAttribute(getThreadLocal_AttrName(result.name),
                         builder.getUnitAttr());
+  if (comdat)
+    result.addAttribute(getComdatAttrName(result.name), comdat);
 
   // Only add an alignment attribute if the "alignment" input
   // is different from 0. The value must also be a power of two, but
   // this is tested in GlobalOp::verify, not here.
   if (alignment != 0)
     result.addAttribute(getAlignmentAttrName(result.name),
                         builder.getI64IntegerAttr(alignment));
 
void GlobalOp::print(OpAsmPrinter &p) {
   }
   if (getConstant())
     p << "constant ";
   p.printSymbolName(getSymName());
   p << '(';
   if (auto value = getValueOrNull())
     p.printAttribute(value);
   p << ')';
+  if (auto comdat = getComdat())
+    p << " comdat(" << *comdat << ')';
+
   // Note that the alignment attribute is printed using the
   // default syntax here, even though it is an inherent attribute
   // (as defined in https://mlir.llvm.org/docs/LangRef/#attributes)
   p.printOptionalAttrDict((*this)->getAttrs(),
                           {SymbolTable::getSymbolAttrName(),
                            getGlobalTypeAttrName(), getConstantAttrName(),
                            getValueAttrName(), getLinkageAttrName(),
                            getUnnamedAddrAttrName(), getThreadLocal_AttrName(),
-                           getVisibility_AttrName()});
+                           getVisibility_AttrName(), getComdatAttrName()});
 
   // Print the trailing type unless it's a string global.
   if (llvm::dyn_cast_or_null<StringAttr>(getValueOrNull()))
     return;
   p << " : " << getType();
 
   Region &initializer = getInitializerRegion();
   if (!initializer.empty()) {
for (unsigned i = 0, e = EnumTraits<EnumTy>::getMaxEnumVal(); i <= e; ++i)
     names.push_back(EnumTraits<EnumTy>::stringify(static_cast<EnumTy>(i)));
 
   int index = parseOptionalKeywordAlternative(parser, names);
   if (index == -1)
     return static_cast<RetTy>(defaultValue);
   return static_cast<RetTy>(index);
 }
 
+static LogicalResult verifyComdat(Operation *op,
+                                  std::optional<SymbolRefAttr> attr) {
+  if (!attr)
+    return success();
+
+  auto *comdatSelector = SymbolTable::lookupNearestSymbolFrom(op, *attr);
+  if (!isa_and_nonnull<ComdatSelectorOp>(comdatSelector))
+    return op->emitError() << "expected comdat symbol";
+
+  return success();
+}
+
 // operation ::= `llvm.mlir.global` linkage? `constant`? `@` identifier
 //               `(` attribute? `)` align? attribute-list? (`:` type)? region?
 // align     ::= `align` `=` UINT64
 //
 // The type can be omitted for string attributes, in which case it will be
 // inferred from the value of the string as [strlen(value) x i8].
 ParseResult GlobalOp::parse(OpAsmParser &parser, OperationState &result) {
   MLIRContext *ctx = parser.getContext();
ParseResult GlobalOp::parse(OpAsmParser &parser, OperationState &result) {
   Attribute value;
   if (parser.parseOptionalRParen()) {
     if (parser.parseAttribute(value, getValueAttrName(result.name),
                               result.attributes) ||
         parser.parseRParen())
       return failure();
   }
 
+  if (succeeded(parser.parseOptionalKeyword("comdat"))) {
+    SymbolRefAttr comdat;
+    if (parser.parseLParen() || parser.parseAttribute(comdat) ||
+        parser.parseRParen())
+      return failure();
+
+    result.addAttribute(getComdatAttrName(result.name), comdat);
+  }
+
   SmallVector<Type, 1> types;
   if (parser.parseOptionalAttrDict(result.attributes) ||
       parser.parseOptionalColonTypeList(types))
     return failure();
 
   if (types.size() > 1)
     return parser.emitError(parser.getNameLoc(), "expected zero or one type");
 
LogicalResult GlobalOp::verify() {
   if (getLinkage() == Linkage::Appending) {
     if (!llvm::isa<LLVMArrayType>(getType())) {
       return emitOpError() << "expected array type for '"
                            << stringifyLinkage(Linkage::Appending)
                            << "' linkage";
     }
   }
 
+  if (failed(verifyComdat(*this, getComdat())))
+    return failure();
+
   std::optional<uint64_t> alignAttr = getAlignment();
   if (alignAttr.has_value()) {
     uint64_t value = alignAttr.value();
     if (!llvm::isPowerOf2_64(value))
       return emitError() << "alignment attribute is not a power of 2";
   }
 
   return success();

mlir/lib/Target/LLVMIR/ModuleImport.cpp

 #include "mlir/IR/Builders.h"
 #include "mlir/IR/Matchers.h"
 #include "mlir/Interfaces/DataLayoutInterfaces.h"
 #include "mlir/Tools/mlir-translate/Translation.h"
 
 #include "llvm/ADT/PostOrderIterator.h"
 #include "llvm/ADT/ScopeExit.h"
 #include "llvm/ADT/StringSet.h"
+#include "llvm/IR/Comdat.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/InlineAsm.h"
 #include "llvm/IR/InstIterator.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/IntrinsicInst.h"
 #include "llvm/IR/Metadata.h"
 #include "llvm/IR/Operator.h"
 #include "llvm/Support/ModRef.h"

 }
 
 /// Returns the symbol name for the module-level metadata operation. It must not
 /// conflict with the user namespace.
 static constexpr StringRef getGlobalMetadataOpName() {
   return "__llvm_global_metadata";
 }
 
+/// Returns the symbol name for the module-level comdat operation. It must not
+/// conflict with the user namespace.
+static constexpr StringRef getGlobalComdatOpName() {
+  return "__llvm_global_comdat";
+}
+
 /// Converts the sync scope identifier of `inst` to the string representation
 /// necessary to build an atomic LLVM dialect operation. Returns the empty
 /// string if the operation has either no sync scope or the default system-level
 /// sync scope attached. The atomic operations only set their sync scope
 /// attribute if they have a non-default sync scope attached.
 static StringRef getLLVMSyncScope(llvm::Instruction *inst) {
   std::optional<llvm::SyncScope::ID> syncScopeID =
       llvm::getAtomicSyncScopeID(inst);
if (globalMetadataOp)
     return globalMetadataOp;
 
   OpBuilder::InsertionGuard guard(builder);
   builder.setInsertionPointToEnd(mlirModule.getBody());
   return globalMetadataOp = builder.create<MetadataOp>(
              mlirModule.getLoc(), getGlobalMetadataOpName());
 }
 
+ComdatOp ModuleImport::getGlobalComdatOp() {
+  if (globalComdatOp)
+    return globalComdatOp;
+
+  OpBuilder::InsertionGuard guard(builder);
+  builder.setInsertionPointToStart(mlirModule.getBody());
+  return globalComdatOp = builder.create<ComdatOp>(mlirModule.getLoc(),
+                                                   getGlobalComdatOpName());
+}
+
 LogicalResult ModuleImport::processTBAAMetadata(const llvm::MDNode *node) {
   Location loc = mlirModule.getLoc();
   SmallVector<const llvm::MDNode *> workList;
   SetVector<const llvm::MDNode *> nodesToConvert;
   workList.push_back(node);
   while (!workList.empty()) {
     const llvm::MDNode *current = workList.pop_back_val();
     if (tbaaMapping.contains(current))
for (const llvm::Instruction &inst : llvm::instructions(func)) {
       if (aliasAnalysisNodes.NoAlias)
         if (failed(processAliasScopeMetadata(aliasAnalysisNodes.NoAlias)))
           return failure();
     }
   }
   return success();
 }
 
+LogicalResult ModuleImport::convertComdats() {
+  ComdatOp comdat = getGlobalComdatOp();
+  OpBuilder::InsertionGuard guard(builder);
+  builder.setInsertionPointToEnd(&comdat.getBody().back());
+  for (auto &kv : llvmModule->getComdatSymbolTable()) {
+    StringRef name = kv.getKey();
+    llvm::Comdat::SelectionKind selector = kv.getValue().getSelectionKind();
+    builder.create<ComdatSelectorOp>(mlirModule.getLoc(), name,
+                                     convertComdatFromLLVM(selector));
+  }
+
+  return success();
+}
+
 LogicalResult ModuleImport::convertGlobals() {
   for (llvm::GlobalVariable &globalVar : llvmModule->globals()) {
     if (globalVar.getName() == getGlobalCtorsVarName() ||
         globalVar.getName() == getGlobalDtorsVarName()) {
       if (failed(convertGlobalCtorsAndDtors(&globalVar))) {
         return emitError(mlirModule.getLoc())
                << "unhandled global variable: " << diag(globalVar);
       }
if (globalVar->hasAtLeastLocalUnnamedAddr()) {
     globalOp.setUnnamedAddr(
         convertUnnamedAddrFromLLVM(globalVar->getUnnamedAddr()));
   }
   if (globalVar->hasSection())
     globalOp.setSection(globalVar->getSection());
   globalOp.setVisibility_(
       convertVisibilityFromLLVM(globalVar->getVisibility()));
 
+  if (globalVar->hasComdat()) {
+    llvm::Comdat *llvmComdat = globalVar->getComdat();
+    ComdatOp comdat = getGlobalComdatOp();
+    if (ComdatSelectorOp selector = dyn_cast<ComdatSelectorOp>(
+            comdat.lookupSymbol(llvmComdat->getName()))) {
+      auto symbolRef =
+          SymbolRefAttr::get(builder.getContext(), getGlobalComdatOpName(),
+                             FlatSymbolRefAttr::get(selector.getSymNameAttr()));
+      globalOp.setComdatAttr(symbolRef);
+    } else
+      return failure();
+  }
+
   return success();
 }
 
 LogicalResult
 ModuleImport::convertGlobalCtorsAndDtors(llvm::GlobalVariable *globalVar) {
   if (!globalVar->hasInitializer() || !globalVar->hasAppendingLinkage())
     return failure();
   auto *initializer =
mlir::translateLLVMIRToModule(std::unique_ptr<llvm::Module> llvmModule,
 
   ModuleImport moduleImport(module.get(), std::move(llvmModule));
   if (failed(moduleImport.initializeImportInterface()))
     return {};
   if (failed(moduleImport.convertDataLayout()))
     return {};
   if (failed(moduleImport.convertMetadata()))
     return {};
+  if (failed(moduleImport.convertComdats()))
+    return {};
   if (failed(moduleImport.convertGlobals()))
     return {};
   if (failed(moduleImport.convertFunctions()))
     return {};
 
   return module;
 }

mlir/lib/Target/LLVMIR/ModuleTranslation.cpp

 #include "mlir/Dialect/LLVMIR/Transforms/LegalizeForExport.h"
 #include "mlir/Dialect/OpenMP/OpenMPDialect.h"
 #include "mlir/Dialect/OpenMP/OpenMPInterfaces.h"
 #include "mlir/IR/Attributes.h"
 #include "mlir/IR/BuiltinOps.h"
 #include "mlir/IR/BuiltinTypes.h"
 #include "mlir/IR/RegionGraphTraits.h"
 #include "mlir/Support/LLVM.h"
+#include "mlir/Support/LogicalResult.h"
 #include "mlir/Target/LLVMIR/LLVMTranslationInterface.h"
 #include "mlir/Target/LLVMIR/TypeToLLVM.h"
 
 #include "llvm/ADT/PostOrderIterator.h"
 #include "llvm/ADT/SetVector.h"
 #include "llvm/ADT/TypeSwitch.h"
 #include "llvm/Frontend/OpenMP/OMPIRBuilder.h"
 #include "llvm/IR/BasicBlock.h"
for (auto op : getModuleBody(mlirModule).getOps<LLVM::GlobalOp>()) {
 
     auto *var = new llvm::GlobalVariable(
         *llvmModule, type, op.getConstant(), linkage, cst, op.getSymName(),
         /*InsertBefore=*/nullptr,
         op.getThreadLocal_() ? llvm::GlobalValue::GeneralDynamicTLSModel
                              : llvm::GlobalValue::NotThreadLocal,
         addrSpace);
 
+    if (std::optional<mlir::SymbolRefAttr> comdat = op.getComdat()) {
+      StringRef name = comdat->getLeafReference().getValue();
+      if (!llvmModule->getComdatSymbolTable().contains(name))
+        return emitError(op.getLoc(), "global references non-existant comdat");
+      llvm::Comdat *llvmComdat = llvmModule->getOrInsertComdat(name);
+      var->setComdat(llvmComdat);
+    }
+
     if (op.getUnnamedAddr().has_value())
       var->setUnnamedAddr(convertUnnamedAddrToLLVM(*op.getUnnamedAddr()));
 
     if (op.getSection().has_value())
       var->setSection(*op.getSection());
 
     addRuntimePreemptionSpecifier(op.getDsoLocal(), var);
 
for (auto function : getModuleBody(mlirModule).getOps<LLVMFuncOp>()) {
 
     if (failed(convertOneFunction(function)))
       return failure();
   }
 
   return success();
 }
 
+LogicalResult ModuleTranslation::convertComdats() {
+  for (ComdatOp comdat : getModuleBody(mlirModule).getOps<ComdatOp>()) {
+    for (ComdatSelectorOp selector : comdat.getOps<ComdatSelectorOp>()) {
+      StringRef name = selector.getName();
+      llvm::Module *module = getLLVMModule();
+      if (module->getComdatSymbolTable().contains(name)) {
+        return emitError(selector.getLoc())
+               << "comdat selection symbols must be unique even in different "
+                  "comdat regions";
+      }
+      llvm::Comdat *comdat = module->getOrInsertComdat(name);
+      comdat->setSelectionKind(convertComdatToLLVM(selector.getComdat()));
+    }
+  }
+  return success();
+}
+
 LogicalResult ModuleTranslation::createAccessGroupMetadata() {
   return loopAnnotationTranslation->createAccessGroupMetadata();
 }
 
 void ModuleTranslation::setAccessGroupsMetadata(AccessGroupOpInterface op,
                                                 llvm::Instruction *inst) {
   if (llvm::MDNode *node = loopAnnotationTranslation->getAccessGroups(op))
     inst->setMetadata(llvm::LLVMContext::MD_access_group, node);
mlir::translateModuleToLLVMIR(Operation *module, llvm::LLVMContext &llvmContext,
   if (!llvmModule)
     return nullptr;
 
   LLVM::ensureDistinctSuccessors(module);
 
   ModuleTranslation translator(module, std::move(llvmModule));
   if (failed(translator.convertFunctionSignatures()))
     return nullptr;
+  if (failed(translator.convertComdats()))
+    return nullptr;
   if (failed(translator.convertGlobals()))
     return nullptr;
   if (failed(translator.createAccessGroupMetadata()))
     return nullptr;
   if (failed(translator.createAliasScopeMetadata()))
     return nullptr;
   if (failed(translator.createTBAAMetadata()))
     return nullptr;
   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>(&o) &&
+             LLVM::GlobalDtorsOp, LLVM::MetadataOp, LLVM::ComdatOp>(&o) &&
         !o.hasTrait<OpTrait::IsTerminator>() &&
         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);
 }

mlir/test/Dialect/LLVMIR/comdat.mlir

+// RUN: mlir-opt -split-input-file -verify-diagnostics %s | FileCheck %s
+
+// CHECK: llvm.comdat @__llvm_comdat
+llvm.comdat @__llvm_comdat {
+  // CHECK: llvm.comdat_selector @any_comdat any
+  llvm.comdat_selector @any_comdat any
+  // CHECK: llvm.comdat_selector @exactmatch_comdat exactmatch
+  llvm.comdat_selector @exactmatch_comdat exactmatch
+  // CHECK: llvm.comdat_selector @largest_comdat largest
+  llvm.comdat_selector @largest_comdat largest
+  // CHECK: llvm.comdat_selector @nodeduplicate_comdat nodeduplicate
+  llvm.comdat_selector @nodeduplicate_comdat nodeduplicate
+  // CHECK: llvm.comdat_selector @samesize_comdat samesize
+  llvm.comdat_selector @samesize_comdat samesize
+}
+

mlir/test/Dialect/LLVMIR/global.mlir

 llvm.mlir.global weak_odr @weak_odr() : i64
 // CHECK: llvm.mlir.global external @has_thr_local(42 : i64) {addr_space = 0 : i32, thr_local} : i64
 llvm.mlir.global external @has_thr_local(42 : i64) {thr_local} : i64
 // CHECK: llvm.mlir.global external @has_dso_local(42 : i64) {addr_space = 0 : i32, dso_local} : i64
 llvm.mlir.global external @has_dso_local(42 : i64) {dso_local} : i64
 // CHECK: llvm.mlir.global external @has_addr_space(32 : i64) {addr_space = 3 : i32} : i64
 llvm.mlir.global external @has_addr_space(32 : i64) {addr_space = 3: i32} : i64
 
+// CHECK: llvm.comdat @__llvm_comdat
+llvm.comdat @__llvm_comdat {
+  // CHECK: llvm.comdat_selector @any any
+  llvm.comdat_selector @any any
+}
+// CHECK: llvm.mlir.global external @any() comdat(@__llvm_comdat::@any) {addr_space = 0 : i32} : i64
+llvm.mlir.global @any() comdat(@__llvm_comdat::@any) : i64
+
 // CHECK-LABEL: references
 func.func @references() {
   // CHECK: llvm.mlir.addressof @".string" : !llvm.ptr
   %0 = llvm.mlir.addressof @".string" : !llvm.ptr
 
   // CHECK: llvm.mlir.addressof @global : !llvm.ptr
   %1 = llvm.mlir.addressof @global : !llvm.ptr
 

mlir/test/Dialect/LLVMIR/invalid.mlir

func.func @invalid_target_ext_constant() {
   %0 = llvm.mlir.constant(0 : index) : !llvm.target<"invalid_constant">
 }
 
 // -----
 
 func.func @invalid_target_ext_constant() {
   // expected-error@+1 {{only zero-initializer allowed for target extension types}}
   %0 = llvm.mlir.constant(42 : index) : !llvm.target<"spirv.Event">
 }
+
+// -----
+
+llvm.comdat @__llvm_comdat {
+  // expected-error@+1 {{only comdat selector symbols can appear in a comdat region}}
+  llvm.return
+}
+
+// -----
+
+llvm.mlir.global @not_comdat(0 : i32) : i32
+// expected-error@+1 {{expected comdat symbol}}
+llvm.mlir.global @invalid_comdat_use(0 : i32) comdat(@not_comdat) : i32

mlir/test/Target/LLVMIR/Import/comdat.ll

+; RUN: mlir-translate -import-llvm %s | FileCheck %s
+
+; CHECK: llvm.mlir.global external @foo(42 : i64) comdat(@__llvm_global_comdat::@foo) {addr_space = 0 : i32} : i64
+@foo = global i64 42, comdat
+; CHECK: llvm.mlir.global external @bar(42 : i64) comdat(@__llvm_global_comdat::@foo) {addr_space = 0 : i32} : i64
+@bar = global i64 42, comdat($foo)
+
+; CHECK: llvm.comdat @__llvm_global_comdat {
+; CHECK-DAG: llvm.comdat_selector @foo any
+$foo = comdat any
+; CHECK-DAG: llvm.comdat_selector @exact exactmatch
+$exact = comdat exactmatch
+; CHECK-DAG: llvm.comdat_selector @largest largest
+$largest = comdat largest
+; CHECK-DAG: llvm.comdat_selector @nodedup nodeduplicate
+$nodedup = comdat nodeduplicate
+; CHECK-DAG: llvm.comdat_selector @same samesize
+$same = comdat samesize
+
+; CHECK: }

mlir/test/Target/LLVMIR/llvmir-invalid.mlir

 
 // -----
 
 llvm.func @stepvector_intr_wrong_type() -> vector<7xf32> {
   // expected-error @below{{op result #0 must be LLVM dialect-compatible vector of signless integer, but got 'vector<7xf32>'}}
   %0 = llvm.intr.experimental.stepvector : vector<7xf32>
   llvm.return %0 : vector<7xf32>
 }
+
+// -----
+
+llvm.comdat @__llvm_comdat {
+  llvm.comdat_selector @foo any
+}
+
+llvm.comdat @__llvm_comdat_1 {
+  // expected-error @below{{comdat selection symbols must be unique even in different comdat regions}}
+  llvm.comdat_selector @foo any
+}

mlir/test/Target/LLVMIR/llvmir.mlir

 // RUN: mlir-translate -mlir-to-llvmir -split-input-file %s | FileCheck %s
 
+
+// Comdat sections
+llvm.comdat @__llvm_comdat {
+  // CHECK: $any = comdat any
+  llvm.comdat_selector @any any
+  // CHECK: $exactmatch = comdat exactmatch
+  llvm.comdat_selector @exactmatch exactmatch
+  // CHECK: $largest = comdat largest
+  llvm.comdat_selector @largest largest
+  // CHECK: $nodeduplicate = comdat nodeduplicate
+  llvm.comdat_selector @nodeduplicate nodeduplicate
+  // CHECK: $samesize = comdat samesize
+  llvm.comdat_selector @samesize samesize
+}
+
+
 // CHECK: @global_aligned32 = private global i64 42, align 32
 "llvm.mlir.global"() ({}) {sym_name = "global_aligned32", global_type = i64, value = 42 : i64, linkage = #llvm.linkage<private>, alignment = 32} : () -> ()
 
 // CHECK: @global_aligned64 = private global i64 42, align 64
 llvm.mlir.global private @global_aligned64(42 : i64) {alignment = 64 : i64} : i64
 
 // CHECK: @global_aligned64_native = private global i64 42, align 64
 llvm.mlir.global private @global_aligned64_native(42 : i64) { alignment = 64 } : i64

 //
 // Section attribute.
 //
 
 // CHECK: @sectionvar = internal constant [10 x i8] c"teststring", section ".mysection"
 llvm.mlir.global internal constant @sectionvar("teststring")  {section = ".mysection"}: !llvm.array<10 x i8>
 
 //
+// Comdat attribute.
+//
+// CHECK: @has_any_comdat = internal constant i64 1, comdat($any)
+llvm.mlir.global internal constant @has_any_comdat(1 : i64) comdat(@__llvm_comdat::@any) : i64
+// CHECK: @has_exactmatch_comdat = internal constant i64 1, comdat($exactmatch)
+llvm.mlir.global internal constant @has_exactmatch_comdat(1 : i64) comdat(@__llvm_comdat::@exactmatch) : i64
+// CHECK: @has_largest_comdat = internal constant i64 1, comdat($largest)
+llvm.mlir.global internal constant @has_largest_comdat(1 : i64) comdat(@__llvm_comdat::@largest) : i64
+// CHECK: @has_nodeduplicate_comdat = internal constant i64 1, comdat($nodeduplicate)
+llvm.mlir.global internal constant @has_nodeduplicate_comdat(1 : i64) comdat(@__llvm_comdat::@nodeduplicate) : i64
+// CHECK: @has_samesize_comdat = internal constant i64 1, comdat($samesize)
+llvm.mlir.global internal constant @has_samesize_comdat(1 : i64) comdat(@__llvm_comdat::@samesize) : i64
+
+//
 // Declarations of the allocation functions to be linked against. These are
 // inserted before other functions in the module.
 //
 
 // CHECK: declare ptr @malloc(i64)
 llvm.func @malloc(i64) -> !llvm.ptr<i8>
 // CHECK: declare void @free(ptr)