[llvm-reduce] Add MIR support.

[markus]

Summary

In response to https://groups.google.com/g/llvm-dev/c/dggTGzLIezw/m/AYA97MVcAwAJ

I had a go at extending the llvm-reduce framework to also be able to do reduction on MIR.

For convenience and more easy integration into our downstream repository (without breaking current llvm-reduce) the source code of llvm-reduce has been copied into llvm-mir-reduce and then modified instead of modified in place on a separate branch. So I think the end goal should be integration with llvm-reduce but for now during initial development this is how it is.

Actually the differences in the existing code are really minor as can be seen by recursively diffing the two directories as in

$ meld llvm-reduce/ llvm-mir-reduce/

It is mostly about wrapping Module inside a made up class MyMachineModule that contains a Module as well as MachineFunction and then provide methods and functions to import, export and clone these.

Previously LLVM has been lacking utility functions to clone MachineFunctions and this is something that I have brought up as well (https://groups.google.com/g/llvm-dev/c/kTD5t_iHhTM/m/nLMuQOGgAwAJ) because I think it could be useful in other scenarios. The one I have implemented here is not perfect but it does seem to work for this purpose and if there are other needs maybe it could be evolved and properly integrated into lib/CodeGen.

So I guess there are a few questions to answer here

1. Should this tool be upstreamed?
2. Should it be integrated with llvm-reduce?
3. How should we handle/wrap the Module and MachineFunctions?
4. Should we provide generic MahcineFunction cloning support?

Thoughts and comments please!

[aeubanks]

I definitely think this should be upstreamed if possible.
It'd be nice if it could fit into the existing llvm-reduce to reduce copy/paste. e.g. llc can read IR and MIR.

I'm not familiar enough with MIR to comment on cloning MachineFunctions.

[markus]

Did a quick & dirty integration into llvm-reduce. All lit-tests as in llvm/test/tools/llvm-reduce/ pass but I suspect that the integration needs to be much prettier.

[markus]

Slightly better integration.

[markus]

Ok, so lets drop the [WIP] status and try to get this thing reviewed.

As far as I can tell the impact on existing llvm-reduce code should be quite limited at this point.

Obviously the MyMachineModule type name is a bad one and needs to be replaced with something better. Maybe WrappedModule, WrappedMandMF or WrappedModuleAndMachineFunction?

I am not sure who would be interested in reviewing but for anyone who is feel free to add yourself.

[aeubanks]

llvm/test/tools/llvm-reduce/mir/instr-reduce.mir

2

is it possible to do this via FileCheck like the other tests?

llvm/tools/llvm-reduce/MyMachineModule.cpp

22 ↗

(On Diff #377774)

moving this inside llvm/lib would be nice

llvm/tools/llvm-reduce/deltas/Delta.h

106

I'd prefer if this were still a Module param for normal passes to avoid the MyMachineModule abstraction inside the delta passes.
Is there a way to overload this with a Module and a MachineFunction version? e.g. forwarding them to an internal version of runDeltaPass() with wrappers to convert from a MyMachineModule to Module/MachineFunction

llvm/tools/llvm-reduce/deltas/ReduceInstructionsMIR.h

2

needs updating

llvm/tools/llvm-reduce/llvm-reduce.cpp

80

will this work before initialization?

82

it'd be nice if we could automatically infer this from the input (like llc)

[markus]

Rebased to top of main and addressed some review remarks.

[markus]

llvm/test/tools/llvm-reduce/mir/instr-reduce.mir

2

Maybe but others e.g. llvm/test/tools/llvm-reduce/remove-instructions.ll do it with custom python as well and I felt that best resembles a realistic use case scenario.

llvm/tools/llvm-reduce/MyMachineModule.cpp

22 ↗

(On Diff #377774)

Agree but maybe we can consider that a longer term goal. This implementation seems to be OK for this purpose but not sure it would be for generic use inside llvm/lib.

llvm/tools/llvm-reduce/deltas/Delta.h

106

Agree! It is always a good idea to reduce the amount of diffs and the patch looks much cleaner now.
I ran into some problems with the function_ref and overload resolution so I downgrade to a more primitive function pointer and things worked as expected again. I think the problem is related to https://stackoverflow.com/questions/7608741/c11-template-function-that-takes-a-stdfunction-which-depends-of-template-par but I have not looked at it too closely yet.

llvm/tools/llvm-reduce/llvm-reduce.cpp

82

Yeah, but maybe we can save that for later as well.

[markus]

Renamed MyMachineModule to ReducerWorkItem
Got rid of raw function pointer.

[markus]

Added -x flag to set input language as well as autodetection from filename.

But besides that, how far are we from landing this patch?

[aeubanks]

llvm/test/tools/llvm-reduce/mir/instr-reduce.mir

5

why does this need plugins?

llvm/tools/llvm-reduce/DeltaManager.cpp

96–98

I think we can probably always print everything here, split into IR and MIR passes

llvm/tools/llvm-reduce/ReducerWorkItem.h

22

I'm not super familiar with MIR, but do we only support one function at a time?

llvm/tools/llvm-reduce/deltas/ReduceInstructionsMIR.cpp

22

is this include needed?

llvm/tools/llvm-reduce/llvm-reduce.cpp

82

could you add a TODO?

134–141

a cl::opt with cl::values would be nicer, see debug-pass-manager in NewPMDriver.cpp

[lebedev.ri]

I'm not sure i fully like the coupling here.
In reality, how much code duplication is being avoided by bundling these two tools together?
Would it not be better to extract the common interface and simplify writing new back/front -ends for llvm-reduce,
instead of having everything in a single tool?

[markus]

Addressed review remarks.

[markus]

llvm/test/tools/llvm-reduce/mir/instr-reduce.mir

5

It does not.

llvm/tools/llvm-reduce/ReducerWorkItem.h

22

There could be multiple functions but we do not support it here right now. There is a comment about it in parsing in ReducerWorkItem.cpp:114. When reducing MIR reproducers you have typically already limited yourself to a single functions so I do not see that there is a great need. Not initially at least, it can always be done as a follow up improvement later on.

llvm/tools/llvm-reduce/llvm-reduce.cpp

82

I thought this comment was about replacing EnableMIR with InputLanguage and inferring from the filename which I have done already.

[markus]

In D110527#3079133, @lebedev.ri wrote:

I'm not sure i fully like the coupling here.
In reality, how much code duplication is being avoided by bundling these two tools together?

Well, it is true that the llvm-reduce tool did not contain that many lines of code in the first place, and especially not if one excludes the IR specific reduction passes.
There is the Delta Debugging Algorithm in Delta.cpp and some general stuff for handling input and output files as well as running the interestingness tests.
In general code duplication is considered a bad thing so I think we all can agree that code reuse in some sense is desirable.

Would it not be better to extract the common interface and simplify writing new back/front -ends for llvm-reduce,
instead of having everything in a single tool?

Could be but it also seems like that would be a much larger change (at least to the existing llvm-reduce). I am not particularly interested in doing that in this patch but as always anyone is free to evolve things further in a follow up commit if they consider it worth while.

[markus]

So how do we proceed?

[luke957]

So sorry for my bad herald script.

[aeubanks]

In D110527#3080186, @markus wrote:

In D110527#3079133, @lebedev.ri wrote:

I'm not sure i fully like the coupling here.
In reality, how much code duplication is being avoided by bundling these two tools together?

Well, it is true that the llvm-reduce tool did not contain that many lines of code in the first place, and especially not if one excludes the IR specific reduction passes.
There is the Delta Debugging Algorithm in Delta.cpp and some general stuff for handling input and output files as well as running the interestingness tests.
In general code duplication is considered a bad thing so I think we all can agree that code reuse in some sense is desirable.

Would it not be better to extract the common interface and simplify writing new back/front -ends for llvm-reduce,
instead of having everything in a single tool?

Could be but it also seems like that would be a much larger change (at least to the existing llvm-reduce). I am not particularly interested in doing that in this patch but as always anyone is free to evolve things further in a follow up commit if they consider it worth while.

I think currently the shared mir vs ir code doesn't hinder development too much. If it ever does come to that point we should split off an llvm-mir-reduce, but that can be done in the future.

(and sorry, I've been busy, trying to find time to review)

llvm/tools/llvm-reduce/DeltaManager.cpp

42

this really shouldn't be a global, it should be passed in as a parameter

llvm/tools/llvm-reduce/deltas/ReduceInstructionsMIR.cpp

85

delete

llvm/tools/llvm-reduce/llvm-reduce.cpp

138

we shouldn't need this, I think the cl::opt will handle misspellings

[lebedev.ri]

In D110527#3093864, @aeubanks wrote:

In D110527#3080186, @markus wrote:

In D110527#3079133, @lebedev.ri wrote:

I'm not sure i fully like the coupling here.
In reality, how much code duplication is being avoided by bundling these two tools together?

Well, it is true that the llvm-reduce tool did not contain that many lines of code in the first place, and especially not if one excludes the IR specific reduction passes.
There is the Delta Debugging Algorithm in Delta.cpp and some general stuff for handling input and output files as well as running the interestingness tests.
In general code duplication is considered a bad thing so I think we all can agree that code reuse in some sense is desirable.

Would it not be better to extract the common interface and simplify writing new back/front -ends for llvm-reduce,
instead of having everything in a single tool?

Could be but it also seems like that would be a much larger change (at least to the existing llvm-reduce). I am not particularly interested in doing that in this patch but as always anyone is free to evolve things further in a follow up commit if they consider it worth while.

I think currently the shared mir vs ir code doesn't hinder development too much. If it ever does come to that point we should split off an llvm-mir-reduce, but that can be done in the future.

Do these tools have anything in common other than the delta algorithm?
Will *any* pass be shared?

(and sorry, I've been busy, trying to find time to review)

[markus]

Addressed review remarks.

[markus]

In D110527#3093880, @lebedev.ri wrote:

Do these tools have anything in common other than the delta algorithm?

I would say that the tools are almost identical except that they work on different representations (IR and MIR). The purpose of the tools are the same, the command line interface, the handling of temporary files and the execution of interestingness tests are all the same and of course the main component the delta algorithm is the same.

Will *any* pass be shared?

The passes are unlikely to ever be shared as they are specific to the representation.

One can of course go the other way around and split the tools, refactor to make the common parts reusable (and put them in some lib somewhere) but to me that seems like a much larger change and the code duplication will be higher. This is what we have right now. Either way is doable but none of the alternatives are likely to please everyone.

[aeubanks]

In D110527#3095676, @markus wrote:

In D110527#3093880, @lebedev.ri wrote:

Do these tools have anything in common other than the delta algorithm?

I would say that the tools are almost identical except that they work on different representations (IR and MIR). The purpose of the tools are the same, the command line interface, the handling of temporary files and the execution of interestingness tests are all the same and of course the main component the delta algorithm is the same.

Will *any* pass be shared?

The passes are unlikely to ever be shared as they are specific to the representation.

One can of course go the other way around and split the tools, refactor to make the common parts reusable (and put them in some lib somewhere) but to me that seems like a much larger change and the code duplication will be higher. This is what we have right now. Either way is doable but none of the alternatives are likely to please everyone.

I agree at least for now. Currently I think the overhead of maintaining two llvm-reduces would be much larger than the problems that arise from sharing code. This may change in the future, and then we should consider splitting them.

[reames]

I'm looking at using this functionality, and ran into a question on the design. I'm not clear why you exposed an mtriple command line argument on llvm-reduce. It appears you're using this to derive a default data layout, and as an input to parsing the machine function. However, LLVM IR allows specifying both data layout and triple in IR. As a result, we should be able to have the parsing derive the appropriate target directly from the test case. Is there something I'm missing here?

[aeubanks]

In D110527#3121812, @reames wrote:

I'm looking at using this functionality, and ran into a question on the design. I'm not clear why you exposed an mtriple command line argument on llvm-reduce. It appears you're using this to derive a default data layout, and as an input to parsing the machine function. However, LLVM IR allows specifying both data layout and triple in IR. As a result, we should be able to have the parsing derive the appropriate target directly from the test case. Is there something I'm missing here?

I believe it's only used in the MIR case, not the IR case. This could definitely be made clearer in the cl::opt help.

[reames]

In D110527#3121844, @aeubanks wrote:

In D110527#3121812, @reames wrote:

I'm looking at using this functionality, and ran into a question on the design. I'm not clear why you exposed an mtriple command line argument on llvm-reduce. It appears you're using this to derive a default data layout, and as an input to parsing the machine function. However, LLVM IR allows specifying both data layout and triple in IR. As a result, we should be able to have the parsing derive the appropriate target directly from the test case. Is there something I'm missing here?

I believe it's only used in the MIR case, not the IR case. This could definitely be made clearer in the cl::opt help.

I don't think it's necessary even for the MIR case. MIR includes the full IR module, and is as a result, is also fully self describing. (If the optional datalayout and triple fields are present.)

[bjope]

In D110527#3121905, @reames wrote:

In D110527#3121844, @aeubanks wrote:

In D110527#3121812, @reames wrote:

I'm looking at using this functionality, and ran into a question on the design. I'm not clear why you exposed an mtriple command line argument on llvm-reduce. It appears you're using this to derive a default data layout, and as an input to parsing the machine function. However, LLVM IR allows specifying both data layout and triple in IR. As a result, we should be able to have the parsing derive the appropriate target directly from the test case. Is there something I'm missing here?

I believe it's only used in the MIR case, not the IR case. This could definitely be made clearer in the cl::opt help.

I don't think it's necessary even for the MIR case. MIR includes the full IR module, and is as a result, is also fully self describing. (If the optional datalayout and triple fields are present.)

The IR part can often be eliminated from a MIR based test case. But sure, one could argue that when running llvm-reduce it could be mandatory to add an IR section in the .mir file first (but then I think one needs to also add the function prototype).

[reames]

In D110527#3121915, @bjope wrote:

The IR part can often be eliminated from a MIR based test case. But sure, one could argue that when running llvm-reduce it could be mandatory to add an IR section in the .mir file first (but then I think one needs to also add the function prototype).

I can maybe see this as an argument for allowing override of the triple, but not as an argument for not defaulting to the triple if present. Frankly, I find even the override case unconvincing.

And if MIR format doesn't allow an empty-except-for-DL/triple module, that's a bug in the parser/printer and we should just fix that.

Just to be clear here, I'm happy to do the work to adjust this. I'm just trying to make sure I'm not missing some subtlety in the interface before investing the time.

[bjope]

In D110527#3121935, @reames wrote:

In D110527#3121915, @bjope wrote:

The IR part can often be eliminated from a MIR based test case. But sure, one could argue that when running llvm-reduce it could be mandatory to add an IR section in the .mir file first (but then I think one needs to also add the function prototype).

I can maybe see this as an argument for allowing override of the triple, but not as an argument for not defaulting to the triple if present. Frankly, I find even the override case unconvincing.

Yes. If there is a target triple in the IR then overriding it might be weird. I don't remember exactly how it works in llc, but as a user I guess I'd probably would assume that the behavior would be the same between the tools when using cl option vs having the triple in the IR, or having both.

[markus]

In D110527#3121954, @bjope wrote:

In D110527#3121935, @reames wrote:

In D110527#3121915, @bjope wrote:

The IR part can often be eliminated from a MIR based test case. But sure, one could argue that when running llvm-reduce it could be mandatory to add an IR section in the .mir file first (but then I think one needs to also add the function prototype).

I can maybe see this as an argument for allowing override of the triple, but not as an argument for not defaulting to the triple if present. Frankly, I find even the override case unconvincing.

Yes. If there is a target triple in the IR then overriding it might be weird. I don't remember exactly how it works in llc, but as a user I guess I'd probably would assume that the behavior would be the same between the tools when using cl option vs having the triple in the IR, or having both.

The way I see it is more or less what @bjope already said, often with MIR tests the IR section is eliminated (e.g. llvm/test/tools/llvm-reduce/mir/instr-reduce.mir) and you want to be able to work with that so some kind of option for setting the triple is needed.
If the IR section specifies a triple and/or data layout then it makes sense that that is used and -mtriple is not required. If both are specified then either -mtriple should have precedence or an error message should be printed. Perhaps the latter option is preferred to avoid confusion.
Besides that there was no deep thinking behind it other than trying to have MIR support working with the least amount of code changes.

llvm/test/tools/llvm-reduce/mir/instr-reduce.mir

+# RUN: llvm-reduce -mtriple=riscv32 --test %python --test-arg %p/instr-reduce.py %s -o %t
+# RUN: cat %t | FileCheck --match-full-lines %s
+
+# REQUIRES: riscv-registered-target
+
+# Verify that after reduction the following instruction sequence remains. The
+# interestingness-test 'instr-reduce.py' matches a '%[0-9]+:gpr = ADDI %[0-9]+, 5'
+# pattern in the output and that combined with that the MIR has to be valid
+# (pass verify) results in the given sequence.
+
+# CHECK:      %0:gpr = COPY $x10
+# CHECK-NEXT: %2:gpr = ADDI %0, 5
+# CHECK-NEXT: PseudoRET implicit $x10
+
+...
+---
+name:            f
+tracksRegLiveness: true
+body:             |
+  bb.0:
+    liveins: $x10
+
+    %10:gpr = COPY $x10
+    %20:gpr = ADDI %10, 1
+    %30:gpr = ADDI %20, 5
+    %40:gpr = ADDI %30, 9
+    $x10 = COPY %40
+    PseudoRET implicit $x10
+...
+---

llvm/test/tools/llvm-reduce/mir/instr-reduce.py

+from subprocess import run, PIPE
+import re
+import sys
+
+llc = run( [ 'llc', '-disable-symbolication','-verify-machineinstrs', '-mtriple=riscv32', '-run-pass=none', '-o', '-', sys.argv[1]], stdout=PIPE, stderr=PIPE )
+
+stdout = llc.stdout.decode()
+
+p = re.compile(r'^\s*%[0-9]+:gpr = ADDI %[0-9]+, 5$', flags=re.MULTILINE)
+
+if (llc.returncode == 0 and p.search(stdout)):
+  print('This is interesting!')
+  sys.exit(0)
+else:
+  print('This is NOT interesting!')
+  sys.exit(1)

llvm/tools/llvm-reduce/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   AllTargetsAsmParsers
   AllTargetsCodeGens
   AllTargetsDescs
   AllTargetsInfos
   Core
   IRReader
+  MIRParser
   Support
   Target
   TransformUtils
   )
 
 add_llvm_tool(llvm-reduce
   DeltaManager.cpp
+  ReducerWorkItem.cpp
   TestRunner.cpp
   deltas/Delta.cpp
   deltas/ReduceAliases.cpp
   deltas/ReduceArguments.cpp
   deltas/ReduceAttributes.cpp
   deltas/ReduceBasicBlocks.cpp
   deltas/ReduceFunctionBodies.cpp
   deltas/ReduceFunctions.cpp
   deltas/ReduceGlobalValues.cpp
   deltas/ReduceGlobalVarInitializers.cpp
   deltas/ReduceGlobalVars.cpp
   deltas/ReduceInstructions.cpp
   deltas/ReduceMetadata.cpp
   deltas/ReduceModuleData.cpp
   deltas/ReduceOperandBundles.cpp
   deltas/ReduceSpecialGlobals.cpp
   deltas/ReduceOperands.cpp
   deltas/ReduceOperandsToArgs.cpp
+  deltas/ReduceInstructionsMIR.cpp
   llvm-reduce.cpp
 
   DEPENDS
   intrinsics_gen
   )

llvm/tools/llvm-reduce/DeltaManager.cpp

 #include "deltas/ReduceAttributes.h"
 #include "deltas/ReduceBasicBlocks.h"
 #include "deltas/ReduceFunctionBodies.h"
 #include "deltas/ReduceFunctions.h"
 #include "deltas/ReduceGlobalValues.h"
 #include "deltas/ReduceGlobalVarInitializers.h"
 #include "deltas/ReduceGlobalVars.h"
 #include "deltas/ReduceInstructions.h"
+#include "deltas/ReduceInstructionsMIR.h"
 #include "deltas/ReduceMetadata.h"
 #include "deltas/ReduceModuleData.h"
 #include "deltas/ReduceOperandBundles.h"
 #include "deltas/ReduceOperands.h"
 #include "deltas/ReduceOperandsToArgs.h"
 #include "deltas/ReduceSpecialGlobals.h"
 #include "llvm/Support/CommandLine.h"
 
 using namespace llvm;
 
 static cl::opt<std::string>
     DeltaPasses("delta-passes",
                 cl::desc("Delta passes to run, separated by commas. By "
                          "default, run all delta passes."));
 
 #define DELTA_PASSES                                                           \
   DELTA_PASS("special-globals", reduceSpecialGlobalsDeltaPass)                 \
   DELTA_PASS("aliases", reduceAliasesDeltaPass)                                \
   DELTA_PASS("function-bodies", reduceFunctionBodiesDeltaPass)                 \
   DELTA_PASS("functions", reduceFunctionsDeltaPass)                            \
   DELTA_PASS("basic-blocks", reduceBasicBlocksDeltaPass)                       \
   DELTA_PASS("global-values", reduceGlobalValuesDeltaPass)                     \
   DELTA_PASS("global-initializers", reduceGlobalsInitializersDeltaPass)        \
   DELTA_PASS("global-variables", reduceGlobalsDeltaPass)                       \
   DELTA_PASS("metadata", reduceMetadataDeltaPass)                              \
   DELTA_PASS("arguments", reduceArgumentsDeltaPass)                            \
   DELTA_PASS("instructions", reduceInstructionsDeltaPass)                      \
   DELTA_PASS("operands-zero", reduceOperandsZeroDeltaPass)                     \
   DELTA_PASS("operands-one", reduceOperandsOneDeltaPass)                       \
   DELTA_PASS("operands-undef", reduceOperandsUndefDeltaPass)                   \
   DELTA_PASS("operands-to-args", reduceOperandsToArgsDeltaPass)                \
   DELTA_PASS("operand-bundles", reduceOperandBundesDeltaPass)                  \
   DELTA_PASS("attributes", reduceAttributesDeltaPass)                          \
   DELTA_PASS("module-data", reduceModuleDataDeltaPass)
 
+#define DELTA_PASSES_MIR                                                       \
+  DELTA_PASS("instructions", reduceInstructionsMIRDeltaPass)
+
 static void runAllDeltaPasses(TestRunner &Tester) {
 #define DELTA_PASS(NAME, FUNC) FUNC(Tester);
+  if (Tester.getProgram().isMIR()) {
+    DELTA_PASSES_MIR
+  } else {
     DELTA_PASSES
+  }
 #undef DELTA_PASS
 }
 
 static void runDeltaPassName(TestRunner &Tester, StringRef PassName) {
 #define DELTA_PASS(NAME, FUNC)                                                 \
   if (PassName == NAME) {                                                      \
     FUNC(Tester);                                                              \
     return;                                                                    \
   }
+  if (Tester.getProgram().isMIR()) {
+    DELTA_PASSES_MIR
+  } else {
     DELTA_PASSES
+  }
 #undef DELTA_PASS
   errs() << "unknown pass \"" << PassName << "\"";
   exit(1);
 }
 
 void llvm::printDeltaPasses(raw_ostream &OS) {
   OS << "Delta passes (pass to `--delta-passes=` as a comma separated list):\n";
 #define DELTA_PASS(NAME, FUNC) OS << "  " << NAME << "\n";
+  OS << " IR:\n";
   DELTA_PASSES
+  OS << " MIR:\n";
+  DELTA_PASSES_MIR
 #undef DELTA_PASS
 }
 
 void llvm::runDeltaPasses(TestRunner &Tester) {
   if (DeltaPasses.empty()) {
     runAllDeltaPasses(Tester);
   } else {
     StringRef Passes = DeltaPasses;
     while (!Passes.empty()) {
       auto Split = Passes.split(",");
       runDeltaPassName(Tester, Split.first);
       Passes = Split.second;
     }
   }
 }

llvm/tools/llvm-reduce/ReducerWorkItem.h

+//===- ReducerWorkItem.h - Wrapper for Module and MachineFunction ---------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_TOOLS_LLVM_REDUCE_REDUCERWORKITEM_H
+#define LLVM_TOOLS_LLVM_REDUCE_REDUCERWORKITEM_H
+
+#include "llvm/CodeGen/MachineFunction.h"
+#include "llvm/CodeGen/MachineModuleInfo.h"
+#include "llvm/IR/Module.h"
+
+using namespace llvm;
+
+class ReducerWorkItem {
+public:
+  std::shared_ptr<Module> M;
+  std::unique_ptr<MachineFunction> MF;
+  void print(raw_ostream &ROS, void *p = nullptr) const;
+  bool isMIR() { return MF != nullptr; }
+  operator Module &() const { return *M; }
+  operator MachineFunction &() const { return *MF; }
+};
+
+std::unique_ptr<ReducerWorkItem> parseReducerWorkItem(StringRef Filename,
+                                                      LLVMContext &Ctxt,
+                                                      MachineModuleInfo *MMI);
+
+std::unique_ptr<ReducerWorkItem>
+cloneReducerWorkItem(const ReducerWorkItem &MMM);
+
+bool verifyReducerWorkItem(const ReducerWorkItem &MMM, raw_fd_ostream *OS);
+
+#endif

llvm/tools/llvm-reduce/ReducerWorkItem.cpp

+//===- ReducerWorkItem.cpp - Wrapper for Module and MachineFunction -------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "ReducerWorkItem.h"
+#include "llvm/CodeGen/MIRParser/MIRParser.h"
+#include "llvm/CodeGen/MIRPrinter.h"
+#include "llvm/CodeGen/MachineDominators.h"
+#include "llvm/CodeGen/MachineFunction.h"
+#include "llvm/CodeGen/MachineFunctionPass.h"
+#include "llvm/CodeGen/MachineRegisterInfo.h"
+#include "llvm/CodeGen/TargetInstrInfo.h"
+#include "llvm/IR/Verifier.h"
+#include "llvm/IRReader/IRReader.h"
+#include "llvm/Target/TargetMachine.h"
+#include "llvm/Transforms/Utils/Cloning.h"
+
+static std::unique_ptr<MachineFunction> cloneMF(MachineFunction *SrcMF) {
+  auto DstMF = std::make_unique<MachineFunction>(
+      SrcMF->getFunction(), SrcMF->getTarget(), SrcMF->getSubtarget(),
+      SrcMF->getFunctionNumber(), SrcMF->getMMI());
+  DenseMap<MachineBasicBlock *, MachineBasicBlock *> Src2DstMBB;
+  DenseMap<Register, Register> Src2DstReg;
+
+  auto *SrcMRI = &SrcMF->getRegInfo();
+  auto *DstMRI = &DstMF->getRegInfo();
+
+  // Create vregs.
+  for (auto &SrcMBB : *SrcMF) {
+    for (auto &SrcMI : SrcMBB) {
+      for (unsigned I = 0, E = SrcMI.getNumOperands(); I < E; ++I) {
+        auto &DMO = SrcMI.getOperand(I);
+        if (!DMO.isReg() || !DMO.isDef())
+          continue;
+        Register SrcReg = DMO.getReg();
+        if (Register::isPhysicalRegister(SrcReg))
+          continue;
+        auto SrcRC = SrcMRI->getRegClass(SrcReg);
+        auto DstReg = DstMRI->createVirtualRegister(SrcRC);
+        Src2DstReg[SrcReg] = DstReg;
+      }
+    }
+  }
+
+  // Clone blocks.
+  for (auto &SrcMBB : *SrcMF)
+    Src2DstMBB[&SrcMBB] = DstMF->CreateMachineBasicBlock();
+  // Link blocks.
+  for (auto &SrcMBB : *SrcMF) {
+    auto *DstMBB = Src2DstMBB[&SrcMBB];
+    DstMF->push_back(DstMBB);
+    for (auto It = SrcMBB.succ_begin(), IterEnd = SrcMBB.succ_end();
+         It != IterEnd; ++It) {
+      auto *SrcSuccMBB = *It;
+      auto *DstSuccMBB = Src2DstMBB[SrcSuccMBB];
+      DstMBB->addSuccessor(DstSuccMBB);
+    }
+    for (auto &LI : SrcMBB.liveins())
+      DstMBB->addLiveIn(LI);
+  }
+  // Clone instructions.
+  for (auto &SrcMBB : *SrcMF) {
+    auto *DstMBB = Src2DstMBB[&SrcMBB];
+    for (auto &SrcMI : SrcMBB) {
+      const auto &MCID =
+          DstMF->getSubtarget().getInstrInfo()->get(SrcMI.getOpcode());
+      auto *DstMI = DstMF->CreateMachineInstr(MCID, SrcMI.getDebugLoc(),
+                                              /*NoImplicit=*/true);
+      DstMBB->push_back(DstMI);
+      for (auto &SrcMO : SrcMI.operands()) {
+        MachineOperand DstMO(SrcMO);
+        DstMO.clearParent();
+        // Update vreg.
+        if (DstMO.isReg() && Src2DstReg.count(DstMO.getReg())) {
+          DstMO.setReg(Src2DstReg[DstMO.getReg()]);
+        }
+        // Update MBB.
+        if (DstMO.isMBB()) {
+          DstMO.setMBB(Src2DstMBB[DstMO.getMBB()]);
+        }
+        DstMI->addOperand(DstMO);
+      }
+      DstMI->setMemRefs(*DstMF, SrcMI.memoperands());
+    }
+  }
+
+  DstMF->verify(nullptr, "", /*AbortOnErrors=*/true);
+  return DstMF;
+}
+
+std::unique_ptr<ReducerWorkItem> parseReducerWorkItem(StringRef Filename,
+                                                      LLVMContext &Ctxt,
+                                                      MachineModuleInfo *MMI) {
+  auto MMM = std::make_unique<ReducerWorkItem>();
+  if (MMI) {
+    auto FileOrErr = MemoryBuffer::getFileOrSTDIN(Filename, /*IsText=*/true);
+    std::unique_ptr<MIRParser> MParser =
+        createMIRParser(std::move(FileOrErr.get()), Ctxt);
+
+    auto SetDataLayout =
+        [&](StringRef DataLayoutTargetTriple) -> Optional<std::string> {
+      return MMI->getTarget().createDataLayout().getStringRepresentation();
+    };
+
+    std::unique_ptr<Module> M = MParser->parseIRModule(SetDataLayout);
+    MParser->parseMachineFunctions(*M, *MMI);
+    MachineFunction *MF = nullptr;
+    for (auto &F : *M) {
+      if (auto *MF4F = MMI->getMachineFunction(F)) {
+        // XXX: Maybe it would not be a lot of effort to handle multiple MFs by
+        // simply storing them in a ReducerWorkItem::SmallVector or similar. The
+        // single MF use-case seems a lot more common though so that will do for
+        // now.
+        assert(!MF && "Only single MF supported!");
+        MF = MF4F;
+      }
+    }
+    assert(MF && "No MF found!");
+
+    MMM->M = std::move(M);
+    MMM->MF = cloneMF(MF);
+  } else {
+    SMDiagnostic Err;
+    std::unique_ptr<Module> Result = parseIRFile(Filename, Err, Ctxt);
+    if (!Result) {
+      Err.print("llvm-reduce", errs());
+      return std::unique_ptr<ReducerWorkItem>();
+    }
+    MMM->M = std::move(Result);
+  }
+  if (verifyReducerWorkItem(*MMM, &errs())) {
+    errs() << "Error: " << Filename << " - input module is broken!\n";
+    return std::unique_ptr<ReducerWorkItem>();
+  }
+  return MMM;
+}
+
+std::unique_ptr<ReducerWorkItem>
+cloneReducerWorkItem(const ReducerWorkItem &MMM) {
+  auto CloneMMM = std::make_unique<ReducerWorkItem>();
+  if (MMM.MF) {
+    // Note that we cannot clone the Module as then we would need a way to
+    // updated the cloned MachineFunction's IR references.
+    // XXX: Actually have a look at
+    // std::unique_ptr<Module> CloneModule(const Module &M, ValueToValueMapTy
+    // &VMap);
+    CloneMMM->M = MMM.M;
+    CloneMMM->MF = cloneMF(MMM.MF.get());
+  } else {
+    CloneMMM->M = CloneModule(*MMM.M);
+  }
+  return CloneMMM;
+}
+
+bool verifyReducerWorkItem(const ReducerWorkItem &MMM, raw_fd_ostream *OS) {
+  if (verifyModule(*MMM.M, OS))
+    return true;
+  if (MMM.MF && !MMM.MF->verify(nullptr, "", /*AbortOnErrors=*/false))
+    return true;
+  return false;
+}
+
+void ReducerWorkItem::print(raw_ostream &ROS, void *p) const {
+  if (MF) {
+    printMIR(ROS, *M);
+    printMIR(ROS, *MF);
+  } else {
+    M->print(ROS, nullptr);
+  }
+}

llvm/tools/llvm-reduce/TestRunner.h

 //===-- tools/llvm-reduce/TestRunner.h ---------------------------*- C++ -*-===/
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TOOLS_LLVM_REDUCE_TESTRUNNER_H
 #define LLVM_TOOLS_LLVM_REDUCE_TESTRUNNER_H
 
+#include "ReducerWorkItem.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/IR/Module.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/Program.h"
 #include <vector>
 
 namespace llvm {
 
 // This class contains all the info necessary for running the provided
 // interesting-ness test, as well as the most reduced module and its
 // respective filename.
 class TestRunner {
 public:
   TestRunner(StringRef TestName, const std::vector<std::string> &TestArgs,
-             std::unique_ptr<Module> Program);
+             std::unique_ptr<ReducerWorkItem> Program);
 
   /// Runs the interesting-ness test for the specified file
   /// @returns 0 if test was successful, 1 if otherwise
   int run(StringRef Filename);
 
   /// Returns the most reduced version of the original testcase
-  Module &getProgram() const { return *Program; }
+  ReducerWorkItem &getProgram() const { return *Program; }
 
-  void setProgram(std::unique_ptr<Module> P) {
+  void setProgram(std::unique_ptr<ReducerWorkItem> P) {
     assert(P && "Setting null program?");
     Program = std::move(P);
   }
 
 private:
   StringRef TestName;
   const std::vector<std::string> &TestArgs;
-  std::unique_ptr<Module> Program;
+  std::unique_ptr<ReducerWorkItem> Program;
 };
 
 } // namespace llvm
 
 #endif

llvm/tools/llvm-reduce/TestRunner.cpp

 //===-- TestRunner.cpp ----------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "TestRunner.h"
 
 using namespace llvm;
 
 TestRunner::TestRunner(StringRef TestName,
                        const std::vector<std::string> &TestArgs,
-                       std::unique_ptr<Module> Program)
+                       std::unique_ptr<ReducerWorkItem> Program)
     : TestName(TestName), TestArgs(TestArgs), Program(std::move(Program)) {
   assert(this->Program && "Initialized with null program?");
 }
 
 /// Runs the interestingness test, passes file to be tested as first argument
 /// and other specified test arguments after that.
 int TestRunner::run(StringRef Filename) {
   std::vector<StringRef> ProgramArgs;

llvm/tools/llvm-reduce/deltas/Delta.h

 /// * ExtractChunksFromModule: A function used to tailor the main program so it
 /// only contains Targets that are inside Chunks of the given iteration.
 /// Note: This function is implemented by each specialized Delta pass
 ///
 /// Other implementations of the Delta Debugging algorithm can also be found in
 /// the CReduce, Delta, and Lithium projects.
 void runDeltaPass(
     TestRunner &Test, int Targets,
     function_ref<void(Oracle &, Module &)> ExtractChunksFromModule);
+void runDeltaPass(
+    TestRunner &Test, int Targets,
+    function_ref<void(Oracle &, MachineFunction &)> ExtractChunksFromModule);
 } // namespace llvm
 
 #endif

llvm/tools/llvm-reduce/deltas/Delta.cpp

 //===- Delta.cpp - Delta Debugging Algorithm Implementation ---------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file contains the implementation for the Delta Debugging Algorithm:
 // it splits a given set of Targets (i.e. Functions, Instructions, BBs, etc.)
 // into chunks and tries to reduce the number chunks that are interesting.
 //
 //===----------------------------------------------------------------------===//
 
 #include "Delta.h"
+#include "ReducerWorkItem.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/IR/Verifier.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/ToolOutputFile.h"
-#include "llvm/Transforms/Utils/Cloning.h"
 #include <fstream>
 #include <set>
 
 using namespace llvm;
 
 static cl::opt<bool> AbortOnInvalidReduction(
     "abort-on-invalid-reduction",
     cl::desc("Abort if any reduction results in invalid IR"));
 
-void writeOutput(llvm::Module &M, llvm::StringRef Message);
+void writeOutput(ReducerWorkItem &M, llvm::StringRef Message);
 
-bool isReduced(Module &M, TestRunner &Test, SmallString<128> &CurrentFilepath) {
-  // Write Module to tmp file
+bool isReduced(ReducerWorkItem &M, TestRunner &Test,
+               SmallString<128> &CurrentFilepath) {
+  // Write ReducerWorkItem to tmp file
   int FD;
-  std::error_code EC =
-      sys::fs::createTemporaryFile("llvm-reduce", "ll", FD, CurrentFilepath);
+  std::error_code EC = sys::fs::createTemporaryFile(
+      "llvm-reduce", M.isMIR() ? "mir" : "ll", FD, CurrentFilepath);
   if (EC) {
     errs() << "Error making unique filename: " << EC.message() << "!\n";
     exit(1);
   }
 
   ToolOutputFile Out(CurrentFilepath, FD);
   M.print(Out.os(), /*AnnotationWriter=*/nullptr);
   Out.os().close();
if (SplitOne) {
     }
   }
   return SplitOne;
 }
 
 /// Runs the Delta Debugging algorithm, splits the code into chunks and
 /// reduces the amount of chunks that are considered interesting by the
 /// given test.
-void llvm::runDeltaPass(
+template <typename T>
+void runDeltaPassInt(
     TestRunner &Test, int Targets,
-    function_ref<void(Oracle &, Module &)> ExtractChunksFromModule) {
+    function_ref<void(Oracle &, T &)> ExtractChunksFromModule) {
   assert(Targets >= 0);
   if (!Targets) {
     errs() << "\nNothing to reduce\n";
     return;
   }
 
   SmallString<128> CurrentFilepath;
   if (!isReduced(Test.getProgram(), Test, CurrentFilepath)) {
     errs() << "\nInput isn't interesting! Verify interesting-ness test\n";
     exit(1);
   }
 
-  assert(!verifyModule(Test.getProgram(), &errs()) &&
+  assert(!verifyReducerWorkItem(Test.getProgram(), &errs()) &&
          "input module is broken before making changes");
 
   std::vector<Chunk> ChunksStillConsideredInteresting = {{1, Targets}};
-  std::unique_ptr<Module> ReducedProgram;
+  std::unique_ptr<ReducerWorkItem> ReducedProgram;
 
   bool FoundAtLeastOneNewUninterestingChunkWithCurrentGranularity;
   do {
     FoundAtLeastOneNewUninterestingChunkWithCurrentGranularity = false;
 
     std::set<Chunk> UninterestingChunks;
     for (Chunk &ChunkToCheckForUninterestingness :
          reverse(ChunksStillConsideredInteresting)) {
       // Take all of ChunksStillConsideredInteresting chunks, except those we've
       // already deemed uninteresting (UninterestingChunks) but didn't remove
       // from ChunksStillConsideredInteresting yet, and additionally ignore
       // ChunkToCheckForUninterestingness chunk.
       std::vector<Chunk> CurrentChunks;
       CurrentChunks.reserve(ChunksStillConsideredInteresting.size() -
                             UninterestingChunks.size() - 1);
       copy_if(ChunksStillConsideredInteresting,
               std::back_inserter(CurrentChunks), [&](const Chunk &C) {
                 return !UninterestingChunks.count(C) &&
                        C != ChunkToCheckForUninterestingness;
               });
 
       // Clone module before hacking it up..
-      std::unique_ptr<Module> Clone = CloneModule(Test.getProgram());
+      std::unique_ptr<ReducerWorkItem> Clone =
+          cloneReducerWorkItem(Test.getProgram());
       // Generate Module with only Targets inside Current Chunks
       Oracle O(CurrentChunks);
       ExtractChunksFromModule(O, *Clone);
 
       // Some reductions may result in invalid IR. Skip such reductions.
-      if (verifyModule(*Clone, &errs())) {
+      if (verifyReducerWorkItem(*Clone, &errs())) {
         if (AbortOnInvalidReduction) {
           errs() << "Invalid reduction\n";
           exit(1);
         }
         errs() << " **** WARNING | reduction resulted in invalid module, "
                   "skipping\n";
         continue;
       }
erase_if(ChunksStillConsideredInteresting,
            (FoundAtLeastOneNewUninterestingChunkWithCurrentGranularity ||
             increaseGranularity(ChunksStillConsideredInteresting)));
 
   // If we reduced the testcase replace it
   if (ReducedProgram)
     Test.setProgram(std::move(ReducedProgram));
   errs() << "Couldn't increase anymore.\n";
 }
+
+void llvm::runDeltaPass(
+    TestRunner &Test, int Targets,
+    function_ref<void(Oracle &, Module &)> ExtractChunksFromModule) {
+  runDeltaPassInt<Module>(Test, Targets, ExtractChunksFromModule);
+}
+
+void llvm::runDeltaPass(
+    TestRunner &Test, int Targets,
+    function_ref<void(Oracle &, MachineFunction &)> ExtractChunksFromModule) {
+  runDeltaPassInt<MachineFunction>(Test, Targets, ExtractChunksFromModule);
+}

llvm/tools/llvm-reduce/deltas/ReduceInstructionsMIR.h

+//===- ReduceInstructionsMIR.h  - Specialized Delta Pass ------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file implements a function which calls the Generic Delta pass in order
+// to reduce uninteresting MachineInstr from the MachineFunction.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_TOOLS_LLVM_REDUCE_DELTAS_REDUCEINSTRUCTIONS_MIR_H
+#define LLVM_TOOLS_LLVM_REDUCE_DELTAS_REDUCEINSTRUCTIONS_MIR_H
+
+#include "Delta.h"
+
+namespace llvm {
+void reduceInstructionsMIRDeltaPass(TestRunner &Test);
+} // namespace llvm
+
+#endif

llvm/tools/llvm-reduce/deltas/ReduceInstructionsMIR.cpp

+//===- ReduceInstructionsMIR.cpp - Specialized Delta Pass -----------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file implements a function which calls the Generic Delta pass in order
+// to reduce uninteresting MachineInstr from the MachineFunction.
+//
+//===----------------------------------------------------------------------===//
+
+#include "ReduceInstructionsMIR.h"
+
+#include "llvm/CodeGen/MachineDominators.h"
+#include "llvm/CodeGen/MachineFunction.h"
+#include "llvm/CodeGen/MachineFunctionPass.h"
+#include "llvm/CodeGen/MachineRegisterInfo.h"
+#include "llvm/CodeGen/TargetInstrInfo.h"
+
+using namespace llvm;
+
+static Register getPrevDefOfRCInMBB(MachineBasicBlock &MBB,
+                                    MachineBasicBlock::reverse_iterator &RI,
+                                    const TargetRegisterClass *RC,
+                                    SetVector<MachineInstr *> &ExcludeMIs) {
+  auto MRI = &MBB.getParent()->getRegInfo();
+  for (MachineBasicBlock::reverse_instr_iterator E = MBB.instr_rend(); RI != E;
+       ++RI) {
+    auto &MI = *RI;
+    // All Def operands explicit and implicit.
+    for (auto &MO : MI.operands()) {
+      if (!MO.isReg() || !MO.isDef())
+        continue;
+      auto Reg = MO.getReg();
+      if (Register::isPhysicalRegister(Reg))
+        continue;
+
+      if (MRI->getRegClass(Reg) == RC && !ExcludeMIs.count(MO.getParent()))
+        return Reg;
+    }
+  }
+  return 0;
+}
+
+static unsigned countInstructions(MachineFunction &MF) {
+  unsigned Count = 0;
+  MachineInstr *TopMI = nullptr;
+  for (auto &MBB : MF) {
+    for (auto &MI : MBB) {
+      if (MI.isTerminator())
+        continue;
+      if (MBB.isEntryBlock() && !TopMI) {
+        TopMI = &MI;
+        continue;
+      }
+      Count++;
+    }
+  }
+  return Count;
+}
+
+static void extractInstrFromModule(Oracle &O, MachineFunction &MF) {
+  MachineDominatorTree MDT;
+  MDT.runOnMachineFunction(MF);
+
+  auto MRI = &MF.getRegInfo();
+  SetVector<MachineInstr *> ToDelete;
+
+  MachineInstr *TopMI = nullptr;
+
+  // Mark MIs for deletion according to some criteria.
+  for (auto &MBB : MF) {
+    for (auto &MI : MBB) {
+      if (MI.isTerminator())
+        continue;
+      if (MBB.isEntryBlock() && !TopMI) {
+        TopMI = &MI;
+        continue;
+      }
+      if (!O.shouldKeep())
+        ToDelete.insert(&MI);
+    }
+  }
+
+  // For each MI to be deleted update users of regs defined by that MI to use
+  // some other dominating definition (that is not to be deleted).
+  for (auto *MI : ToDelete) {
+    for (auto &MO : MI->operands()) {
+      if (!MO.isReg() || !MO.isDef())
+        continue;
+      auto Reg = MO.getReg();
+      if (Register::isPhysicalRegister(Reg))
+        continue;
+      auto UI = MRI->use_begin(Reg);
+      auto UE = MRI->use_end();
+
+      auto RegRC = MRI->getRegClass(Reg);
+      Register NewReg = 0;
+      // If this is not a physical register and there are some uses.
+      if (UI != UE) {
+        MachineBasicBlock::reverse_iterator RI(*MI);
+        MachineBasicBlock *BB = MI->getParent();
+        ++RI;
+        while (NewReg == 0 && BB) {
+          NewReg = getPrevDefOfRCInMBB(*BB, RI, RegRC, ToDelete);
+          // Prepare for idom(BB).
+          if (auto *IDM = MDT.getNode(BB)->getIDom()) {
+            BB = IDM->getBlock();
+            RI = BB->rbegin();
+          } else {
+            BB = nullptr;
+          }
+        }
+      }
+
+      // If no dominating definition was found then add an implicit one to the
+      // first instruction in the entry block.
+      if (!NewReg && TopMI) {
+        NewReg = MRI->createVirtualRegister(RegRC);
+        TopMI->addOperand(MachineOperand::CreateReg(
+            NewReg, true /*IsDef*/, true /*IsImp*/, false /*IsKill*/));
+      }
+
+      // Update all uses.
+      while (UI != UE) {
+        auto &UMO = *UI++;
+        UMO.setReg(NewReg);
+      }
+    }
+  }
+
+  // Finally delete the MIs.
+  for (auto *MI : ToDelete)
+    MI->eraseFromParent();
+}
+
+void llvm::reduceInstructionsMIRDeltaPass(TestRunner &Test) {
+  outs() << "*** Reducing Instructions...\n";
+  unsigned InstCount = countInstructions(Test.getProgram());
+  runDeltaPass(Test, InstCount, extractInstrFromModule);
+}

llvm/tools/llvm-reduce/llvm-reduce.cpp

 // test. It runs multiple delta debugging passes in order to minimize the input
 // file. It's worth noting that this is a part of the bugpoint redesign
 // proposal, and thus a *temporary* tool that will eventually be integrated
 // into the bugpoint tool itself.
 //
 //===----------------------------------------------------------------------===//
 
 #include "DeltaManager.h"
+#include "ReducerWorkItem.h"
 #include "TestRunner.h"
 #include "llvm/ADT/SmallString.h"
+#include "llvm/CodeGen/CommandFlags.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Verifier.h"
 #include "llvm/IRReader/IRReader.h"
+#include "llvm/MC/TargetRegistry.h"
 #include "llvm/Support/CommandLine.h"
+#include "llvm/Support/Host.h"
 #include "llvm/Support/InitLLVM.h"
 #include "llvm/Support/SourceMgr.h"
+#include "llvm/Support/TargetSelect.h"
 #include "llvm/Support/raw_ostream.h"
+#include "llvm/Target/TargetMachine.h"
 #include <system_error>
 #include <vector>
 
 using namespace llvm;
 
 static cl::OptionCategory Options("llvm-reduce options");
 
 static cl::opt<bool> Help("h", cl::desc("Alias for -help"), cl::Hidden,
                           cl::cat(Options));
 static cl::opt<bool> Version("v", cl::desc("Alias for -version"), cl::Hidden,
                              cl::cat(Options));
 
 static cl::opt<bool>
     PrintDeltaPasses("print-delta-passes",
                      cl::desc("Print list of delta passes, passable to "
-                              "--delta-passes as a comma separated list"));
+                              "--delta-passes as a comma separated list"),
+                     cl::cat(Options));
 
 static cl::opt<std::string> InputFilename(cl::Positional, cl::Required,
                                           cl::desc("<input llvm ll/bc file>"),
                                           cl::cat(Options));
 
 static cl::opt<std::string>
     TestFilename("test", cl::Required,
                  cl::desc("Name of the interesting-ness test to be run"),
                  cl::cat(Options));
 
 static cl::list<std::string>
     TestArguments("test-arg", cl::ZeroOrMore,
                   cl::desc("Arguments passed onto the interesting-ness test"),
                   cl::cat(Options));
 
-static cl::opt<std::string>
-    OutputFilename("output",
-                   cl::desc("Specify the output file. default: reduced.ll"));
+static cl::opt<std::string> OutputFilename(
+    "output", cl::desc("Specify the output file. default: reduced.ll|mir"));
 static cl::alias OutputFileAlias("o", cl::desc("Alias for -output"),
                                  cl::aliasopt(OutputFilename),
                                  cl::cat(Options));
 
 static cl::opt<bool>
     ReplaceInput("in-place",
                  cl::desc("WARNING: This option will replace your input file "
                           "with the reduced version!"),
                  cl::cat(Options));
 
-// Parses IR into a Module and verifies it
-static std::unique_ptr<Module> parseInputFile(StringRef Filename,
-                                              LLVMContext &Ctxt) {
-  SMDiagnostic Err;
-  std::unique_ptr<Module> Result = parseIRFile(Filename, Err, Ctxt);
-  if (!Result) {
-    Err.print("llvm-reduce", errs());
-    return Result;
-  }
+enum class InputLanguages { None, IR, MIR };
 
-  if (verifyModule(*Result, &errs())) {
-    errs() << "Error: " << Filename << " - input module is broken!\n";
-    return std::unique_ptr<Module>();
-  }
+static cl::opt<InputLanguages>
+    InputLanguage("x", cl::ValueOptional,
+                  cl::desc("Input language ('ir' or 'mir')"),
+                  cl::init(InputLanguages::None),
+                  cl::values(clEnumValN(InputLanguages::IR, "ir", ""),
+                             clEnumValN(InputLanguages::MIR, "mir", "")),
+                  cl::cat(Options));
 
-  return Result;
-}
+static cl::opt<std::string> TargetTriple("mtriple",
+                                         cl::desc("Set the target triple"),
+                                         cl::cat(Options));
+
+static codegen::RegisterCodeGenFlags CGF;
 
-void writeOutput(Module &M, StringRef Message) {
+void writeOutput(ReducerWorkItem &M, StringRef Message) {
   if (ReplaceInput) // In-place
     OutputFilename = InputFilename.c_str();
   else if (OutputFilename.empty() || OutputFilename == "-")
-    OutputFilename = "reduced.ll";
-
+    OutputFilename = M.isMIR() ? "reduced.mir" : "reduced.ll";
   std::error_code EC;
   raw_fd_ostream Out(OutputFilename, EC);
   if (EC) {
     errs() << "Error opening output file: " << EC.message() << "!\n";
     exit(1);
   }
   M.print(Out, /*AnnotationWriter=*/nullptr);
   errs() << Message << OutputFilename << "\n";
 }
 
+static std::unique_ptr<LLVMTargetMachine> createTargetMachine() {
+  InitializeAllTargets();
+  InitializeAllTargetMCs();
+  InitializeAllAsmPrinters();
+  InitializeAllAsmParsers();
+
+  if (TargetTriple == "")
+    TargetTriple = sys::getDefaultTargetTriple();
+  auto TT(Triple::normalize(TargetTriple));
+  std::string CPU(codegen::getCPUStr());
+  std::string FS(codegen::getFeaturesStr());
+
+  std::string Error;
+  const Target *TheTarget = TargetRegistry::lookupTarget(TT, Error);
+
+  return std::unique_ptr<LLVMTargetMachine>(
+      static_cast<LLVMTargetMachine *>(TheTarget->createTargetMachine(
+          TT, CPU, FS, TargetOptions(), None, None, CodeGenOpt::Default)));
+}
+
 int main(int Argc, char **Argv) {
   InitLLVM X(Argc, Argv);
 
   cl::HideUnrelatedOptions({&Options, &getColorCategory()});
   cl::ParseCommandLineOptions(Argc, Argv, "LLVM automatic testcase reducer.\n");
 
+  bool ReduceModeMIR = false;
+  if (InputLanguage != InputLanguages::None) {
+    if (InputLanguage == InputLanguages::MIR)
+      ReduceModeMIR = true;
+  } else if (StringRef(InputFilename).endswith(".mir")) {
+    ReduceModeMIR = true;
+  }
+
   if (PrintDeltaPasses) {
     printDeltaPasses(errs());
     return 0;
   }
 
   LLVMContext Context;
-  std::unique_ptr<Module> OriginalProgram =
-      parseInputFile(InputFilename, Context);
-
+  std::unique_ptr<LLVMTargetMachine> TM;
+  std::unique_ptr<MachineModuleInfo> MMI;
+  std::unique_ptr<ReducerWorkItem> OriginalProgram;
+  if (ReduceModeMIR) {
+    TM = createTargetMachine();
+    MMI = std::make_unique<MachineModuleInfo>(TM.get());
+  }
+  OriginalProgram = parseReducerWorkItem(InputFilename, Context, MMI.get());
   if (!OriginalProgram) {
     return 1;
   }
 
   // Initialize test environment
   TestRunner Tester(TestFilename, TestArguments, std::move(OriginalProgram));
 
   // Try to reduce code