MIR Serialization: Report diagnostics with correct locations for LLVM IR Errors.

[arphaman]

Summary

This patch translates the line and column numbers from LLVM IR block string to the
line and column numbers in the MIR file so that llc reports LLVM IR errors with
correct locations.

llvm/trunk/lib/CodeGen/MIRParser/MIRParser.cpp

 //===----------------------------------------------------------------------===//
 
 #include "llvm/CodeGen/MIRParser/MIRParser.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/AsmParser/Parser.h"
 #include "llvm/CodeGen/MIRYamlMapping.h"
 #include "llvm/IR/Module.h"
+#include "llvm/Support/LineIterator.h"
 #include "llvm/Support/SMLoc.h"
 #include "llvm/Support/SourceMgr.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/YAMLTraits.h"
 #include <memory>
 
 using namespace llvm;
 
public:
   ///
   /// Return null if an error occurred.
   std::unique_ptr<Module> parse(SMDiagnostic &Error);
 
   /// Parse the machine function in the current YAML document.
   ///
   /// Return true if an error occurred.
   bool parseMachineFunction(yaml::Input &In);
+
+private:
+  /// Return a MIR diagnostic converted from an LLVM assembly diagnostic.
+  SMDiagnostic diagFromLLVMAssemblyDiag(const SMDiagnostic &Error,
+                                        SMRange SourceRange);
 };
 
 } // end anonymous namespace
 
 MIRParserImpl::MIRParserImpl(std::unique_ptr<MemoryBuffer> Contents,
                              StringRef Filename, LLVMContext &Context)
     : SM(), Filename(Filename), Context(Context) {
   SM.AddNewSourceBuffer(std::move(Contents), SMLoc());
std::unique_ptr<Module> MIRParserImpl::parse(SMDiagnostic &Error) {
 
   std::unique_ptr<Module> M;
   // Parse the block scalar manually so that we can return unique pointer
   // without having to go trough YAML traits.
   if (const auto *BSN =
           dyn_cast_or_null<yaml::BlockScalarNode>(In.getCurrentNode())) {
     M = parseAssembly(MemoryBufferRef(BSN->getValue(), Filename), Error,
                       Context);
-    if (!M)
+    if (!M) {
+      Error = diagFromLLVMAssemblyDiag(Error, BSN->getSourceRange());
       return M;
+    }
     In.nextDocument();
     if (!In.setCurrentDocument())
       return M;
   } else {
     // Create an new, empty module.
     M = llvm::make_unique<Module>(Filename, Context);
   }
 
bool MIRParserImpl::parseMachineFunction(yaml::Input &In) {
   yaml::yamlize(In, MF, false);
   if (In.error())
     return true;
   // TODO: Initialize the real machine function with the state in the yaml
   // machine function later on.
   return false;
 }
 
+SMDiagnostic MIRParserImpl::diagFromLLVMAssemblyDiag(const SMDiagnostic &Error,
+                                                     SMRange SourceRange) {
+  assert(SourceRange.isValid());
+
+  // Translate the location of the error from the location in the llvm IR string
+  // to the corresponding location in the MIR file.
+  auto LineAndColumn = SM.getLineAndColumn(SourceRange.Start);
+  unsigned Line = LineAndColumn.first + Error.getLineNo() - 1;
+  unsigned Column = Error.getColumnNo();
+  StringRef LineStr = Error.getLineContents();
+  SMLoc Loc = Error.getLoc();
+
+  // Get the full line and adjust the column number by taking the indentation of
+  // LLVM IR into account.
+  for (line_iterator L(*SM.getMemoryBuffer(SM.getMainFileID()), false), E;
+       L != E; ++L) {
+    if (L.line_number() == Line) {
+      LineStr = *L;
+      Loc = SMLoc::getFromPointer(LineStr.data());
+      auto Indent = LineStr.find(Error.getLineContents());
+      if (Indent != StringRef::npos)
+        Column += Indent;
+      break;
+    }
+  }
+
+  return SMDiagnostic(SM, Loc, Filename, Line, Column, Error.getKind(),
+                      Error.getMessage(), LineStr, Error.getRanges(),
+                      Error.getFixIts());
+}
+
 std::unique_ptr<Module> llvm::parseMIRFile(StringRef Filename,
                                            SMDiagnostic &Error,
                                            LLVMContext &Context) {
   auto FileOrErr = MemoryBuffer::getFile(Filename);
   if (std::error_code EC = FileOrErr.getError()) {
     Error = SMDiagnostic(Filename, SourceMgr::DK_Error,
                          "Could not open input file: " + EC.message());
     return std::unique_ptr<Module>();

llvm/trunk/test/CodeGen/MIR/llvm-ir-error-reported.mir

+# RUN: not llc -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | FileCheck %s
+# This test ensures an error is reported if the embedded LLVM IR contains an
+# error.
+
+--- |
+  
+  ; CHECK: [[@LINE+3]]:15: error: use of undefined value '%a'
+  define i32 @foo(i32 %x, i32 %y) {
+    %z = alloca i32, align 4
+    store i32 %a, i32* %z, align 4
+    br label %Test
+  Test:
+    %m = load i32, i32* %z, align 4
+    %cond = icmp eq i32 %y, %m
+    br i1 %cond, label %IfEqual, label %IfUnequal
+  IfEqual:
+    ret i32 1
+  IfUnequal:
+    ret i32 0
+  }
+  
+...