[mlir][LLVM] Stop importing module location for all unknown locs

[Dinistro]

Summary

This commit changes the LLVM IR import to use UnkownLoc for missing
debug locations. This change ensures that we do not accidentially
introduce failty locations that can influence debugging post export.

This behavior change is not applied to locations of global metadata
operations, as their location will not be exported.

[gysit]

LGTM!

mlir/lib/Target/LLVMIR/DebugImporter.h

 class DebugImporter {
 public:
   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 debug information for the given function into a Location.
+  /// Returns UnknownLoc if `func` has no debug information attached to it.
+  Location translateFuncLocation(llvm::Function *func);
 
   /// Translates the given LLVM debug metadata to MLIR.
   DINodeAttr translate(llvm::DINode *node);
 
   /// Infers the metadata type and translates it to MLIR.
   template <typename DINodeT>
   auto translate(DINodeT *node) {
     // Infer the MLIR type from the LLVM metadata type.

mlir/lib/Target/LLVMIR/DebugImporter.cpp

 #include "llvm/IR/Metadata.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/ErrorHandling.h"
 
 using namespace mlir;
 using namespace mlir::LLVM;
 using namespace mlir::LLVM::detail;
 
-void DebugImporter::translate(llvm::Function *func, LLVMFuncOp funcOp) {
+Location DebugImporter::translateFuncLocation(llvm::Function *func) {
   if (!func->getSubprogram())
-    return;
+    return UnknownLoc::get(context);
 
   // Add a fused location to link the subprogram information.
   StringAttr name = StringAttr::get(context, func->getSubprogram()->getName());
-  funcOp->setLoc(FusedLocWith<DISubprogramAttr>::get(
-      {NameLoc::get(name)}, translate(func->getSubprogram()), context));
+  return FusedLocWith<DISubprogramAttr>::get(
+      {NameLoc::get(name)}, translate(func->getSubprogram()), context);
 }
 
 //===----------------------------------------------------------------------===//
 // Attributes
 //===----------------------------------------------------------------------===//
 
 DIBasicTypeAttr DebugImporter::translateImpl(llvm::DIBasicType *node) {
   return DIBasicTypeAttr::get(context, node->getTag(), node->getName(),

 }
 
 //===----------------------------------------------------------------------===//
 // Locations
 //===----------------------------------------------------------------------===//
 
 Location DebugImporter::translateLoc(llvm::DILocation *loc) {
   if (!loc)
-    return mlirModule.getLoc();
+    return UnknownLoc::get(context);
 
   // 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));

mlir/lib/Target/LLVMIR/ModuleImport.cpp

LogicalResult ModuleImport::convertComdats() {
   return success();
 }
 
 LogicalResult ModuleImport::convertGlobals() {
   for (llvm::GlobalVariable &globalVar : llvmModule->globals()) {
     if (globalVar.getName() == getGlobalCtorsVarName() ||
         globalVar.getName() == getGlobalDtorsVarName()) {
       if (failed(convertGlobalCtorsAndDtors(&globalVar))) {
-        return emitError(mlirModule.getLoc())
+        return emitError(UnknownLoc::get(context))
                << "unhandled global variable: " << diag(globalVar);
       }
       continue;
     }
     if (failed(convertGlobal(&globalVar))) {
-      return emitError(mlirModule.getLoc())
+      return emitError(UnknownLoc::get(context))
              << "unhandled global variable: " << diag(globalVar);
     }
   }
   return success();
 }
 
 LogicalResult ModuleImport::convertDataLayout() {
   Location loc = mlirModule.getLoc();
if (valueMapping.contains(dependency) || workList.contains(dependency) ||
       continue;
     workList.insert(dependency);
   }
 
   return orderedSet;
 }
 
 FailureOr<Value> ModuleImport::convertConstant(llvm::Constant *constant) {
-  Location loc = mlirModule.getLoc();
+  Location loc = UnknownLoc::get(context);
 
   // Convert constants that can be represented as attributes.
   if (Attribute attr = getConstantAsAttr(constant)) {
     Type type = convertType(constant->getType());
     if (auto symbolRef = dyn_cast<FlatSymbolRefAttr>(attr)) {
       return builder.create<AddressOfOp>(loc, type, symbolRef.getValue())
           .getResult();
     }
FailureOr<Value> ModuleImport::convertValue(llvm::Value *value) {
   auto it = valueMapping.find(value);
   if (it != valueMapping.end())
     return it->getSecond();
 
   // Convert constants such as immediate values that have no mapping yet.
   if (auto *constant = dyn_cast<llvm::Constant>(value))
     return convertConstantExpr(constant);
 
-  Location loc = mlirModule.getLoc();
+  Location loc = UnknownLoc::get(context);
   if (auto *inst = dyn_cast<llvm::Instruction>(value))
     loc = translateLoc(inst->getDebugLoc());
   return emitError(loc) << "unhandled value: " << diag(*value);
 }
 
 FailureOr<Value> ModuleImport::convertMetadataValue(llvm::Value *value) {
   // A value may be wrapped as metadata, for example, when passed to a debug
   // intrinsic. Unwrap these values before the conversion.
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());
 
+  Location loc = debugImporter->translateFuncLocation(func);
   LLVMFuncOp funcOp = builder.create<LLVMFuncOp>(
-      mlirModule.getLoc(), func->getName(), functionType,
+      loc, func->getName(), functionType,
       convertLinkageFromLLVM(func->getLinkage()), dsoLocal, cconv);
 
-  // Set the function debug information if available.
-  debugImporter->translate(func, funcOp);
-
   convertParameterAttributes(func, funcOp, builder);
 
   if (FlatSymbolRefAttr personality = getPersonalityAsAttr(func))
     funcOp.setPersonalityAttr(personality);
   else if (func->hasPersonalityFn())
     emitWarning(funcOp.getLoc(), "could not deduce personality, skipping it");
 
   if (func->hasGC())

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: #[[MODULELOC:.+]] = loc({{.*}}basic.ll{{.*}}:0:0)
+; CHECK-DBG: #[[UNKNOWN_LOC:.+]] = loc(unknown)
 
 @global = external global double, align 8
 
 ; CHECK: llvm.func @fe(i32) -> f32
 declare float @fe(i32)
 
 ; CHECK-LABEL: llvm.func internal @f1(%arg0: i64) -> i32 attributes {dso_local, passthrough = ["norecurse"]} {
-; CHECK-DBG: llvm.func internal @f1(%arg0: i64 loc({{.*}}basic.ll{{.*}}:0:0)) -> i32 attributes {dso_local, passthrough = ["norecurse"]} {
+; CHECK-DBG: llvm.func internal @f1(%arg0: i64 loc(unknown)) -> i32 attributes {dso_local, passthrough = ["norecurse"]} {
 ; 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
   %aa = inttoptr i64 %a to ptr
-; CHECK-DBG: llvm.mlir.addressof @global : !llvm.ptr loc(#[[MODULELOC]])
+; CHECK-DBG: llvm.mlir.addressof @global : !llvm.ptr loc(#[[UNKNOWN_LOC]])
 ; %[[addrof:[0-9]+]] = llvm.mlir.addressof @global : !llvm.ptr
 ; %[[addrof2:[0-9]+]] = llvm.mlir.addressof @global : !llvm.ptr
 ; %{{[0-9]+}} = llvm.inttoptr %arg0 : i64 to !llvm.ptr
 ; %{{[0-9]+}} = llvm.ptrtoint %[[addrof2]] : !llvm.ptr to i64
 ; %{{[0-9]+}} = llvm.getelementptr %[[addrof]][%3] : (!llvm.ptr, i32) -> !llvm.ptr
   %bb = ptrtoint ptr @global to i64
   %cc = getelementptr double, ptr @global, i32 3
 ; CHECK: %[[b:[0-9]+]] = llvm.trunc %arg0 : i64 to i32
-; CHECK-DBG: llvm.trunc %arg0 : i64 to i32 loc(#[[MODULELOC]])
+; CHECK-DBG: llvm.trunc %arg0 : i64 to i32 loc(#[[UNKNOWN_LOC]])
   %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(#[[MODULELOC]])
+; CHECK-DBG: } loc(#[[UNKNOWN_LOC]])
 
 ; CHECK-LABEL: @hasGCFunction
 ; CHECK-SAME: garbageCollector = "statepoint-example"
 define void @hasGCFunction() gc "statepoint-example" {
     ret void
 }
 
-;CHECK-LABEL: @useFreezeOp
+; CHECK-LABEL: @useFreezeOp
 define i32 @useFreezeOp(i32 %x) {
   ;CHECK: %{{[0-9]+}} = llvm.freeze %{{[0-9a-z]+}} : i32
   %1 = freeze i32 %x
   %2 = add i8 10, 10
   ;CHECK: %{{[0-9]+}} = llvm.freeze %{{[0-9]+}} : i8
   %3 = freeze i8 %2
   %poison = add nsw i1 0, undef
   ret i32 0

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

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

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

 ; RUN: not mlir-translate -import-llvm -emit-expensive-warnings -split-input-file %s 2>&1 | FileCheck %s
 
-; CHECK:      import-failure.ll
+; CHECK:      <unknown>
 ; CHECK-SAME: error: unhandled instruction: indirectbr ptr %dst, [label %bb1, label %bb2]
 define i32 @unhandled_instruction(ptr %dst) {
   indirectbr ptr %dst, [label %bb1, label %bb2]
 bb1:
   ret i32 0
 bb2:
   ret i32 1
 }
 
 ; // -----
 
-; CHECK:      import-failure.ll
+; CHECK:      <unknown>
 ; CHECK-SAME: error: unhandled value: ptr asm "bswap $0", "=r,r"
 define i32 @unhandled_value(i32 %arg1) {
   %1 = call i32 asm "bswap $0", "=r,r"(i32 %arg1)
   ret i32 %1
 }
 
 ; // -----
 
-; CHECK:      import-failure.ll
+; CHECK:      <unknown>
 ; CHECK-SAME: unhandled constant: ptr blockaddress(@unhandled_constant, %bb1) since blockaddress(...) is unsupported
-; CHECK:      import-failure.ll
+; CHECK:      <unknown>
 ; 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:      <unknown>
 ; CHECK-SAME: unhandled constant: ptr blockaddress(@unhandled_global, %bb1) since blockaddress(...) is unsupported
-; CHECK:      import-failure.ll
+; CHECK:      <unknown>
 ; 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:      <unknown>
 ; 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
 }
 
 ; // -----

 !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_dtors with non-null data fields cannot be represented in MLIR.
-; CHECK:      import-failure.ll
+; CHECK:      <unknown>
 ; 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
 }
 
 ; // -----
define void @access_group(ptr %arg1) {
   %1 = load i32, ptr %arg1, !llvm.access.group !0
   ret void
 }
 
 !0 = !{}
 
 ; // -----
 
-; CHECK:      import-failure.ll
+; CHECK:      <unknown>
 ; CHECK-SAME: warning: expected all loop properties to be either debug locations or metadata nodes
-; CHECK:      import-failure.ll
+; CHECK:      <unknown>
 ; 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, i32 42}
 
 ; // -----
 
-; CHECK:      import-failure.ll
+; CHECK:      <unknown>
 ; CHECK-SAME: warning: cannot import empty loop property
-; CHECK:      import-failure.ll
+; CHECK:      <unknown>
 ; CHECK-SAME: warning: unhandled metadata: !0 = distinct !{!0, !1}
 define void @invalid_loop_node(i64 %n, ptr %A) {
 entry:
   br label %end, !llvm.loop !0
 end:
   ret void
 }
 
 !0 = distinct !{!0, !1}
 !1 = distinct !{}
 
 ; // -----
 
-; CHECK:      import-failure.ll
+; CHECK:      <unknown>
 ; CHECK-SAME: warning: cannot import loop property without a name
-; CHECK:      import-failure.ll
+; CHECK:      <unknown>
 ; CHECK-SAME: warning: unhandled metadata: !0 = distinct !{!0, !1}
 define void @invalid_loop_node(i64 %n, ptr %A) {
 entry:
   br label %end, !llvm.loop !0
 end:
   ret void
 }
 
 !0 = distinct !{!0, !1}
 !1 = distinct !{i1 0}
 
 ; // -----
 
-; CHECK:      import-failure.ll
+; CHECK:      <unknown>
 ; CHECK-SAME: warning: cannot import loop properties with duplicated names llvm.loop.disable_nonforced
-; CHECK:      import-failure.ll
+; CHECK:      <unknown>
 ; CHECK-SAME: warning: unhandled metadata: !0 = distinct !{!0, !1, !1}
 define void @unsupported_loop_annotation(i64 %n, ptr %A) {
 entry:
   br label %end, !llvm.loop !0
 end:
   ret void
 }
 
 !0 = distinct !{!0, !1, !1}
 !1 = !{!"llvm.loop.disable_nonforced"}
 
 ; // -----
 
-; CHECK:      import-failure.ll
+; CHECK:      <unknown>
 ; CHECK-SAME: warning: expected metadata node llvm.loop.disable_nonforced to hold no value
-; CHECK:      import-failure.ll
+; CHECK:      <unknown>
 ; CHECK-SAME: warning: unhandled metadata: !0 = distinct !{!0, !1}
 define void @unsupported_loop_annotation(i64 %n, ptr %A) {
 entry:
   br label %end, !llvm.loop !0
 end:
   ret void
 }
 
 !0 = distinct !{!0, !1}
 !1 = !{!"llvm.loop.disable_nonforced", i1 0}
 
 ; // -----
 
-; CHECK:      import-failure.ll
+; CHECK:      <unknown>
 ; CHECK-SAME: warning: expected metadata nodes llvm.loop.unroll.enable and llvm.loop.unroll.disable to be mutually exclusive
-; CHECK:      import-failure.ll
+; CHECK:      <unknown>
 ; CHECK-SAME: warning: unhandled metadata: !0 = distinct !{!0, !1, !2}
 define void @unsupported_loop_annotation(i64 %n, ptr %A) {
 entry:
   br label %end, !llvm.loop !0
 end:
   ret void
 }
 
 !0 = distinct !{!0, !1, !2}
 !1 = !{!"llvm.loop.unroll.enable"}
 !2 = !{!"llvm.loop.unroll.disable"}
 
 ; // -----
 
-; CHECK:      import-failure.ll
+; CHECK:      <unknown>
 ; CHECK-SAME: warning: expected metadata node llvm.loop.vectorize.enable to hold a boolean value
-; CHECK:      import-failure.ll
+; CHECK:      <unknown>
 ; CHECK-SAME: warning: unhandled metadata: !0 = distinct !{!0, !1}
 define void @unsupported_loop_annotation(i64 %n, ptr %A) {
 entry:
   br label %end, !llvm.loop !0
 end:
   ret void
 }
 
 !0 = distinct !{!0, !1}
 !1 = !{!"llvm.loop.vectorize.enable"}
 
 ; // -----
 
-; CHECK:      import-failure.ll
+; CHECK:      <unknown>
 ; CHECK-SAME: warning: expected metadata node llvm.loop.vectorize.width to hold an i32 value
-; CHECK:      import-failure.ll
+; CHECK:      <unknown>
 ; CHECK-SAME: warning: unhandled metadata: !0 = distinct !{!0, !1}
 define void @unsupported_loop_annotation(i64 %n, ptr %A) {
 entry:
   br label %end, !llvm.loop !0
 end:
   ret void
 }
 
 !0 = distinct !{!0, !1}
 !1 = !{!"llvm.loop.vectorize.width", !0}
 
 ; // -----
 
-; CHECK:      import-failure.ll
+; CHECK:      <unknown>
 ; CHECK-SAME: warning: expected metadata node llvm.loop.vectorize.followup_all to hold an MDNode
-; CHECK:      import-failure.ll
+; CHECK:      <unknown>
 ; CHECK-SAME: warning: unhandled metadata: !0 = distinct !{!0, !1}
 define void @unsupported_loop_annotation(i64 %n, ptr %A) {
 entry:
   br label %end, !llvm.loop !0
 end:
   ret void
 }
 
 !0 = distinct !{!0, !1}
 !1 = !{!"llvm.loop.vectorize.followup_all", i32 42}
 
 ; // -----
 
-; CHECK:      import-failure.ll
+; CHECK:      <unknown>
 ; CHECK-SAME: warning: expected metadata node llvm.loop.parallel_accesses to hold one or multiple MDNodes
-; CHECK:      import-failure.ll
+; CHECK:      <unknown>
 ; CHECK-SAME: warning: unhandled metadata: !0 = distinct !{!0, !1}
 define void @unsupported_loop_annotation(i64 %n, ptr %A) {
 entry:
   br label %end, !llvm.loop !0
 end:
   ret void
 }
 
 !0 = distinct !{!0, !1}
 !1 = !{!"llvm.loop.parallel_accesses", i32 42}
 
 ; // -----
 
-; CHECK:      import-failure.ll
+; CHECK:      <unknown>
 ; CHECK-SAME: warning: unknown loop annotation llvm.loop.typo
-; CHECK:      import-failure.ll
+; CHECK:      <unknown>
 ; CHECK-SAME: warning: unhandled metadata: !0 = distinct !{!0, !1, !2}
 define void @unsupported_loop_annotation(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:      <unknown>
 ; CHECK-SAME: warning: could not lookup access group
 define void @unused_access_group(ptr %arg) {
 entry:
   %0 = load i32, ptr %arg, !llvm.access.group !0
   br label %end, !llvm.loop !1
 end:
   ret void
 }
 
 !0 = distinct !{}
 !1 = distinct !{!1, !2}
 !2 = !{!"llvm.loop.parallel_accesses", !0, !3}
 !3 = distinct !{}
 
 ; // -----
 
-; CHECK:      import-failure.ll
+; CHECK:      <unknown>
 ; 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:      <unknown>
 ; CHECK-SAME: warning: dropped instruction: call void @llvm.experimental.noalias.scope.decl(metadata !0)
 define void @unused_scope() {
   call void @llvm.experimental.noalias.scope.decl(metadata !0)
   ret void
 }
 
 declare void @llvm.experimental.noalias.scope.decl(metadata)