[mlir] Support TBAA metadata in LLVMIR dialect.

[vzakhari]

Summary

This change introduces new LLVMIR dialect operations to represent
TBAA root, type descriptor and access tag metadata nodes.

For the purpose of importing TBAA metadata from LLVM IR it only
supports the current version of TBAA format described in
https://llvm.org/docs/LangRef.html#tbaa-metadata (i.e. size-aware
representation introduced in D41501 is not supported).

TBAA attribute support is only added for LLVM::LoadOp and LLVM::StoreOp.
Support for intrinsics operations (e.g. LLVM::MemcpyOp) may be added later.

The TBAA attribute is represented as an array of access tags, though,
LLVM IR supports only single access tag per memory accessing instruction.
I implemented it as an array anticipating similar support in LLVM IR
to combine TBAA graphs with different roots for Flang - one of the options
described in https://docs.google.com/document/d/16kKZVmI585wth01VSaJAqZMZpoX68rcdBmgfj0kNAt0/edit#heading=h.jzzheaz9vqac

It should be easy to restrict MLIR operation to a single access tag,
if we end up using a different approach for Flang.

[ftynse]

This change deserves a short RFC due to its non-trivial design component. Specifically, the handling of potential cycles and the need for some symbol references to be fully qualified need to be described.

mlir/include/mlir/Dialect/LLVMIR/LLVMOpBase.td

55

Please prefix with llvm.

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

155

Nit: add the doc comment.

234

Nit: we don't use Latex-style commands in MLIR documentation. Inline code can be added with Markdown-style backticks.

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

2580–2593

Nit: we usually do something like

if (parser.parseLess() ||
    parser.parseAttribute(...) ||
    parser.parseComma())
  return failure();
...

to make the syntax more "visible" in the code.

2622

This verification ends up being very expensive because we keep retraversing the region of the symbol table op on every call to this function. The less expensive approach is to perform the verification of symbol references in the verifier of the symbol table op. That verifier can traverse the IR twice: the first time to collect all symbols (just use SymbolTable APIs), and the second time to find all references and check their validity.

mlir/lib/Target/LLVMIR/ModuleImport.cpp

53

Nit: Please document top-level entities

[ftynse]

mlir/lib/Target/LLVMIR/ModuleImport.cpp

342

Nit: flip the condition + use continue to decrease indentation below.

343

I find it strange that we will just ignore the metadata on some ops, or if it isn't present in the mapping. This is something that we should report IMO. Potentially as a warning because it's not fatal to the translation process.

359–361

Can't we have the builder of the MetadataOp do this instead?

360

I'm not sure we want to use ReturnOp as a terminator for metadata. It has the semantics of returning from the function with the associated control/data flow-related interfaces.

Also nit: can we use a better location than unknown? We know at least the file name.

376–377

Can't this just use SetVector and avoid the potential footgun of two parallel containers?

394

Nit: there's llvm::for_each. Also, a simple for loop with return in the middle is likely more concise here.

398

We typically want a test for any user-visible error message. I don't see one. Can this happen on valid IR? If not, it's better to turn this into an assert, eventually after emitting a diagnostic.

398–399

I wonder if we should just linearize (e.g., topological sort) the entire graph of MDNodes in the first sweep and then go over that list.
Don't remember offhand, is the graph expected to be a DAG or are cycles legit and just not supported (yet) here? Actually, do we care about the order of conversion? All references go through symbols, it should be okay to create a symbol after creating a reference to it, as long as all references are resolved in the end.

433–434

Nit: don't use specific numbers of stack elements in vectors unless you have a strong reason to pick up, 10 feels arbitrary here.

437

Nit: const auto *, I suppose. clang-tidy will complain.

mlir/lib/Target/LLVMIR/ModuleTranslation.cpp

1189–1191

I would emit a warning instead. Ignoring metadata completely is okay, ignoring it partially sounds like a bug and we should notify the user what we are doing.

1204

mlirModule->getBody().getOps<LLVM::MetadataOp>() is going to be much cheaper because it wouldn't traverse the module in depth, metadata ops can only appear at the top level in a module.

1206

Nit: no need to prefix SmallVector with llvm::. Also, drop the explicit number of stack elements.

1213

Nit: we prefer explicit nullptr for null pointers in MLIR.

1237

Same as above.

[vzakhari]

Thank you for the review, @ftynse! I created RFC: https://discourse.llvm.org/t/rfc-support-tbaa-metadata-in-llvmir-dialect/67436

[vzakhari]

Hi @ftynse, I fixed most of the remarks, and will update the files shortly.

I will change the ModuleImport in a separate update.

mlir/include/mlir/Dialect/LLVMIR/LLVMOpBase.td

55

Yes, it seemed off to me that llvm prefix is not used for noalias_scopes, alias_scopes, parallel_access, options and access_groups as well.

The tablegen does not prefix the attribute names with llvm. because of the way the attributes are defined for operations, e.g.:

def LLVM_LoadOp : LLVM_Op<"load">, MemoryOpWithAlignmentAndAttributes {
  let arguments = (ins Arg<LLVM_PointerTo<LLVM_LoadableType>, "", [MemRead]>:$addr,
                   OptionalAttr<SymbolRefArrayAttr>:$access_groups,
                   OptionalAttr<SymbolRefArrayAttr>:$alias_scopes,
                   OptionalAttr<SymbolRefArrayAttr>:$noalias_scopes,
                   OptionalAttr<SymbolRefArrayAttr>:$tbaa,

Do you have a suggestion how to do this right? Should I create special LLVM attribute to represent an array of SymbolRefAttr's?

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

2622

Thank you for the suggestion! I will do this as part of MetadataOp verification.

mlir/lib/Target/LLVMIR/ModuleImport.cpp

343

I added a warning for the missing mapping. It should never kick in, though, because this would mean some TBAA mapping logic is broken before this code is invoked.

Since setAAMetadata is invoked via mlirBuilder path, it will currently engage only for LoadOp and StoreOp, so adding a Default case with a warning will not help to report that the metadata is dropped for CallOp etc. And adding support for other operations in LLVMOps seems to be too much for this change.

359–361

I guess we can. I can do this in a separate commit, because I do not know how many changes it will involve in other places.

360

I agree. I think it makes sense to declare MetadataOp as SingleBlock and NoTerminator, but not as part of this change.

FWIW, unknown location is already used for "global" entities such as GlobalVariable, Constant, but I will use FileLineColLoc for convenience.

398–399

I believe the graph must not have cycles, at least TypeBasedAliasAnalysis verifies that there is no cycles in the Parent relation path https://github.com/llvm/llvm-project/blob/main/llvm/lib/Analysis/TypeBasedAliasAnalysis.cpp#L494
From the language point of view the cycle would mean a type containing itself (struct s { struct s x; }).

I think you are right, and the order does not matter here, since we can create references before definitions, so I will just collect all reachable nodes and convert them without any cycle detection. I think we should check for cycles in the dialect verification code (during MetadataOp region verification). Does it sound right?

[gysit]

Thanks for adding tbaa support!

I am currently working on making the LLVM IR import extensible (https://reviews.llvm.org/D140374 and https://reviews.llvm.org/D140556). Especially the second revision has a bit of overlap with your work (it aims at making the metadata import extensible). For example, we may want to call the setAAMetadata function from LLVMDialectLLVMIRImportInterface::setMetadataAttrs. I think that can be done as a follow up once both revisions landed.

This is the corresponding rfc:
https://discourse.llvm.org/t/rfc-extensible-llvm-ir-import/67256

mlir/lib/Target/LLVMIR/ModuleImport.cpp

348

Are you sure the MLIR CallOp needs to be supported?

I may be wrong but I would assume LLVMIR CallInst supports the attribute due to the numerous memory access related intrinsics (e.g. memcpy or masked vector load/store). These are converted to actual MLIR operations rather than function calls. I would thus assume that these intrinsics plus probably the atomic operations have to be supported but not MLIR CallOp?

360

I think using FileLineColLoc with the file name is a good idea and if I am not mistaken it should be accessible via mlirModule->getLoc().

501

nit: quailified -> qualified.

511–513

nit: return emitError(loc) << ... directly returns failure.

[vzakhari]

Hi @gysit, thank you for the review and the links! I will rebase and see what additional changes are needed.

mlir/lib/Target/LLVMIR/ModuleImport.cpp

348

I looked through the cases where clang attaches MD_tbaa to instructions, and I think you are right: it only attaches it to loads/stores and memcpys currently. I cannot think of an example where Flang would attach TBAA to a generic call, so I removed the CallOp mentioning from the comment. Thanks!

360

Thanks!

[vzakhari]

• Changed ModuleImport to translate TBAA metadata as-is.
• Moved cycles detection to LLVM dialect verification.

[vzakhari]

This is a rebase with a minimal change for StoreOp's mlirBuilder to pass LIT testing.

More changes to follow D140556 will come next.

[vzakhari]

• Moved setAAMetadata call to setMetadataAttrs.

@gysit I suppose the TBAA conversion from LLVM IR to LLVMIR dialect operations should also be part of LLVMImportDialectInterface/LLVMDialectLLVMIRImportInterface, correct?

[gysit]

@gysit I suppose the TBAA conversion from LLVM IR to LLVMIR dialect operations should also be part of LLVMImportDialectInterface/LLVMDialectLLVMIRImportInterface, correct?

I commented on the setAAMetadata method. I would probably extend ModuleImport with a method to lookup the tbaa metadata symbol given the metadata node and then move the code to set the attribute on the operations to the LLVMDialectLLVMIRImportInterface.

mlir/lib/Target/LLVMIR/ModuleImport.cpp

28

nit: I think this is not needed anymore?

334

I think I would move the method to LLVMIRToLLVMTranslation.cpp and have a method similar to setProfilingAttrs (e.g. setTBAAAttrs). The moduleImport could then have a lookupTBBAAttr similar to the other lookup methods used to query import mappings. That way the two metadata imports would be more similar and if an external user wants to extend the tbaa import for their custom intrinsic they can use the lookup.

Also the kind == llvm::LLVMContext::MD_tbaa check should not be needed anymore and you can probably just return failure and the extensible metadata import will generate a failure. I will use your diagMD helper to improve the error message generated once your change landed.

403

Would it make sense to do this with two consecutive loops over nodesToConvert instead of using the steps?

511–512

It may make sense to add a test case in import-failure.ll or similar file to verify the error messages are actually generated as expected.

[vzakhari]

mlir/lib/Target/LLVMIR/ModuleImport.cpp

28

Thanks! Removed.

334

Thanks! Done.

403

This will require duplicating the checks to recognize the "kind" of the node we are processing, because different kinds require different processing and I want to give them different base names. I guess I could have created a classification utility to host all the checks, but since this is a local code I decided to go with the two-steps loop.

511–512

Sounds right. I will add the tests.

[vzakhari]

• Rebase to fix the patch application failure.

[gysit]

This will require duplicating the checks to recognize the "kind" of the node we are processing, because different kinds require different processing and I want to give them different base names. I guess I could have created a classification utility to host all the checks, but since this is a local code I decided to go with the two-steps loop.

Yeah I find the while loop quite hard to understand, which admittedly is also due to the complexity of the metadata. I think your idea of having lambdas to check if a node is a particular kind (e.g. isDescriptorNode isTagNode) sounds nice!

Apart from that the revision LGTM and I only had a few nit comments. @ftynse do you plan to have a second look?

mlir/lib/Target/LLVMIR/ModuleImport.cpp

415

nit: (copying Alex's comment since it got lost) don't use specific numbers of stack elements in vectors unless you have a strong reason to pick up, 10 feels arbitrary here.

[vzakhari]

Thank you for the review, @gysit! I will make changes in processTBAAMetadata.

mlir/lib/Target/LLVMIR/ModuleImport.cpp

415

Thank you! I missed it.

[ftynse]

mlir/include/mlir/Dialect/LLVMIR/LLVMOpBase.td

55

Then we shouldn't have this attribute here. (I suppose same is true for the other unprefixed attributes). It's an inherent attribute of the op, it should be entirely managed by the op. The dialect-level attributes must be prefixed with the dialect namespace, and are managed (e.g., verified) by the dialect. Dialect-level attribute are typically intended to be attached to operations from other dialects.

I don't think you need a special attribute kind, just reshuffle the code a bit.

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

2585–2587

Would it make sense to use SymbolRefAttr instead? Attributes are unique pointers, so we'd save the cost of hashing strings and trivially hash the pointer.

mlir/lib/Target/LLVMIR/ModuleImport.cpp

359–361

Ack.

360

I agree. I think it makes sense to declare MetadataOp as SingleBlock and NoTerminator, but not as part of this change.

Works for me, thanks.

398–399

Sounds reasonable. We can have a type containing a pointer to itself, and the LLVM dialect modeling will have a recursive Type object for that, hence the anticipation that it's better to check.

415

Looks like the new patch wasn't uploaded?

[vzakhari]

mlir/include/mlir/Dialect/LLVMIR/LLVMOpBase.td

55

Please check if the latest patch does it right.

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

2585–2587

Makes sense. Thanks!

mlir/lib/Target/LLVMIR/ModuleImport.cpp

415

Should be fixed now.

[vzakhari]

Fixed tbaa attribute name + other clean-up changes.

[vzakhari]

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

2585–2587

I suppose using StringAttr should be okay too. It just makes it easier to combine keys that are symbol definitions and symbol references in the same map.

[gysit]

Thanks for the nice improvement!

[vzakhari]

Thank you for the review, @ftynse and @gysit! I will go ahead with merging it and making follow-up changes for MetadataOp. Please feel free to add post-commit comments, if something looks off in the latest patch.

[ftynse]

mlir/include/mlir/Dialect/LLVMIR/LLVMOpBase.td

55

I was thinking the other way around: this becomes an inherent attribute of the ops, and the verifier is attached via an OpTrait. But the approach with dialect attribute also works. Just be aware that transforms may drop it (which sounds closer to LLVM IR in spirit).

[vzakhari]

mlir/include/mlir/Dialect/LLVMIR/LLVMOpBase.td

55

Oh, I thought you were actually in favor of the dialect attribute, since this discussion started with the missing llvm. prefix. I will leave it as-is for now.

To be on the same page, I think you suggest:

• Keep using OptionalAttr<SymbolRefArrayAttr>:$tbaa argument for LoadOp, StoreOp, etc.
• Add a TBAATrait with appropriate verification for the tbaa attribute.
• Probably add TBAAAttrInteface to generalize code in TBAATrait::verifyTrait().

Did I catch it correctly?

mlir/include/mlir/Dialect/LLVMIR/LLVMOpBase.td

let extraClassDeclaration = [{
     static StringRef getStructAttrsAttrName() { return "llvm.struct_attrs"; }
     static StringRef getByValAttrName() { return "llvm.byval"; }
     static StringRef getByRefAttrName() { return "llvm.byref"; }
     static StringRef getStructRetAttrName() { return "llvm.sret"; }
     static StringRef getInAllocaAttrName() { return "llvm.inalloca"; }
     static StringRef getNoUndefAttrName() { return "llvm.noundef"; }
     static StringRef getSExtAttrName() { return "llvm.signext"; }
     static StringRef getZExtAttrName() { return "llvm.zeroext"; }
+    static StringRef getTBAAAttrName() { return "tbaa"; }
 
     /// Verifies if the attribute is a well-formed value for "llvm.struct_attrs"
     static LogicalResult verifyStructAttr(
         Operation *op, Attribute attr, Type annotatedType);
 
     /// Verifies if the given string is a well-formed data layout descriptor.
     /// Uses `reportError` to report errors.
     static LogicalResult verifyDataLayoutString(

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

class MemoryOpWithAlignmentAndAttributes : MemoryOpWithAlignmentBase {
 
   code setAccessGroupsMetadataCode = [{
     moduleTranslation.setAccessGroupsMetadata(op, inst);
   }];
 
   code setAliasScopeMetadataCode = [{
     moduleTranslation.setAliasScopeMetadata(op, inst);
   }];
+
+  code setTBAAMetadataCode = [{
+    moduleTranslation.setTBAAMetadata(op, inst);
+  }];
 }
 
 // Memory-related operations.
 def LLVM_AllocaOp : LLVM_Op<"alloca">, MemoryOpWithAlignmentBase {
   let arguments = (ins AnyInteger:$arraySize,
                    OptionalAttr<I64Attr>:$alignment,
                    OptionalAttr<TypeAttr>:$elem_type);
   let results = (outs Res<LLVM_AnyPointer, "",
def LLVM_GEPOp : LLVM_Op<"getelementptr", [Pure]> {
   let hasVerifier = 1;
 }
 
 def LLVM_LoadOp : LLVM_Op<"load">, MemoryOpWithAlignmentAndAttributes {
   let arguments = (ins Arg<LLVM_PointerTo<LLVM_LoadableType>, "", [MemRead]>:$addr,
                    OptionalAttr<SymbolRefArrayAttr>:$access_groups,
                    OptionalAttr<SymbolRefArrayAttr>:$alias_scopes,
                    OptionalAttr<SymbolRefArrayAttr>:$noalias_scopes,
+                   OptionalAttr<SymbolRefArrayAttr>:$tbaa,
                    OptionalAttr<I64Attr>:$alignment, UnitAttr:$volatile_,
                    UnitAttr:$nontemporal);
   let results = (outs LLVM_LoadableType:$res);
   string llvmInstName = "Load";
   string llvmBuilder = [{
     auto *inst = builder.CreateLoad($_resultType, $addr, $volatile_);
   }] # setAlignmentCode
      # setNonTemporalMetadataCode
      # setAccessGroupsMetadataCode
      # setAliasScopeMetadataCode
+     # setTBAAMetadataCode
      # [{
     $res = inst;
   }];
   // FIXME: Import attributes.
   string mlirBuilder = [{
-    $res = $_builder.create<LLVM::LoadOp>($_location, $_resultType, $addr);
+    auto op = $_builder.create<LLVM::LoadOp>($_location, $_resultType, $addr);
+    setAAMetadata(inst, op);
+    $res = op;
   }];
   let builders = [
     OpBuilder<(ins "Value":$addr, CArg<"unsigned", "0">:$alignment,
       CArg<"bool", "false">:$isVolatile, CArg<"bool", "false">:$isNonTemporal),
     [{
       auto type = addr.getType().cast<LLVMPointerType>().getElementType();
       assert(type && "must provide explicit element type to the constructor "
                      "when the pointer type is opaque");
       build($_builder, $_state, type, addr, alignment, isVolatile, isNonTemporal);
     }]>,
     OpBuilder<(ins "Type":$t, "Value":$addr,
       CArg<"unsigned", "0">:$alignment, CArg<"bool", "false">:$isVolatile,
       CArg<"bool", "false">:$isNonTemporal)>,];
   let hasCustomAssemblyFormat = 1;
   let hasVerifier = 1;
 }
 
 def LLVM_StoreOp : LLVM_Op<"store">, MemoryOpWithAlignmentAndAttributes {
   let arguments = (ins LLVM_LoadableType:$value,
                    Arg<LLVM_PointerTo<LLVM_LoadableType>,"",[MemWrite]>:$addr,
                    OptionalAttr<SymbolRefArrayAttr>:$access_groups,
                    OptionalAttr<SymbolRefArrayAttr>:$alias_scopes,
                    OptionalAttr<SymbolRefArrayAttr>:$noalias_scopes,
+                   OptionalAttr<SymbolRefArrayAttr>:$tbaa,
                    OptionalAttr<I64Attr>:$alignment, UnitAttr:$volatile_,
                    UnitAttr:$nontemporal);
   string llvmInstName = "Store";
   string llvmBuilder = [{
     auto *inst = builder.CreateStore($value, $addr, $volatile_);
   }] # setAlignmentCode
      # setNonTemporalMetadataCode
      # setAccessGroupsMetadataCode
-     # setAliasScopeMetadataCode;
+     # setAliasScopeMetadataCode
+     # setTBAAMetadataCode;
   // FIXME: Import attributes.
   string mlirBuilder = [{
-    $_op = $_builder.create<LLVM::StoreOp>($_location, $value, $addr);
+    auto op = $_builder.create<LLVM::StoreOp>($_location, $value, $addr);
+    setAAMetadata(inst, op);
+    $_op = op;
   }];
   let builders = [
     OpBuilder<(ins "Value":$value, "Value":$addr,
       CArg<"unsigned", "0">:$alignment, CArg<"bool", "false">:$isVolatile,
       CArg<"bool", "false">:$isNonTemporal)>
     ];
   let hasCustomAssemblyFormat = 1;
   let hasVerifier = 1;
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 hasRegionVerifier = 1;
 }
 
 def LLVM_AliasScopeDomainMetadataOp : LLVM_Op<"alias_scope_domain", [
   HasParent<"MetadataOp">, Symbol
 ]> {
   let arguments = (ins
     SymbolNameAttr:$sym_name,
     OptionalAttr<StrAttr>:$description
let description = [{
     `llvm.loop.parallel_accesses` metadata.
 
     See the following link for more details:
     https://llvm.org/docs/LangRef.html#llvm-access-group-metadata
   }];
   let assemblyFormat = "$sym_name attr-dict";
 }
 
+def LLVM_TBAARootMetadataOp : LLVM_Op<"tbaa_root", [
+  HasParent<"MetadataOp">, Symbol
+]> {
+  let arguments = (ins
+    SymbolNameAttr:$sym_name,
+    StrAttr:$identity
+  );
+  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
+  }];
+  let hasVerifier = 1;
+}
+
+def LLVM_TBAATypeDescriptorOp : LLVM_Op<"tbaa_type_desc", [
+  HasParent<"MetadataOp">, Symbol
+]> {
+  let arguments = (ins
+    SymbolNameAttr:$sym_name,
+    OptionalAttr<StrAttr>:$identity,
+    FlatSymbolRefArrayAttr:$members,
+    DenseI64ArrayAttr:$offsets
+  );
+  let summary = "LLVM dialect TBAA node describing a type.";
+  let description = [{
+    Defines a TBAA node describing a type.
+
+    Example:
+      llvm.metadata @tbaa {
+        llvm.tbaa_root @tbaa_root_0 {identity = "Simple C/C++ TBAA"}
+        llvm.tbaa_type_desc @tbaa_type_desc_1 {
+            identity = "omnipotent char",
+            members = [@tbaa_root_0],
+            offsets = array<i64: 0>
+        }
+        llvm.tbaa_type_desc @tbaa_type_desc_2 {
+            identity = "long long",
+            members = [@tbaa_type_desc_1],
+            offsets = array<i64: 0>
+        }
+        llvm.tbaa_type_desc @tbaa_type_desc_3 {
+            identity = "agg2_t",
+            members = [@tbaa_type_desc_2, @tbaa_type_desc_2],
+            offsets = array<i64: 0, 8>
+        }
+        llvm.tbaa_type_desc @tbaa_type_desc_5 {
+            identity = "int",
+            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.
+  let assemblyFormat = [{
+    $sym_name ` ` `{`
+      ( `id` `=` $identity^ )? `,`
+      `members` `=` `{` custom<TBAAMembers>($members, $offsets) `}`
+    `}` attr-dict
+  }];
+  let hasVerifier = 1;
+}
+
+def LLVM_TBAATagOp : LLVM_Op<"tbaa_tag", [
+  HasParent<"MetadataOp">, Symbol
+]> {
+  let arguments = (ins
+    SymbolNameAttr:$sym_name,
+    FlatSymbolRefAttr:$base_type,
+    FlatSymbolRefAttr:$access_type,
+    I64Attr:$offset,
+    UnitAttr:$constant
+  );
+  let summary = "LLVM dialect TBAA node describing a memory access.";
+  let description = [{
+    Defines a TBAA node describing a memory access.
+
+    Example:
+      llvm.metadata @tbaa {
+        llvm.tbaa_root @tbaa_root_0 {identity = "Simple C/C++ TBAA"}
+        llvm.tbaa_type_desc @tbaa_type_desc_1 {
+            identity = "omnipotent char",
+            members = [@tbaa_root_0],
+            offsets = array<i64: 0>
+        }
+        llvm.tbaa_type_desc @tbaa_type_desc_2 {
+            identity = "long long",
+            members = [@tbaa_type_desc_1],
+            offsets = array<i64: 0>
+        }
+        llvm.tbaa_type_desc @tbaa_type_desc_3 {
+            identity = "agg2_t",
+            members = [@tbaa_type_desc_2, @tbaa_type_desc_2],
+            offsets = array<i64: 0, 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 {
+            identity = "int",
+            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.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";
+}
+
 def LLVM_GlobalOp : LLVM_Op<"mlir.global",
     [IsolatedFromAbove, SingleBlockImplicitTerminator<"ReturnOp">, Symbol]> {
   let arguments = (ins
     TypeAttr:$global_type,
     UnitAttr:$constant,
     StrAttr:$sym_name,
     Linkage:$linkage,
     UnitAttr:$dso_local,

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

public:
   /// Imports `globalVar` as a GlobalOp, creating it if it doesn't exist.
   GlobalOp processGlobal(llvm::GlobalVariable *globalVar);
 
   /// Sets the fastmath flags attribute for the imported operation `op` given
   /// the original instruction `inst`. Asserts if the operation does not
   /// implement the fastmath interface.
   void setFastmathFlagsAttr(llvm::Instruction *inst, Operation *op) const;
 
+  /// Converts LLVM metadata to corresponding MLIR representation,
+  /// e.g. metadata nodes referenced via !tbaa are converted to
+  /// TBAA operations hosted inside a MetadataOp.
+  LogicalResult convertMetadata();
+
 private:
   /// Clears the block and value mapping before processing a new region.
   void clearBlockAndValueMapping() {
     valueMapping.clear();
     noResultOpMapping.clear();
     blockMapping.clear();
   }
   /// Sets the constant insertion point to the start of the given block.
private:
   /// ConstantGEPs).
   FailureOr<Value> convertConstant(llvm::Constant *constant);
   /// Converts an LLVM constant and its transitive constant dependencies to MLIR
   /// operations by converting them in topological order using the
   /// `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 symbol name to be used for MetadataOp containing
+  /// TBAA metadata operations. It must not conflict with the user
+  /// name space.
+  StringRef getTBAAMetadataOpName() const { return "__tbaa"; }
+  /// Returns a terminated MetadataOp into which TBAA metadata
+  /// operations can be placed. The MetadataOp is created
+  /// on the first invocation of this function.
+  MetadataOp getTBAAMetadataOp();
+  /// 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);
+  /// Returns unique string name of a symbol that may be used
+  /// for a TBAA metadata operation. The name will contain
+  /// the provided `basename` and will be uniqued via
+  /// tbaaNodeCounter (see below).
+  std::string getNewTBAANodeName(StringRef basename);
+  /// If `inst` has TBAA metadata attached to it, then
+  /// the corresponding TBAA attribute is attached to `op`,
+  /// otherwise, no changes are made to `op`.
+  void setAAMetadata(const llvm::Instruction *inst, Operation *op) const;
 
   /// Builder pointing at where the next instruction should be generated.
   OpBuilder builder;
   /// 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.
private:
   /// return a result have a valueMapping entry instead.
   DenseMap<llvm::Instruction *, Operation *> noResultOpMapping;
   /// Uniquing map of GlobalVariables.
   DenseMap<llvm::GlobalVariable *, GlobalOp> globals;
   /// The stateful type translator (contains named structs).
   LLVM::TypeFromLLVMIRTranslator typeTranslator;
   /// Stateful debug information importer.
   std::unique_ptr<detail::DebugImporter> debugImporter;
+  /// A terminated MetadataOp where TBAA metadata operations
+  /// can be inserted.
+  MetadataOp tbaaMetadataOp{};
+  /// Mapping between LLVM TBAA metadata nodes and symbol references
+  /// to the LLVMIR dialect TBAA operations corresponding to these
+  /// nodes.
+  DenseMap<const llvm::MDNode *, SymbolRefAttr> tbaaMapping;
+  /// A counter to be used as a unique suffix for symbols
+  /// defined by TBAA operations.
+  unsigned tbaaNodeCounter = 0;
 };
 
 } // namespace LLVM
 } // namespace mlir
 
 #endif // MLIR_TARGET_LLVMIR_MODULEIMPORT_H

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

public:
   }
 
   // Sets LLVM metadata for memory operations that are in a parallel loop.
   void setAccessGroupsMetadata(Operation *op, llvm::Instruction *inst);
 
   // Sets LLVM metadata for memory operations that have alias scope information.
   void setAliasScopeMetadata(Operation *op, llvm::Instruction *inst);
 
+  /// Sets LLVM TBAA metadata for memory operations that have
+  /// TBAA attributes.
+  void setTBAAMetadata(Operation *op, llvm::Instruction *inst);
+
   /// Converts the type from MLIR LLVM dialect to LLVM.
   llvm::Type *convertType(Type type);
 
   /// Returns the MLIR context of the module being translated.
   MLIRContext &getContext() { return *mlirModule->getContext(); }
 
   /// Returns the LLVM context in which the IR is being constructed.
   llvm::LLVMContext &getLLVMContext() const { return llvmModule->getContext(); }
private:
   /// Process access_group LLVM Metadata operations and create LLVM
   /// metadata nodes.
   LogicalResult createAccessGroupMetadata();
 
   /// Process alias.scope LLVM Metadata operations and create LLVM
   /// metadata nodes for them and their domains.
   LogicalResult createAliasScopeMetadata();
 
+  /// Returns the LLVM metadata corresponding to a reference to an mlir LLVM
+  /// dialect TBAATagOp operation.
+  llvm::MDNode *getTBAANode(Operation &memOp, SymbolRefAttr tagRef) const;
+
+  /// Process tbaa LLVM Metadata operations and create LLVM
+  /// metadata nodes for them.
+  LogicalResult createTBAAMetadata();
+
   /// Translates dialect attributes attached to the given operation.
   LogicalResult convertDialectAttributes(Operation *op);
 
   /// Original and translated module.
   Operation *mlirModule;
   std::unique_ptr<llvm::Module> llvmModule;
   /// A converter for translating debug information.
   std::unique_ptr<detail::DebugTranslation> debugTranslation;
private:
   /// identified via their branches) and contained memory accesses.
   DenseMap<Operation *, llvm::MDNode *> accessGroupMetadataMapping;
 
   /// Mapping from an attribute describing loop codegen options to its LLVM
   /// metadata. The metadata is attached to Latch block branches with this
   /// attribute.
   DenseMap<Attribute, llvm::MDNode *> loopOptionsMetadataMapping;
 
-  /// Mapping from an access scope metadata operation to its LLVM metadata.
+  /// Mapping from an alias scope metadata operation to its LLVM metadata.
   /// This map is populated on module entry.
   DenseMap<Operation *, llvm::MDNode *> aliasScopeMetadataMapping;
 
+  /// Mapping from a tbaa metadata operation to its LLVM metadata.
+  /// This map is populated on module entry.
+  DenseMap<const Operation *, llvm::MDNode *> tbaaMetadataMapping;
+
   /// Stack of user-specified state elements, useful when translating operations
   /// with regions.
   SmallVector<std::unique_ptr<StackFrame>> stack;
 
   /// A cache for the symbol tables constructed during symbols lookup.
   SymbolTableCollection symbolTableCollection;
 };
 

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

 #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 "mlir/Transforms/InliningUtils.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"
if (failed(verifyOpMetadata<LLVM::AliasScopeMetadataOp>(
           op, LLVMDialect::getAliasScopesAttrName())))
     return failure();
 
   // noalias_scopes
   if (failed(verifyOpMetadata<LLVM::AliasScopeMetadataOp>(
           op, LLVMDialect::getNoAliasScopesAttrName())))
     return failure();
 
+  // tbaa
+  if (failed(verifyOpMetadata<LLVM::TBAATagOp>(op,
+                                               LLVMDialect::getTBAAAttrName())))
+    return failure();
+
   return success();
 }
 
 LogicalResult LoadOp::verify() { return verifyMemoryOpMetadata(*this); }
 
 void LoadOp::build(OpBuilder &builder, OperationState &result, Type t,
                    Value addr, unsigned alignment, bool isVolatile,
                    bool isNonTemporal) {
if (changed) {
     setRawConstantIndices(rawConstantIndices);
     return Value{*this};
   }
 
   return {};
 }
 
 //===----------------------------------------------------------------------===//
+// Utilities for LLVM::MetadataOp
+//===----------------------------------------------------------------------===//
+
+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;
+};
+
+// TBAA graph.
+class TBAAGraph {
+  // Mapping between symbol names defined by TBAA
+  // operations and corresponding TBAAGraphNode's.
+  DenseMap<StringRef, TBAAGraphNode> nodeMap;
+  // Synthetic root node that has all graph nodes
+  // in its operands list.
+  TBAAGraphNode root;
+
+public:
+  using iterator = SmallVectorImpl<TBAAGraphNode *>::iterator;
+
+  iterator begin() { return root.operands.begin(); }
+  iterator end() { return root.operands.end(); }
+  TBAAGraphNode *getEntryNode() { return &root; }
+
+  // Add new graph node corresponding to `symbol`
+  // defined by a TBAA operation.
+  void addNodeDefinition(StringRef symbol) {
+    TBAAGraphNode &node = nodeMap[symbol];
+    assert(node.symbol.empty() && "node is already in the graph");
+    node.symbol = symbol;
+    root.operands.push_back(&node);
+  }
+
+  // Get a pointer to TBAAGraphNode corresponding
+  // to `symbol`. The node must be already in the graph.
+  TBAAGraphNode *operator[](StringRef symbol) {
+    auto it = nodeMap.find(symbol);
+    assert(it != nodeMap.end() && "node must be in the graph");
+    return &it->second;
+  }
+};
+} // end anonymous namespace
+namespace llvm {
+// GraphTraits definitions for using TBAAGraph with
+// scc_iterator.
+template <>
+struct GraphTraits<TBAAGraphNode *> {
+  using NodeRef = TBAAGraphNode *;
+  using ChildIteratorType = SmallVectorImpl<TBAAGraphNode *>::iterator;
+  static ChildIteratorType child_begin(NodeRef ref) {
+    return ref->operands.begin();
+  }
+  static ChildIteratorType child_end(NodeRef ref) {
+    return ref->operands.end();
+  }
+};
+template <>
+struct GraphTraits<TBAAGraph *> : public GraphTraits<TBAAGraphNode *> {
+  static NodeRef getEntryNode(TBAAGraph *graph) {
+    return graph->getEntryNode();
+  }
+  static ChildIteratorType nodes_begin(TBAAGraph *graph) {
+    return graph->begin();
+  }
+  static ChildIteratorType nodes_end(TBAAGraph *graph) { return graph->end(); }
+};
+} // end namespace llvm
+
+LogicalResult MetadataOp::verifyRegions() {
+  // Verify correctness of TBAA-related symbol references.
+  Region &body = getBody();
+  // Symbol names defined by TBAARootMetadataOp and TBAATypeDescriptorOp.
+  llvm::SmallDenseSet<StringRef> definedGraphSymbols;
+  // Complete TBAA graph consisting of TBAARootMetadataOp,
+  // TBAATypeDescriptorOp, and TBAATagOp symbols. It is used
+  // for detecting cycles in the TBAA graph, which is illegal.
+  TBAAGraph tbaaGraph;
+
+  for (Operation &op : body.getOps())
+    if (isa<LLVM::TBAARootMetadataOp>(op) ||
+        isa<LLVM::TBAATypeDescriptorOp>(op)) {
+      StringRef symbolDef = cast<SymbolOpInterface>(op).getNameAttr();
+      definedGraphSymbols.insert(symbolDef);
+      tbaaGraph.addNodeDefinition(symbolDef);
+    } else if (auto tagOp = dyn_cast<LLVM::TBAATagOp>(op)) {
+      tbaaGraph.addNodeDefinition(tagOp.getSymName());
+    }
+
+  // Verify that TBAA metadata operations refer symbols
+  // from definedGraphSymbols only. Note that TBAATagOp
+  // cannot refer a symbol defined by TBAATagOp.
+  auto verifyReference = [&](Operation &op, StringRef symbolName,
+                             StringAttr referencingAttr) -> LogicalResult {
+    if (definedGraphSymbols.contains(symbolName))
+      return success();
+    return op.emitOpError()
+           << "expected " << referencingAttr << " to reference a symbol from '"
+           << (*this)->getName() << " @" << getSymName()
+           << "' defined by either '"
+           << LLVM::TBAARootMetadataOp::getOperationName() << "' or '"
+           << LLVM::TBAATypeDescriptorOp::getOperationName()
+           << "' while it references '@" << symbolName << "'";
+  };
+  for (Operation &op : body.getOps()) {
+    if (auto tdOp = dyn_cast<LLVM::TBAATypeDescriptorOp>(op)) {
+      SmallVectorImpl<TBAAGraphNode *> &operands =
+          tbaaGraph[tdOp.getSymName()]->operands;
+      for (Attribute attr : tdOp.getMembers()) {
+        StringRef symbolRef = attr.cast<FlatSymbolRefAttr>().getValue();
+        if (failed(verifyReference(op, symbolRef, tdOp.getMembersAttrName())))
+          return failure();
+
+        // Since the reference is valid, we have to be able
+        // to find TBAAGraphNode corresponding to the operand.
+        operands.push_back(tbaaGraph[symbolRef]);
+      }
+    }
+
+    if (auto tagOp = dyn_cast<LLVM::TBAATagOp>(op)) {
+      SmallVectorImpl<TBAAGraphNode *> &operands =
+          tbaaGraph[tagOp.getSymName()]->operands;
+      if (failed(verifyReference(op, tagOp.getBaseType(),
+                                 tagOp.getBaseTypeAttrName())))
+        return failure();
+      if (failed(verifyReference(op, tagOp.getAccessType(),
+                                 tagOp.getAccessTypeAttrName())))
+        return failure();
+
+      operands.push_back(tbaaGraph[tagOp.getBaseType()]);
+      operands.push_back(tbaaGraph[tagOp.getAccessType()]);
+    }
+  }
+
+  // Detect cycles in the TBAA graph.
+  for (llvm::scc_iterator<TBAAGraph *> sccIt = llvm::scc_begin(&tbaaGraph);
+       !sccIt.isAtEnd(); ++sccIt) {
+    if (!sccIt.hasCycle())
+      continue;
+    auto diagOut = emitOpError() << "has cycle in TBAA graph (graph closure: <";
+    llvm::interleaveComma(
+        *sccIt, diagOut, [&](TBAAGraphNode *node) { diagOut << node->symbol; });
+    return diagOut << ">)";
+  }
+  return success();
+}
+
+//===----------------------------------------------------------------------===//
+// Utilities for TBAA related operations/attributes
+//===----------------------------------------------------------------------===//
+
+static ParseResult parseTBAAMembers(OpAsmParser &parser, ArrayAttr &members,
+                                    DenseI64ArrayAttr &offsets) {
+  SmallVector<Attribute> membersVec;
+  SmallVector<int64_t> offsetsVec;
+  auto parseMembers = [&]() {
+    // Parse a pair of `<@tbaa_type_desc_sym, integer-offset>`.
+    FlatSymbolRefAttr member;
+    int64_t offset;
+    if (parser.parseLess() || parser.parseAttribute(member, Type()) ||
+        parser.parseComma() || parser.parseInteger(offset) ||
+        parser.parseGreater())
+      return failure();
+
+    membersVec.push_back(member);
+    offsetsVec.push_back(offset);
+    return success();
+  };
+
+  if (parser.parseCommaSeparatedList(parseMembers))
+    return failure();
+
+  members = ArrayAttr::get(parser.getContext(), membersVec);
+  offsets = DenseI64ArrayAttr::get(parser.getContext(), offsetsVec);
+  return success();
+}
+
+static void printTBAAMembers(OpAsmPrinter &printer,
+                             LLVM::TBAATypeDescriptorOp tdOp, ArrayAttr members,
+                             DenseI64ArrayAttr offsets) {
+  llvm::interleaveComma(
+      llvm::zip(members, offsets.asArrayRef()), printer, [&](auto it) {
+        // Print `<@tbaa_type_desc_sym, integer-offset>`.
+        printer << '<' << std::get<0>(it) << ", " << std::get<1>(it) << '>';
+      });
+}
+
+LogicalResult TBAARootMetadataOp::verify() {
+  if (!getIdentity().empty())
+    return success();
+  return emitOpError() << "expected non-empty " << getIdentityAttrName();
+}
+
+LogicalResult TBAATypeDescriptorOp::verify() {
+  // Verify that the members and offsets arrays have the same
+  // number of elements.
+  ArrayAttr members = getMembers();
+  StringAttr membersName = getMembersAttrName();
+  if (members.size() != getOffsets().size())
+    return emitOpError() << "expected the same number of elements in "
+                         << membersName << " and " << getOffsetsAttrName()
+                         << ": " << members.size()
+                         << " != " << getOffsets().size();
+
+  return success();
+}
+
+//===----------------------------------------------------------------------===//
 // OpAsmDialectInterface
 //===----------------------------------------------------------------------===//
 
 namespace {
 struct LLVMOpAsmDialectInterface : public OpAsmDialectInterface {
   using OpAsmDialectInterface::OpAsmDialectInterface;
 
   AliasResult getAlias(Attribute attr, raw_ostream &os) const override {

mlir/lib/Target/LLVMIR/ModuleImport.cpp

 #include "mlir/Dialect/LLVMIR/LLVMDialect.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/ADT/TypeSwitch.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"
 
 using namespace mlir;
 using namespace mlir::LLVM;
 using namespace mlir::LLVM::detail;
 
 #include "mlir/Dialect/LLVMIR/LLVMConversionEnumsFromLLVM.inc"
 
 // Utility to print an LLVM value as a string for passing to emitError().
 // FIXME: Diagnostic should be able to natively handle types that have
 // operator << (raw_ostream&) defined.
-static std::string diag(llvm::Value &value) {
+static std::string diag(const llvm::Value &value) {
   std::string str;
   llvm::raw_string_ostream os(str);
   os << value;
   return os.str();
 }
 
+// Utility to print an LLVM metadata node as a string for passing
+// to emitError(). The module argument is needed to print the nodes
+// canonically numbered.
+static std::string diagMD(const llvm::Metadata *node,
+                          const llvm::Module *module) {
+  std::string str;
+  llvm::raw_string_ostream os(str);
+  node->print(os, module, /*IsForDebug=*/true);
+  return os.str();
+}
+
 /// Creates an attribute containing ABI and preferred alignment numbers parsed
 /// a string. The string may be either "abi:preferred" or just "abi". In the
 /// latter case, the preferred alignment is considered equal to ABI alignment.
 static DenseIntElementsAttr parseDataLayoutAlignment(MLIRContext &ctx,
                                                      StringRef spec) {
   auto i32 = IntegerType::get(&ctx, 32);
 
   StringRef abiString, preferredString;
ModuleImport::ModuleImport(ModuleOp mlirModule,
     : builder(mlirModule->getContext()), context(mlirModule->getContext()),
       mlirModule(mlirModule), llvmModule(std::move(llvmModule)),
       iface(mlirModule->getContext()),
       typeTranslator(*mlirModule->getContext()),
       debugImporter(std::make_unique<DebugImporter>(mlirModule->getContext())) {
   builder.setInsertionPointToStart(mlirModule.getBody());
 }
 
+void ModuleImport::setAAMetadata(const llvm::Instruction *inst,
+                                 Operation *op) const {
+  llvm::AAMDNodes nodes = inst->getAAMetadata();
+  if (!nodes)
+    return;
+
+  if (const llvm::MDNode *tbaaMD = nodes.TBAA) {
+    auto it = tbaaMapping.find(tbaaMD);
+    if (it == tbaaMapping.end()) {
+      emitWarning(op->getLoc())
+          << "TBAA metadata was not converted for instruction " << diag(*inst);
+      return;
+    }
+
+    // TODO: add support for intrinsic operations (such as MemcpyOp).
+    TypeSwitch<Operation *>(op).Case<LoadOp, StoreOp>([&](auto op) {
+      op.setTbaaAttr(ArrayAttr::get(op->getContext(), {it->second}));
+    });
+  }
+}
+
+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();
+}
+
+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.count(current))
+      continue;
+    // Allow cycles in TBAA metadata. Just import it as-is,
+    // and diagnose the problem during LLVMIR dialect verification.
+    if (!nodesToConvert.insert(current))
+      continue;
+    for (const llvm::MDOperand &operand : current->operands())
+      if (auto *opNode = dyn_cast_or_null<const llvm::MDNode>(operand.get()))
+        workList.push_back(opNode);
+  }
+
+  // Insert new operations before the terminator.
+  OpBuilder::InsertionGuard guard(builder);
+  builder.setInsertionPoint(&getTBAAMetadataOp().getBody().back().back());
+  StringAttr metadataOpName = SymbolTable::getSymbolName(getTBAAMetadataOp());
+
+  unsigned step = 0;
+  while (step < 2) {
+    ++step;
+
+    // On the first walk, create SymbolRefAttr's and map them
+    // to nodes in `nodesToConvert`. On the second walk,
+    // create TBAA operations using the symbol names from the map.
+    for (const auto *current : nodesToConvert) {
+      unsigned numOperands = current->getNumOperands();
+      if (numOperands == 1) {
+        // Root node, e.g.:
+        //   !0 = !{!"Simple C/C++ TBAA"}
+        if (step > 1)
+          continue;
+
+        // The root nodes do not have operands, so we can create
+        // the TBAARootMetadataOp on the first walk.
+        StringRef identity =
+            cast<const llvm::MDString>(current->getOperand(0))->getString();
+        auto rootNode = builder.create<TBAARootMetadataOp>(
+            loc, getNewTBAANodeName("root"), identity);
+        tbaaMapping.try_emplace(current, FlatSymbolRefAttr::get(rootNode));
+        continue;
+      }
+      if (auto identity =
+              dyn_cast<const llvm::MDString>(current->getOperand(0))) {
+        // Type descriptor, e.g.:
+        //   !1 = !{!"int", !0, /*optional*/i64 0} /* scalar int type */
+        //   !2 = !{!"agg_t", !1, i64 0} /* struct agg_t { int x; } */
+        if (step == 1) {
+          tbaaMapping.try_emplace(
+              current, FlatSymbolRefAttr::get(builder.getContext(),
+                                              getNewTBAANodeName("type_desc")));
+          continue;
+        }
+
+        SmallVector<Attribute, 10> memberTypes;
+        SmallVector<int64_t, 10> offsets;
+        for (unsigned pairNum = 0, e = numOperands / 2; pairNum < e;
+             ++pairNum) {
+          // Get the converted member metadata.
+          auto memberType = tbaaMapping.lookup(
+              cast<const llvm::MDNode>(current->getOperand(2 * pairNum + 1)));
+          memberTypes.push_back(memberType);
+
+          // Get the member offset.
+          if (2 * pairNum + 2 >= numOperands) {
+            // Allow for optional 0 offset in 2-operand nodes.
+            if (numOperands != 2)
+              return emitError(loc) << "missing member offset: "
+                                    << diagMD(current, llvmModule.get());
+
+            offsets.push_back(0);
+            break;
+          }
+          offsets.push_back(llvm::mdconst::extract<llvm::ConstantInt>(
+                                current->getOperand(2 * pairNum + 2))
+                                ->getZExtValue());
+        }
+
+        builder.create<TBAATypeDescriptorOp>(
+            loc, tbaaMapping.lookup(current).getLeafReference(),
+            builder.getStringAttr(identity->getString()),
+            builder.getArrayAttr(memberTypes), offsets);
+        continue;
+      }
+      // This should be an access tag, e.g.:
+      //   !3 = !{!1, !1, i64 0} /* scalar int access */
+      //   !4 = !{!2, !1, i64 0} /* agg_t::x access */
+      //
+      // Optional 4th argument is ConstantInt 0/1 identifying whether
+      // the location being accessed is "constant" (see for details:
+      // https://llvm.org/docs/LangRef.html#representation).
+      if (numOperands == 3 || numOperands == 4) {
+        auto baseMD = dyn_cast<const llvm::MDNode>(current->getOperand(0));
+        auto accessMD = dyn_cast<const llvm::MDNode>(current->getOperand(1));
+        auto offsetCI = llvm::mdconst::dyn_extract<llvm::ConstantInt>(
+            current->getOperand(2));
+        if (baseMD && accessMD && offsetCI &&
+            // TODO: support new TBAA format, if needed (see D41501).
+            // In the "old" format the first operand of the access type
+            // metadata is MDString.
+            accessMD->getNumOperands() > 0 &&
+            isa<llvm::MDString>(accessMD->getOperand(0))) {
+          if (step == 1) {
+            // TBAATagOp symbols must be referred by their fully qualified
+            // names, so create a path to TBAATagOp symbol.
+            tbaaMapping.try_emplace(
+                current,
+                SymbolRefAttr::get(
+                    builder.getContext(), metadataOpName,
+                    FlatSymbolRefAttr::get(builder.getContext(),
+                                           getNewTBAANodeName("tag"))));
+            continue;
+          }
+          bool isConstant = false;
+          if (numOperands == 4)
+            if (auto isConstantCI =
+                    llvm::mdconst::dyn_extract<llvm::ConstantInt>(
+                        current->getOperand(3)))
+              isConstant = isConstantCI->getValue()[0];
+          builder.create<TBAATagOp>(
+              loc, tbaaMapping.lookup(current).getLeafReference(),
+              tbaaMapping.lookup(baseMD).getLeafReference(),
+              tbaaMapping.lookup(accessMD).getLeafReference(),
+              offsetCI->getZExtValue(), isConstant);
+          continue;
+        }
+      }
+      return emitError(loc) << "unsupported TBAA node format: "
+                            << diagMD(current, llvmModule.get());
+    }
+  }
+
+  return success();
+}
+
+LogicalResult ModuleImport::convertMetadata() {
+  OpBuilder::InsertionGuard guard(builder);
+  builder.setInsertionPoint(mlirModule.getBody(), mlirModule.getBody()->end());
+  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)))
+          return failure();
+      // TODO: only TBAA metadata is currently supported.
+    }
+
+  return success();
+}
+
 LogicalResult ModuleImport::convertGlobals() {
   for (llvm::GlobalVariable &globalVar : llvmModule->globals())
     if (!processGlobal(&globalVar))
       return failure();
   return success();
 }
 
 LogicalResult ModuleImport::convertFunctions() {
if (!dlSpec) {
     emitError(UnknownLoc::get(context), "can't translate data layout");
     return {};
   }
   module.get()->setAttr(DLTIDialect::kDataLayoutAttrName, dlSpec);
 
   ModuleImport moduleImport(module.get(), std::move(llvmModule));
   if (failed(moduleImport.initializeImportInterface()))
     return {};
+  if (failed(moduleImport.convertMetadata()))
+    return {};
   if (failed(moduleImport.convertGlobals()))
     return {};
   if (failed(moduleImport.convertFunctions()))
     return {};
 
   return module;
 }

mlir/lib/Target/LLVMIR/ModuleTranslation.cpp

auto populateScopeMetadata = [this, op, inst](StringRef attrName,
     llvm::MDNode *unionMD = llvm::MDNode::get(module->getContext(), scopeMDs);
     inst->setMetadata(module->getMDKindID(llvmMetadataName), unionMD);
   };
 
   populateScopeMetadata(LLVMDialect::getAliasScopesAttrName(), "alias.scope");
   populateScopeMetadata(LLVMDialect::getNoAliasScopesAttrName(), "noalias");
 }
 
+llvm::MDNode *ModuleTranslation::getTBAANode(Operation &memOp,
+                                             SymbolRefAttr tagRef) const {
+  StringAttr metadataName = tagRef.getRootReference();
+  StringAttr tagName = tagRef.getLeafReference();
+  auto metadataOp = SymbolTable::lookupNearestSymbolFrom<LLVM::MetadataOp>(
+      memOp.getParentOp(), metadataName);
+  Operation *tagOp = SymbolTable::lookupNearestSymbolFrom(metadataOp, tagName);
+  return tbaaMetadataMapping.lookup(tagOp);
+}
+
+void ModuleTranslation::setTBAAMetadata(Operation *op,
+                                        llvm::Instruction *inst) {
+  auto tbaa = op->getAttrOfType<ArrayAttr>(LLVMDialect::getTBAAAttrName());
+  if (!tbaa || tbaa.empty())
+    return;
+  // LLVM IR currently does not support attaching more than one
+  // TBAA access tag to a memory accessing instruction.
+  // It may be useful to support this in future, but for the time being
+  // just ignore the metadata if MLIR operation has multiple access tags.
+  if (tbaa.size() > 1) {
+    op->emitWarning() << "TBAA access tags were not translated, because LLVM "
+                         "IR only supports a single tag per instruction";
+    return;
+  }
+  SymbolRefAttr tagRef = tbaa[0].cast<SymbolRefAttr>();
+  llvm::MDNode *tagNode = getTBAANode(*op, tagRef);
+  inst->setMetadata(llvm::LLVMContext::MD_tbaa, tagNode);
+}
+
+LogicalResult ModuleTranslation::createTBAAMetadata() {
+  llvm::LLVMContext &ctx = llvmModule->getContext();
+  llvm::IntegerType *offsetTy = llvm::IntegerType::get(ctx, 64);
+
+  // Walk TBAA metadata and create MDNode's with placeholder
+  // operands for the references of other TBAA nodes.
+  for (auto metadata : getModuleBody(mlirModule).getOps<LLVM::MetadataOp>()) {
+    for (auto &op : metadata.getBody().getOps()) {
+      SmallVector<llvm::Metadata *> operands;
+      if (auto rootOp = dyn_cast<LLVM::TBAARootMetadataOp>(op)) {
+        operands.push_back(llvm::MDString::get(ctx, rootOp.getIdentity()));
+      } else if (auto tdOp = dyn_cast<LLVM::TBAATypeDescriptorOp>(op)) {
+        operands.push_back(llvm::MDString::get(
+            ctx, tdOp.getIdentity().value_or(llvm::StringRef{})));
+        for (int64_t offset : tdOp.getOffsets()) {
+          operands.push_back(nullptr); // Placeholder for the member type.
+          operands.push_back(llvm::ConstantAsMetadata::get(
+              llvm::ConstantInt::get(offsetTy, offset)));
+        }
+      } else if (auto tagOp = dyn_cast<LLVM::TBAATagOp>(op)) {
+        operands.push_back(nullptr); // Placeholder for the base type.
+        operands.push_back(nullptr); // Placeholder for the access type.
+        operands.push_back(llvm::ConstantAsMetadata::get(
+            llvm::ConstantInt::get(offsetTy, tagOp.getOffset())));
+        if (tagOp.getConstant())
+          operands.push_back(llvm::ConstantAsMetadata::get(
+              llvm::ConstantInt::get(offsetTy, 1)));
+      }
+
+      if (operands.empty())
+        continue;
+
+      tbaaMetadataMapping.insert({&op, llvm::MDNode::get(ctx, operands)});
+    }
+  }
+
+  // Walk TBAA metadata second time and update the placeholder
+  // references.
+  for (auto metadata : getModuleBody(mlirModule).getOps<LLVM::MetadataOp>()) {
+    for (auto &op : metadata.getBody().getOps()) {
+      SmallVector<StringRef> refNames;
+      SmallVector<int64_t> operandIndices;
+      if (auto tdOp = dyn_cast<LLVM::TBAATypeDescriptorOp>(op)) {
+        // The type references are in 1, 3, 5, etc. positions.
+        unsigned opNum = 1;
+        for (Attribute typeAttr : tdOp.getMembers()) {
+          refNames.push_back(typeAttr.cast<FlatSymbolRefAttr>().getValue());
+          operandIndices.push_back(opNum);
+          opNum += 2;
+        }
+      } else if (auto tagOp = dyn_cast<LLVM::TBAATagOp>(op)) {
+        refNames.push_back(tagOp.getBaseType());
+        operandIndices.push_back(0);
+        refNames.push_back(tagOp.getAccessType());
+        operandIndices.push_back(1);
+      }
+
+      if (refNames.empty())
+        continue;
+
+      llvm::MDNode *descNode = tbaaMetadataMapping.lookup(&op);
+      for (auto [refName, opNum] : llvm::zip(refNames, operandIndices)) {
+        // refDef availability in the parent MetadataOp
+        // is checked by module verifier.
+        Operation *refDef = SymbolTable::lookupSymbolIn(metadata, refName);
+        llvm::MDNode *refNode = tbaaMetadataMapping.lookup(refDef);
+        if (!refNode) {
+          op.emitOpError() << "llvm::MDNode missing for the member '@"
+                           << refName << "'";
+          return failure();
+        }
+        descNode->replaceOperandWith(opNum, refNode);
+      }
+    }
+  }
+
+  return success();
+}
+
 llvm::Type *ModuleTranslation::convertType(Type type) {
   return typeTranslator.translateType(type);
 }
 
 /// A helper to look up remapped operands in the value remapping table.
 SmallVector<llvm::Value *> ModuleTranslation::lookupValues(ValueRange values) {
   SmallVector<llvm::Value *> remapped;
   remapped.reserve(values.size());
mlir::translateModuleToLLVMIR(Operation *module, llvm::LLVMContext &llvmContext,
   if (failed(translator.convertFunctionSignatures()))
     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) &&

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 {tbaa = [@tbaa_tag_1]} : i8, !llvm.ptr
+    llvm.return
+  }
+}
+
+// -----
+
+llvm.func @tbaa(%arg0: !llvm.ptr) {
+  %0 = llvm.mlir.constant(1 : i8) : i8
+  // expected-error@below {{attribute 'tbaa' failed to satisfy constraint: symbol ref array attribute}}
+  llvm.store %0, %arg0 {tbaa = ["sym"]} : 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 {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 {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.store %0, %arg0 {tbaa = [@tbaa::@sym]} : i8, !llvm.ptr
+  llvm.return
+}
+
+// -----
+
+llvm.func @tbaa() {
+  // expected-error@below {{expects parent op 'llvm.metadata'}}
+  llvm.tbaa_root @tbaa_root_0 {id = "Simple C/C++ 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
+define dso_local void @tbaa1(ptr %0, ptr %1) {
+  store i8 1, ptr %0, align 4, !tbaa !1
+  store i8 1, ptr %1, align 4, !tbaa !3
+  ret void
+}
+
+!0 = !{!"Simple C/C++ TBAA"}
+!1 = !{!0, !0, i64 0}
+!2 = !{!"Other language TBAA"}
+!3 = !{!2, !2, i64 0}
+
+// -----
+
+; 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 = @[[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
+%struct.agg2_t = type { i64, i64 }
+%struct.agg1_t = type { i32, i32 }
+
+define dso_local void @tbaa2(ptr %0, ptr %1) {
+  %3 = getelementptr inbounds %struct.agg2_t, ptr %1, i32 0, i32 1
+  %4 = load i64, ptr %3, align 8, !tbaa !6
+  %5 = trunc i64 %4 to i32
+  %6 = getelementptr inbounds %struct.agg1_t, ptr %0, i32 0, i32 0
+  store i32 %5, ptr %6, align 4, !tbaa !11
+  ret void
+}
+
+!6 = !{!7, !8, i64 8}
+!7 = !{!"agg2_t", !8, i64 0, !8, i64 8}
+!8 = !{!"long long", !9, i64 0}
+!9 = !{!"omnipotent char", !10, i64 0}
+!10 = !{!"Simple C/C++ TBAA"}
+!11 = !{!12, !13, i64 0}
+!12 = !{!"agg1_t", !13, i64 0, !13, i64 4}
+!13 = !{!"int", !9, i64 0}

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 {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)>
+    // CHECK: store i32 %{{.*}}, ptr %{{.*}},{{.*}}!tbaa ![[STAG:[0-9]*]]
+    llvm.store %4, %5 {tbaa = [@__tbaa::@tbaa_tag_7]} : i32, !llvm.ptr
+    llvm.return
+  }
+}
+
+// CHECK-DAG: ![[LTAG]] = !{![[AGG2T:[0-9]*]], ![[I64T:[0-9]*]], i64 8}
+// CHECK-DAG: ![[AGG2T]] = !{!"agg2_t", ![[I64T]], i64 0, ![[I64T]], i64 8}
+// CHECK-DAG: ![[I64T]] = !{!"long long", ![[CHART:[0-9]*]], i64 0}
+// CHECK-DAG: ![[CHART]] = !{!"omnipotent char", ![[ROOT:[0-9]*]], i64 0}
+// CHECK-DAG: ![[ROOT]] = !{!"Simple C/C++ TBAA"}
+// CHECK-DAG: ![[STAG]] = !{![[AGG1T:[0-9]*]], ![[I32T:[0-9]*]], i64 0, i64 1}
+// CHECK-DAG: ![[AGG1T]] = !{!"agg1_t", ![[I32T]], i64 0, ![[I32T]], i64 4}
+// CHECK-DAG: ![[I32T]] = !{!"int", ![[CHART]], i64 0}