Machine Level IR Serialization: print and parse LLVM IR.

[arphaman]

Summary

This patch is the initial patch for the machine level IR serialization. It creates a new library in CodeGen called Serialization.
This patch introduces the 'mir' file extension that is used by the machine level IR files.

This new library adds a new machine function pass that is responsible for printing out the machine level IR in the new
format.
It also adds the functions and a class that allows llc to parse machine level IR. I've adopted a two stage parsing
approach - at first the optional LLVM IR is parsed so that the corresponding LLVM module can be created. Then
the machine level IR will be parsed at a later stage after llc creates the TargetMachine with the target information
from the already parsed module.

[arphaman]

Use @LINE filecheck expression instead of the line number in one of the tests.

[arphaman]

I've decided to split the patch up so it will be easier to review.
The updated patch has some of the error handling and second stage parsing declarations taken out.

[reames]

A few random comments, not a systematic review.

General comment: Likely too much complexity for the current functionality. Start with the simple code, add complexity as justified.

include/llvm/CodeGen/Serialization/Parser.h

10 ↗

(On Diff #25598)

I'd strongly suggest adding a clear comment explaining the in progress nature of the work.

Also, terminology wise, I'd strongly suggest you strict with machine instruction representation rather than machine level IR. It's not clear what the later is, while the former is well defined.

18 ↗

(On Diff #25598)

Include order.

30 ↗

(On Diff #25598)

It looks like this is a helpful class which should live in the cpp file?

lib/CodeGen/Serialization/MIRPrintingPass.cpp

28 ↗

(On Diff #25598)

Is there a MachineModulePass? The use of the HaveToPrintModule flag feels very dirty.

lib/CodeGen/Serialization/YAML.h

1 ↗

(On Diff #25598)

This is overly generally named. I'm not really clear what the purpose of this file is at all.

tools/llc/llc.cpp

221

Without context, it's impossible to tell if this in the right place. Please upload with full context.

[arphaman]

I've updated the patch using Philip's suggestions.

[arphaman]

include/llvm/CodeGen/Serialization/Parser.h

10 ↗

(On Diff #25598)

Done.

I also replaced the machine level IR terminology with MIR in this patch.

18 ↗

(On Diff #25598)

Fixed.

30 ↗

(On Diff #25598)

This class will be useful as a public class later, but for now I removed it from this patch.

lib/CodeGen/Serialization/YAML.h

1 ↗

(On Diff #25598)

I've renamed it and updated the comments. Hopefully it is better now.

tools/llc/llc.cpp

221

The updated patch includes more context now.

[arphaman]

lib/CodeGen/Serialization/MIRPrintingPass.cpp

28 ↗

(On Diff #25598)

There's no machine module pass, but I decided to use a module pass and to get rid of this flag.
This means I will have to add a new pass that prints out machine functions in later patches. It will have to run right after the module printing pass.

[arphaman]

I rebased this patch and reflowed a long line in lib/CodeGen/LLVMBuild.txt based on
r237367 (it reflows long lines of LLVMBuild files).

[arphaman]

I've updated the patch with fixes suggested by Duncan:

• Changed the mir printing pass name.
• Replaced 'Serialization' with 'MIR'.
• Modified the parsing interface to use a single error.
• Fixed namespace '}' comments.

[MatzeB]

This is mostly a skeleton of the API, so I can't say much about the algorithms/implementation. Also this is one of your first commits so this will be a lot of nitpicking:

In general: For what the code does at the moment there are too many .cpp and .h files for my taste, better start simple and self-contained and break it up later when it has grown (the breaking apart will happen naturally, merging stuff together usually never happens).

include/llvm/CodeGen/MIR/Parser.h

30–31 ↗

(On Diff #25875)

I changed the doxygen settings yesterday so you don't need to prepend \brief anymore if you have exactly one sentence as brief description.

include/llvm/InitializePasses.h

291

It may not be llvm coding style but all the others declarations below and above have no extra space in fron of the & here...

include/llvm/Support/YAMLTraits.h

1093–1094

This does not modify the object and should be marked const.

lib/CodeGen/MIR/MIRParser.h

29–31 ↗

(On Diff #25875)

My understanding is that this class is only used internally to implement the parser and is not intended for external users. It may be a good idea to move it to the MIRParser.cpp file then and not provide a header for it to make this fact obvious.

lib/CodeGen/MIR/MIRPrintingPasses.cpp

1 ↗

(On Diff #25875)

Call this MIRPrintingPass.cpp unless you intend to really implement multiple different printing passes.

26–27 ↗

(On Diff #25875)

Don't repeat the type name in the documentation comment.

lib/CodeGen/MIR/Parser.cpp

22–23 ↗

(On Diff #25875)

Generally the auto keyword is very unfriendly towards readers of your code. On the other hand having very longish types isn't friendly either. So I'm find with avoiding the Error<std::unique_ptr<...>> monster in the getFile() - although the best solution here would be a typedef in the MemoryBuffer class that can be used instead, but that should be part of a separate patch. The 2nd auto should definitely be replaced by std::error.

lib/CodeGen/MIR/YAMLMapping.cpp

1 ↗

(On Diff #25875)

Call it MIRPrinter.cpp like the declarations inside.

32 ↗

(On Diff #25875)

Use llvm_unreachable instead of assert(false);

lib/CodeGen/MIR/YAMLMapping.h

1 ↗

(On Diff #25875)

Call it MIRPrinter.h like the class that is declared within.

24–33 ↗

(On Diff #25875)

This looks to me like the external interface can be reduced to something like "void printMIR(raw_ostream &OS, const Module &Mod);" and leave the class internal to the .cpp file.

[arphaman]

I've updated the patch using the recommendations made by Matthias.

[arphaman]

Small formatting update that I forgot in the last update.

[arphaman]

I decided to switch back to the MachineFunctionPass, but this time the 'HaveToPrintModule' flag isn't required - I print out the
module in the 'doFinalization' method. This means I will have to print out the machine functions into a
temporary string and then print out the string after the module is printed in the 'doFinalization' method.

[arphaman]

Remove unnecessary #include in MIRPrinter header.

[MatzeB]

Newest patch LGTM once Matthias and Philip sign off.

I'm fine with it.

[reames]

I haven't reviewed the more recent versions but am happy to defer to
Matthias and Duncan who have.

Philip

[mehdi_amini]

llvm/trunk/test/CodeGen/MIR/llvmIRMissing.mir

1 ↗

(On Diff #26076)

The absolute path to llc sounds wrong to me?
(same in the other test).

[arphaman]

2015-05-19 16:01 GMT-07:00 Mehdi AMINI <[e-mail]>:

REPOSITORY

rL LLVM

Comment at: llvm/trunk/test/CodeGen/MIR/llvmIRMissing.mir:1
@@ +1,2 @@
+# RUN: ~/build/llvm/bin/llc -start-after branch-folder -stop-after
branch-folder -o /dev/null %s

+# This test ensures that the MIR parser accepts files without the LLVM IR.

The absolute path to llc sounds wrong to me?
(same in the other test).

Yes, this was a mistake that I fixed. However there was an unrelated bug
that caused
the incremental buildbots to fail so I reverted this commit.

Alex.

http://reviews.llvm.org/D9616

EMAIL PREFERENCES

http://reviews.llvm.org/settings/panel/emailpreferences/

[arphaman]

I would like to resubmit the reverted commit now that I committed the
AsmParser change in r237833.

I've attached an updated patch and a smaller patch that shows the change
between the reverted commit and the
updated patch.

The updated patch adds a terminating null character to the LLVM IR sourced
that's passed from MIRParser
to LLParser.

Thanks,
Alex

2015-05-19 11:21 GMT-07:00 Alex Lorenz <[e-mail]>:

REPOSITORY

rL LLVM

http://reviews.llvm.org/D9616

Files:

llvm/trunk/include/llvm/CodeGen/MIR/MIRParser.h
llvm/trunk/include/llvm/CodeGen/Passes.h
llvm/trunk/include/llvm/InitializePasses.h
llvm/trunk/include/llvm/Support/YAMLTraits.h
llvm/trunk/lib/CodeGen/CMakeLists.txt
llvm/trunk/lib/CodeGen/LLVMBuild.txt
llvm/trunk/lib/CodeGen/LLVMTargetMachine.cpp
llvm/trunk/lib/CodeGen/MIR/CMakeLists.txt
llvm/trunk/lib/CodeGen/MIR/LLVMBuild.txt
llvm/trunk/lib/CodeGen/MIR/MIRParser.cpp
llvm/trunk/lib/CodeGen/MIR/MIRPrinter.cpp
llvm/trunk/lib/CodeGen/MIR/MIRPrinter.h
llvm/trunk/lib/CodeGen/MIR/MIRPrintingPass.cpp
llvm/trunk/lib/CodeGen/MIR/Makefile
llvm/trunk/lib/CodeGen/Makefile
llvm/trunk/lib/Support/YAMLTraits.cpp
llvm/trunk/test/CodeGen/Generic/stop-after.ll
llvm/trunk/test/CodeGen/MIR/lit.local.cfg
llvm/trunk/test/CodeGen/MIR/llvmIR.mir
llvm/trunk/test/CodeGen/MIR/llvmIRMissing.mir
llvm/trunk/tools/llc/llc.cpp

EMAIL PREFERENCES

http://reviews.llvm.org/settings/panel/emailpreferences/

• MIR_Revert_vs_Update.patch3 KBDownload
• MIR.patch50 KBDownload

include/llvm/CodeGen/MIR/MIRParser.h

+//===- MIRParser.h - MIR serialization format parser ----------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This MIR serialization library is currently a work in progress. It can't
+// serialize machine functions at this time.
+//
+// This file declares the functions that parse the MIR serialization format
+// files.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CODEGEN_MIR_MIRPARSER_H
+#define LLVM_CODEGEN_MIR_MIRPARSER_H
+
+#include "llvm/ADT/StringRef.h"
+#include "llvm/IR/Module.h"
+#include "llvm/Support/MemoryBuffer.h"
+#include <memory>
+
+namespace llvm {
+
+class SMDiagnostic;
+
+/// This function is the main interface to the MIR serialization format parser.
+///
+/// It reads a YAML file that has an optional LLVM IR and returns an LLVM
+/// module.
+/// \param Filename - The name of the file to parse.
+/// \param Error - Error result info.
+/// \param Context - Context in which to allocate globals info.
+std::unique_ptr<Module> parseMIRFile(StringRef Filename, SMDiagnostic &Error,
+                                     LLVMContext &Context);
+
+/// This function is another interface to the MIR serialization format parser.
+///
+/// It parses the optional LLVM IR in the given buffer, and returns an LLVM
+/// module.
+/// \param Contents - The MemoryBuffer containing the machine level IR.
+/// \param Error - Error result info.
+/// \param Context - Context in which to allocate globals info.
+std::unique_ptr<Module> parseMIR(std::unique_ptr<MemoryBuffer> Contents,
+                                 SMDiagnostic &Error, LLVMContext &Context);
+
+} // end namespace llvm
+
+#endif

include/llvm/CodeGen/Passes.h

   /// last LLVM modifying pass to clean up blocks that are not reachable from
   /// the entry block.
   FunctionPass *createUnreachableBlockEliminationPass();
 
   /// MachineFunctionPrinter pass - This pass prints out the machine function to
   /// the given stream as a debugging tool.
   MachineFunctionPass *
   createMachineFunctionPrinterPass(raw_ostream &OS,
                                    const std::string &Banner ="");
 
+  /// MIRPrinting pass - this pass prints out the LLVM IR into the given stream
+  /// using the MIR serialization format.
+  ModulePass *createPrintMIRPass(raw_ostream &OS);
+
   /// createCodeGenPreparePass - Transform the code to expose more pattern
   /// matching during instruction selection.
   FunctionPass *createCodeGenPreparePass(const TargetMachine *TM = nullptr);
 
   /// AtomicExpandID -- Lowers atomic operations in terms of either cmpxchg
   /// load-linked/store-conditional loops.
   extern char &AtomicExpandID;
 
   /// MachineLoopInfo - This pass is a loop analysis pass.
   extern char &MachineLoopInfoID;

 
   /// BranchFolding - This pass performs machine code CFG based
   /// optimizations to delete branches to branches, eliminate branches to
   /// successor blocks (creating fall throughs), and eliminating branches over
   /// branches.
   extern char &BranchFolderPassID;
 
   /// MachineFunctionPrinterPass - This pass prints out MachineInstr's.
   extern char &MachineFunctionPrinterPassID;
 
+  /// MIRPrintingPass - this pass prints out the LLVM IR using the MIR
+  /// serialization format.
+  extern char &MIRPrintingPassID;
+
   /// TailDuplicate - Duplicate blocks with unconditional branches
   /// into tails of their predecessors.
   extern char &TailDuplicateID;
 
   /// MachineTraceMetrics - This pass computes critical path and CPU resource
   /// usage in an ensemble of traces.
   extern char &MachineTraceMetricsID;
 
   /// EarlyIfConverter - This pass performs if-conversion on SSA form by
   /// inserting cmov instructions.

include/llvm/InitializePasses.h

 void initializeVirtRegMapPass(PassRegistry&);
 void initializeVirtRegRewriterPass(PassRegistry&);
 void initializeInstSimplifierPass(PassRegistry&);
 void initializeUnpackMachineBundlesPass(PassRegistry&);
 void initializeFinalizeMachineBundlesPass(PassRegistry&);
 void initializeLoopAccessAnalysisPass(PassRegistry&);
 void initializeLoopVectorizePass(PassRegistry&);
 void initializeSLPVectorizerPass(PassRegistry&);
 void initializeBBVectorizePass(PassRegistry&);
 void initializeMachineFunctionPrinterPassPass(PassRegistry&);
+void initializeMIRPrintingPassPass(PassRegistry&);
 void initializeStackMapLivenessPass(PassRegistry&);
 void initializeMachineCombinerPass(PassRegistry &);
 void initializeLoadCombinePass(PassRegistry&);
 void initializeRewriteSymbolsPass(PassRegistry&);
 void initializeWinEHPreparePass(PassRegistry&);
 void initializePlaceBackedgeSafepointsImplPass(PassRegistry&);
 void initializePlaceSafepointsPass(PassRegistry&);
 void initializeDwarfEHPreparePass(PassRegistry&);
 void initializeFloat2IntPass(PassRegistry&);
 void initializeLoopDistributePass(PassRegistry&);

include/llvm/Support/YAMLTraits.h

   void setError(HNode *hnode, const Twine &message);
   void setError(Node *node, const Twine &message);
 
 
 public:
   // These are only used by operator>>. They could be private
   // if those templated things could be made friends.
   bool setCurrentDocument();
   bool nextDocument();
 
+  /// Returns the current node that's being parsed by the YAML Parser.
+  const Node *getCurrentNode() const;
+
 private:
   llvm::SourceMgr                     SrcMgr; // must be before Strm
   std::unique_ptr<llvm::yaml::Stream> Strm;
   std::unique_ptr<HNode>              TopNode;
   std::error_code                     EC;
   llvm::BumpPtrAllocator              StringAllocator;
   llvm::yaml::document_iterator       DocIterator;
   std::vector<bool>                   BitValuesUsed;
   HNode                              *CurrentNode;
   bool                                ScalarMatchFound;

lib/CodeGen/CMakeLists.txt

 
   ADDITIONAL_HEADER_DIRS
   ${LLVM_MAIN_INCLUDE_DIR}/llvm/CodeGen
   ${LLVM_MAIN_INCLUDE_DIR}/llvm/CodeGen/PBQP
   )
 
 add_dependencies(LLVMCodeGen intrinsics_gen)
 
 add_subdirectory(SelectionDAG)
 add_subdirectory(AsmPrinter)
+add_subdirectory(MIR)

lib/CodeGen/LLVMBuild.txt

 ;
 ; This is an LLVMBuild description file for the components in this subdirectory.
 ;
 ; For more information on the LLVMBuild system, please see:
 ;
 ;   http://llvm.org/docs/LLVMBuild.html
 ;
 ;===------------------------------------------------------------------------===;
 
 [common]
-subdirectories = AsmPrinter SelectionDAG
+subdirectories = AsmPrinter SelectionDAG MIR
 
 [component_0]
 type = Library
 name = CodeGen
 parent = Libraries
-required_libraries = Analysis Core MC Scalar Support Target TransformUtils
+required_libraries = Analysis Core MC Scalar Support Target TransformUtils MIR

lib/CodeGen/LLVMTargetMachine.cpp

 bool LLVMTargetMachine::addPassesToEmitFile(
     PassManagerBase &PM, raw_pwrite_stream &Out, CodeGenFileType FileType,
     bool DisableVerify, AnalysisID StartAfter, AnalysisID StopAfter) {
   // Add common CodeGen passes.
   MCContext *Context = addPassesToGenerateCode(this, PM, DisableVerify,
                                                StartAfter, StopAfter);
   if (!Context)
     return true;
 
   if (StopAfter) {
-    // FIXME: The intent is that this should eventually write out a YAML file,
-    // containing the LLVM IR, the machine-level IR (when stopping after a
-    // machine-level pass), and whatever other information is needed to
-    // deserialize the code and resume compilation.  For now, just write the
-    // LLVM IR.
-    PM.add(createPrintModulePass(Out));
+    PM.add(createPrintMIRPass(outs()));
     return false;
   }
 
   if (Options.MCOptions.MCSaveTempLabels)
     Context->setAllowTemporaryLabels(false);
 
   const MCSubtargetInfo &STI = *getMCSubtargetInfo();
   const MCAsmInfo &MAI = *getMCAsmInfo();
   const MCRegisterInfo &MRI = *getMCRegisterInfo();
   const MCInstrInfo &MII = *getMCInstrInfo();

lib/CodeGen/MIR/CMakeLists.txt

+add_llvm_library(LLVMMIR
+  MIRPrinter.cpp
+  MIRPrintingPass.cpp
+  MIRParser.cpp
+  )
+
+add_dependencies(LLVMMIR intrinsics_gen)

lib/CodeGen/MIR/LLVMBuild.txt

+;===- ./lib/CodeGen/MIR/LLVMBuild.txt --------------------------*- Conf -*--===;
+;
+;                     The LLVM Compiler Infrastructure
+;
+; This file is distributed under the University of Illinois Open Source
+; License. See LICENSE.TXT for details.
+;
+;===------------------------------------------------------------------------===;
+;
+; This is an LLVMBuild description file for the components in this subdirectory.
+;
+; For more information on the LLVMBuild system, please see:
+;
+;   http://llvm.org/docs/LLVMBuild.html
+;
+;===------------------------------------------------------------------------===;
+
+[component_0]
+type = Library
+name = MIR
+parent = CodeGen
+required_libraries = Core Support Target AsmParser

lib/CodeGen/MIR/MIRParser.cpp

+//===- MIRParser.cpp - MIR serialization format parser implementation -----===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file implements the class that parses the optional LLVM IR and machine
+// functions that are stored in MIR files.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/CodeGen/MIR/MIRParser.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/ADT/STLExtras.h"
+#include "llvm/AsmParser/Parser.h"
+#include "llvm/IR/Module.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;
+
+namespace {
+
+/// This class implements the parsing of LLVM IR that's embedded inside a MIR
+/// file.
+class MIRParserImpl {
+  SourceMgr SM;
+  StringRef Filename;
+  LLVMContext &Context;
+
+public:
+  MIRParserImpl(std::unique_ptr<MemoryBuffer> Contents, StringRef Filename,
+                LLVMContext &Context);
+
+  /// Try to parse the optional LLVM module in the MIR file.
+  ///
+  /// Return null if an error occurred while parsing the LLVM module.
+  std::unique_ptr<Module> parseLLVMModule(SMDiagnostic &Error);
+};
+
+} // 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::parseLLVMModule(SMDiagnostic &Error) {
+  yaml::Input In(SM.getMemoryBuffer(SM.getMainFileID())->getBuffer());
+
+  // Parse the block scalar manually so that we can return unique pointer
+  // without having to go trough YAML traits.
+  if (In.setCurrentDocument()) {
+    if (const auto *BSN =
+            dyn_cast_or_null<yaml::BlockScalarNode>(In.getCurrentNode())) {
+      return parseAssembly(MemoryBufferRef(BSN->getValue(), Filename), Error, Context);
+    }
+  }
+
+  // Create an new, empty module.
+  return llvm::make_unique<Module>(Filename, Context);
+}
+
+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>();
+  }
+  return parseMIR(std::move(FileOrErr.get()), Error, Context);
+}
+
+std::unique_ptr<Module> llvm::parseMIR(std::unique_ptr<MemoryBuffer> Contents,
+                                       SMDiagnostic &Error,
+                                       LLVMContext &Context) {
+  auto Filename = Contents->getBufferIdentifier();
+  MIRParserImpl Parser(std::move(Contents), Filename, Context);
+  return Parser.parseLLVMModule(Error);
+}

lib/CodeGen/MIR/MIRPrinter.h

+//===- MIRPrinter.h - MIR serialization format printer --------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file declares the function that prints out the LLVM IR using the MIR
+// serialization format.
+// TODO: Print out machine functions.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_LIB_CODEGEN_MIR_MIRPRINTER_H
+#define LLVM_LIB_CODEGEN_MIR_MIRPRINTER_H
+
+#include "llvm/Support/YAMLTraits.h"
+
+namespace llvm {
+
+class Module;
+
+/// Print LLVM IR using the MIR serialization format to the given output stream.
+void printMIR(raw_ostream &OS, const Module &Mod);
+
+} // end namespace llvm
+
+#endif

lib/CodeGen/MIR/MIRPrinter.cpp

+//===- MIRPrinter.cpp - MIR serialization format printer ------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file implements the class that prints out the LLVM IR and machine
+// functions using the MIR serialization format.
+//
+//===----------------------------------------------------------------------===//
+
+#include "MIRPrinter.h"
+#include "llvm/ADT/STLExtras.h"
+#include "llvm/IR/Module.h"
+#include "llvm/Support/MemoryBuffer.h"
+#include "llvm/Support/raw_ostream.h"
+
+using namespace llvm;
+
+namespace {
+
+/// This class prints out the LLVM IR using the MIR serialization format and
+/// YAML I/O.
+class MIRPrinter {
+  raw_ostream &OS;
+
+public:
+  MIRPrinter(raw_ostream &OS);
+
+  void printModule(const Module &Mod);
+};
+
+} // end anonymous namespace
+
+namespace llvm {
+namespace yaml {
+
+/// This struct serializes the LLVM IR module.
+template <> struct BlockScalarTraits<Module> {
+  static void output(const Module &Mod, void *Ctxt, raw_ostream &OS) {
+    Mod.print(OS, nullptr);
+  }
+  static StringRef input(StringRef Str, void *Ctxt, Module &Mod) {
+    llvm_unreachable("LLVM Module is supposed to be parsed separately");
+    return "";
+  }
+};
+
+} // end namespace yaml
+} // end namespace llvm
+
+MIRPrinter::MIRPrinter(raw_ostream &OS) : OS(OS) {}
+
+void MIRPrinter::printModule(const Module &Mod) {
+  yaml::Output Out(OS);
+  Out << const_cast<Module &>(Mod);
+}
+
+void llvm::printMIR(raw_ostream &OS, const Module &Mod) {
+  MIRPrinter Printer(OS);
+  Printer.printModule(Mod);
+}

lib/CodeGen/MIR/MIRPrintingPass.cpp

+//===- MIRPrintingPass.cpp - Pass that prints out using the MIR format ----===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file implements a pass that prints out the LLVM module using the MIR
+// serialization format.
+//
+//===----------------------------------------------------------------------===//
+
+#include "MIRPrinter.h"
+#include "llvm/CodeGen/Passes.h"
+#include "llvm/CodeGen/MachineFunction.h"
+#include "llvm/Support/Debug.h"
+#include "llvm/Support/raw_ostream.h"
+
+using namespace llvm;
+
+namespace {
+
+/// This pass prints out the LLVM IR to an output stream using the MIR
+/// serialization format.
+struct MIRPrintingPass : public ModulePass {
+  static char ID;
+  raw_ostream &OS;
+
+  MIRPrintingPass() : ModulePass(ID), OS(dbgs()) {}
+  MIRPrintingPass(raw_ostream &OS) : ModulePass(ID), OS(OS) {}
+
+  const char *getPassName() const override { return "MIR Printing Pass"; }
+
+  void getAnalysisUsage(AnalysisUsage &AU) const override {
+    AU.setPreservesAll();
+    ModulePass::getAnalysisUsage(AU);
+  }
+
+  virtual bool runOnModule(Module &M) override {
+    printMIR(OS, M);
+    return false;
+  }
+};
+
+char MIRPrintingPass::ID = 0;
+
+} // end anonymous namespace
+
+char &llvm::MIRPrintingPassID = MIRPrintingPass::ID;
+INITIALIZE_PASS(MIRPrintingPass, "mir-printer", "MIR Printer", false, false)
+
+namespace llvm {
+
+ModulePass *createPrintMIRPass(raw_ostream &OS) {
+  return new MIRPrintingPass(OS);
+}
+
+} // end namespace llvm

lib/CodeGen/MIR/Makefile

+##===- lib/CodeGen/MIR/Makefile ----------------------------*- Makefile -*-===##
+#
+#                     The LLVM Compiler Infrastructure
+#
+# This file is distributed under the University of Illinois Open Source
+# License. See LICENSE.TXT for details.
+#
+##===----------------------------------------------------------------------===##
+
+LEVEL = ../../..
+LIBRARYNAME = LLVMMIR
+
+include $(LEVEL)/Makefile.common

lib/CodeGen/Makefile

 #
 #                     The LLVM Compiler Infrastructure
 #
 # This file is distributed under the University of Illinois Open Source
 # License. See LICENSE.TXT for details.
 #
 ##===----------------------------------------------------------------------===##
 
 LEVEL = ../..
 LIBRARYNAME = LLVMCodeGen
-PARALLEL_DIRS = SelectionDAG AsmPrinter
+PARALLEL_DIRS = SelectionDAG AsmPrinter MIR
 BUILD_ARCHIVE = 1
 
 include $(LEVEL)/Makefile.common
 
 # Xcode prior to 2.4 generates an error in -pedantic mode with use of HUGE_VAL
 # in this directory.  Disable -pedantic for this broken compiler.
 ifneq ($(HUGE_VAL_SANITY),yes)
 CompileCommonOpts := $(filter-out -pedantic, $(CompileCommonOpts))
 endif
 

lib/Support/YAMLTraits.cpp

     CurrentNode = TopNode.get();
     return true;
   }
   return false;
 }
 
 bool Input::nextDocument() {
   return ++DocIterator != Strm->end();
 }
 
+const Node *Input::getCurrentNode() const {
+  return CurrentNode ? CurrentNode->_node : nullptr;
+}
+
 bool Input::mapTag(StringRef Tag, bool Default) {
   std::string foundTag = CurrentNode->_node->getVerbatimTag();
   if (foundTag.empty()) {
     // If no tag found and 'Tag' is the default, say it was found.
     return Default;
   }
   // Return true iff found tag matches supplied tag.
   return Tag.equals(foundTag);
 }
 

test/CodeGen/Generic/stop-after.ll

 ; RUN: llc < %s -debug-pass=Structure -stop-after=loop-reduce -o /dev/null 2>&1 | FileCheck %s -check-prefix=STOP
 ; RUN: llc < %s -debug-pass=Structure -start-after=loop-reduce -o /dev/null 2>&1 | FileCheck %s -check-prefix=START
 
-; STOP: -loop-reduce -print-module
+; STOP: -loop-reduce
 ; STOP: Loop Strength Reduction
 ; STOP-NEXT: Machine Function Analysis
+; STOP-NEXT: MIR Printing Pass
 
 ; START: -machine-branch-prob -gc-lowering
 ; START: FunctionPass Manager
 ; START-NEXT: Lower Garbage Collection Instructions

test/CodeGen/MIR/lit.local.cfg

+config.suffixes = ['.mir']
+

test/CodeGen/MIR/llvmIR.mir

+# RUN: ~/build/llvm/bin/llc -start-after branch-folder -stop-after branch-folder -o /dev/null %s | FileCheck %s
+# This test ensures that the LLVM IR that's embedded with MIR is parsed
+# correctly.
+
+--- |
+  target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
+  target triple = "x86_64-apple-darwin14.3.0"
+  
+  ; CHECK: define i32 @foo(i32 %x, i32 %y)
+  ; CHECK: %z = alloca i32, align 4
+  ; CHECK: store i32 %x, i32* %z, align 4
+  ; CHECK: br label %Test
+  ; CHECK: Test:
+  ; CHECK: %m = load i32, i32* %z, align 4
+  ; CHECK: %cond = icmp eq i32 %y, %m
+  ; CHECK: br i1 %cond, label %IfEqual, label %IfUnequal
+  ; CHECK: IfEqual:
+  ; CHECK: ret i32 1
+  ; CHECK: IfUnequal:
+  ; CHECK: ret i32 0
+  define i32 @foo(i32 %x, i32 %y) {
+    %z = alloca i32, align 4
+    store i32 %x, 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
+  }
+  
+...

test/CodeGen/MIR/llvmIRMissing.mir

+# RUN: ~/build/llvm/bin/llc -start-after branch-folder -stop-after branch-folder -o /dev/null %s
+# This test ensures that the MIR parser accepts files without the LLVM IR.
+
+---
+...

tools/llc/llc.cpp

 
 
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/Analysis/TargetLibraryInfo.h"
 #include "llvm/CodeGen/CommandFlags.h"
 #include "llvm/CodeGen/LinkAllAsmWriterComponents.h"
 #include "llvm/CodeGen/LinkAllCodegenComponents.h"
+#include "llvm/CodeGen/MIR/MIRParser.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/IRPrintingPasses.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/LegacyPassManager.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/Verifier.h"
 #include "llvm/IRReader/IRReader.h"
 #include "llvm/MC/SubtargetFeature.h"
GetOutputStream(const char *TargetName, Triple::OSType OS,
   if (OutputFilename.empty()) {
     if (InputFilename == "-")
       OutputFilename = "-";
     else {
       // If InputFilename ends in .bc or .ll, remove it.
       StringRef IFN = InputFilename;
       if (IFN.endswith(".bc") || IFN.endswith(".ll"))
         OutputFilename = IFN.drop_back(3);
+      else if (IFN.endswith(".mir"))
+        OutputFilename = IFN.drop_back(4);
       else
         OutputFilename = IFN;
 
       switch (FileType) {
       case TargetMachine::CGFT_AssemblyFile:
         if (TargetName[0] == 'c') {
           if (TargetName[1] == 0)
             OutputFilename += ".cbe.c";
static int compileModule(char **argv, LLVMContext &Context) {
   std::unique_ptr<Module> M;
   Triple TheTriple;
 
   bool SkipModule = MCPU == "help" ||
                     (!MAttrs.empty() && MAttrs.front() == "help");
 
   // If user just wants to list available options, skip module loading
   if (!SkipModule) {
+    if (StringRef(InputFilename).endswith_lower(".mir"))
+      M = parseMIRFile(InputFilename, Err, Context);
+    else
       M = parseIRFile(InputFilename, Err, Context);
     if (!M) {
       Err.print(argv[0], errs());
       return 1;
     }
 
     // Verify module immediately to catch problems before doInitialization() is
     // called on any passes.
     if (!NoVerify && verifyModule(*M, &errs())) {