[mlir][llvm] Improve error messages during LLVM IR import.

[gysit]

Summary

Use the module location instead of unknown location if the imported
LLVM IR module does not have more precise debug information.
Additionally, use the diagMD function to print the metadata instead
of just the metadata kind if the import fails.

[definelicht]

LGTM!

[Dinistro]

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

1

Should we also check if the module location was emitted in this test file?

[gysit]

Address review comment and rebase.

mlir/lib/Target/LLVMIR/DebugImporter.h

 
 namespace LLVM {
 class LLVMFuncOp;
 
 namespace detail {
 
 class DebugImporter {
 public:
-  DebugImporter(MLIRContext *context) : context(context) {}
+  DebugImporter(ModuleOp mlirModule)
+      : context(mlirModule.getContext()), mlirModule(mlirModule) {}
 
   /// Translates the given LLVM debug location to an MLIR location.
   Location translateLoc(llvm::DILocation *loc);
 
   /// Translates the debug information for the given function.
   void translate(llvm::Function *func, LLVMFuncOp funcOp);
 
   /// Translates the given LLVM debug metadata to MLIR.
private:
   DISubrangeAttr translateImpl(llvm::DISubrange *node);
   DISubroutineTypeAttr translateImpl(llvm::DISubroutineType *node);
   DITypeAttr translateImpl(llvm::DIType *node);
 
   /// A mapping between LLVM debug metadata and the corresponding attribute.
   DenseMap<llvm::DINode *, DINodeAttr> nodeToAttr;
 
   MLIRContext *context;
+  ModuleOp mlirModule;
 };
 
 } // namespace detail
 } // namespace LLVM
 } // namespace mlir
 
 #endif // MLIR_LIB_TARGET_LLVMIR_DEBUIMPORTN_H_

mlir/lib/Target/LLVMIR/DebugImporter.cpp

 }
 
 //===----------------------------------------------------------------------===//
 // Locations
 //===----------------------------------------------------------------------===//
 
 Location DebugImporter::translateLoc(llvm::DILocation *loc) {
   if (!loc)
-    return UnknownLoc::get(context);
+    return mlirModule.getLoc();
 
   // Get the file location of the instruction.
   Location result = FileLineColLoc::get(context, loc->getFilename(),
                                         loc->getLine(), loc->getColumn());
 
   // Add call site information, if available.
   if (llvm::DILocation *inlinedAt = loc->getInlinedAt())
     result = CallSiteLoc::get(result, translateLoc(inlinedAt));
 
   // Add scope information.
   assert(loc->getScope() && "expected non-null scope");
   result = FusedLocWith<DIScopeAttr>::get({result}, translate(loc->getScope()),
                                           context);
   return result;
 }

mlir/lib/Target/LLVMIR/ModuleImport.cpp

 }
 
 ModuleImport::ModuleImport(ModuleOp mlirModule,
                            std::unique_ptr<llvm::Module> llvmModule)
     : 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())) {
+      debugImporter(std::make_unique<DebugImporter>(mlirModule)) {
   builder.setInsertionPointToStart(mlirModule.getBody());
 }
 
 MetadataOp ModuleImport::getTBAAMetadataOp() {
   if (tbaaMetadataOp)
     return tbaaMetadataOp;
 
   OpBuilder::InsertionGuard guard(builder);

 }
 
 LogicalResult ModuleImport::convertGlobals() {
   for (llvm::GlobalVariable &globalVar : llvmModule->globals()) {
     if (globalVar.getName() == getGlobalCtorsVarName() ||
         globalVar.getName() == getGlobalDtorsVarName()) {
       if (failed(convertGlobalCtorsAndDtors(&globalVar))) {
         return emitError(mlirModule.getLoc())
-               << "unhandled global variable " << diag(globalVar);
+               << "unhandled global variable: " << diag(globalVar);
       }
       continue;
     }
     if (failed(convertGlobal(&globalVar))) {
       return emitError(mlirModule.getLoc())
-             << "unhandled global variable " << diag(globalVar);
+             << "unhandled global variable: " << diag(globalVar);
     }
   }
   return success();
 }
 
 LogicalResult ModuleImport::convertFunctions() {
   for (llvm::Function &func : llvmModule->functions())
     if (failed(processFunction(&func)))
       return failure();
   return success();
 }
 
 void ModuleImport::setNonDebugMetadataAttrs(llvm::Instruction *inst,
                                             Operation *op) {
   SmallVector<std::pair<unsigned, llvm::MDNode *>> allMetadata;
   inst->getAllMetadataOtherThanDebugLoc(allMetadata);
   for (auto &[kind, node] : allMetadata) {
     if (!iface.isConvertibleMetadata(kind))
       continue;
     if (failed(iface.setMetadataAttrs(builder, kind, node, op, *this))) {
       Location loc = debugImporter->translateLoc(inst->getDebugLoc());
-      emitWarning(loc) << "unhandled metadata (" << kind << ") " << diag(*inst);
+      emitWarning(loc) << "unhandled metadata: "
+                       << diagMD(node, llvmModule.get()) << " on "
+                       << diag(*inst);
     }
   }
 }
 
 void ModuleImport::setFastmathFlagsAttr(llvm::Instruction *inst,
                                         Operation *op) const {
   auto iface = cast<FastmathFlagsInterface>(op);
 
ModuleImport::getConstantsToConvert(llvm::Constant *constant) {
   // are uniqued and only one `valueMapping` entry per constant is possible.
   SetVector<llvm::Constant *> orderedSet;
   for (llvm::Constant *orderedConst : llvm::reverse(orderedList))
     orderedSet.insert(orderedConst);
   return orderedSet;
 }
 
 FailureOr<Value> ModuleImport::convertConstant(llvm::Constant *constant) {
-  // Constants have no location attached.
-  Location loc = UnknownLoc::get(context);
+  Location loc = mlirModule.getLoc();
 
   // Convert constants that can be represented as attributes.
   if (Attribute attr = getConstantAsAttr(constant)) {
     Type type = convertType(constant->getType());
     if (auto symbolRef = attr.dyn_cast<FlatSymbolRefAttr>()) {
       return builder.create<AddressOfOp>(loc, type, symbolRef.getValue())
           .getResult();
     }
for (const auto &it : llvm::enumerate(elementValues)) {
             builder.create<ConstantOp>(loc, builder.getI32Type(), indexAttr);
         root = builder.create<InsertElementOp>(loc, rootType, root, it.value(),
                                                indexValue);
       }
     }
     return root;
   }
 
-  return emitError(loc) << "unhandled constant " << diag(*constant);
+  return emitError(loc) << "unhandled constant: " << diag(*constant);
 }
 
 FailureOr<Value> ModuleImport::convertConstantExpr(llvm::Constant *constant) {
   assert(constantInsertionBlock &&
          "expected the constant insertion block to be non-null");
 
   // Insert the constant after the last one or at the start or the entry block.
   OpBuilder::InsertionGuard guard(builder);
FailureOr<Value> ModuleImport::convertValue(llvm::Value *value) {
   // Return the mapped value if it has been converted before.
   if (valueMapping.count(value))
     return lookupValue(value);
 
   // Convert constants such as immediate values that have no mapping yet.
   if (auto *constant = dyn_cast<llvm::Constant>(value))
     return convertConstantExpr(constant);
 
-  Location loc = UnknownLoc::get(context);
+  Location loc = mlirModule.getLoc();
   if (auto *inst = dyn_cast<llvm::Instruction>(value))
     loc = translateLoc(inst->getDebugLoc());
-  return emitError(loc) << "unhandled value " << diag(*value);
+  return emitError(loc) << "unhandled value: " << diag(*value);
 }
 
 FailureOr<SmallVector<Value>>
 ModuleImport::convertValues(ArrayRef<llvm::Value *> values) {
   SmallVector<Value> remapped;
   remapped.reserve(values.size());
   for (llvm::Value *value : values) {
     FailureOr<Value> converted = convertValue(value);
ModuleImport::convertCallTypeAndOperands(llvm::CallBase *callInst,
   return success();
 }
 
 LogicalResult ModuleImport::convertIntrinsic(llvm::CallInst *inst) {
   if (succeeded(iface.convertIntrinsic(builder, inst, *this)))
     return success();
 
   Location loc = translateLoc(inst->getDebugLoc());
-  return emitError(loc) << "unhandled intrinsic " << diag(*inst);
+  return emitError(loc) << "unhandled intrinsic: " << diag(*inst);
 }
 
 LogicalResult ModuleImport::convertInstruction(llvm::Instruction *inst) {
   // Convert all instructions that do not provide an MLIR builder.
   Location loc = translateLoc(inst->getDebugLoc());
   if (inst->getOpcode() == llvm::Instruction::Br) {
     auto *brInst = cast<llvm::BranchInst>(inst);
 
if (inst->getOpcode() == llvm::Instruction::GetElementPtr) {
     mapValue(inst, gepOp);
     return success();
   }
 
   // Convert all instructions that have an mlirBuilder.
   if (succeeded(convertInstructionImpl(builder, inst, *this)))
     return success();
 
-  return emitError(loc) << "unhandled instruction " << diag(*inst);
+  return emitError(loc) << "unhandled instruction: " << diag(*inst);
 }
 
 LogicalResult ModuleImport::processInstruction(llvm::Instruction *inst) {
   // FIXME: Support uses of SubtargetData.
   // FIXME: Add support for call / operand attributes.
   // FIXME: Add support for the indirectbr, cleanupret, catchret, catchswitch,
   // callbr, vaarg, landingpad, catchpad, cleanuppad instructions.
 
LogicalResult ModuleImport::processFunction(llvm::Function *func) {
   bool dsoLocal = func->hasLocalLinkage();
   CConv cconv = convertCConvFromLLVM(func->getCallingConv());
 
   // Insert the function at the end of the module.
   OpBuilder::InsertionGuard guard(builder);
   builder.setInsertionPoint(mlirModule.getBody(), mlirModule.getBody()->end());
 
   LLVMFuncOp funcOp = builder.create<LLVMFuncOp>(
-      UnknownLoc::get(context), func->getName(), functionType,
+      mlirModule.getLoc(), func->getName(), functionType,
       convertLinkageFromLLVM(func->getLinkage()), dsoLocal, cconv);
 
   // Set the function debug information if available.
   debugImporter->translate(func, funcOp);
 
   for (const auto &it : llvm::enumerate(functionType.getParams())) {
     llvm::SmallVector<NamedAttribute, 1> argAttrs;
     if (auto *type = func->getParamByValType(it.index())) {
for (const auto &it : llvm::enumerate(functionType.getParams())) {
     }
 
     funcOp.setArgAttrs(it.index(), argAttrs);
   }
 
   if (FlatSymbolRefAttr personality = getPersonalityAsAttr(func))
     funcOp.setPersonalityAttr(personality);
   else if (func->hasPersonalityFn())
-    emitWarning(UnknownLoc::get(context),
-                "could not deduce personality, skipping it");
+    emitWarning(funcOp.getLoc(), "could not deduce personality, skipping it");
 
   if (func->hasGC())
     funcOp.setGarbageCollector(StringRef(func->getGC()));
 
   // Handle Function attributes.
   processFunctionAttributes(func, funcOp);
 
   // Convert non-debug metadata by using the dialect interface.
   SmallVector<std::pair<unsigned, llvm::MDNode *>> allMetadata;
   func->getAllMetadata(allMetadata);
   for (auto &[kind, node] : allMetadata) {
     if (!iface.isConvertibleMetadata(kind))
       continue;
     if (failed(iface.setMetadataAttrs(builder, kind, node, funcOp, *this))) {
-      emitWarning(funcOp->getLoc())
-          << "unhandled function metadata (" << kind << ") " << diag(*func);
+      emitWarning(funcOp.getLoc())
+          << "unhandled function metadata: " << diagMD(node, llvmModule.get())
+          << " on " << diag(*func);
     }
   }
 
   if (func->isDeclaration())
     return success();
 
   // Eagerly create all blocks.
   for (llvm::BasicBlock &bb : *func) {
for (llvm::Instruction &inst : *bb) {
 
     // Set the non-debug metadata attributes on the imported operation and emit
     // a warning if an instruction other than a phi instruction is dropped
     // during the import.
     if (Operation *op = lookupOperation(&inst)) {
       setNonDebugMetadataAttrs(&inst, op);
     } else if (inst.getOpcode() != llvm::Instruction::PHI) {
       Location loc = debugImporter->translateLoc(inst.getDebugLoc());
-      emitWarning(loc) << "dropped instruction " << diag(inst);
+      emitWarning(loc) << "dropped instruction: " << diag(inst);
     }
   }
   return success();
 }
 
 OwningOpRef<ModuleOp>
 mlir::translateLLVMIRToModule(std::unique_ptr<llvm::Module> llvmModule,
                               MLIRContext *context) {

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

 ; RUN: mlir-translate -import-llvm %s | FileCheck %s
 ; RUN: mlir-translate -import-llvm -mlir-print-debuginfo %s | FileCheck %s --check-prefix=CHECK-DBG
 
-; CHECK-DBG: #[[UNKNOWNLOC:.+]] = loc(unknown)
+; CHECK-DBG: #[[MODULELOC:.+]] = loc({{.*}}basic.ll{{.*}}:0:0)
 
 @global = external global double, align 8
 
 ; CHECK: llvm.func @fe(i32) -> f32
 declare float @fe(i32)
 
 ; FIXME: function attributes.
 ; CHECK-LABEL: llvm.func internal @f1(%arg0: i64) -> i32 attributes {dso_local} {
-; CHECK-DBG: llvm.func internal @f1(%arg0: i64 loc(unknown)) -> i32 attributes {dso_local} {
+; CHECK-DBG: llvm.func internal @f1(%arg0: i64 loc({{.*}}basic.ll{{.*}}:0:0)) -> i32 attributes {dso_local} {
 ; CHECK: %[[c2:[0-9]+]] = llvm.mlir.constant(2 : i32) : i32
 ; CHECK: %[[c1:[0-9]+]] = llvm.mlir.constant(true) : i1
 ; CHECK: %[[c43:[0-9]+]] = llvm.mlir.constant(43 : i32) : i32
 ; CHECK: %[[c42:[0-9]+]] = llvm.mlir.constant(42 : i32) : i32
 define internal dso_local i32 @f1(i64 %a) norecurse {
 entry:
 ; CHECK: %{{[0-9]+}} = llvm.inttoptr %arg0 : i64 to !llvm.ptr<i64>
   %aa = inttoptr i64 %a to i64*
-; CHECK-DBG: llvm.mlir.addressof @global : !llvm.ptr<f64> loc(#[[UNKNOWNLOC]])
+; CHECK-DBG: llvm.mlir.addressof @global : !llvm.ptr<f64> loc(#[[MODULELOC]])
 ; %[[addrof:[0-9]+]] = llvm.mlir.addressof @global : !llvm.ptr<f64>
 ; %[[addrof2:[0-9]+]] = llvm.mlir.addressof @global : !llvm.ptr<f64>
 ; %{{[0-9]+}} = llvm.inttoptr %arg0 : i64 to !llvm.ptr<i64>
 ; %{{[0-9]+}} = llvm.ptrtoint %[[addrof2]] : !llvm.ptr<f64> to i64
 ; %{{[0-9]+}} = llvm.getelementptr %[[addrof]][%3] : (!llvm.ptr<f64>, i32) -> !llvm.ptr<f64>
   %bb = ptrtoint double* @global to i64
   %cc = getelementptr double, double* @global, i32 3
 ; CHECK: %[[b:[0-9]+]] = llvm.trunc %arg0 : i64 to i32
-; CHECK-DBG: llvm.trunc %arg0 : i64 to i32 loc(#[[UNKNOWNLOC]])
+; CHECK-DBG: llvm.trunc %arg0 : i64 to i32 loc(#[[MODULELOC]])
   %b = trunc i64 %a to i32
 ; CHECK: %[[c:[0-9]+]] = llvm.call @fe(%[[b]]) : (i32) -> f32
   %c = call float @fe(i32 %b)
 ; CHECK: %[[d:[0-9]+]] = llvm.fptosi %[[c]] : f32 to i32
   %d = fptosi float %c to i32
 ; FIXME: icmp should return i1.
 ; CHECK: %[[e:[0-9]+]] = llvm.icmp "ne" %[[d]], %[[c2]] : i32
   %e = icmp ne i32 %d, 2
 ; CHECK: llvm.cond_br %[[e]], ^bb1, ^bb2
   br i1 %e, label %if.then, label %if.end
 
 ; CHECK: ^bb1:
 if.then:
 ; CHECK: llvm.return %[[c42]] : i32
   ret i32 42
 
 ; CHECK: ^bb2:
 if.end:
 ; CHECK: %[[orcond:[0-9]+]] = llvm.or %[[e]], %[[c1]] : i1
   %or.cond = or i1 %e, 1
 ; CHECK: llvm.return %[[c43]]
   ret i32 43
 }
-; CHECK-DBG: } loc(#[[UNKNOWNLOC]])
+; CHECK-DBG: } loc(#[[MODULELOC]])
 
 
 @_ZTIi = external dso_local constant i8*
 @_ZTIii= external dso_local constant i8**
 declare void @foo(i8*)
 declare i8* @bar(i8*)
 declare i32 @__gxx_personality_v0(...)
 

mlir/test/Target/LLVMIR/Import/debug-info.ll

 ; RUN: mlir-translate -import-llvm -mlir-print-debuginfo -split-input-file %s | FileCheck %s
 
-; CHECK-LABEL: @unknown(
-define i32 @unknown(i32 %0) {
+; CHECK: #[[$MODULELOC:.+]] = loc({{.*}}debug-info.ll{{.*}}:0:0)
+
+; CHECK-LABEL: @module_loc(
+define i32 @module_loc(i32 %0) {
 entry:
   br label %next
 end:
-  ; CHECK: ^{{.*}}(%{{.+}}: i32 loc(unknown)):
+  ; CHECK: ^{{.*}}(%{{.+}}: i32 loc({{.*}}debug-info.ll{{.*}}:0:0)):
   %1 = phi i32 [ %2, %next ]
   ret i32 %1
 next:
-  ; CHECK: = llvm.mul %{{.+}}, %{{.+}} : i32 loc(#[[UNKNOWNLOC:.+]])
+  ; CHECK: = llvm.mul %{{.+}}, %{{.+}} : i32 loc(#[[$MODULELOC]])
   %2 = mul i32 %0, %0
   br label %end
 }
 
-; CHECK: #[[UNKNOWNLOC:.+]] = loc(unknown)
-
 ; // -----
 
 ; CHECK-LABEL: @instruction_loc
 define i32 @instruction_loc(i32 %arg1) {
   ; CHECK: llvm.add {{.*}} loc(#[[FILE_LOC:.*]])
   %1 = add i32 %arg1, %arg1, !dbg !5
 
   ; CHECK: llvm.mul {{.*}} loc(#[[CALLSITE_LOC:.*]])

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

 ; RUN: not mlir-translate -import-llvm -split-input-file %s 2>&1 | FileCheck %s
 
-; CHECK: error: unhandled instruction indirectbr i8* %dst, [label %bb1, label %bb2]
+; CHECK:      import-failure.ll
+; CHECK-SAME: error: unhandled instruction: indirectbr i8* %dst, [label %bb1, label %bb2]
 define i32 @unhandled_instruction(i8* %dst) {
   indirectbr i8* %dst, [label %bb1, label %bb2]
 bb1:
   ret i32 0
 bb2:
   ret i32 1
 }
 
 ; // -----
 
-; CHECK: unhandled value ptr asm "bswap $0", "=r,r"
+; CHECK:      import-failure.ll
+; CHECK-SAME: error: unhandled value: ptr asm "bswap $0", "=r,r"
 define i32 @unhandled_value(i32 %arg0) {
   %1 = call i32 asm "bswap $0", "=r,r"(i32 %arg0)
   ret i32 %1
 }
 
 ; // -----
 
-; CHECK: error: unhandled constant i8* blockaddress(@unhandled_constant, %bb1)
+; CHECK:      import-failure.ll
+; CHECK-SAME: error: unhandled constant: i8* blockaddress(@unhandled_constant, %bb1)
+; CHECK:      import-failure.ll
+; CHECK-SAME: error: unhandled instruction: ret i8* blockaddress(@unhandled_constant, %bb1)
 define i8* @unhandled_constant() {
 bb1:
   ret i8* blockaddress(@unhandled_constant, %bb1)
 }
 
 ; // -----
 
-; CHECK: error: unhandled constant i8* blockaddress(@unhandled_global, %bb1)
-; CHECK: error: unhandled global variable @private = private global i8* blockaddress(@unhandled_global, %bb1)
+; CHECK:      import-failure.ll
+; CHECK-SAME: error: unhandled constant: i8* blockaddress(@unhandled_global, %bb1)
+; CHECK:      import-failure.ll
+; CHECK-SAME: error: unhandled global variable: @private = private global i8* blockaddress(@unhandled_global, %bb1)
 @private = private global i8* blockaddress(@unhandled_global, %bb1)
 
 define void @unhandled_global() {
 bb1:
   ret void
 }
 
 ; // -----
 
 declare void @llvm.gcroot(ptr %arg0, ptr %arg1)
 
-; CHECK: error: unhandled intrinsic call void @llvm.gcroot(ptr %arg0, ptr %arg1)
+; CHECK:      import-failure.ll
+; CHECK-SAME: error: unhandled intrinsic: call void @llvm.gcroot(ptr %arg0, ptr %arg1)
 define void @unhandled_intrinsic(ptr %arg0, ptr %arg1) {
   call void @llvm.gcroot(ptr %arg0, ptr %arg1)
   ret void
 }
 
 ; // -----
 
-; CHECK: warning: unhandled metadata (2)   br i1 %arg1, label %bb1, label %bb2, !prof !0
-define i64 @cond_br(i1 %arg1, i64 %arg2) {
+; CHECK:      import-failure.ll
+; CHECK-SAME: 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:      import-failure.ll
+; CHECK-SAME: 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: 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 i64 %arg1, metadata !3, metadata !DIExpression(DW_OP_plus_uconst, 42, 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
   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: "arg", file: !2, line: 1, arg: 1, align: 32);
 !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: error: unhandled global variable @llvm.global_ctors
+; CHECK:      import-failure.ll
+; CHECK-SAME: error: unhandled global variable: @llvm.global_ctors
 @llvm.global_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: error: unhandled global variable @llvm.global_dtors
+; 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: error: unhandled global variable @llvm.global_ctors
+; CHECK:      import-failure.ll
+; CHECK-SAME: error: unhandled global variable: @llvm.global_ctors
 @llvm.global_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: error: unhandled global variable @llvm.global_dtors
+; CHECK:      import-failure.ll
+; CHECK-SAME: error: unhandled global variable: @llvm.global_dtors
 @llvm.global_dtors = appending global [1 x { ptr, i32, ptr }] [{ ptr, i32, ptr } { ptr @foo, i32 0, ptr null }]
 
 define void @foo() {
   ret void
 }
 
 ; // -----
 
-; CHECK: error: TBAA root node must have non-empty identity: !2 = !{!""}
+; 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: error: unsupported TBAA node format: !0 = !{!1, i64 0, 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: error: operand '1' must be MDNode: !1 = !{!"omnipotent char", 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: error: missing member offset: !1 = !{!"agg_t", !2, i64 0, !2}
+; 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: error: operand '4' must be ConstantInt: !1 = !{!"agg_t", !2, i64 0, !2, double 1.000000e+00}
+; 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: error: operand '3' must be ConstantInt: !0 = !{!1, !1, i64 0, double 1.000000e+00}
+; 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: error: unsupported TBAA node format: !0 = !{!1, !1, i64 0, i64 4}
+; 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"}
 !4 = !{!5, i64 1, !"omnipotent char"}
 !5 = !{!"Simple C++ TBAA"}