[mlir][llvmir] Cleaned up MetadataOp.

[vzakhari]

Summary

Added NoTerminator trait, and created a single builder
that adds a block into the region at operation construction.
Added custom assembly parser that automatically adds the body
block, when the region appears to be empty to parseRegion().

[ftynse]

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

1015–1022

Nit: can we move this to a .cpp file?

mlir/test/Dialect/LLVMIR/invalid.mlir

869–870

Can't we omit this? I think the C++ printer/parser API has a flag for this.

[vzakhari]

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

1015–1022

Sure.

mlir/test/Dialect/LLVMIR/invalid.mlir

869–870

The operation's region is defined as SizedRegion<1>, so removing the block id causes verification failure:

'llvm.metadata' op region #0 ('body') failed to verify constraint: region with 1 blocks

I was not able to find the printer/parse API flag to avoid this - can you please give me a pointer?

I could probably add custom parser that uses parseRegion and then automatically creates the body block, if one was not created due to parseRegionBody not being invoked in mlir/lib/AsmParser/Parser.cpp:OperationParser::parseRegion:

// Parse the region body.
if ((!entryArguments.empty() || getToken().isNot(Token::r_brace)) &&
    parseRegionBody(region, lBraceTok.getLoc(), entryArguments,
                    isIsolatedNameScope)) {
  return failure();
}

Alternatively, we can define MetadataOp's region as:

let regions = (region MaxSizedRegion<1>:$body);

This will require adding MaxSizedRegion constraint definition (we only have MinSizedRegion right now).

Which approach would you prefer?

[vzakhari]

• Changed MetadataOp builder implementation placement.

[ftynse]

mlir/test/Dialect/LLVMIR/invalid.mlir

869–870

We do custom parsing for, e.g., loop constructs such as scf.for, so I'd go with that. Allowing something in the ODS constraint only to disallow it in the verifier (assuming we don't really want zero-block regions here) is smelly.

[vzakhari]

• Added custom printer/parser.

mlir/test/Dialect/LLVMIR/invalid.mlir

869–870

For the latter, I thought about actually allowing zero-block regions for MetadataOp. This would be a nop operation, so it should make little sense but no harm. The custom printer/parser seems to be best solution.

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

let extraClassDeclaration = [{
     /// Return the llvm.func operation that is referenced here.
     LLVMFuncOp getFunction(SymbolTableCollection &symbolTable);
   }];
 
   let assemblyFormat = "$global_name attr-dict `:` qualified(type($res))";
 }
 
 def LLVM_MetadataOp : LLVM_Op<"metadata", [
-   NoRegionArguments, SymbolTable, Symbol
+   NoRegionArguments, NoTerminator, SymbolTable, Symbol
 ]> {
   let arguments = (ins
     SymbolNameAttr:$sym_name
   );
   let summary = "LLVM dialect metadata.";
   let description = [{
     llvm.metadata op defines one or more metadata nodes.
 
     Example:
       llvm.metadata @metadata {
         llvm.access_group @group1
         llvm.access_group @group2
-        llvm.return
       }
   }];
   let regions = (region SizedRegion<1>:$body);
-  let assemblyFormat = "$sym_name attr-dict-with-keyword $body";
+
+  let skipDefaultBuilders = 1;
+
+  let builders = [
+    OpBuilder<(ins "StringRef":$symName,
+        CArg<"bool", "true">:$createBodyBlock,
+        CArg<"ArrayRef<NamedAttribute>", "{}">:$attributes)>
+  ];
+
+  let hasCustomAssemblyFormat = 1;
   let hasRegionVerifier = 1;
 }
 
 def LLVM_AliasScopeDomainMetadataOp : LLVM_Op<"alias_scope_domain", [
   HasParent<"MetadataOp">, Symbol
 ]> {
   let arguments = (ins
     SymbolNameAttr:$sym_name,
     OptionalAttr<StrAttr>:$description
   );
   let summary = "LLVM dialect alias.scope domain metadata.";
   let description = [{
     Defines a domain that may be associated with an alias scope.
Example:
             llvm.return
         }
 
         llvm.metadata @metadata {
           llvm.alias_scope_domain @unused_domain
           llvm.alias_scope_domain @domain { description = "Optional domain description"}
           llvm.alias_scope @scope1 { domain = @domain }
           llvm.alias_scope @scope2 { domain = @domain, description = "Optional scope description" }
-          llvm.return
         }
       }
 
     See the following link for more details:
     https://llvm.org/docs/LangRef.html#noalias-and-alias-scope-metadata
   }];
   let assemblyFormat = "$sym_name attr-dict";
 }
]> {
   );
   let summary = "LLVM dialect TBAA root node metadata.";
   let description = [{
     Defines a TBAA root node.
 
     Example:
       llvm.metadata @tbaa {
         llvm.tbaa_root @tbaa_root_0 {identity = "Simple C/C++ TBAA"}
-        llvm.return
       }
 
     See the following link for more details:
     https://llvm.org/docs/LangRef.html#tbaa-metadata
   }];
   let assemblyFormat = [{
     $sym_name ` ` `{` `id` `=` $identity `}` attr-dict
   }];
Example:
             members = [@tbaa_type_desc_1],
             offsets = array<i64: 0>
         }
         llvm.tbaa_type_desc @tbaa_type_desc_6 {
             identity = "agg1_t",
             members = [@tbaa_type_desc_5, @tbaa_type_desc_5],
             offsets = array<i64: 0, 4>
         }
-        llvm.return
       }
 
     See the following link for more details:
     https://llvm.org/docs/LangRef.html#tbaa-metadata
   }];
 
   // Interleave member types and offsets for better matching
   // LLVM IR text representation.
Example:
             members = [@tbaa_type_desc_5, @tbaa_type_desc_5],
             offsets = array<i64: 0, 4>
         }
         llvm.tbaa_tag @tbaa_tag_7 {
             access_type = @tbaa_type_desc_5,
             base_type = @tbaa_type_desc_6,
             offset = 0 : i64
         }
-        llvm.return
       }
 
     See the following link for more details:
     https://llvm.org/docs/LangRef.html#tbaa-metadata
   }];
   let assemblyFormat = "$sym_name attr-dict";
 }
 

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

OpFoldResult LLVM::GEPOp::fold(FoldAdaptor adaptor) {
 
   return {};
 }
 
 //===----------------------------------------------------------------------===//
 // Utilities for LLVM::MetadataOp
 //===----------------------------------------------------------------------===//
 
+void MetadataOp::build(OpBuilder &builder, OperationState &result,
+                       StringRef symName, bool createBodyBlock,
+                       ArrayRef<NamedAttribute> attributes) {
+  result.addAttribute(getSymNameAttrName(result.name),
+                      builder.getStringAttr(symName));
+  result.attributes.append(attributes.begin(), attributes.end());
+  Region *body = result.addRegion();
+  if (createBodyBlock)
+    body->emplaceBlock();
+}
+
+ParseResult MetadataOp::parse(OpAsmParser &parser, OperationState &result) {
+  StringAttr symName;
+  if (parser.parseSymbolName(symName, getSymNameAttrName(result.name),
+                             result.attributes) ||
+      parser.parseOptionalAttrDictWithKeyword(result.attributes))
+    return failure();
+
+  Region *bodyRegion = result.addRegion();
+  if (parser.parseRegion(*bodyRegion))
+    return failure();
+
+  // If the region appeared to be empty to parseRegion(),
+  // add the body block explicitly.
+  if (bodyRegion->empty())
+    bodyRegion->emplaceBlock();
+
+  return success();
+}
+
+void MetadataOp::print(OpAsmPrinter &printer) {
+  printer << ' ';
+  printer.printSymbolName(getSymName());
+  printer.printOptionalAttrDictWithKeyword((*this)->getAttrs(),
+                                           {getSymNameAttrName().getValue()});
+  printer << ' ';
+  printer.printRegion(getBody());
+}
+
 namespace {
 // A node of the TBAA graph.
 struct TBAAGraphNode {
   // Symbol name defined by a TBAA operation.
   StringRef symbol;
   // Operands (if any) of the TBAA operation.
   SmallVector<TBAAGraphNode *> operands;
 };

mlir/lib/Target/LLVMIR/ModuleImport.cpp

MetadataOp ModuleImport::getTBAAMetadataOp() {
   if (tbaaMetadataOp)
     return tbaaMetadataOp;
 
   OpBuilder::InsertionGuard guard(builder);
   Location loc = mlirModule.getLoc();
 
   builder.setInsertionPointToEnd(mlirModule.getBody());
   tbaaMetadataOp = builder.create<MetadataOp>(loc, getTBAAMetadataOpName());
-  builder.createBlock(&tbaaMetadataOp.getBody());
-  builder.create<ReturnOp>(loc, Value{});
 
   return tbaaMetadataOp;
 }
 
 std::string ModuleImport::getNewTBAANodeName(StringRef basename) {
   return (Twine("tbaa_") + Twine(basename) + Twine('_') +
           Twine(tbaaNodeCounter++))
       .str();
if (accessSymRef)
       *accessSymRef = tbaaMapping.lookup(accessMD);
     if (offset)
       *offset = offsetCI->getZExtValue();
     if (isConstant)
       *isConstant = isConst;
     return true;
   };
 
-  // Insert new operations before the terminator.
+  // Insert new operations at the end of the MetadataOp.
   OpBuilder::InsertionGuard guard(builder);
-  builder.setInsertionPoint(&getTBAAMetadataOp().getBody().back().back());
+  builder.setInsertionPointToEnd(&getTBAAMetadataOp().getBody().back());
   StringAttr metadataOpName = SymbolTable::getSymbolName(getTBAAMetadataOp());
 
   // On the first walk, create SymbolRefAttr's and map them
   // to nodes in `nodesToConvert`.
   for (const auto *current : nodesToConvert) {
     if (std::optional<StringRef> identity = getIdentityIfRootNode(current)) {
       if (identity.value().empty())
         return emitError(loc) << "TBAA root node must have non-empty identity: "
for (const auto *current : nodesToConvert) {
     }
   }
 
   return success();
 }
 
 LogicalResult ModuleImport::convertMetadata() {
   OpBuilder::InsertionGuard guard(builder);
-  builder.setInsertionPoint(mlirModule.getBody(), mlirModule.getBody()->end());
+  builder.setInsertionPointToEnd(mlirModule.getBody());
   for (const llvm::Function &func : llvmModule->functions())
     for (const llvm::Instruction &inst : llvm::instructions(func)) {
       llvm::AAMDNodes nodes = inst.getAAMetadata();
       if (!nodes)
         continue;
 
       if (const llvm::MDNode *tbaaMD = nodes.TBAA)
         if (failed(processTBAAMetadata(tbaaMD)))

mlir/test/Dialect/LLVMIR/invalid.mlir

 
 module {
   llvm.func @loopOptions() {
       // expected-error@below {{expected '@metadata' to reference an access_group op}}
       llvm.br ^bb4 {llvm.loop = {parallel_access = [@metadata]}}
     ^bb4:
       llvm.return
   }
   llvm.metadata @metadata {
-    llvm.return
   }
 }
 
 // -----
 
 module {
   llvm.func @loopOptions() {
       // expected-error@below {{expected 'options' to be a `loopopts` attribute}}
       llvm.br ^bb4 {llvm.loop = {options = "name"}}

 
 module {
   llvm.func @accessGroups(%arg0 : !llvm.ptr<i32>) {
       // expected-error@below {{expected '@accessGroups::@group1' to reference a metadata op}}
       %0 = llvm.load %arg0 { "access_groups" = [@accessGroups::@group1] } : !llvm.ptr<i32>
       llvm.return
   }
   llvm.metadata @metadata {
-    llvm.return
   }
 }
 
 // -----
 
 module {
   llvm.func @accessGroups(%arg0 : !llvm.ptr<i32>) {
       // expected-error@below {{expected '@metadata::@group1' to be a valid reference}}
       %0 = llvm.load %arg0 { "access_groups" = [@metadata::@group1] } : !llvm.ptr<i32>
       llvm.return
   }
   llvm.metadata @metadata {
-    llvm.return
   }
 }
 
 // -----
 
 module {
   llvm.func @accessGroups(%arg0 : !llvm.ptr<i32>) {
       // expected-error@below {{expected '@metadata::@scope' to resolve to a llvm.access_group}}
       %0 = llvm.load %arg0 { "access_groups" = [@metadata::@scope] } : !llvm.ptr<i32>
       llvm.return
   }
   llvm.metadata @metadata {
     llvm.alias_scope_domain @domain
     llvm.alias_scope @scope { domain = @domain }
-    llvm.return
   }
 }
 
 // -----
 
 module {
   llvm.func @accessGroups(%arg0 : !llvm.ptr<i32>) {
       // expected-error@below {{attribute 'alias_scopes' failed to satisfy constraint: symbol ref array attribute}}

 module {
   llvm.func @aliasScope(%arg0 : !llvm.ptr<i32>) {
       // expected-error@below {{expected '@metadata::@group' to resolve to a llvm.alias_scope}}
       %0 = llvm.load %arg0 { "alias_scopes" = [@metadata::@group] } : !llvm.ptr<i32>
       llvm.return
   }
   llvm.metadata @metadata {
     llvm.access_group @group
-    llvm.return
   }
 }
 
 // -----
 
 module {
   llvm.func @aliasScope(%arg0 : !llvm.ptr<i32>) {
       // expected-error@below {{expected '@metadata::@group' to resolve to a llvm.alias_scope}}
       %0 = llvm.load %arg0 { "noalias_scopes" = [@metadata::@group] } : !llvm.ptr<i32>
       llvm.return
   }
   llvm.metadata @metadata {
     llvm.access_group @group
-    llvm.return
   }
 }
 
 // -----
 
 llvm.func @wmmaLoadOp_invalid_mem_space(%arg0: !llvm.ptr<i32, 5>, %arg1: i32) {
   // expected-error@+1 {{'nvvm.wmma.load' op expected source pointer in memory space 0, 1, 3}}
   %0 = nvvm.wmma.load %arg0, %arg1

mlir/test/Dialect/LLVMIR/roundtrip.mlir

llvm.func @loopOptions() {
     llvm.br ^bb1 {llvm.loop = {options = #llvm.loopopts<disable_unroll = true, disable_licm = true, interleave_count = 1, disable_pipeline = true, pipeline_initiation_interval = 1>}, parallel_access = [@metadata::@group1]}
   ^bb1:
     llvm.return
   }
   // CHECK: llvm.metadata @metadata attributes {test_attribute} {
   llvm.metadata @metadata attributes {test_attribute} {
     // CHECK: llvm.access_group @group1
     llvm.access_group @group1
-    llvm.return
   }
 }
 
 // CHECK-LABEL: llvm.func @vararg_func
 llvm.func @vararg_func(%arg0: i32, ...) {
   // CHECK: %{{.*}} = llvm.mlir.constant(1 : i32) : i32
   // CHECK: %{{.*}} = llvm.mlir.constant(1 : i32) : i32
   %0 = llvm.mlir.constant(1 : i32) : i32

mlir/test/Dialect/LLVMIR/tbaa-invalid.mlir

 // RUN: mlir-opt -split-input-file -verify-diagnostics %s
 
 module {
   llvm.metadata @__tbaa {
     llvm.tbaa_root @tbaa_root_0 {id = "Simple C/C++ TBAA"}
     llvm.tbaa_tag @tbaa_tag_1 {access_type = @tbaa_root_0, base_type = @tbaa_root_0, offset = 0 : i64}
-    llvm.return
   }
   llvm.func @tbaa(%arg0: !llvm.ptr) {
     %0 = llvm.mlir.constant(1 : i8) : i8
     // expected-error@below {{expected '@tbaa_tag_1' to specify a fully qualified reference}}
     llvm.store %0, %arg0 {llvm.tbaa = [@tbaa_tag_1]} : i8, !llvm.ptr
     llvm.return
   }
 }
module {
   llvm.func @tbaa(%arg0: !llvm.ptr) {
     %0 = llvm.mlir.constant(1 : i8) : i8
     // expected-error@below {{expected '@metadata::@group1' to resolve to a llvm.tbaa_tag}}
     llvm.store %0, %arg0 {llvm.tbaa = [@metadata::@group1]} : i8, !llvm.ptr
     llvm.return
   }
   llvm.metadata @metadata {
     llvm.access_group @group1
-    llvm.return
   }
 }
 
 // -----
 
 module {
   llvm.func @tbaa(%arg0: !llvm.ptr) {
     %0 = llvm.mlir.constant(1 : i8) : i8
     // expected-error@below {{expected '@metadata::@sym' to be a valid reference}}
     llvm.store %0, %arg0 {llvm.tbaa = [@metadata::@sym]} : i8, !llvm.ptr
     llvm.return
   }
   llvm.metadata @metadata {
-    llvm.return
   }
 }
 
 // -----
 
 llvm.func @tbaa(%arg0: !llvm.ptr) {
   %0 = llvm.mlir.constant(1 : i8) : i8
   // expected-error@below {{expected '@tbaa::@sym' to reference a metadata op}}
llvm.func @tbaa() {
   llvm.return
 }
 
 // -----
 
 module {
   llvm.metadata @__tbaa {
     llvm.tbaa_root @tbaa_root_0 {id = "Simple C/C++ TBAA"}
-    llvm.return
   }
 
   llvm.func @tbaa() {
     // expected-error@below {{expects parent op 'llvm.metadata'}}
     llvm.tbaa_type_desc @tbaa_type_desc_1 {id = "omnipotent char", members = {<@tbaa_root_0, 0>}}
     llvm.return
   }
 }
 
 // -----
 
 module {
   llvm.metadata @__tbaa {
     llvm.tbaa_root @tbaa_root_0 {id = "Simple C/C++ TBAA"}
-    llvm.return
   }
 
   llvm.func @tbaa() {
     // expected-error@below {{expects parent op 'llvm.metadata'}}
     llvm.tbaa_tag @tbaa_tag_1 {access_type = @tbaa_root_0, base_type = @tbaa_root_0, offset = 0 : i64}
     llvm.return
   }
 }
 
 // -----
 
 module {
   llvm.metadata @__tbaa {
     // expected-error@below {{expected non-empty "identity"}}
     llvm.tbaa_root @tbaa_root_0 {id = ""}
-    llvm.return
   }
 }
 
 // -----
 
   "builtin.module"() ({
     "llvm.metadata"() ({
       "llvm.tbaa_root"() {identity = "Simple C/C++ TBAA", sym_name = "tbaa_root_0"} : () -> ()
       "llvm.tbaa_type_desc"() {identity = "omnipotent char", members = [@tbaa_root_0], offsets = array<i64: 0>, sym_name = "tbaa_type_desc_1"} : () -> ()
     // expected-error@below {{expected the same number of elements in "members" and "offsets": 2 != 1}}
       "llvm.tbaa_type_desc"() {identity = "agg_t", members = [@tbaa_type_desc_1, @tbaa_type_desc_1], offsets = array<i64: 0>, sym_name = "tbaa_type_desc_2"} : () -> ()
-      "llvm.return"() : () -> ()
     }) {sym_name = "__tbaa"} : () -> ()
   }) : () -> ()
 
 // -----
 
 module {
   llvm.metadata @__tbaa {
     llvm.tbaa_root @tbaa_root_0 {id = "Simple C/C++ TBAA"}
     // expected-error@below {{expected "base_type" to reference a symbol from 'llvm.metadata @__tbaa' defined by either 'llvm.tbaa_root' or 'llvm.tbaa_type_desc' while it references '@tbaa_root_2'}}
     llvm.tbaa_tag @tbaa_tag_1 {access_type = @tbaa_root_0, base_type = @tbaa_root_2, offset = 0 : i64}
-    llvm.return
   }
 }
 
 // -----
 
 module {
   llvm.metadata @__tbaa {
     llvm.tbaa_root @tbaa_root_0 {id = "Simple C/C++ TBAA"}
     // expected-error@below {{expected "access_type" to reference a symbol from 'llvm.metadata @__tbaa' defined by either 'llvm.tbaa_root' or 'llvm.tbaa_type_desc' while it references '@tbaa_root_2'}}
     llvm.tbaa_tag @tbaa_tag_1 {access_type = @tbaa_root_2, base_type = @tbaa_root_0, offset = 0 : i64}
-    llvm.return
   }
 }
 
 // -----
 
 module {
   llvm.metadata @__tbaa {
     llvm.tbaa_root @tbaa_root_0 {id = "Simple C/C++ TBAA"}
     llvm.tbaa_type_desc @tbaa_type_desc_1 {id = "omnipotent char", members = {<@tbaa_root_0, 0>}}
     llvm.tbaa_type_desc @tbaa_type_desc_2 {id = "long long", members = {<@tbaa_type_desc_1, 0>}}
     // expected-error@below {{expected "members" to reference a symbol from 'llvm.metadata @__tbaa' defined by either 'llvm.tbaa_root' or 'llvm.tbaa_type_desc' while it references '@tbaa_type_desc_4'}}
     llvm.tbaa_type_desc @tbaa_type_desc_3 {id = "agg2_t", members = {<@tbaa_type_desc_2, 0>, <@tbaa_type_desc_4, 8>}}
-    llvm.return
   }
 }
 
 // -----
 
 module {
   llvm.metadata @__tbaa {
     llvm.tbaa_root @tbaa_root_0 {id = "Simple C/C++ TBAA"}
     llvm.tbaa_tag @tbaa_tag_1 {access_type = @tbaa_root_0, base_type = @tbaa_root_0, offset = 0 : i64}
     // expected-error@below {{expected "access_type" to reference a symbol from 'llvm.metadata @__tbaa' defined by either 'llvm.tbaa_root' or 'llvm.tbaa_type_desc' while it references '@tbaa_tag_1'}}
     llvm.tbaa_tag @tbaa_tag_2 {access_type = @tbaa_tag_1, base_type = @tbaa_root_0, offset = 0 : i64}
-    llvm.return
   }
 }
 
 // -----
 
 module {
   // expected-error@below {{has cycle in TBAA graph (graph closure: <tbaa_type_desc_2, tbaa_type_desc_1>)}}
   llvm.metadata @__tbaa {
     llvm.tbaa_root @tbaa_root_0 {id = "Simple C/C++ TBAA"}
     llvm.tbaa_type_desc @tbaa_type_desc_1 {id = "omnipotent char", members = {<@tbaa_type_desc_2, 0>}}
     llvm.tbaa_type_desc @tbaa_type_desc_2 {id = "long long", members = {<@tbaa_type_desc_1, 0>}}
-    llvm.return
   }
 }

mlir/test/Dialect/LLVMIR/tbaa-roundtrip.mlir

 // RUN: mlir-opt %s | mlir-opt | FileCheck %s
 
 module {
   llvm.metadata @__tbaa {
     llvm.tbaa_root @tbaa_root_0 {id = "Simple C/C++ TBAA"}
     llvm.tbaa_tag @tbaa_tag_1 {access_type = @tbaa_root_0, base_type = @tbaa_root_0, offset = 0 : i64}
     llvm.tbaa_root @tbaa_root_2 {id = "Other language TBAA"}
     llvm.tbaa_tag @tbaa_tag_3 {access_type = @tbaa_root_2, base_type = @tbaa_root_2, offset = 0 : i64}
-    llvm.return
   }
   llvm.func @tbaa1(%arg0: !llvm.ptr, %arg1: !llvm.ptr) {
     %0 = llvm.mlir.constant(1 : i8) : i8
     llvm.store %0, %arg0 {tbaa = [@__tbaa::@tbaa_tag_1]} : i8, !llvm.ptr
     llvm.store %0, %arg1 {tbaa = [@__tbaa::@tbaa_tag_3]} : i8, !llvm.ptr
     llvm.return
   }
 }
 
 // CHECK-LABEL:     llvm.metadata @__tbaa {
 // CHECK:             llvm.tbaa_root @tbaa_root_0 {id = "Simple C/C++ TBAA"}
 // CHECK:             llvm.tbaa_tag @tbaa_tag_1 {access_type = @tbaa_root_0, base_type = @tbaa_root_0, offset = 0 : i64}
 // CHECK:             llvm.tbaa_root @tbaa_root_2 {id = "Other language TBAA"}
 // CHECK:             llvm.tbaa_tag @tbaa_tag_3 {access_type = @tbaa_root_2, base_type = @tbaa_root_2, offset = 0 : i64}
-// CHECK:             llvm.return
 // CHECK:           }
 // CHECK:           llvm.func @tbaa1(%[[VAL_0:.*]]: !llvm.ptr, %[[VAL_1:.*]]: !llvm.ptr) {
 // CHECK:             %[[VAL_2:.*]] = llvm.mlir.constant(1 : i8) : i8
 // CHECK:             llvm.store %[[VAL_2]], %[[VAL_0]] {tbaa = [@__tbaa::@tbaa_tag_1]} : i8, !llvm.ptr
 // CHECK:             llvm.store %[[VAL_2]], %[[VAL_1]] {tbaa = [@__tbaa::@tbaa_tag_3]} : i8, !llvm.ptr
 // CHECK:             llvm.return
 // CHECK:           }
 
 module {
   llvm.metadata @__tbaa {
     llvm.tbaa_root @tbaa_root_0 {id = "Simple C/C++ TBAA"}
     llvm.tbaa_type_desc @tbaa_type_desc_1 {id = "omnipotent char", members = {<@tbaa_root_0, 0>}}
     llvm.tbaa_type_desc @tbaa_type_desc_2 {id = "long long", members = {<@tbaa_type_desc_1, 0>}}
     llvm.tbaa_type_desc @tbaa_type_desc_3 {id = "agg2_t", members = {<@tbaa_type_desc_2, 0>, <@tbaa_type_desc_2, 8>}}
     llvm.tbaa_tag @tbaa_tag_4 {access_type = @tbaa_type_desc_2, base_type = @tbaa_type_desc_3, offset = 8 : i64}
     llvm.tbaa_type_desc @tbaa_type_desc_5 {id = "int", members = {<@tbaa_type_desc_1, 0>}}
     llvm.tbaa_type_desc @tbaa_type_desc_6 {id = "agg1_t", members = {<@tbaa_type_desc_5, 0>, <@tbaa_type_desc_5, 4>}}
     llvm.tbaa_tag @tbaa_tag_7 {access_type = @tbaa_type_desc_5, base_type = @tbaa_type_desc_6, offset = 0 : i64}
-    llvm.return
   }
   llvm.func @tbaa2(%arg0: !llvm.ptr, %arg1: !llvm.ptr) {
     %0 = llvm.mlir.constant(0 : i32) : i32
     %1 = llvm.mlir.constant(1 : i32) : i32
     %2 = llvm.getelementptr inbounds %arg1[%0, 1] : (!llvm.ptr, i32) -> !llvm.ptr, !llvm.struct<"struct.agg2_t", (i64, i64)>
     %3 = llvm.load %2 {tbaa = [@__tbaa::@tbaa_tag_4]} : !llvm.ptr -> i64
     %4 = llvm.trunc %3 : i64 to i32
     %5 = llvm.getelementptr inbounds %arg0[%0, 0] : (!llvm.ptr, i32) -> !llvm.ptr, !llvm.struct<"struct.agg1_t", (i32, i32)>
     llvm.store %4, %5 {tbaa = [@__tbaa::@tbaa_tag_7]} : i32, !llvm.ptr
     llvm.return
   }
 }
 
 // CHECK-LABEL:     llvm.metadata @__tbaa {
 // CHECK:             llvm.tbaa_root @tbaa_root_0 {id = "Simple C/C++ TBAA"}
 // CHECK:             llvm.tbaa_type_desc @tbaa_type_desc_1 {id = "omnipotent char", members = {<@tbaa_root_0, 0>}}
 // CHECK:             llvm.tbaa_type_desc @tbaa_type_desc_2 {id = "long long", members = {<@tbaa_type_desc_1, 0>}}
 // CHECK:             llvm.tbaa_type_desc @tbaa_type_desc_3 {id = "agg2_t", members = {<@tbaa_type_desc_2, 0>, <@tbaa_type_desc_2, 8>}}
 // CHECK:             llvm.tbaa_tag @tbaa_tag_4 {access_type = @tbaa_type_desc_2, base_type = @tbaa_type_desc_3, offset = 8 : i64}
 // CHECK:             llvm.tbaa_type_desc @tbaa_type_desc_5 {id = "int", members = {<@tbaa_type_desc_1, 0>}}
 // CHECK:             llvm.tbaa_type_desc @tbaa_type_desc_6 {id = "agg1_t", members = {<@tbaa_type_desc_5, 0>, <@tbaa_type_desc_5, 4>}}
 // CHECK:             llvm.tbaa_tag @tbaa_tag_7 {access_type = @tbaa_type_desc_5, base_type = @tbaa_type_desc_6, offset = 0 : i64}
-// CHECK:             llvm.return
 // CHECK:           }
 // CHECK:           llvm.func @tbaa2(%[[VAL_0:.*]]: !llvm.ptr, %[[VAL_1:.*]]: !llvm.ptr) {
 // CHECK:             %[[VAL_2:.*]] = llvm.mlir.constant(0 : i32) : i32
 // CHECK:             %[[VAL_3:.*]] = llvm.mlir.constant(1 : i32) : i32
 // CHECK:             %[[VAL_4:.*]] = llvm.getelementptr inbounds %[[VAL_1]]{{\[}}%[[VAL_2]], 1] : (!llvm.ptr, i32) -> !llvm.ptr, !llvm.struct<"struct.agg2_t", (i64, i64)>
 // CHECK:             %[[VAL_5:.*]] = llvm.load %[[VAL_4]] {tbaa = [@__tbaa::@tbaa_tag_4]} : !llvm.ptr -> i64
 // CHECK:             %[[VAL_6:.*]] = llvm.trunc %[[VAL_5]] : i64 to i32
 // CHECK:             %[[VAL_7:.*]] = llvm.getelementptr inbounds %[[VAL_0]]{{\[}}%[[VAL_2]], 0] : (!llvm.ptr, i32) -> !llvm.ptr, !llvm.struct<"struct.agg1_t", (i32, i32)>
 // CHECK:             llvm.store %[[VAL_6]], %[[VAL_7]] {tbaa = [@__tbaa::@tbaa_tag_7]} : i32, !llvm.ptr
 // CHECK:             llvm.return
 // CHECK:           }
 
 module {
   llvm.metadata @__tbaa {
     llvm.tbaa_root @tbaa_root_0 {id = "Simple C/C++ TBAA"}
     llvm.tbaa_tag @tbaa_tag_1 {access_type = @tbaa_root_0, base_type = @tbaa_root_0, offset = 0 : i64}
     llvm.tbaa_root @tbaa_root_2 {id = "Other language TBAA"}
     llvm.tbaa_tag @tbaa_tag_3 {access_type = @tbaa_root_2, base_type = @tbaa_root_2, offset = 0 : i64}
-    llvm.return
   }
   llvm.func @tbaa1(%arg0: !llvm.ptr) {
     %0 = llvm.mlir.constant(1 : i8) : i8
     llvm.store %0, %arg0 {tbaa = [@__tbaa::@tbaa_tag_1, @__tbaa::@tbaa_tag_3]} : i8, !llvm.ptr
     llvm.return
   }
 }
 
 // CHECK-LABEL:     llvm.metadata @__tbaa {
 // CHECK:             llvm.tbaa_root @tbaa_root_0 {id = "Simple C/C++ TBAA"}
 // CHECK:             llvm.tbaa_tag @tbaa_tag_1 {access_type = @tbaa_root_0, base_type = @tbaa_root_0, offset = 0 : i64}
 // CHECK:             llvm.tbaa_root @tbaa_root_2 {id = "Other language TBAA"}
 // CHECK:             llvm.tbaa_tag @tbaa_tag_3 {access_type = @tbaa_root_2, base_type = @tbaa_root_2, offset = 0 : i64}
-// CHECK:             llvm.return
 // CHECK:           }
 // CHECK:           llvm.func @tbaa1(%[[VAL_0:.*]]: !llvm.ptr) {
 // CHECK:             %[[VAL_1:.*]] = llvm.mlir.constant(1 : i8) : i8
 // CHECK:             llvm.store %[[VAL_1]], %[[VAL_0]] {tbaa = [@__tbaa::@tbaa_tag_1, @__tbaa::@tbaa_tag_3]} : i8, !llvm.ptr
 // CHECK:             llvm.return
 // CHECK:           }

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

 ; RUN: mlir-translate -import-llvm -split-input-file %s | FileCheck %s
 
 // -----
 
 ; CHECK-LABEL: llvm.metadata @__tbaa {
 ; CHECK-NEXT:    llvm.tbaa_root @[[R0:tbaa_root_[0-9]+]] {id = "Simple C/C++ TBAA"}
 ; CHECK-NEXT:    llvm.tbaa_tag @[[T0:tbaa_tag_[0-9]+]] {access_type = @[[R0]], base_type = @[[R0]], offset = 0 : i64}
 ; CHECK-NEXT:    llvm.tbaa_root @[[R1:tbaa_root_[0-9]+]] {id = "Other language TBAA"}
 ; CHECK-NEXT:    llvm.tbaa_tag @[[T1:tbaa_tag_[0-9]+]] {access_type = @[[R1]], base_type = @[[R1]], offset = 0 : i64}
-; CHECK-NEXT:    llvm.return
 ; CHECK-NEXT:  }
 ; CHECK:       llvm.func @tbaa1
 ; CHECK:         llvm.store %{{.*}}, %{{.*}} {
 ; CHECK-SAME:        tbaa = [@__tbaa::@[[T0]]]
 ; CHECK-SAME:    } : i8, !llvm.ptr
 ; CHECK:         llvm.store %{{.*}}, %{{.*}} {
 ; CHECK-SAME:        tbaa = [@__tbaa::@[[T1]]]
 ; CHECK-SAME:    } : i8, !llvm.ptr

 ; CHECK-NEXT:    llvm.tbaa_root @[[R0:tbaa_root_[0-9]+]] {id = "Simple C/C++ TBAA"}
 ; CHECK-NEXT:    llvm.tbaa_tag @[[T0:tbaa_tag_[0-9]+]] {access_type = @[[D1:tbaa_type_desc_[0-9]+]], base_type = @[[D2:tbaa_type_desc_[0-9]+]], offset = 8 : i64}
 ; CHECK-NEXT:    llvm.tbaa_type_desc @[[D1]] {id = "long long", members = {<@[[D0:tbaa_type_desc_[0-9]+]], 0>}}
 ; CHECK-NEXT:    llvm.tbaa_type_desc @[[D0]] {id = "omnipotent char", members = {<@[[R0]], 0>}}
 ; CHECK-NEXT:    llvm.tbaa_type_desc @[[D2]] {id = "agg2_t", members = {<@[[D1]], 0>, <@[[D1]], 8>}}
 ; CHECK-NEXT:    llvm.tbaa_tag @[[T1:tbaa_tag_[0-9]+]] {access_type = @[[D3:tbaa_type_desc_[0-9]+]], base_type = @[[D4:tbaa_type_desc_[0-9]+]], offset = 0 : i64}
 ; CHECK-NEXT:    llvm.tbaa_type_desc @[[D3]] {id = "int", members = {<@[[D0]], 0>}}
 ; CHECK-NEXT:    llvm.tbaa_type_desc @[[D4]] {id = "agg1_t", members = {<@[[D3]], 0>, <@[[D3]], 4>}}
-; CHECK-NEXT:    llvm.return
 ; CHECK-NEXT:  }
 ; CHECK:       llvm.func @tbaa2
 ; CHECK:         llvm.load %{{.*}} {
 ; CHECK-SAME:        tbaa = [@__tbaa::@[[T0]]]
 ; CHECK-SAME:    } : !llvm.ptr -> i64
 ; CHECK:         llvm.store %{{.*}}, %{{.*}} {
 ; CHECK-SAME:        tbaa = [@__tbaa::@[[T1]]]
 ; CHECK-SAME:    } : i32, !llvm.ptr

mlir/test/Target/LLVMIR/llvmir.mlir

^bb4:
       llvm.br ^bb3(%3 : i32) {llvm.loop = {parallel_access = [@metadata::@group1, @metadata::@group2], options = #llvm.loopopts<disable_unroll = true, disable_licm = true, interleave_count = 1, disable_pipeline = true, pipeline_initiation_interval = 2>}}
     ^bb5:
       llvm.return
   }
 
   llvm.metadata @metadata {
     llvm.access_group @group1
     llvm.access_group @group2
-    llvm.return
   }
 }
 
 // CHECK: ![[LOOP_NODE]] = distinct !{![[LOOP_NODE]], ![[PA_NODE:[0-9]+]], ![[UNROLL_DISABLE_NODE:[0-9]+]], ![[LICM_DISABLE_NODE:[0-9]+]], ![[INTERLEAVE_NODE:[0-9]+]], ![[PIPELINE_DISABLE_NODE:[0-9]+]], ![[II_NODE:[0-9]+]]}
 // CHECK: ![[PA_NODE]] = !{!"llvm.loop.parallel_accesses", ![[GROUP_NODE1:[0-9]+]], ![[GROUP_NODE2:[0-9]+]]}
 // CHECK: ![[GROUP_NODE1]] = distinct !{}
 // CHECK: ![[GROUP_NODE2]] = distinct !{}
 // CHECK: ![[UNROLL_DISABLE_NODE]] = !{!"llvm.loop.unroll.disable", i1 true}
llvm.func @aliasScope(%arg1 : !llvm.ptr<i32>, %arg2 : !llvm.ptr<i32>, %arg3 : !llvm.ptr<i32>) {
       llvm.return
   }
 
   llvm.metadata @metadata {
     llvm.alias_scope_domain @domain { description = "The domain"}
     llvm.alias_scope @scope1 { domain = @domain, description = "The first scope" }
     llvm.alias_scope @scope2 { domain = @domain }
     llvm.alias_scope @scope3 { domain = @domain }
-    llvm.return
   }
 }
 
 // Function
 // CHECK-LABEL: aliasScope
 // CHECK:  store {{.*}}, !alias.scope ![[SCOPES1:[0-9]+]], !noalias ![[SCOPES23:[0-9]+]]
 // CHECK:  store {{.*}}, !alias.scope ![[SCOPES2:[0-9]+]], !noalias ![[SCOPES13:[0-9]+]]
 // CHECK:  load {{.*}},  !alias.scope ![[SCOPES3:[0-9]+]], !noalias ![[SCOPES12:[0-9]+]]

mlir/test/Target/LLVMIR/tbaa.mlir

 // RUN: mlir-translate -mlir-to-llvmir -split-input-file %s | FileCheck %s
 
 module {
   llvm.metadata @__tbaa {
     llvm.tbaa_root @tbaa_root_0 {id = "Simple C/C++ TBAA"}
     llvm.tbaa_type_desc @tbaa_type_desc_1 {id = "omnipotent char", members = {<@tbaa_root_0, 0>}}
     llvm.tbaa_type_desc @tbaa_type_desc_2 {id = "long long", members = {<@tbaa_type_desc_1, 0>}}
     llvm.tbaa_type_desc @tbaa_type_desc_3 {id = "agg2_t", members = {<@tbaa_type_desc_2, 0>, <@tbaa_type_desc_2, 8>}}
     llvm.tbaa_tag @tbaa_tag_4 {access_type = @tbaa_type_desc_2, base_type = @tbaa_type_desc_3, offset = 8 : i64}
     llvm.tbaa_type_desc @tbaa_type_desc_5 {id = "int", members = {<@tbaa_type_desc_1, 0>}}
     llvm.tbaa_type_desc @tbaa_type_desc_6 {id = "agg1_t", members = {<@tbaa_type_desc_5, 0>, <@tbaa_type_desc_5, 4>}}
     llvm.tbaa_tag @tbaa_tag_7 {access_type = @tbaa_type_desc_5, base_type = @tbaa_type_desc_6, offset = 0 : i64, constant}
-    llvm.return
   }
   llvm.func @tbaa2(%arg0: !llvm.ptr, %arg1: !llvm.ptr) {
     %0 = llvm.mlir.constant(0 : i32) : i32
     %1 = llvm.mlir.constant(1 : i32) : i32
     %2 = llvm.getelementptr inbounds %arg1[%0, 1] : (!llvm.ptr, i32) -> !llvm.ptr, !llvm.struct<"struct.agg2_t", (i64, i64)>
     // CHECK: load i64, ptr %{{.*}},{{.*}}!tbaa ![[LTAG:[0-9]*]]
     %3 = llvm.load %2 {llvm.tbaa = [@__tbaa::@tbaa_tag_4]} : !llvm.ptr -> i64
     %4 = llvm.trunc %3 : i64 to i32