[mlir] Avoid expensive LLVM IR import warnings

[gysit]

Summary

The revision adds a flag to the LLVM IR import
that avoids emitting expensive warnings about
unsupported debug intrinsics and unhandled
metadata.

[Dinistro]

Thanks for adding this. LGTM!

mlir/include/mlir/Target/LLVMIR/Import.h

 class DataLayoutSpecInterface;
 class MLIRContext;
 class ModuleOp;
 
 /// Translates the LLVM module into an MLIR module living in the given context.
 /// The translation supports operations from any dialect that has a registered
 /// implementation of the LLVMImportDialectInterface. It returns nullptr if the
 /// translation fails and reports errors using the error handler registered with
-/// the MLIR context.
+/// the MLIR context. The `emitExpensiveWarnings` option controls if expensive
+/// but uncritical diagnostics should be emitted.
 OwningOpRef<ModuleOp>
 translateLLVMIRToModule(std::unique_ptr<llvm::Module> llvmModule,
-                        MLIRContext *context);
+                        MLIRContext *context,
+                        bool emitExpensiveWarnings = true);
 
 /// Translate the given LLVM data layout into an MLIR equivalent using the DLTI
 /// dialect.
 DataLayoutSpecInterface translateDataLayout(const llvm::DataLayout &dataLayout,
                                             MLIRContext *context);
 
 } // namespace mlir
 
 #endif // MLIR_TARGET_LLVMIR_IMPORT_H

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

 /// Module import implementation class that provides methods to import globals
 /// and functions from an LLVM module into an MLIR module. It holds mappings
 /// between the original and translated globals, basic blocks, and values used
 /// during the translation. Additionally, it keeps track of the current constant
 /// insertion point since LLVM immediate values translate to MLIR operations
 /// that are introduced at the beginning of the region.
 class ModuleImport {
 public:
-  ModuleImport(ModuleOp mlirModule, std::unique_ptr<llvm::Module> llvmModule);
+  ModuleImport(ModuleOp mlirModule, std::unique_ptr<llvm::Module> llvmModule,
+               bool emitExpensiveWarnings);
 
   /// Calls the LLVMImportInterface initialization that queries the registered
   /// dialect interfaces for the supported LLVM IR intrinsics and metadata kinds
   /// and builds the dispatch tables. Returns failure if multiple dialect
   /// interfaces translate the same LLVM IR intrinsic.
   LogicalResult initializeImportInterface() { return iface.initializeImport(); }
 
   /// Converts all functions of the LLVM module to MLIR functions.
private:
   /// dialect TBAA operations corresponding to these nodes.
   DenseMap<const llvm::MDNode *, SymbolRefAttr> tbaaMapping;
   /// The stateful type translator (contains named structs).
   LLVM::TypeFromLLVMIRTranslator typeTranslator;
   /// Stateful debug information importer.
   std::unique_ptr<detail::DebugImporter> debugImporter;
   /// Loop annotation importer.
   std::unique_ptr<detail::LoopAnnotationImporter> loopAnnotationImporter;
+
+  /// An option to control if expensive but uncritical diagnostics should be
+  /// emitted. Avoids generating warnings for unhandled debug intrinsics and
+  /// metadata that otherwise dominate the translation time for large inputs.
+  bool emitExpensiveWarnings;
 };
 
 } // namespace LLVM
 } // namespace mlir
 
 #endif // MLIR_TARGET_LLVMIR_MODULEIMPORT_H

mlir/lib/Target/LLVMIR/ConvertFromLLVMIR.cpp

 #include "llvm/IR/Verifier.h"
 #include "llvm/IRReader/IRReader.h"
 #include "llvm/Support/SourceMgr.h"
 
 using namespace mlir;
 
 namespace mlir {
 void registerFromLLVMIRTranslation() {
+  static llvm::cl::opt<bool> emitExpensiveWarnings(
+      "emit-expensive-warnings",
+      llvm::cl::desc("Emit expensive warnings during LLVM IR import "
+                     "(discouraged: testing only!)"),
+      llvm::cl::init(false));
+
   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);
+
+        return translateLLVMIRToModule(std::move(llvmModule), context,
+                                       emitExpensiveWarnings);
       },
       [](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/ModuleImport.cpp

for (llvm::BasicBlock &bb : *func) {
     }
   }
   assert(blocks.size() == func->size() && "some blocks are not sorted");
 
   return blocks;
 }
 
 ModuleImport::ModuleImport(ModuleOp mlirModule,
-                           std::unique_ptr<llvm::Module> llvmModule)
+                           std::unique_ptr<llvm::Module> llvmModule,
+                           bool emitExpensiveWarnings)
     : builder(mlirModule->getContext()), context(mlirModule->getContext()),
       mlirModule(mlirModule), llvmModule(std::move(llvmModule)),
       iface(mlirModule->getContext()),
       typeTranslator(*mlirModule->getContext()),
       debugImporter(std::make_unique<DebugImporter>(mlirModule)),
       loopAnnotationImporter(
-          std::make_unique<LoopAnnotationImporter>(*this, builder)) {
+          std::make_unique<LoopAnnotationImporter>(*this, builder)),
+      emitExpensiveWarnings(emitExpensiveWarnings) {
   builder.setInsertionPointToStart(mlirModule.getBody());
 }
 
 MetadataOp ModuleImport::getGlobalMetadataOp() {
   if (globalMetadataOp)
     return globalMetadataOp;
 
   OpBuilder::InsertionGuard guard(builder);

 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))) {
+      if (emitExpensiveWarnings) {
         Location loc = debugImporter->translateLoc(inst->getDebugLoc());
         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);
 
   // Even if the imported operation implements the fastmath interface, the
   // original instruction may not have fastmath flags set. Exit if an
   // instruction, such as a non floating-point function call, does not have
if (failed(processInstruction(&inst)))
       return failure();
 
     // 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) {
+      if (emitExpensiveWarnings) {
         Location loc = debugImporter->translateLoc(inst.getDebugLoc());
         emitWarning(loc) << "dropped instruction: " << diag(inst);
       }
     }
+  }
   return success();
 }
 
 FailureOr<SmallVector<SymbolRefAttr>>
 ModuleImport::lookupAccessGroupAttrs(const llvm::MDNode *node) const {
   return loopAnnotationImporter->lookupAccessGroupAttrs(node);
 }
 
 LoopAnnotationAttr
 ModuleImport::translateLoopAnnotationAttr(const llvm::MDNode *node,
                                           Location loc) const {
   return loopAnnotationImporter->translateLoopAnnotation(node, loc);
 }
 
 OwningOpRef<ModuleOp>
 mlir::translateLLVMIRToModule(std::unique_ptr<llvm::Module> llvmModule,
-                              MLIRContext *context) {
+                              MLIRContext *context,
+                              bool emitExpensiveWarnings) {
   // Preload all registered dialects to allow the import to iterate the
   // registered LLVMImportDialectInterface implementations and query the
   // supported LLVM IR constructs before starting the translation. Assumes the
   // LLVM and DLTI dialects that convert the core LLVM IR constructs have been
   // registered before.
   assert(llvm::is_contained(context->getAvailableDialects(),
                             LLVMDialect::getDialectNamespace()));
   assert(llvm::is_contained(context->getAvailableDialects(),
                             DLTIDialect::getDialectNamespace()));
   context->loadAllAvailableDialects();
-
   OwningOpRef<ModuleOp> module(ModuleOp::create(FileLineColLoc::get(
       StringAttr::get(context, llvmModule->getSourceFileName()), /*line=*/0,
       /*column=*/0)));
 
-  ModuleImport moduleImport(module.get(), std::move(llvmModule));
+  ModuleImport moduleImport(module.get(), std::move(llvmModule),
+                            emitExpensiveWarnings);
   if (failed(moduleImport.initializeImportInterface()))
     return {};
   if (failed(moduleImport.convertDataLayout()))
     return {};
   if (failed(moduleImport.convertMetadata()))
     return {};
   if (failed(moduleImport.convertComdats()))
     return {};
   if (failed(moduleImport.convertGlobals()))
     return {};
   if (failed(moduleImport.convertFunctions()))
     return {};
 
   return module;
 }

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

-; RUN: not mlir-translate -import-llvm -split-input-file %s 2>&1 | FileCheck %s
+; RUN: not mlir-translate -import-llvm -emit-expensive-warnings -split-input-file %s 2>&1 | FileCheck %s
 
 ; CHECK:      import-failure.ll
 ; 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:

mlir/test/mlir-translate/import-diagnostics.ll

+; RUN: not mlir-translate %s -import-llvm -split-input-file -error-diagnostics-only 2>&1 | FileCheck %s --check-prefix=ERROR
+; RUN: not mlir-translate %s -import-llvm -split-input-file 2>&1 | FileCheck %s --check-prefix=DEFAULT
+; RUN: not mlir-translate %s -import-llvm -split-input-file -emit-expensive-warnings 2>&1 | FileCheck %s --check-prefix=EXPENSIVE
+
+; ERROR-NOT: warning:
+; DEFAULT:   warning:
+; EXPENSIVE: warning:
+define void @warning(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"}
+
+; // -----
+
+; ERROR:     error:
+; DEFAULT:   error:
+; EXPENSIVE: error:
+define i32 @error(ptr %dst) {
+  indirectbr ptr %dst, [label %bb1, label %bb2]
+bb1:
+  ret i32 0
+bb2:
+  ret i32 1
+}
+
+; // -----
+
+declare void @llvm.dbg.value(metadata, metadata, metadata)
+
+; ERROR-NOT:   warning:
+; DEFAULT-NOT: warning:
+; EXPENSIVE:   warning:
+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: "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)

mlir/test/mlir-translate/import-error-only.ll

-; RUN: not mlir-translate %s -import-llvm -split-input-file -error-diagnostics-only 2>&1 | FileCheck %s --check-prefix=ERROR
-; RUN: not mlir-translate %s -import-llvm -split-input-file 2>&1 | FileCheck %s --check-prefix=ALL
-
-; ERROR-NOT: warning:
-; ALL:       warning:
-define void @warning(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"}
-
-; // -----
-
-; ERROR: error:
-; ALL:   error:
-define i32 @error(ptr %dst) {
-  indirectbr ptr %dst, [label %bb1, label %bb2]
-bb1:
-  ret i32 0
-bb2:
-  ret i32 1
-}