MIR Parser: use the correct, file based locations for machine instruction diagnostics.

[arphaman]

Summary

This patch is based on the patch that serializes immediate machine operands (http://reviews.llvm.org/D10573).

This patch translates the source locations for machine instruction parsing diagnostics from the locations in the
machine instruction source string to the locations in the MIR file.

llvm/trunk/include/llvm/CodeGen/MIRYamlMapping.h

 
 #ifndef LLVM_LIB_CODEGEN_MIRYAMLMAPPING_H
 #define LLVM_LIB_CODEGEN_MIRYAMLMAPPING_H
 
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/YAMLTraits.h"
 #include <vector>
 
-LLVM_YAML_IS_SEQUENCE_VECTOR(std::string)
+namespace llvm {
+namespace yaml {
+
+/// A wrapper around std::string which contains a source range that's being
+/// set during parsing.
+struct StringValue {
+  std::string Value;
+  SMRange SourceRange;
+
+  StringValue() {}
+  StringValue(std::string Value) : Value(std::move(Value)) {}
+
+  bool operator==(const StringValue &Other) const {
+    return Value == Other.Value;
+  }
+};
+
+template <> struct ScalarTraits<StringValue> {
+  static void output(const StringValue &S, void *, llvm::raw_ostream &OS) {
+    OS << S.Value;
+  }
+
+  static StringRef input(StringRef Scalar, void *Ctx, StringValue &S) {
+    S.Value = Scalar.str();
+    if (const auto *Node =
+            reinterpret_cast<yaml::Input *>(Ctx)->getCurrentNode())
+      S.SourceRange = Node->getSourceRange();
+    return "";
+  }
+
+  static bool mustQuote(StringRef Scalar) { return needsQuotes(Scalar); }
+};
+
+} // end namespace yaml
+} // end namespace llvm
+
+LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::yaml::StringValue)
 
 namespace llvm {
 namespace yaml {
 
 struct MachineBasicBlock {
   std::string Name;
   unsigned Alignment = 0;
   bool IsLandingPad = false;
   bool AddressTaken = false;
   // TODO: Serialize the successors and liveins.
 
-  std::vector<std::string> Instructions;
+  std::vector<StringValue> Instructions;
 };
 
 template <> struct MappingTraits<MachineBasicBlock> {
   static void mapping(IO &YamlIO, MachineBasicBlock &MBB) {
     YamlIO.mapOptional("name", MBB.Name,
                        std::string()); // Don't print out an empty name.
     YamlIO.mapOptional("alignment", MBB.Alignment);
     YamlIO.mapOptional("isLandingPad", MBB.IsLandingPad);

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

public:
 
   /// Initialize the machine basic block using it's YAML representation.
   ///
   /// Return true if an error occurred.
   bool initializeMachineBasicBlock(MachineFunction &MF, MachineBasicBlock &MBB,
                                    const yaml::MachineBasicBlock &YamlMBB);
 
 private:
+  /// Return a MIR diagnostic converted from an MI string diagnostic.
+  SMDiagnostic diagFromMIStringDiag(const SMDiagnostic &Error,
+                                    SMRange SourceRange);
+
   /// Return a MIR diagnostic converted from an LLVM assembly diagnostic.
   SMDiagnostic diagFromLLVMAssemblyDiag(const SMDiagnostic &Error,
                                         SMRange SourceRange);
 
   /// Create an empty function with the given name.
   void createDummyFunction(StringRef Name, Module &M);
 };
 

 
 static void handleYAMLDiag(const SMDiagnostic &Diag, void *Context) {
   reinterpret_cast<MIRParserImpl *>(Context)->reportDiagnostic(Diag);
 }
 
 std::unique_ptr<Module> MIRParserImpl::parse() {
   yaml::Input In(SM.getMemoryBuffer(SM.getMainFileID())->getBuffer(),
                  /*Ctxt=*/nullptr, handleYAMLDiag, this);
+  In.setContext(&In);
 
   if (!In.setCurrentDocument()) {
     if (In.error())
       return nullptr;
     // Create an empty module when the MIR file is empty.
     return llvm::make_unique<Module>(Filename, Context);
   }
 
bool MIRParserImpl::initializeMachineBasicBlock(
     const yaml::MachineBasicBlock &YamlMBB) {
   MBB.setAlignment(YamlMBB.Alignment);
   if (YamlMBB.AddressTaken)
     MBB.setHasAddressTaken();
   MBB.setIsLandingPad(YamlMBB.IsLandingPad);
   // Parse the instructions.
   for (const auto &MISource : YamlMBB.Instructions) {
     SMDiagnostic Error;
-    if (auto *MI = parseMachineInstr(SM, MF, MISource, Error)) {
+    if (auto *MI = parseMachineInstr(SM, MF, MISource.Value, Error)) {
       MBB.insert(MBB.end(), MI);
       continue;
     }
-    reportDiagnostic(Error);
+    reportDiagnostic(diagFromMIStringDiag(Error, MISource.SourceRange));
     return true;
   }
   return false;
 }
 
+SMDiagnostic MIRParserImpl::diagFromMIStringDiag(const SMDiagnostic &Error,
+                                                 SMRange SourceRange) {
+  assert(SourceRange.isValid() && "Invalid source range");
+  SMLoc Loc = SourceRange.Start;
+  bool HasQuote = Loc.getPointer() < SourceRange.End.getPointer() &&
+                  *Loc.getPointer() == '\'';
+  // Translate the location of the error from the location in the MI string to
+  // the corresponding location in the MIR file.
+  Loc = Loc.getFromPointer(Loc.getPointer() + Error.getColumnNo() +
+                           (HasQuote ? 1 : 0));
+
+  // TODO: Translate any source ranges as well.
+  return SM.GetMessage(Loc, Error.getKind(), Error.getMessage(), None,
+                       Error.getFixIts());
+}
+
 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;

llvm/trunk/test/CodeGen/MIR/X86/expected-machine-operand.mir

 # RUN: not llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | FileCheck %s
 
 --- |
 
   define i32 @foo() {
   entry:
     ret i32 0
   }
 
 ...
 ---
 name:            foo
 body:
  - name:         entry
    instructions:
-     # CHECK: 1:16: expected a machine operand
+     # CHECK: [[@LINE+1]]:24: expected a machine operand
      - '%eax = XOR32rr ='
      - 'RETQ %eax'
 ...
 

llvm/trunk/test/CodeGen/MIR/X86/missing-comma.mir

 # RUN: not llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | FileCheck %s
 
 --- |
 
   define i32 @foo() {
   entry:
     ret i32 0
   }
 
 ...
 ---
 name:            foo
 body:
  - name:         entry
    instructions:
-     # CHECK: 1:21: expected ',' before the next machine operand
+     # CHECK: [[@LINE+1]]:29: expected ',' before the next machine operand
      - '%eax = XOR32rr %eax %eflags'
      - 'RETQ %eax'
 ...
 

llvm/trunk/test/CodeGen/MIR/X86/missing-instruction.mir

 # RUN: not llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | FileCheck %s
 
 --- |
 
   define void @foo() {
   entry:
     ret void
   }
 
 ...
 ---
 name:            foo
 body:
  - name:         entry
    instructions:
-     # CHECK: 1:1: expected a machine instruction
+     # CHECK: [[@LINE+1]]:9: expected a machine instruction
      - ''
 ...

llvm/trunk/test/CodeGen/MIR/X86/unknown-instruction.mir

--- |
   }
 
 ...
 ---
 name:            foo
 body:
  - name:         entry
    instructions:
-     # CHECK: 1:1: unknown machine instruction name 'retJust0'
+     # CHECK: [[@LINE+1]]:8: unknown machine instruction name 'retJust0'
      - retJust0
 ...

llvm/trunk/test/CodeGen/MIR/X86/unknown-register.mir

--- |
   }
 
 ...
 ---
 name:            foo
 body:
  - name:         entry
    instructions:
-     # CHECK: 1:1: unknown register name 'xax'
+     # CHECK: [[@LINE+1]]:9: unknown register name 'xax'
      - '%xax = MOV32r0'
      - 'RETQ %xax'
 ...

llvm/trunk/test/CodeGen/MIR/X86/unrecognized-character.mir

 # RUN: not llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | FileCheck %s
 
 --- |
 
   define void @foo() {
   entry:
     ret void
   }
 
 ...
 ---
 name:            foo
 body:
  - name:         entry
    instructions:
-     # CHECK: 1:1: unexpected character '`'
+     # CHECK: [[@LINE+1]]:9: unexpected character '`'
      - '` RETQ'
 ...