[mlir][llvm] Verify LLVM module before import

[Dinistro]

Summary

This commit ensures that the importing of LLVM modules first verifies
that the module is even valid. As many tests did not work with valid
LLVM IR, they were fixed as part of this commit.

Some error messages were only reachable with invalid input IR, thus they
were replaced with a failures.

[gysit]

LGTM. I think running the LLVM verifier rather than implementing our own imperfect one is the way to go here.

mlir/lib/Target/LLVMIR/Dialect/LLVMIR/LLVMIRToLLVMTranslation.cpp

110

nit: Return failure for ...

mlir/lib/Target/LLVMIR/ConvertFromLLVMIR.cpp

 //===----------------------------------------------------------------------===//
 
 #include "mlir/Dialect/DLTI/DLTI.h"
 #include "mlir/IR/BuiltinOps.h"
 #include "mlir/Target/LLVMIR/Dialect/All.h"
 #include "mlir/Target/LLVMIR/Import.h"
 #include "mlir/Tools/mlir-translate/Translation.h"
 #include "llvm/IR/Module.h"
+#include "llvm/IR/Verifier.h"
 #include "llvm/IRReader/IRReader.h"
 #include "llvm/Support/SourceMgr.h"
 
 using namespace mlir;
 
 namespace mlir {
 void registerFromLLVMIRTranslation() {
   TranslateToMLIRRegistration registration(
       "import-llvm", "translate llvmir to mlir",
       [](llvm::SourceMgr &sourceMgr,
          MLIRContext *context) -> OwningOpRef<Operation *> {
         llvm::SMDiagnostic err;
         llvm::LLVMContext llvmContext;
         std::unique_ptr<llvm::Module> llvmModule =
             llvm::parseIR(*sourceMgr.getMemoryBuffer(sourceMgr.getMainFileID()),
                           err, llvmContext);
         if (!llvmModule) {
           std::string errStr;
           llvm::raw_string_ostream errStream(errStr);
           err.print(/*ProgName=*/"", errStream);
           emitError(UnknownLoc::get(context)) << errStream.str();
           return {};
         }
+        if (llvm::verifyModule(*llvmModule, &llvm::errs()))
+          return nullptr;
         return translateLLVMIRToModule(std::move(llvmModule), context);
       },
       [](DialectRegistry &registry) {
         // Register the DLTI dialect used to express the data layout
         // specification of the imported module.
         registry.insert<DLTIDialect>();
         // Register all dialects that implement the LLVMImportDialectInterface
         // including the LLVM dialect.
         registerAllFromLLVMIRTranslations(registry);
       });
 }
 } // namespace mlir

mlir/lib/Target/LLVMIR/Dialect/LLVMIR/LLVMIRToLLVMTranslation.cpp

 } // namespace
 
 /// Converts the given profiling metadata `node` to an MLIR profiling attribute
 /// and attaches it to the imported operation if the translation succeeds.
 /// Returns failure otherwise.
 static LogicalResult setProfilingAttr(OpBuilder &builder, llvm::MDNode *node,
                                       Operation *op,
                                       LLVM::ModuleImport &moduleImport) {
-  // Return success for empty metadata nodes since there is nothing to import.
+  // Return failure for empty metadata nodes since there is nothing to import.
   if (!node->getNumOperands())
-    return op->emitWarning() << "expected non-empty profiling metadata node";
+    return failure();
 
   auto *name = dyn_cast<llvm::MDString>(node->getOperand(0));
   if (!name)
-    return op->emitWarning()
-           << "expected profiling metadata node to have a string identifier";
+    return failure();
 
   // Handle function entry count metadata.
   if (name->getString().equals("function_entry_count")) {
-    auto emitNodeWarning = [&]() {
-      return op->emitWarning()
-             << "expected function_entry_count to hold a single i64 value";
-    };
 
     // TODO support function entry count metadata with GUID fields.
     if (node->getNumOperands() != 2)
-      return emitNodeWarning();
+      return failure();
 
     llvm::ConstantInt *entryCount =
         llvm::mdconst::dyn_extract<llvm::ConstantInt>(node->getOperand(1));
     if (!entryCount)
-      return emitNodeWarning();
+      return failure();
     if (auto funcOp = dyn_cast<LLVMFuncOp>(op)) {
       funcOp.setFunctionEntryCount(entryCount->getZExtValue());
       return success();
     }
     return op->emitWarning()
            << "expected function_entry_count to be attached to a function";
   }
 
   if (!name->getString().equals("branch_weights"))
-    return op->emitWarning()
-           << "unknown profiling metadata node " << name->getString();
+    return failure();
 
   // Handle branch weights metadata.
   SmallVector<int32_t> branchWeights;
   branchWeights.reserve(node->getNumOperands() - 1);
   for (unsigned i = 1, e = node->getNumOperands(); i != e; ++i) {
     llvm::ConstantInt *branchWeight =
         llvm::mdconst::dyn_extract<llvm::ConstantInt>(node->getOperand(i));
     if (!branchWeight)
-      return op->emitWarning() << "expected branch weights to be integers";
+      return failure();
     branchWeights.push_back(branchWeight->getZExtValue());
   }
 
   return AttributeSetter<CondBrOp, SwitchOp, CallOp, InvokeOp>(op).apply(
       [&](auto branchWeightOp) {
         branchWeightOp.setBranchWeightsAttr(
             builder.getI32VectorAttr(branchWeights));
       });

mlir/lib/Target/LLVMIR/LoopAnnotationImporter.cpp

 LogicalResult LoopAnnotationImporter::translateAccessGroup(
     const llvm::MDNode *node, Location loc, MetadataOp metadataOp) {
   SmallVector<const llvm::MDNode *> accessGroups;
   if (!node->getNumOperands())
     accessGroups.push_back(node);
   for (const llvm::MDOperand &operand : node->operands()) {
     auto *childNode = dyn_cast<llvm::MDNode>(operand);
     if (!childNode)
-      return emitWarning(loc)
-             << "expected access group operands to be metadata nodes";
+      return failure();
     accessGroups.push_back(cast<llvm::MDNode>(operand.get()));
   }
 
   // Convert all entries of the access group list to access group operations.
   for (const llvm::MDNode *accessGroup : accessGroups) {
     if (accessGroupMapping.count(accessGroup))
       continue;
     // Verify the access group node is distinct and empty.

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

 define i32 @invokeLandingpad() personality ptr @__gxx_personality_v0 {
   ; CHECK: %[[a1:[0-9]+]] = llvm.mlir.addressof @_ZTIii : !llvm.ptr
   ; CHECK: %[[a3:[0-9]+]] = llvm.alloca %{{[0-9]+}} x i8 {alignment = 1 : i64} : (i32) -> !llvm.ptr
   %1 = alloca i8
   ; CHECK: llvm.invoke @foo(%[[a3]]) to ^bb2 unwind ^bb1 : (!llvm.ptr) -> ()
   invoke void @foo(ptr %1) to label %4 unwind label %2
 
 ; CHECK: ^bb1:
-  ; CHECK: %{{[0-9]+}} = llvm.landingpad (catch %{{[0-9]+}} : !llvm.ptr) (catch %[[a1]] : !llvm.ptr) (filter %{{[0-9]+}} : !llvm.array<1 x i8>) : !llvm.struct<(ptr, i32)>
+  ; CHECK: %{{[0-9]+}} = llvm.landingpad (catch %{{[0-9]+}} : !llvm.ptr) (catch %[[a1]] : !llvm.ptr) (filter %{{[0-9]+}} : !llvm.array<1 x i1>) : !llvm.struct<(ptr, i32)>
   %3 = landingpad { ptr, i32 } catch ptr @_ZTIi catch ptr @_ZTIii
-  ; FIXME: Change filter to a constant array once they are handled.
-  ; Currently, even though it parses this, LLVM module is broken
-          filter [1 x i8] [i8 1]
+          filter [1 x i1] [i1 1]
   resume { ptr, i32 } %3
 
 ; CHECK: ^bb2:
   ; CHECK: llvm.return %{{[0-9]+}} : i32
   ret i32 1
 
 ; CHECK: ^bb3:
   ; CHECK: %{{[0-9]+}} = llvm.invoke @bar(%[[a3]]) to ^bb2 unwind ^bb1 : (!llvm.ptr) -> !llvm.ptr

mlir/test/Target/LLVMIR/Import/function-attributes.ll

 declare void @func_readnone_indirect() #0
 attributes #0 = { readnone }
 
 ; // -----
 
 ; CHECK-LABEL: @func_arg_attrs
 ; CHECK-SAME:  !llvm.ptr {llvm.byval = i64}
 ; CHECK-SAME:  !llvm.ptr {llvm.byref = i64}
-; CHECK-SAME:  !llvm.ptr {llvm.sret = i64}
-; CHECK-SAME:  !llvm.ptr {llvm.inalloca = i64}
 ; CHECK-SAME:  !llvm.ptr {llvm.noalias}
 ; CHECK-SAME:  !llvm.ptr {llvm.readonly}
 ; CHECK-SAME:  !llvm.ptr {llvm.nest}
 ; CHECK-SAME:  i32 {llvm.signext}
 ; CHECK-SAME:  i64 {llvm.zeroext}
 ; CHECK-SAME:  !llvm.ptr {llvm.align = 64 : i64, llvm.noundef}
 ; CHECK-SAME:  !llvm.ptr {llvm.dereferenceable = 12 : i64}
 ; CHECK-SAME:  !llvm.ptr {llvm.dereferenceable_or_null = 42 : i64}
 ; CHECK-SAME:  f64 {llvm.inreg}
 ; CHECK-SAME:  !llvm.ptr {llvm.nocapture}
 ; CHECK-SAME:  !llvm.ptr {llvm.nofree}
 ; CHECK-SAME:  !llvm.ptr {llvm.nonnull}
 ; CHECK-SAME:  !llvm.ptr {llvm.preallocated = f64}
 ; CHECK-SAME:  !llvm.ptr {llvm.returned}
 ; CHECK-SAME:  !llvm.ptr {llvm.alignstack = 32 : i64}
 ; CHECK-SAME:  !llvm.ptr {llvm.writeonly}
 define ptr @func_arg_attrs(
     ptr byval(i64) %arg0,
     ptr byref(i64) %arg1,
-    ptr sret(i64) %arg2,
-    ptr inalloca(i64) %arg3,
     ptr noalias %arg4,
     ptr readonly %arg5,
     ptr nest %arg6,
     i32 signext %arg7,
     i64 zeroext %arg8,
     ptr align(64) noundef %arg9,
     ptr dereferenceable(12) %arg10,
     ptr dereferenceable_or_null(42) %arg11,
     double inreg %arg12,
     ptr nocapture %arg13,
     ptr nofree %arg14,
     ptr nonnull %arg15,
     ptr preallocated(double) %arg16,
     ptr returned %arg17,
     ptr alignstack(32) %arg18,
     ptr writeonly %arg19) {
   ret ptr %arg17
 }
 
+; CHECK-LABEL: @sret
+; CHECK-SAME:  !llvm.ptr {llvm.sret = i64}
+define void @sret(ptr sret(i64) %arg0) {
+  ret void
+}
+
+; CHECK-LABEL: @inalloca
+; CHECK-SAME:  !llvm.ptr {llvm.inalloca = i64}
+define void @inalloca(ptr inalloca(i64) %arg0) {
+  ret void
+}
+
 ; CHECK-LABEL: @allocator
 ; CHECK-SAME:  i64 {llvm.allocalign}
 ; CHECK-SAME:  ptr {llvm.allocptr}
 declare ptr @allocator(i64 allocalign, ptr allocptr)
 
 ; // -----
 
 ; CHECK-LABEL: @func_res_attr_noalias

mlir/test/Target/LLVMIR/Import/import-failure.ll

 
 ; // -----
 
 ; CHECK:      import-failure.ll
 ; CHECK-SAME: error: blockaddress is not implemented in the LLVM dialect
 ; CHECK:      import-failure.ll
 ; CHECK-SAME: error: unhandled instruction: ret ptr blockaddress(@unhandled_constant, %bb1)
 define ptr @unhandled_constant() {
+  br label %bb1
 bb1:
   ret ptr blockaddress(@unhandled_constant, %bb1)
 }
 
 ; // -----
 
 ; CHECK:      import-failure.ll
 ; CHECK-SAME: error: blockaddress is not implemented in the LLVM dialect
 ; CHECK:      import-failure.ll
 ; CHECK-SAME: error: unhandled global variable: @private = private global ptr blockaddress(@unhandled_global, %bb1)
 @private = private global ptr blockaddress(@unhandled_global, %bb1)
 
 define void @unhandled_global() {
+  br label %bb1
 bb1:
   ret void
 }
 
 ; // -----
 
 declare void @llvm.gcroot(ptr %arg1, ptr %arg2)
 
 ; CHECK:      import-failure.ll
-; CHECK-SAME: error: unhandled intrinsic: call void @llvm.gcroot(ptr %arg1, ptr %arg2)
-define void @unhandled_intrinsic(ptr %arg1, ptr %arg2) {
-  call void @llvm.gcroot(ptr %arg1, ptr %arg2)
+; CHECK-SAME: error: unhandled intrinsic: call void @llvm.gcroot(ptr %arg1, ptr null)
+define void @unhandled_intrinsic() gc "example" {
+  %arg1 = alloca ptr
+  call void @llvm.gcroot(ptr %arg1, ptr null)
   ret void
 }
 
 ; // -----
 
-; CHECK: warning: unhandled metadata: !0 = !{!"unknown metadata"} on br i1 %arg1, label %bb1, label %bb2, !prof !0
-define i64 @unhandled_metadata(i1 %arg1, i64 %arg2) {
-entry:
-  br i1 %arg1, label %bb1, label %bb2, !prof !0
-bb1:
-  ret i64 %arg2
-bb2:
-  ret i64 %arg2
-}
-
-!0 = !{!"unknown metadata"}
-
-; // -----
-
-; CHECK: warning: unhandled function metadata: !0 = !{!"unknown metadata"} on define void @unhandled_func_metadata(i1 %arg1, i64 %arg2) !prof !0
-define void @unhandled_func_metadata(i1 %arg1, i64 %arg2) !prof !0 {
-  ret void
-}
-
-!0 = !{!"unknown metadata"}
-
-; // -----
-
 declare void @llvm.dbg.value(metadata, metadata, metadata)
 
 ; CHECK:      import-failure.ll
 ; CHECK-SAME: warning: dropped instruction: call void @llvm.dbg.value(metadata i64 %arg1, metadata !3, metadata !DIExpression(DW_OP_plus_uconst, 42, DW_OP_stack_value)), !dbg !5
 ; CHECK:      import-failure.ll
 ; CHECK-SAME: warning: dropped instruction: call void @llvm.dbg.value(metadata !DIArgList(i64 %arg1, i64 undef), metadata !3, metadata !DIExpression(DW_OP_LLVM_arg, 0, DW_OP_LLVM_arg, 1, DW_OP_constu, 1, DW_OP_mul, DW_OP_plus, DW_OP_stack_value)), !dbg !5
 define void @dropped_instruction(i64 %arg1) {
   call void @llvm.dbg.value(metadata i64 %arg1, metadata !3, metadata !DIExpression(DW_OP_plus_uconst, 42, DW_OP_stack_value)), !dbg !5
   call void @llvm.dbg.value(metadata !DIArgList(i64 %arg1, i64 undef), metadata !3, metadata !DIExpression(DW_OP_LLVM_arg, 0, DW_OP_LLVM_arg, 1, DW_OP_constu, 1, DW_OP_mul, DW_OP_plus, DW_OP_stack_value)), !dbg !5
   ret void
 }
 
 !llvm.dbg.cu = !{!1}
 !llvm.module.flags = !{!0}
 !0 = !{i32 2, !"Debug Info Version", i32 3}
 !1 = distinct !DICompileUnit(language: DW_LANG_C, file: !2)
 !2 = !DIFile(filename: "import-failure.ll", directory: "/")
 !3 = !DILocalVariable(scope: !4, name: "arg1", file: !2, line: 1, arg: 1, align: 64);
 !4 = distinct !DISubprogram(name: "intrinsic", scope: !2, file: !2, spFlags: DISPFlagDefinition, unit: !1)
 !5 = !DILocation(line: 1, column: 2, scope: !4)
 
 ; // -----
 
-; global_ctors requires the appending linkage type.
-; CHECK:      import-failure.ll
-; CHECK-SAME: error: unhandled global variable: @llvm.global_ctors
[e-mail]_ctors = global [1 x { i32, ptr, ptr }] [{ i32, ptr, ptr } { i32 0, ptr @foo, ptr null }]
-
-define void @foo() {
-  ret void
-}
-
-; // -----
-
 ; global_dtors with non-null data fields cannot be represented in MLIR.
 ; CHECK:      import-failure.ll
 ; CHECK-SAME: error: unhandled global variable: @llvm.global_dtors
 @llvm.global_dtors = appending global [1 x { i32, ptr, ptr }] [{ i32, ptr, ptr } { i32 0, ptr @foo, ptr @foo }]
 
 define void @foo() {
   ret void
 }
 
 ; // -----
 
-; global_ctors without a data field should not be imported.
-; CHECK:      import-failure.ll
-; CHECK-SAME: error: unhandled global variable: @llvm.global_ctors
[e-mail]_ctors = appending global [1 x { i32, ptr }] [{ i32, ptr } { i32 0, ptr @foo }]
-
-define void @foo() {
-  ret void
-}
-
-; // -----
-
-; global_dtors with a wrong argument order should not be imported.
-; CHECK:      import-failure.ll
-; CHECK-SAME: error: unhandled global variable: @llvm.global_dtors
[e-mail]_dtors = appending global [1 x { ptr, i32, ptr }] [{ ptr, i32, ptr } { ptr @foo, i32 0, ptr null }]
-
-define void @foo() {
-  ret void
-}
-
-; // -----
-
 ; CHECK:      import-failure.ll
 ; CHECK-SAME: error: TBAA root node must have non-empty identity: !2 = !{!""}
 define dso_local void @tbaa(ptr %0) {
   store i8 1, ptr %0, align 4, !tbaa !2
   ret void
 }
 
 !0 = !{!""}
 !1 = !{!"omnipotent char", !0, i64 0}
 !2 = !{!1, !1, i64 0}
 
 ; // -----
 
 ; CHECK:      import-failure.ll
-; CHECK-SAME: error: unsupported TBAA node format: !0 = !{!1, i64 0, i64 0}
-define dso_local void @tbaa(ptr %0) {
-  store i8 1, ptr %0, align 4, !tbaa !2
-  ret void
-}
-
-!0 = !{!"Simple C/C++ TBAA"}
-!1 = !{!"omnipotent char", !0, i64 0}
-!2 = !{!1, i64 0, i64 0}
-
-; // -----
-
-; CHECK:      import-failure.ll
-; CHECK-SAME: error: operand '1' must be MDNode: !1 = !{!"omnipotent char", i64 0, i64 0}
-define dso_local void @tbaa(ptr %0) {
-  store i8 1, ptr %0, align 4, !tbaa !2
-  ret void
-}
-
-!0 = !{!"Simple C/C++ TBAA"}
-!1 = !{!"omnipotent char", i64 0, i64 0}
-!2 = !{!1, !1, i64 0}
-
-; // -----
-
-; CHECK:      import-failure.ll
-; CHECK-SAME: error: missing member offset: !1 = !{!"agg_t", !2, i64 0, !2}
-define dso_local void @tbaa(ptr %0) {
-  store i8 1, ptr %0, align 4, !tbaa !3
-  ret void
-}
-
-!0 = !{!"Simple C/C++ TBAA"}
-!1 = !{!"omnipotent char", !0, i64 0}
-!2 = !{!"agg_t", !1, i64 0, !1}
-!3 = !{!2, !1, i64 0}
-
-; // -----
-
-; CHECK:      import-failure.ll
-; CHECK-SAME: error: operand '4' must be ConstantInt: !1 = !{!"agg_t", !2, i64 0, !2, double 1.000000e+00}
-define dso_local void @tbaa(ptr %0) {
-  store i8 1, ptr %0, align 4, !tbaa !3
-  ret void
-}
-
-!0 = !{!"Simple C/C++ TBAA"}
-!1 = !{!"omnipotent char", !0, i64 0}
-!2 = !{!"agg_t", !1, i64 0, !1, double 1.0}
-!3 = !{!2, !1, i64 0}
-
-; // -----
-
-; CHECK:      import-failure.ll
-; CHECK-SAME: error: operand '3' must be ConstantInt: !0 = !{!1, !1, i64 0, double 1.000000e+00}
-define dso_local void @tbaa(ptr %0) {
-  store i8 1, ptr %0, align 4, !tbaa !2
-  ret void
-}
-
-!0 = !{!"Simple C/C++ TBAA"}
-!1 = !{!"omnipotent char", !0, i64 0}
-!2 = !{!1, !1, i64 0, double 1.0}
-
-; // -----
-
-; CHECK:      import-failure.ll
 ; CHECK-SAME: error: unsupported TBAA node format: !0 = !{!1, !1, i64 0, i64 4}
 define dso_local void @tbaa(ptr %0) {
   store i32 1, ptr %0, align 4, !tbaa !2
   ret void
 }
 
 !2 = !{!3, !3, i64 0, i64 4}
 !3 = !{!4, i64 4, !"int"}
define void @access_group(ptr %arg1) {
   ret void
 }
 
 !0 = !{}
 
 ; // -----
 
 ; CHECK:      import-failure.ll
-; CHECK-SAME: warning: expected an access group node to be empty and distinct
-; CHECK:      error: unsupported access group node: !0 = !{!1}
-define void @access_group(ptr %arg1) {
-  %1 = load i32, ptr %arg1, !llvm.access.group !0
-  ret void
-}
-
-!0 = !{!1}
-!1 = distinct !{!"unsupported access group"}
-
-; // -----
-
-; CHECK:      import-failure.ll
-; CHECK-SAME: warning: expected access group operands to be metadata nodes
-; CHECK:      error: unsupported access group node: !0 = !{i1 false}
-define void @access_group(ptr %arg1) {
-  %1 = load i32, ptr %arg1, !llvm.access.group !0
-  ret void
-}
-
-!0 = !{i1 false}
-
-; // -----
-
-; CHECK:      import-failure.ll
 ; CHECK-SAME: warning: expected all loop properties to be either debug locations or metadata nodes
 ; CHECK:      import-failure.ll
 ; CHECK-SAME: warning: unhandled metadata: !0 = distinct !{!0, i32 42}
 define void @invalid_loop_node(i64 %n, ptr %A) {
 entry:
   br label %end, !llvm.loop !0
 end:
   ret void

 
 !0 = distinct !{!0, !1, !2}
 !1 = !{!"llvm.loop.disable_nonforced"}
 !2 = !{!"llvm.loop.typo"}
 
 ; // -----
 
 ; CHECK:      import-failure.ll
-; CHECK-SAME: warning: expected non-empty profiling metadata node
-; CHECK:      warning: unhandled metadata: !0 = !{}
-define void @cond_br(i1 %arg) {
-entry:
-  br i1 %arg, label %bb1, label %bb2, !prof !0
-bb1:
-  ret void
-bb2:
-  ret void
-}
-
-!0 = !{}
-
-; // -----
-
-; CHECK:      import-failure.ll
-; CHECK-SAME: warning: expected profiling metadata node to have a string identifier
-; CHECK:      import-failure.ll:{{.*}} warning: unhandled metadata: !0 = !{i32 64}
-define void @cond_br(i1 %arg) {
-entry:
-  br i1 %arg, label %bb1, label %bb2, !prof !0
-bb1:
-  ret void
-bb2:
-  ret void
-}
-
-!0 = !{i32 64}
-
-; // -----
-
-; CHECK:      import-failure.ll
-; CHECK-SAME: warning: expected function_entry_count to hold a single i64 value
-; CHECK:      warning: unhandled function metadata: !0 = !{!"function_entry_count"}
-define void @cond_br(i1 %arg) !prof !0 {
-entry:
-  br i1 %arg, label %bb1, label %bb2
-bb1:
-  ret void
-bb2:
-  ret void
-}
-
-!0 = !{!"function_entry_count"}
-
-; // -----
-
-; CHECK:      import-failure.ll
-; CHECK-SAME: warning: expected function_entry_count to hold a single i64 value
-; CHECK:      warning: unhandled function metadata: !0 = !{!"function_entry_count", !"string"}
-define void @cond_br(i1 %arg) !prof !0 {
-entry:
-  br i1 %arg, label %bb1, label %bb2
-bb1:
-  ret void
-bb2:
-  ret void
-}
-
-!0 = !{!"function_entry_count", !"string"}
-
-; // -----
-
-; CHECK:      import-failure.ll
 ; CHECK-SAME: warning: expected function_entry_count to be attached to a function
 ; CHECK:      warning: unhandled metadata: !0 = !{!"function_entry_count", i64 42}
 define void @cond_br(i1 %arg) {
 entry:
   br i1 %arg, label %bb1, label %bb2, !prof !0
 bb1:
   ret void
 bb2:
   ret void
 }
 
 !0 = !{!"function_entry_count", i64 42}
-
-; // -----
-
-; CHECK:      import-failure.ll
-; CHECK-SAME: warning: unknown profiling metadata node unknown_prof_type
-; CHECK:      warning: unhandled metadata: !0 = !{!"unknown_prof_type"}
-define void @cond_br(i1 %arg) {
-entry:
-  br i1 %arg, label %bb1, label %bb2, !prof !0
-bb1:
-  ret void
-bb2:
-  ret void
-}
-
-!0 = !{!"unknown_prof_type"}
-
-; // -----
-
-; CHECK:      import-failure.ll
-; CHECK-SAME: warning: expected branch weights to be integers
-; CHECK:      warning: unhandled metadata: !0 = !{!"branch_weights", !"foo"}
-define void @cond_br(i1 %arg) {
-entry:
-  br i1 %arg, label %bb1, label %bb2, !prof !0
-bb1:
-  ret void
-bb2:
-  ret void
-}
-
-!0 = !{!"branch_weights", !"foo"}
-
-; // -----
-
-; CHECK:      import-failure.ll:{{.*}} warning: unhandled function metadata: !0 = !{!"branch_weights", i32 64}
-define void @cond_br(i1 %arg) !prof !0 {
-  ret void
-}
-
-!0 = !{!"branch_weights", i32 64}
-
-; // -----
-
-; CHECK:      import-failure.ll
-; CHECK-SAME: error: unsupported alias scope node: ![[NODE:[0-9]+]] = distinct !{![[NODE]]}
-define void @alias_scope(ptr %arg1) {
-  %1 = load i32, ptr %arg1, !alias.scope !0
-  ret void
-}
-
-!0 = !{!0}
-
-; // -----
-
-; CHECK:      import-failure.ll
-; CHECK-SAME: error: unsupported alias scope node: ![[NODE:[0-9]+]] = distinct !{![[NODE]], !"The domain"}
-define void @alias_scope(ptr %arg1) {
-  %1 = load i32, ptr %arg1, !alias.scope !1
-  ret void
-}
-
-!0 = distinct !{!0, !"The domain"}
-!1 = !{!1, !0}
-
-; // -----
-
-; CHECK:      import-failure.ll
-; CHECK-SAME: error: unsupported alias domain node: ![[NODE:[0-9]+]] = distinct !{![[NODE]], ![[NODE]]}
-define void @alias_scope_domain(ptr %arg1) {
-  %1 = load i32, ptr %arg1, !alias.scope !2
-  ret void
-}
-
-!0 = distinct !{!0, !0}
-!1 = !{!1, !0}
-!2 = !{!1}

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

 ; RUN: mlir-translate -import-llvm -split-input-file %s | FileCheck %s
 
-// -----
-
 ; CHECK-LABEL: llvm.metadata @__llvm_global_metadata {
-; 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-DAG:    llvm.tbaa_root @[[R0:tbaa_root_[0-9]+]] {id = "Simple C/C++ TBAA"}
+; CHECK-DAG:    llvm.tbaa_type_desc @[[D0:tbaa_type_desc_[0-9]+]] {id = "scalar type", members = {<@[[R0]], 0>}}
+; CHECK-DAG:    llvm.tbaa_tag @[[T0:tbaa_tag_[0-9]+]] {access_type = @[[D0]], base_type = @[[D0]], offset = 0 : i64}
+; CHECK-DAG:    llvm.tbaa_root @[[R1:tbaa_root_[0-9]+]] {id = "Other language TBAA"}
+; CHECK-DAG:    llvm.tbaa_type_desc @[[D1:tbaa_type_desc_[0-9]+]] {id = "other scalar type", members = {<@[[R1]], 0>}}
+; CHECK-DAG:    llvm.tbaa_tag @[[T1:tbaa_tag_[0-9]+]] {access_type = @[[D1]], base_type = @[[D1]], offset = 0 : i64}
 ; CHECK-NEXT:  }
 ; CHECK:       llvm.func @tbaa1
 ; CHECK:         llvm.store %{{.*}}, %{{.*}} {
 ; CHECK-SAME:        tbaa = [@__llvm_global_metadata::@[[T0]]]
 ; CHECK-SAME:    } : i8, !llvm.ptr
 ; CHECK:         llvm.store %{{.*}}, %{{.*}} {
 ; CHECK-SAME:        tbaa = [@__llvm_global_metadata::@[[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 %0, align 4, !tbaa !0
   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}
+!0 = !{!1, !1, i64 0}
+!1 = !{!"scalar type", !2, i64 0}
+!2 = !{!"Simple C/C++ TBAA"}
+
+!3 = !{!4, !4, i64 0}
+!4 = !{!"other scalar type", !5, i64 0}
+!5 = !{!"Other language TBAA"}
 
 // -----
 
 ; CHECK-LABEL: llvm.metadata @__llvm_global_metadata {
 ; 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>}}