[mlir][llvmir] Add filename debug info when converting from LLVMIR.

[gysit]

Summary

The revision enriches the debug locations generated during LLVMIR to MLIR translation with file name information and adds a separate test to exercise the debug location translation.

[ftynse]

mlir/lib/Target/LLVMIR/ConvertFromLLVMIR.cpp

190–192

Nit: API-level entries should use /// for comments.

241–242

Is this still useful? Maybe use it to cache UnknownLoc::get()?

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

10

Nit: basic block names are not guaranteed either, use something like ^{{.*}} instead.

[gysit]

Tried to make the linter work.

[gysit]

Address comments.

[gysit]

Address test comment.

[gysit]

I was not sure if there was a specific intention behind the unknownLoc but I assume UnknownLoc did not exist at the time.

mlir/lib/Target/LLVMIR/ConvertFromLLVMIR.cpp

 #include "mlir/Interfaces/DataLayoutInterfaces.h"
 #include "mlir/Target/LLVMIR/TypeFromLLVM.h"
 #include "mlir/Tools/mlir-translate/Translation.h"
 
 #include "llvm/ADT/StringSet.h"
 #include "llvm/ADT/TypeSwitch.h"
 #include "llvm/IR/Attributes.h"
 #include "llvm/IR/Constants.h"
+#include "llvm/IR/DebugInfoMetadata.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/InlineAsm.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/Intrinsics.h"
 #include "llvm/IR/Type.h"
 #include "llvm/IRReader/IRReader.h"
 #include "llvm/Support/Error.h"
mlir::translateDataLayout(const llvm::DataLayout &dataLayout,
   return DataLayoutSpecAttr::get(context, entries);
 }
 
 // Handles importing globals and functions from an LLVM module.
 namespace {
 class Importer {
 public:
   Importer(MLIRContext *context, ModuleOp module)
-      : b(context), context(context), module(module),
-        unknownLoc(FileLineColLoc::get(context, "imported-bitcode", 0, 0)),
-        typeTranslator(*context) {
+      : b(context), context(context), module(module), typeTranslator(*context) {
     b.setInsertionPointToStart(module.getBody());
   }
 
   /// Imports `f` into the current module.
   LogicalResult processFunction(llvm::Function *f);
 
   /// Converts function attributes of LLVM Function \p f
   /// into LLVM dialect attributes of LLVMFuncOp \p funcOp.
private:
   /// Imports `inst` and populates instMap[inst] with the imported Value.
   LogicalResult processInstruction(llvm::Instruction *inst);
   /// Creates an LLVM-compatible MLIR type for `type`.
   Type processType(llvm::Type *type);
   /// `value` is an SSA-use. Return the remapped version of `value` or a
   /// placeholder that will be remapped later if this is an instruction that
   /// has not yet been visited.
   Value processValue(llvm::Value *value);
-  /// Create the most accurate Location possible using a llvm::DebugLoc and
-  /// possibly an llvm::Instruction to narrow the Location if debug information
-  /// is unavailable.
-  Location processDebugLoc(const llvm::DebugLoc &loc,
-                           llvm::Instruction *inst = nullptr);
+  /// Translate the debug location to a FileLineColLoc, if `loc` is non-null.
+  /// Otherwise, return UnknownLoc.
+  Location processDebugLoc(llvm::DILocation *loc);
   /// `br` branches to `target`. Append the block arguments to attach to the
   /// generated branch op to `blockArguments`. These should be in the same order
   /// as the PHIs in `target`.
   LogicalResult processBranchArgs(llvm::Instruction *br,
                                   llvm::BasicBlock *target,
                                   SmallVectorImpl<Value> &blockArguments);
   /// Returns the builtin type equivalent to be used in attributes for the given
   /// LLVM IR dialect type.
private:
   /// Remapped blocks, for the current function.
   DenseMap<llvm::BasicBlock *, Block *> blocks;
   /// Remapped values. These are function-local.
   DenseMap<llvm::Value *, Value> instMap;
   /// Instructions that had not been defined when first encountered as a use.
   /// Maps to the dummy Operation that was created in processValue().
   DenseMap<llvm::Value *, Operation *> unknownInstMap;
   /// Uniquing map of GlobalVariables.
   DenseMap<llvm::GlobalVariable *, GlobalOp> globals;
-  /// Cached FileLineColLoc::get("imported-bitcode", 0, 0).
-  Location unknownLoc;
   /// The stateful type translator (contains named structs).
   LLVM::TypeFromLLVMIRTranslator typeTranslator;
 };
 } // namespace
 
-Location Importer::processDebugLoc(const llvm::DebugLoc &loc,
-                                   llvm::Instruction *inst) {
+Location Importer::processDebugLoc(llvm::DILocation *loc) {
   if (!loc)
-    return unknownLoc;
+    return UnknownLoc::get(context);
 
-  // FIXME: Obtain the filename from DILocationInfo.
-  return FileLineColLoc::get(context, "imported-bitcode", loc.getLine(),
-                             loc.getCol());
+  return FileLineColLoc::get(context, loc->getFilename(), loc->getLine(),
+                             loc->getColumn());
 }
 
 Type Importer::processType(llvm::Type *type) {
   if (Type result = typeTranslator.translateType(type))
     return result;
 
   // FIXME: Diagnostic should be able to natively handle types that have
   // operator<<(raw_ostream&) defined.
   std::string s;
   llvm::raw_string_ostream os(s);
   os << *type;
-  emitError(unknownLoc) << "unhandled type: " << os.str();
+  emitError(UnknownLoc::get(context)) << "unhandled type: " << os.str();
   return nullptr;
 }
 
 // We only need integers, floats, doubles, and vectors and tensors thereof for
 // attributes. Scalar and vector types are converted to the standard
 // equivalents. Array types are converted to ranked tensors; nested array types
 // are converted to multi-dimensional tensors or vectors, depending on the
 // innermost type being a scalar or a vector.
 Type Importer::getStdTypeForAttr(Type type) {
   if (!type)
     return nullptr;
 
   if (type.isa<IntegerType, FloatType>())
     return type;
 
   // LLVM vectors can only contain scalars.
   if (LLVM::isCompatibleVectorType(type)) {
     auto numElements = LLVM::getVectorNumElements(type);
     if (numElements.isScalable()) {
-      emitError(unknownLoc) << "scalable vectors not supported";
+      emitError(UnknownLoc::get(context)) << "scalable vectors not supported";
       return nullptr;
     }
     Type elementType = getStdTypeForAttr(LLVM::getVectorElementType(type));
     if (!elementType)
       return nullptr;
     return VectorType::get(numElements.getKnownMinValue(), elementType);
   }
 
   // LLVM arrays can contain other arrays or vectors.
   if (auto arrayType = type.dyn_cast<LLVMArrayType>()) {
     // Recover the nested array shape.
     SmallVector<int64_t, 4> shape;
     shape.push_back(arrayType.getNumElements());
     while (arrayType.getElementType().isa<LLVMArrayType>()) {
       arrayType = arrayType.getElementType().cast<LLVMArrayType>();
       shape.push_back(arrayType.getNumElements());
     }
 
     // If the innermost type is a vector, use the multi-dimensional vector as
     // attribute type.
     if (LLVM::isCompatibleVectorType(arrayType.getElementType())) {
       auto numElements = LLVM::getVectorNumElements(arrayType.getElementType());
       if (numElements.isScalable()) {
-        emitError(unknownLoc) << "scalable vectors not supported";
+        emitError(UnknownLoc::get(context)) << "scalable vectors not supported";
         return nullptr;
       }
       shape.push_back(numElements.getKnownMinValue());
 
       Type elementType = getStdTypeForAttr(
           LLVM::getVectorElementType(arrayType.getElementType()));
       if (!elementType)
         return nullptr;
Value Importer::processConstant(llvm::Constant *c) {
   OpBuilder bEntry(currentEntryBlock, currentEntryBlock->begin());
   if (Attribute attr = getConstantAsAttr(c)) {
     // These constants can be represented as attributes.
     OpBuilder b(currentEntryBlock, currentEntryBlock->begin());
     Type type = processType(c->getType());
     if (!type)
       return nullptr;
     if (auto symbolRef = attr.dyn_cast<FlatSymbolRefAttr>())
-      return bEntry.create<AddressOfOp>(unknownLoc, type, symbolRef.getValue());
-    return bEntry.create<ConstantOp>(unknownLoc, type, attr);
+      return bEntry.create<AddressOfOp>(UnknownLoc::get(context), type,
+                                        symbolRef.getValue());
+    return bEntry.create<ConstantOp>(UnknownLoc::get(context), type, attr);
   }
   if (auto *cn = dyn_cast<llvm::ConstantPointerNull>(c)) {
     Type type = processType(cn->getType());
     if (!type)
       return nullptr;
-    return bEntry.create<NullOp>(unknownLoc, type);
+    return bEntry.create<NullOp>(UnknownLoc::get(context), type);
   }
   if (auto *gv = dyn_cast<llvm::GlobalVariable>(c))
     return bEntry.create<AddressOfOp>(UnknownLoc::get(context),
                                       processGlobal(gv));
 
   if (auto *ce = dyn_cast<llvm::ConstantExpr>(c)) {
     llvm::Instruction *i = ce->getAsInstruction();
     OpBuilder::InsertionGuard guard(b);
if (isa<llvm::ConstantAggregate>(c) || isa<llvm::ConstantAggregateZero>(c)) {
 
     // Generate a llvm.undef as the root value first.
     Type rootType = processType(c->getType());
     if (!rootType)
       return nullptr;
     bool useInsertValue = rootType.isa<LLVMArrayType, LLVMStructType>();
     assert((useInsertValue || LLVM::isCompatibleVectorType(rootType)) &&
            "unrecognized aggregate type");
-    Value root = bEntry.create<UndefOp>(unknownLoc, rootType);
+    Value root = bEntry.create<UndefOp>(UnknownLoc::get(context), rootType);
     for (unsigned i = 0; i < numElements; ++i) {
       llvm::Constant *element = getElement(i);
       Value elementValue = processConstant(element);
       if (!elementValue)
         return nullptr;
       if (useInsertValue) {
         root = bEntry.create<InsertValueOp>(UnknownLoc::get(context), root,
                                             elementValue, i);
       } else {
         Attribute indexAttr = bEntry.getI32IntegerAttr(static_cast<int32_t>(i));
         Value indexValue = bEntry.create<ConstantOp>(
-            unknownLoc, bEntry.getI32Type(), indexAttr);
+            UnknownLoc::get(context), bEntry.getI32Type(), indexAttr);
         if (!indexValue)
           return nullptr;
         root = bEntry.create<InsertElementOp>(
             UnknownLoc::get(context), rootType, root, elementValue, indexValue);
       }
     }
     return root;
   }
 
-  emitError(unknownLoc) << "unhandled constant: " << diag(*c);
+  emitError(UnknownLoc::get(context)) << "unhandled constant: " << diag(*c);
   return nullptr;
 }
 
 Value Importer::processValue(llvm::Value *value) {
   auto it = instMap.find(value);
   if (it != instMap.end())
     return it->second;
 
   // We don't expect to see instructions in dominator order. If we haven't seen
   // this instruction yet, create an unknown op and remap it later.
   if (isa<llvm::Instruction>(value)) {
     Type type = processType(value->getType());
     if (!type)
       return nullptr;
     unknownInstMap[value] =
         b.create(UnknownLoc::get(context), b.getStringAttr("llvm.unknown"),
                  /*operands=*/{}, type);
     return unknownInstMap[value]->getResult(0);
   }
 
   if (auto *c = dyn_cast<llvm::Constant>(value))
     return processConstant(c);
 
-  emitError(unknownLoc) << "unhandled value: " << diag(*value);
+  emitError(UnknownLoc::get(context)) << "unhandled value: " << diag(*value);
   return nullptr;
 }
 
 /// Return the MLIR OperationName for the given LLVM opcode.
 static StringRef lookupOperationNameFromOpcode(unsigned opcode) {
 // Maps from LLVM opcode to MLIR OperationName. This is deliberately ordered
 // as in llvm/IR/Instructions.def to aid comprehension and spot missing
 // instructions.
for (auto inst = target->begin(); isa<llvm::PHINode>(inst); ++inst) {
     blockArguments.push_back(value);
   }
   return success();
 }
 
 LogicalResult Importer::processInstruction(llvm::Instruction *inst) {
   // FIXME: Support uses of SubtargetData. Currently inbounds GEPs, fast-math
   // flags and call / operand attributes are not supported.
-  Location loc = processDebugLoc(inst->getDebugLoc(), inst);
+  Location loc = processDebugLoc(inst->getDebugLoc());
   assert(!instMap.count(inst) &&
          "processInstruction must be called only once per instruction!");
   switch (inst->getOpcode()) {
   default:
     return emitError(loc) << "unknown instruction: " << diag(*inst);
   case llvm::Instruction::Add:
   case llvm::Instruction::FAdd:
   case llvm::Instruction::Sub:
b.create<SwitchOp>(loc, condition, blocks[defaultBB], defaultBlockArgs,
                        caseValues, caseBlocks, caseOperandRefs);
     return success();
   }
   case llvm::Instruction::PHI: {
     Type type = processType(inst->getType());
     if (!type)
       return failure();
     instMap[inst] = b.getInsertionBlock()->addArgument(
-        type, processDebugLoc(inst->getDebugLoc(), inst));
+        type, processDebugLoc(inst->getDebugLoc()));
     return success();
   }
   case llvm::Instruction::Call: {
     llvm::CallInst *ci = cast<llvm::CallInst>(inst);
     SmallVector<Value, 4> ops;
     ops.reserve(inst->getNumOperands());
     for (auto &op : ci->args()) {
       Value arg = processValue(op.get());

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: #[[ZEROLOC:.+]] = loc("imported-bitcode":0:0)
 
 %struct.t = type {}
 %struct.s = type { %struct.t, i64 }
 
 ; CHECK: llvm.mlir.global external @g1() {addr_space = 0 : i32, alignment = 8 : i64} : !llvm.struct<"struct.s", (struct<"struct.t", ()>, i64)>
 @g1 = external global %struct.s, align 8
 ; CHECK: llvm.mlir.global external @g2() {addr_space = 0 : i32, alignment = 8 : i64} : f64
 @g2 = external global double, align 8

 ; %[[addrof:[0-9]+]] = llvm.mlir.addressof @g2 : !llvm.ptr<f64>
 ; %[[addrof2:[0-9]+]] = llvm.mlir.addressof @g2 : !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* @g2 to i64
   %cc = getelementptr double, double* @g2, i32 2
 ; CHECK: %[[b:[0-9]+]] = llvm.trunc %arg0 : i64 to i32
-; CHECK-DBG: llvm.trunc %arg0 : i64 to i32 loc(#[[ZEROLOC]])
+; CHECK-DBG: llvm.trunc %arg0 : i64 to i32 loc(#[[UNKNOWNLOC]])
   %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

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

+; RUN: mlir-translate -import-llvm -mlir-print-debuginfo -split-input-file %s | FileCheck %s
+
+; CHECK: #[[$UNKNOWNLOC:.+]] = loc(unknown)
+; CHECK-LABEL: @unknown(
+define i32 @unknown(i32 %0) {
+entry:
+  br label %next
+end:
+  ; CHECK: ^{{.*}}(%{{.+}}: i32 loc(unknown)):
+  %1 = phi i32 [ %2, %next ]
+  ret i32 %1
+next:
+  ; CHECK: = llvm.mul %{{.+}}, %{{.+}} : i32 loc(#[[$UNKNOWNLOC:.+]])
+  %2 = mul i32 %0, %0
+  br label %end
+}
+
+; // -----
+
+; CHECK-LABEL: @known_loc(
+define i32 @known_loc(i32 %0) {
+entry:
+  br label %next
+end:
+  ; CHECK: ^{{.*}}(%{{.+}}: i32 loc("known_loc.cpp":5:2)):
+  %1 = phi i32 [ %2, %next ], !dbg !4
+  ret i32 %1
+next:
+  ; CHECK: = llvm.mul %{{.+}}, %{{.+}} : i32 loc(#[[LOC:.+]])
+  %2 = mul i32 %0, %0, !dbg !5
+  br label %end
+}
+; CHECK: #[[LOC]] = loc("known_loc.cpp":8:3)
+
+!llvm.dbg.cu = !{!0}
+!llvm.module.flags = !{!1}
+!0 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus_14, file: !2)
+!1 = !{i32 2, !"Debug Info Version", i32 3}
+!2 = !DIFile(filename: "known_loc.cpp", directory: "/")
+!3 = distinct !DISubprogram(name: "known_loc", scope: !0, file: !2, line: 1, scopeLine: 1, unit: !0)
+!4 = !DILocation(line: 5, column: 2, scope: !3)
+!5 = !DILocation(line: 8, column: 3, scope: !3)