[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

23

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

96

will this work before initialization?

98

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

23

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

98

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

92–96

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

llvm/tools/llvm-reduce/ReducerWorkItem.h

21 ↗

(On Diff #380894)

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

98

could you add a TODO?

143–150

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

21 ↗

(On Diff #380894)

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

98

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

41

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

147

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 -mir -mtriple=riscv32 --test %python --test-arg %p/instr-reduce.py %s -o %t
+# RUN: cat %t | FileCheck --match-full-lines %s
+
+# REQUIRES: plugins
+# 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
   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/ReduceInstructionsMIR.cpp
+  MyMachineModule.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/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."));
+extern cl::opt<bool> EnableMIR;
 
 #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", reduceOperandsDeltaPass)                              \
   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 (EnableMIR) {
+    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 (EnableMIR) {
+    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";
+  if (EnableMIR) {
+    DELTA_PASSES_MIR
+  } else {
     DELTA_PASSES
+  }
 #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/MyMachineModule.h

+//===- MyMachineModule.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_MYMACHINEMODULE_H
+#define LLVM_TOOLS_LLVM_REDUCE_MYMACHINEMODULE_H
+
+#include "llvm/CodeGen/MachineFunction.h"
+#include "llvm/CodeGen/MachineModuleInfo.h"
+#include "llvm/IR/Module.h"
+
+using namespace llvm;
+
+class MyMachineModule {
+public:
+  std::shared_ptr<Module> M;
+  std::unique_ptr<MachineFunction> MF;
+  void print(raw_ostream &ROS, void *p);
+};
+
+std::unique_ptr<MyMachineModule> parseMyMachineModule(StringRef Filename,
+                                                      LLVMContext &Ctxt,
+                                                      MachineModuleInfo &MMI);
+
+std::unique_ptr<MyMachineModule>
+cloneMyMachineModule(const MyMachineModule &MMM);
+
+bool verifyMyMachineModule(const MyMachineModule &MMM, raw_fd_ostream *OS);
+
+void writeMyMachineModule(const MyMachineModule *MMM, StringRef FileName);
+
+bool runMyMachineModule(const std::unique_ptr<MyMachineModule> &MMM);
+
+#endif

llvm/tools/llvm-reduce/MyMachineModule.cpp

+//===- MyMachineModule.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 "MyMachineModule.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/IRReader/IRReader.h"
+#include "llvm/Target/TargetMachine.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<MyMachineModule> parseMyMachineModule(StringRef Filename,
+                                                      LLVMContext &Ctxt,
+                                                      MachineModuleInfo &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 MyMachineModule::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!");
+
+  auto MMM = std::make_unique<MyMachineModule>();
+  MMM->M = std::move(M);
+  MMM->MF = cloneMF(MF);
+  return MMM;
+}
+
+std::unique_ptr<MyMachineModule>
+cloneMyMachineModule(const MyMachineModule &MMM) {
+  auto CloneMMM = std::make_unique<MyMachineModule>();
+  // Note that we cannot clone the Module as then we would need a way to
+  // updated the cloned MachineFunction's IR references.
+  CloneMMM->M = MMM.M;
+  CloneMMM->MF = cloneMF(MMM.MF.get());
+  return CloneMMM;
+}
+
+bool verifyMyMachineModule(const MyMachineModule &MMM, raw_fd_ostream *OS) {
+  return !MMM.MF->verify(nullptr, "", /*AbortOnErrors=*/false);
+}
+
+void writeMyMachineModule(const MyMachineModule *MMM, StringRef FileName) {
+  std::error_code EC;
+  raw_fd_ostream OS(FileName, EC);
+  if (EC) {
+    errs() << "Error opening output file: " << EC.message() << "!\n";
+    exit(1);
+  }
+  printMIR(OS, *MMM->M.get());
+  printMIR(OS, *MMM->MF);
+  OS.close();
+}
+
+void MyMachineModule::print(raw_ostream &ROS, void *p) {
+  printMIR(ROS, *M.get());
+  printMIR(ROS, *MF);
+}

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 "MyMachineModule.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);
 
   /// 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.get(); }
+  MyMachineModule *getProgram() const { return Program.get(); }
 
-  void setProgram(std::unique_ptr<Module> P) { Program = std::move(P); }
+  void setProgram(std::unique_ptr<MyMachineModule> P) {
+    Program = std::move(P);
+  }
 
 private:
   StringRef TestName;
   const std::vector<std::string> &TestArgs;
-  std::unique_ptr<Module> Program;
+  std::unique_ptr<MyMachineModule> Program;
 };
 
 } // namespace llvm
 
 #endif

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

 /// algorithm, for example, the RemoveGlobalVars pass would send the amount of
 /// initialized GVs.
 /// * 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,
-                  std::function<void(const std::vector<Chunk> &, Module *)>
-                      ExtractChunksFromModule);
+void runDeltaPass(
+    TestRunner &Test, int Targets,
+    std::function<void(const std::vector<Chunk> &, MyMachineModule *)>
 } // 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 "MyMachineModule.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);
+extern cl::opt<bool> EnableMIR;
 
-bool isReduced(Module &M, TestRunner &Test, SmallString<128> &CurrentFilepath) {
-  // Write Module to tmp file
+void writeOutput(MyMachineModule *M, llvm::StringRef Message);
+
+bool isReduced(MyMachineModule &M, TestRunner &Test,
+               SmallString<128> &CurrentFilepath) {
+  // Write MyMachineModule 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", EnableMIR ? "mir" : "ll", FD, CurrentFilepath);
   if (EC) {
     errs() << "Error making unique filename: " << EC.message() << "!\n";
     exit(1);
   }
 
   ToolOutputFile Out(CurrentFilepath, FD);
+  if (EnableMIR)
     M.print(Out.os(), /*AnnotationWriter=*/nullptr);
+  else
+    M.M->print(Out.os(), /*AnnotationWriter=*/nullptr);
   Out.os().close();
   if (Out.os().has_error()) {
     errs() << "Error emitting bitcode to file '" << CurrentFilepath << "'!\n";
     exit(1);
   }
 
   // Current Chunks aren't interesting
   return Test.run(CurrentFilepath);
static bool increaseGranularity(std::vector<Chunk> &Chunks) {
   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(
     TestRunner &Test, int Targets,
-    std::function<void(const std::vector<Chunk> &, Module *)>
+    std::function<void(const std::vector<Chunk> &, MyMachineModule *)>
         ExtractChunksFromModule) {
   assert(Targets >= 0);
   if (!Targets) {
     errs() << "\nNothing to reduce\n";
     return;
   }
 
-  if (Module *Program = Test.getProgram()) {
+  if (MyMachineModule *Program = Test.getProgram()) {
     SmallString<128> CurrentFilepath;
     if (!isReduced(*Program, Test, CurrentFilepath)) {
       errs() << "\nInput isn't interesting! Verify interesting-ness test\n";
       exit(1);
     }
 
-    assert(!verifyModule(*Program, &errs()) &&
+    assert(!(EnableMIR ? verifyMyMachineModule(*Program, &errs())
+                       : verifyModule(*Program->M, &errs())) &&
            "input module is broken before making changes");
   }
 
   std::vector<Chunk> ChunksStillConsideredInteresting = {{1, Targets}};
-  std::unique_ptr<Module> ReducedProgram;
+  std::unique_ptr<MyMachineModule> 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());
+      auto Clone = std::make_unique<MyMachineModule>();
+      if (EnableMIR) {
+        Clone = cloneMyMachineModule(*Test.getProgram());
+      } else {
+        Clone->M = CloneModule(*Test.getProgram()->M);
+      }
       // Generate Module with only Targets inside Current Chunks
       ExtractChunksFromModule(CurrentChunks, Clone.get());
 
       // Some reductions may result in invalid IR. Skip such reductions.
-      if (verifyModule(*Clone.get(), &errs())) {
+      if (EnableMIR ? verifyMyMachineModule(*Clone.get(), &errs())
+                    : verifyModule(*Clone->M.get(), &errs())) {
         if (AbortOnInvalidReduction) {
           errs() << "Invalid reduction\n";
           exit(1);
         }
         errs() << " **** WARNING | reduction resulted in invalid module, "
                   "skipping\n";
         continue;
       }

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

 #include "llvm/IR/Constants.h"
 #include "llvm/IR/GlobalValue.h"
 
 using namespace llvm;
 
 /// Removes all aliases aren't inside any of the
 /// desired Chunks.
 static void extractAliasesFromModule(const std::vector<Chunk> &ChunksToKeep,
-                                     Module *Program) {
+                                     MyMachineModule *Program) {
   Oracle O(ChunksToKeep);
 
-  for (auto &GA : make_early_inc_range(Program->aliases())) {
+  for (auto &GA : make_early_inc_range(Program->M->aliases())) {
     if (!O.shouldKeep()) {
       GA.replaceAllUsesWith(GA.getAliasee());
       GA.eraseFromParent();
     }
   }
 }
 
 /// Counts the amount of aliases and prints their respective name & index.
-static int countAliases(Module *Program) {
+static int countAliases(MyMachineModule *Program) {
   // TODO: Silence index with --quiet flag
   errs() << "----------------------------\n";
   errs() << "Aliases Index Reference:\n";
   int Count = 0;
-  for (auto &GA : Program->aliases())
+  for (auto &GA : Program->M->aliases())
     errs() << "\t" << ++Count << ": " << GA.getName() << "\n";
 
   errs() << "----------------------------\n";
   return Count;
 }
 
 void llvm::reduceAliasesDeltaPass(TestRunner &Test) {
   errs() << "*** Reducing Aliases ...\n";
   int Functions = countAliases(Test.getProgram());
   runDeltaPass(Test, Functions, extractAliasesFromModule);
   errs() << "----------------------------\n";
 }

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

 /// fixed.
 static bool shouldRemoveArguments(const Function &F) {
   return !F.arg_empty() && !F.isIntrinsic();
 }
 
 /// Removes out-of-chunk arguments from functions, and modifies their calls
 /// accordingly. It also removes allocations of out-of-chunk arguments.
 static void extractArgumentsFromModule(std::vector<Chunk> ChunksToKeep,
-                                       Module *Program) {
+                                       MyMachineModule *Program) {
   Oracle O(ChunksToKeep);
 
   std::set<Argument *> ArgsToKeep;
   std::vector<Function *> Funcs;
   // Get inside-chunk arguments, as well as their parent function
-  for (auto &F : *Program)
+  for (auto &F : *Program->M)
     if (shouldRemoveArguments(F)) {
       Funcs.push_back(&F);
       for (auto &A : F.args())
         if (O.shouldKeep())
           ArgsToKeep.insert(&A);
     }
 
   for (auto *F : Funcs) {
for (auto *F : Funcs) {
     std::set<int> ArgIndexesToKeep;
     for (auto &Arg : enumerate(F->args()))
       if (ArgsToKeep.count(&Arg.value()))
         ArgIndexesToKeep.insert(Arg.index());
 
     auto *ClonedFunc = CloneFunction(F, VMap);
     // In order to preserve function order, we move Clone after old Function
     ClonedFunc->removeFromParent();
-    Program->getFunctionList().insertAfter(F->getIterator(), ClonedFunc);
+    Program->M->getFunctionList().insertAfter(F->getIterator(), ClonedFunc);
 
     replaceFunctionCalls(*F, *ClonedFunc, ArgIndexesToKeep);
     // Rename Cloned Function to Old's name
     std::string FName = std::string(F->getName());
     F->replaceAllUsesWith(ConstantExpr::getBitCast(ClonedFunc, F->getType()));
     F->eraseFromParent();
     ClonedFunc->setName(FName);
   }
 }
 
 /// Counts the amount of arguments in functions and prints their respective
 /// name, index, and parent function name
-static int countArguments(Module *Program) {
+static int countArguments(MyMachineModule *Program) {
   // TODO: Silence index with --quiet flag
   outs() << "----------------------------\n";
   outs() << "Param Index Reference:\n";
   int ArgsCount = 0;
-  for (auto &F : *Program)
+  for (auto &F : *Program->M)
     if (shouldRemoveArguments(F)) {
       outs() << "  " << F.getName() << "\n";
       for (auto &A : F.args())
         outs() << "\t" << ++ArgsCount << ": " << A.getName() << "\n";
 
       outs() << "----------------------------\n";
     }
 
   return ArgsCount;
 }
 
 void llvm::reduceArgumentsDeltaPass(TestRunner &Test) {
   outs() << "*** Reducing Arguments...\n";
   int ArgCount = countArguments(Test.getProgram());
   runDeltaPass(Test, ArgCount, extractArgumentsFromModule);
 }

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

sort(SetVec, [](const std::pair<unsigned, AttributeSet> &LHS,
     return LHS.first < RHS.first; // All values are unique.
   });
 
   return AttributeList::get(C, SetVec);
 }
 
 /// Removes out-of-chunk attributes from module.
 static void extractAttributesFromModule(std::vector<Chunk> ChunksToKeep,
-                                        Module *Program) {
+                                        MyMachineModule *Program) {
   AttributeRemapper R(ChunksToKeep);
-  R.visit(Program);
+  R.visit(*Program->M);
 
-  LLVMContext &C = Program->getContext();
+  LLVMContext &C = Program->M->getContext();
   for (const auto &I : R.GlobalVariablesToRefine)
     I.first->setAttributes(convertAttributeRefToAttributeSet(C, I.second));
   for (const auto &I : R.FunctionsToRefine)
     I.first->setAttributes(convertAttributeRefVecToAttributeList(C, I.second));
   for (const auto &I : R.CallsToRefine)
     I.first->setAttributes(convertAttributeRefVecToAttributeList(C, I.second));
 }
 
 /// Counts the amount of attributes.
-static int countAttributes(Module *Program) {
+static int countAttributes(MyMachineModule *Program) {
   AttributeCounter C;
 
   // TODO: Silence index with --quiet flag
   outs() << "----------------------------\n";
-  C.visit(Program);
+  C.visit(*Program->M);
   outs() << "Number of attributes: " << C.AttributeCount << "\n";
 
   return C.AttributeCount;
 }
 
 void llvm::reduceAttributesDeltaPass(TestRunner &Test) {
   outs() << "*** Reducing Attributes...\n";
   int AttributeCount = countAttributes(Test.getProgram());
   runDeltaPass(Test, AttributeCount, extractAttributesFromModule);
 }

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

for (int I = 0, E = SwInst.getNumCases(); I != E; ++I) {
         --E;
       }
     }
 }
 
 /// Removes out-of-chunk arguments from functions, and modifies their calls
 /// accordingly. It also removes allocations of out-of-chunk arguments.
 static void extractBasicBlocksFromModule(std::vector<Chunk> ChunksToKeep,
-                                         Module *Program) {
+                                         MyMachineModule *Program) {
   Oracle O(ChunksToKeep);
 
   std::set<BasicBlock *> BBsToKeep;
 
-  for (auto &F : *Program)
+  for (auto &F : *Program->M)
     for (auto &BB : F)
       if (O.shouldKeep())
         BBsToKeep.insert(&BB);
 
   std::vector<BasicBlock *> BBsToDelete;
-  for (auto &F : *Program)
+  for (auto &F : *Program->M)
     for (auto &BB : F) {
       if (!BBsToKeep.count(&BB)) {
         BBsToDelete.push_back(&BB);
         // Remove out-of-chunk BB from successor phi nodes
         for (auto *Succ : successors(&BB))
           Succ->removePredecessor(&BB);
       }
     }
 
   // Replace terminators that reference out-of-chunk BBs
-  for (auto &F : *Program)
+  for (auto &F : *Program->M)
     for (auto &BB : F) {
       if (auto *SwInst = dyn_cast<SwitchInst>(BB.getTerminator()))
         removeUninterestingBBsFromSwitch(*SwInst, BBsToKeep);
       else
         replaceBranchTerminator(BB, BBsToKeep);
     }
 
   // Replace out-of-chunk switch uses
   for (auto &BB : BBsToDelete) {
     // Instructions might be referenced in other BBs
     for (auto &I : *BB)
       I.replaceAllUsesWith(UndefValue::get(I.getType()));
     BB->eraseFromParent();
   }
 }
 
 /// Counts the amount of basic blocks and prints their name & respective index
-static int countBasicBlocks(Module *Program) {
+static int countBasicBlocks(MyMachineModule *Program) {
   // TODO: Silence index with --quiet flag
   outs() << "----------------------------\n";
   int BBCount = 0;
-  for (auto &F : *Program)
+  for (auto &F : *Program->M)
     for (auto &BB : F) {
       if (BB.hasName())
         outs() << "\t" << ++BBCount << ": " << BB.getName() << "\n";
       else
         outs() << "\t" << ++BBCount << ": Unnamed\n";
     }
 
   return BBCount;
 }
 
 void llvm::reduceBasicBlocksDeltaPass(TestRunner &Test) {
   outs() << "*** Reducing Basic Blocks...\n";
   int BBCount = countBasicBlocks(Test.getProgram());
   runDeltaPass(Test, BBCount, extractBasicBlocksFromModule);
 }

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

 #include "llvm/IR/GlobalValue.h"
 
 using namespace llvm;
 
 /// Removes all the bodies of defined functions that aren't inside any of the
 /// desired Chunks.
 static void
 extractFunctionBodiesFromModule(const std::vector<Chunk> &ChunksToKeep,
-                                Module *Program) {
+                                MyMachineModule *Program) {
   Oracle O(ChunksToKeep);
 
   // Delete out-of-chunk function bodies
   std::vector<Function *> FuncDefsToReduce;
-  for (auto &F : *Program)
+  for (auto &F : *Program->M)
     if (!F.isDeclaration() && !O.shouldKeep()) {
       F.deleteBody();
       F.setComdat(nullptr);
     }
 }
 
 /// Counts the amount of non-declaration functions and prints their
 /// respective name & index
-static int countFunctionDefinitions(Module *Program) {
+static int countFunctionDefinitions(MyMachineModule *Program) {
   // TODO: Silence index with --quiet flag
   errs() << "----------------------------\n";
   errs() << "Function Definition Index Reference:\n";
   int FunctionDefinitionCount = 0;
-  for (auto &F : *Program)
+  for (auto &F : *Program->M)
     if (!F.isDeclaration())
       errs() << "\t" << ++FunctionDefinitionCount << ": " << F.getName()
              << "\n";
 
   errs() << "----------------------------\n";
   return FunctionDefinitionCount;
 }
 
 void llvm::reduceFunctionBodiesDeltaPass(TestRunner &Test) {
   errs() << "*** Reducing Function Bodies...\n";
   int Functions = countFunctionDefinitions(Test.getProgram());
   runDeltaPass(Test, Functions, extractFunctionBodiesFromModule);
   errs() << "----------------------------\n";
 }

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

 #include <iterator>
 #include <vector>
 
 using namespace llvm;
 
 /// Removes all the Defined Functions
 /// that aren't inside any of the desired Chunks.
 static void extractFunctionsFromModule(const std::vector<Chunk> &ChunksToKeep,
-                                       Module *Program) {
+                                       MyMachineModule *Program) {
   Oracle O(ChunksToKeep);
 
   // Record all out-of-chunk functions.
   std::vector<std::reference_wrapper<Function>> FuncsToRemove;
-  copy_if(Program->functions(), std::back_inserter(FuncsToRemove),
+  copy_if(Program->M->functions(), std::back_inserter(FuncsToRemove),
           [&O](Function &F) {
             // Intrinsics don't have function bodies that are useful to
             // reduce. Additionally, intrinsics may have additional operand
             // constraints. But, do drop intrinsics that are not referenced.
             return (!F.isIntrinsic() || F.use_empty()) && !O.shouldKeep();
           });
 
   // Then, drop body of each of them. We want to batch this and do nothing else
   // here so that minimal number of remaining exteranal uses will remain.
   for (Function &F : FuncsToRemove)
     F.dropAllReferences();
 
   // And finally, we can actually delete them.
   for (Function &F : FuncsToRemove) {
     // Replace all *still* remaining uses with undef.
     F.replaceAllUsesWith(UndefValue::get(F.getType()));
     // And finally, fully drop it.
     F.eraseFromParent();
   }
 }
 
 /// Counts the amount of functions and prints their
 /// respective name & index
-static int countFunctions(Module *Program) {
+static int countFunctions(MyMachineModule *Program) {
   // TODO: Silence index with --quiet flag
   errs() << "----------------------------\n";
   errs() << "Function Index Reference:\n";
   int FunctionCount = 0;
-  for (auto &F : *Program) {
+  for (auto &F : *Program->M) {
     if (F.isIntrinsic() && !F.use_empty())
       continue;
 
     errs() << '\t' << ++FunctionCount << ": " << F.getName() << '\n';
   }
 
   errs() << "----------------------------\n";
   return FunctionCount;
 }
 
 void llvm::reduceFunctionsDeltaPass(TestRunner &Test) {
   errs() << "*** Reducing Functions...\n";
   int Functions = countFunctions(Test.getProgram());
   runDeltaPass(Test, Functions, extractFunctionsFromModule);
   errs() << "----------------------------\n";
 }

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

 using namespace llvm;
 
 static bool isValidDSOLocalReductionGV(GlobalValue &GV) {
   return GV.isDSOLocal() && !GV.isImplicitDSOLocal();
 }
 
 /// Sets dso_local to false for all global values.
 static void extractGVsFromModule(std::vector<Chunk> ChunksToKeep,
-                                 Module *Program) {
+                                 MyMachineModule *Program) {
   Oracle O(ChunksToKeep);
 
   // remove dso_local from global values
-  for (auto &GV : Program->global_values())
+  for (auto &GV : Program->M->global_values())
     if (isValidDSOLocalReductionGV(GV) && !O.shouldKeep()) {
       GV.setDSOLocal(false);
     }
 }
 
 /// Counts the amount of global values with dso_local and displays their
 /// respective name & index
-static int countGVs(Module *Program) {
+static int countGVs(MyMachineModule *Program) {
   // TODO: Silence index with --quiet flag
   outs() << "----------------------------\n";
   outs() << "GlobalValue Index Reference:\n";
   int GVCount = 0;
-  for (auto &GV : Program->global_values())
+  for (auto &GV : Program->M->global_values())
     if (isValidDSOLocalReductionGV(GV))
       outs() << "\t" << ++GVCount << ": " << GV.getName() << "\n";
   outs() << "----------------------------\n";
   return GVCount;
 }
 
 void llvm::reduceGlobalValuesDeltaPass(TestRunner &Test) {
   outs() << "*** Reducing GlobalValues...\n";
   int GVCount = countGVs(Test.getProgram());
   runDeltaPass(Test, GVCount, extractGVsFromModule);
 }

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

 #include "ReduceGlobalVarInitializers.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/GlobalValue.h"
 
 using namespace llvm;
 
 /// Removes all the Initialized GVs that aren't inside the desired Chunks.
 static void extractGVsFromModule(std::vector<Chunk> ChunksToKeep,
-                                 Module *Program) {
+                                 MyMachineModule *Program) {
   Oracle O(ChunksToKeep);
 
   // Drop initializers of out-of-chunk GVs
-  for (auto &GV : Program->globals())
+  for (auto &GV : Program->M->globals())
     if (GV.hasInitializer() && !O.shouldKeep()) {
       GV.setInitializer(nullptr);
       GV.setLinkage(GlobalValue::LinkageTypes::ExternalLinkage);
       GV.setComdat(nullptr);
     }
 }
 
 /// Counts the amount of initialized GVs and displays their
 /// respective name & index
-static int countGVs(Module *Program) {
+static int countGVs(MyMachineModule *Program) {
   // TODO: Silence index with --quiet flag
   outs() << "----------------------------\n";
   outs() << "GlobalVariable Index Reference:\n";
   int GVCount = 0;
-  for (auto &GV : Program->globals())
+  for (auto &GV : Program->M->globals())
     if (GV.hasInitializer())
       outs() << "\t" << ++GVCount << ": " << GV.getName() << "\n";
   outs() << "----------------------------\n";
   return GVCount;
 }
 
 void llvm::reduceGlobalsInitializersDeltaPass(TestRunner &Test) {
   outs() << "*** Reducing GVs initializers...\n";
   int GVCount = countGVs(Test.getProgram());
   runDeltaPass(Test, GVCount, extractGVsFromModule);
 }

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

 #include "ReduceGlobalVars.h"
 #include "llvm/IR/Constants.h"
 #include <set>
 
 using namespace llvm;
 
 /// Removes all the GVs that aren't inside the desired Chunks.
 static void extractGVsFromModule(std::vector<Chunk> ChunksToKeep,
-                                 Module *Program) {
+                                 MyMachineModule *Program) {
   Oracle O(ChunksToKeep);
 
   // Get GVs inside desired chunks
   std::set<GlobalVariable *> GVsToKeep;
-  for (auto &GV : Program->globals())
+  for (auto &GV : Program->M->globals())
     if (O.shouldKeep())
       GVsToKeep.insert(&GV);
 
   // Delete out-of-chunk GVs and their uses
   std::vector<GlobalVariable *> ToRemove;
   std::vector<WeakVH> InstToRemove;
-  for (auto &GV : Program->globals())
+  for (auto &GV : Program->M->globals())
     if (!GVsToKeep.count(&GV)) {
       for (auto *U : GV.users())
         if (auto *Inst = dyn_cast<Instruction>(U))
           InstToRemove.push_back(Inst);
 
       GV.replaceAllUsesWith(UndefValue::get(GV.getType()));
       ToRemove.push_back(&GV);
     }
 
   // Delete (unique) Instruction uses of unwanted GVs
   for (Value *V : InstToRemove) {
     if (!V)
       continue;
     auto *Inst = cast<Instruction>(V);
     Inst->replaceAllUsesWith(UndefValue::get(Inst->getType()));
     Inst->eraseFromParent();
   }
 
   for (auto *GV : ToRemove)
     GV->eraseFromParent();
 }
 
 /// Counts the amount of GVs and displays their
 /// respective name & index
-static int countGVs(Module *Program) {
+static int countGVs(MyMachineModule *Program) {
   // TODO: Silence index with --quiet flag
   outs() << "----------------------------\n";
   outs() << "GlobalVariable Index Reference:\n";
   int GVCount = 0;
-  for (auto &GV : Program->globals())
+  for (auto &GV : Program->M->globals())
     outs() << "\t" << ++GVCount << ": " << GV.getName() << "\n";
   outs() << "----------------------------\n";
   return GVCount;
 }
 
 void llvm::reduceGlobalsDeltaPass(TestRunner &Test) {
   outs() << "*** Reducing GVs...\n";
   int GVCount = countGVs(Test.getProgram());
   runDeltaPass(Test, GVCount, extractGVsFromModule);
 }

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

 
 #include "ReduceInstructions.h"
 
 using namespace llvm;
 
 /// Removes out-of-chunk arguments from functions, and modifies their calls
 /// accordingly. It also removes allocations of out-of-chunk arguments.
 static void extractInstrFromModule(std::vector<Chunk> ChunksToKeep,
-                                   Module *Program) {
+                                   MyMachineModule *Program) {
   Oracle O(ChunksToKeep);
 
   std::set<Instruction *> InstToKeep;
 
-  for (auto &F : *Program)
+  for (auto &F : *Program->M)
     for (auto &BB : F) {
       // Removing the terminator would make the block invalid. Only iterate over
       // instructions before the terminator.
       InstToKeep.insert(BB.getTerminator());
       for (auto &Inst : make_range(BB.begin(), std::prev(BB.end())))
         if (O.shouldKeep())
           InstToKeep.insert(&Inst);
     }
 
   std::vector<Instruction *> InstToDelete;
-  for (auto &F : *Program)
+  for (auto &F : *Program->M)
     for (auto &BB : F)
       for (auto &Inst : BB)
         if (!InstToKeep.count(&Inst)) {
           Inst.replaceAllUsesWith(UndefValue::get(Inst.getType()));
           InstToDelete.push_back(&Inst);
         }
 
   for (auto &I : InstToDelete)
     I->eraseFromParent();
 }
 
 /// Counts the amount of basic blocks and prints their name & respective index
-static unsigned countInstructions(Module *Program) {
+static unsigned countInstructions(MyMachineModule *Program) {
   // TODO: Silence index with --quiet flag
   outs() << "----------------------------\n";
   int InstCount = 0;
-  for (auto &F : *Program)
+  for (auto &F : *Program->M)
     for (auto &BB : F)
       // Well-formed blocks have terminators, which we cannot remove.
       InstCount += BB.getInstList().size() - 1;
   outs() << "Number of instructions: " << InstCount << "\n";
 
   return InstCount;
 }
 
 void llvm::reduceInstructionsDeltaPass(TestRunner &Test) {
   outs() << "*** Reducing Instructions...\n";
   unsigned InstCount = countInstructions(Test.getProgram());
   runDeltaPass(Test, InstCount, extractInstrFromModule);
 }

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

+//===- ReduceArguments.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 Arguments from defined functions.
+//
+//===----------------------------------------------------------------------===//
+
+#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

+//===- ReduceArguments.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 Arguments from defined functions.
+//
+//===----------------------------------------------------------------------===//
+
+#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"
+#include "llvm/Support/Debug.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(MyMachineModule *Program) {
+  unsigned Count = 0;
+  MachineInstr *TopMI = nullptr;
+  for (auto &MBB : *Program->MF) {
+    for (auto &MI : MBB) {
+      if (MI.isTerminator())
+        continue;
+      if (MBB.isEntryBlock() && !TopMI) {
+        TopMI = &MI;
+        continue;
+      }
+      Count++;
+    }
+  }
+  return Count;
+}
+
+static void extractInstrFromModule(std::vector<Chunk> ChunksToKeep,
+                                   MyMachineModule *Program) {
+  auto &MF = *Program->MF;
+  MachineDominatorTree MDT;
+  MDT.runOnMachineFunction(MF);
+
+  Oracle O(ChunksToKeep);
+
+  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);
+        // errs() << "Deleting: " << 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/deltas/ReduceMetadata.cpp

 #include "llvm/IR/InstIterator.h"
 #include <vector>
 
 using namespace llvm;
 
 /// Removes all the Named and Unnamed Metadata Nodes, as well as any debug
 /// functions that aren't inside the desired Chunks.
 static void extractMetadataFromModule(const std::vector<Chunk> &ChunksToKeep,
-                                      Module *Program) {
+                                      MyMachineModule *Program) {
   Oracle O(ChunksToKeep);
 
   // Get out-of-chunk Named metadata nodes
   SmallVector<NamedMDNode *> NamedNodesToDelete;
-  for (NamedMDNode &MD : Program->named_metadata())
+  for (NamedMDNode &MD : Program->M->named_metadata())
     if (!O.shouldKeep())
       NamedNodesToDelete.push_back(&MD);
 
   for (NamedMDNode *NN : NamedNodesToDelete) {
     for (auto I : seq<unsigned>(0, NN->getNumOperands()))
       NN->setOperand(I, NULL);
     NN->eraseFromParent();
   }
 
   // Delete out-of-chunk metadata attached to globals.
   SmallVector<std::pair<unsigned, MDNode *>> MDs;
-  for (GlobalVariable &GV : Program->globals()) {
+  for (GlobalVariable &GV : Program->M->globals()) {
     GV.getAllMetadata(MDs);
     for (std::pair<unsigned, MDNode *> &MD : MDs)
       if (!O.shouldKeep())
         GV.setMetadata(MD.first, NULL);
   }
 
-  for (Function &F : *Program) {
+  for (Function &F : *Program->M) {
     // Delete out-of-chunk metadata attached to functions.
     F.getAllMetadata(MDs);
     for (std::pair<unsigned, MDNode *> &MD : MDs)
       if (!O.shouldKeep())
         F.setMetadata(MD.first, NULL);
 
     // Delete out-of-chunk metadata attached to instructions.
     for (Instruction &I : instructions(F)) {
       I.getAllMetadata(MDs);
       for (std::pair<unsigned, MDNode *> &MD : MDs)
         if (!O.shouldKeep())
           I.setMetadata(MD.first, NULL);
     }
   }
 }
 
-static int countMetadataTargets(Module *Program) {
-  int NamedMetadataNodes = Program->named_metadata_size();
+static int countMetadataTargets(MyMachineModule *Program) {
+  int NamedMetadataNodes = Program->M->named_metadata_size();
 
   // Get metadata attached to globals.
   int GlobalMetadataArgs = 0;
   SmallVector<std::pair<unsigned, MDNode *>> MDs;
-  for (GlobalVariable &GV : Program->globals()) {
+  for (GlobalVariable &GV : Program->M->globals()) {
     GV.getAllMetadata(MDs);
     GlobalMetadataArgs += MDs.size();
   }
 
   // Get metadata attached to functions & instructions.
   int FunctionMetadataArgs = 0;
   int InstructionMetadataArgs = 0;
-  for (Function &F : *Program) {
+  for (Function &F : *Program->M) {
     F.getAllMetadata(MDs);
     FunctionMetadataArgs += MDs.size();
 
     for (Instruction &I : instructions(F)) {
       I.getAllMetadata(MDs);
       InstructionMetadataArgs += MDs.size();
     }
   }

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

 //===- ReduceModuleData.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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements a reduce pass to reduce various module data.
 //
 //===----------------------------------------------------------------------===//
 
 #include "ReduceModuleData.h"
 
 using namespace llvm;
 
-static void clearModuleData(std::vector<Chunk> ChunksToKeep, Module *Program) {
+static void clearModuleData(std::vector<Chunk> ChunksToKeep,
+                            MyMachineModule *Program) {
   Oracle O(ChunksToKeep);
 
-  if (!Program->getModuleIdentifier().empty() && !O.shouldKeep())
-    Program->setModuleIdentifier("");
-  if (!Program->getSourceFileName().empty() && !O.shouldKeep())
-    Program->setSourceFileName("");
-  if (!Program->getDataLayoutStr().empty() && !O.shouldKeep())
-    Program->setDataLayout("");
-  if (!Program->getTargetTriple().empty() && !O.shouldKeep())
-    Program->setTargetTriple("");
+  if (!Program->M->getModuleIdentifier().empty() && !O.shouldKeep())
+    Program->M->setModuleIdentifier("");
+  if (!Program->M->getSourceFileName().empty() && !O.shouldKeep())
+    Program->M->setSourceFileName("");
+  if (!Program->M->getDataLayoutStr().empty() && !O.shouldKeep())
+    Program->M->setDataLayout("");
+  if (!Program->M->getTargetTriple().empty() && !O.shouldKeep())
+    Program->M->setTargetTriple("");
   // TODO: clear line by line rather than all at once
-  if (!Program->getModuleInlineAsm().empty() && !O.shouldKeep())
-    Program->setModuleInlineAsm("");
+  if (!Program->M->getModuleInlineAsm().empty() && !O.shouldKeep())
+    Program->M->setModuleInlineAsm("");
 }
 
-static int countModuleData(Module *M) {
+static int countModuleData(MyMachineModule *M) {
   int Count = 0;
-  if (!M->getModuleIdentifier().empty())
+  if (!M->M->getModuleIdentifier().empty())
     ++Count;
-  if (!M->getSourceFileName().empty())
+  if (!M->M->getSourceFileName().empty())
     ++Count;
-  if (!M->getDataLayoutStr().empty())
+  if (!M->M->getDataLayoutStr().empty())
     ++Count;
-  if (!M->getTargetTriple().empty())
+  if (!M->M->getTargetTriple().empty())
     ++Count;
-  if (!M->getModuleInlineAsm().empty())
+  if (!M->M->getModuleInlineAsm().empty())
     ++Count;
   return Count;
 }
 
 void llvm::reduceModuleDataDeltaPass(TestRunner &Test) {
   outs() << "*** Reducing Module Data...\n";
   int Count = countModuleData(Test.getProgram());
   runDeltaPass(Test, Count, clearModuleData);
 }

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

static void maybeRewriteCallWithDifferentBundles(
   // Finally actually replace the bundles on the call.
   CallBase *NewCall = CallBase::Create(OrigCall, NewBundles, OrigCall);
   OrigCall->replaceAllUsesWith(NewCall);
   OrigCall->eraseFromParent();
 }
 
 /// Removes out-of-chunk operand bundles from calls.
 static void extractOperandBundesFromModule(std::vector<Chunk> ChunksToKeep,
-                                           Module *Program) {
+                                           MyMachineModule *Program) {
   OperandBundleRemapper R(ChunksToKeep);
-  R.visit(Program);
+  R.visit(*Program->M);
 
   for (const auto &I : R.CallsToRefine)
     maybeRewriteCallWithDifferentBundles(I.first, I.second);
 }
 
 /// Counts the amount of operand bundles.
-static int countOperandBundes(Module *Program) {
+static int countOperandBundes(MyMachineModule *Program) {
   OperandBundleCounter C;
 
   // TODO: Silence index with --quiet flag
   outs() << "----------------------------\n";
-  C.visit(Program);
+  C.visit(*Program->M);
   outs() << "Number of operand bundles: " << C.OperandBundeCount << "\n";
 
   return C.OperandBundeCount;
 }
 
 void llvm::reduceOperandBundesDeltaPass(TestRunner &Test) {
   outs() << "*** Reducing OperandBundes...\n";
   int OperandBundeCount = countOperandBundes(Test.getProgram());
   runDeltaPass(Test, OperandBundeCount, extractOperandBundesFromModule);
 }

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

 static bool canReduceOperand(Use &Op) {
   auto *Ty = Op->getType();
   // Can't reduce labels to undef
   return !Ty->isLabelTy() && !operandIsUndefValue(Op);
 }
 
 /// Sets Operands to undef.
 static void extractOperandsFromModule(std::vector<Chunk> ChunksToKeep,
-                                      Module *Program) {
+                                      MyMachineModule *Program) {
   Oracle O(ChunksToKeep);
 
   // Extract Operands from the module.
-  for (auto &F : Program->functions()) {
+  for (auto &F : Program->M->functions()) {
     for (auto &I : instructions(&F)) {
       for (auto &Op : I.operands()) {
         // Filter Operands then set to undef.
         if (canReduceOperand(Op) && !O.shouldKeep()) {
           auto *Ty = Op->getType();
           Op.set(UndefValue::get(Ty));
         }
       }
     }
   }
 }
 
 /// Counts the amount of operands in the module that can be reduced.
-static int countOperands(Module *Program) {
+static int countOperands(MyMachineModule *Program) {
   int Count = 0;
-  for (auto &F : Program->functions()) {
+  for (auto &F : Program->M->functions()) {
     for (auto &I : instructions(&F)) {
       for (auto &Op : I.operands()) {
         if (canReduceOperand(Op)) {
           Count++;
         }
       }
     }
   }
   return Count;
 }
 
 void llvm::reduceOperandsDeltaPass(TestRunner &Test) {
   errs() << "*** Reducing Operands...\n";
   int Count = countOperands(Test.getProgram());
   runDeltaPass(Test, Count, extractOperandsFromModule);
 }

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

 using namespace llvm;
 
 static StringRef SpecialGlobalNames[] = {"llvm.used", "llvm.compiler.used"};
 
 /// Removes all special globals aren't inside any of the
 /// desired Chunks.
 static void
 extractSpecialGlobalsFromModule(const std::vector<Chunk> &ChunksToKeep,
-                                Module *Program) {
+                                MyMachineModule *Program) {
   Oracle O(ChunksToKeep);
 
   for (StringRef Name : SpecialGlobalNames) {
-    if (auto *Used = Program->getNamedGlobal(Name)) {
+    if (auto *Used = Program->M->getNamedGlobal(Name)) {
       Used->replaceAllUsesWith(UndefValue::get(Used->getType()));
       Used->eraseFromParent();
     }
   }
 }
 
 /// Counts the amount of special globals and prints their
 /// respective name & index
-static int countSpecialGlobals(Module *Program) {
+static int countSpecialGlobals(MyMachineModule *Program) {
   // TODO: Silence index with --quiet flag
   errs() << "----------------------------\n";
   errs() << "Special Globals Index Reference:\n";
   int Count = 0;
   for (StringRef Name : SpecialGlobalNames) {
-    if (auto *Used = Program->getNamedGlobal(Name))
+    if (auto *Used = Program->M->getNamedGlobal(Name))
       errs() << "\t" << ++Count << ": " << Used->getName() << "\n";
   }
   errs() << "----------------------------\n";
   return Count;
 }
 
 void llvm::reduceSpecialGlobalsDeltaPass(TestRunner &Test) {
   errs() << "*** Reducing Special Globals ...\n";
   int Functions = countSpecialGlobals(Test.getProgram());
   runDeltaPass(Test, Functions, extractSpecialGlobalsFromModule);
   errs() << "----------------------------\n";
 }

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 "MyMachineModule.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/Support/CommandLine.h"
 #include "llvm/Support/InitLLVM.h"
 #include "llvm/Support/SourceMgr.h"
+#include "llvm/Support/TargetRegistry.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,

 
 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"));
+                   cl::desc("Specify the output file. default: reduced.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));
 
+static cl::opt<std::string> TargetTriple("mtriple",
+                                         cl::desc("Set the target triple"));
+cl::opt<bool> EnableMIR("mir", cl::desc("MIR mode"));
+
+static codegen::RegisterCodeGenFlags CGF;
+
 // 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;
   }
 
   if (verifyModule(*Result, &errs())) {
     errs() << "Error: " << Filename << " - input module is broken!\n";
     return std::unique_ptr<Module>();
   }
 
   return Result;
 }
 
-void writeOutput(Module *M, StringRef Message) {
+void writeOutput(MyMachineModule *M, StringRef Message) {
   if (ReplaceInput) // In-place
     OutputFilename = InputFilename.c_str();
   else if (OutputFilename.empty() || OutputFilename == "-")
-    OutputFilename = "reduced.ll";
-
+    OutputFilename = EnableMIR ? "reduced.mir" : "reduced.ll";
+  if (!EnableMIR) {
     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);
+    M->M->print(Out, /*AnnotationWriter=*/nullptr);
+  } else {
+    writeMyMachineModule(M, OutputFilename);
+  }
   errs() << Message << OutputFilename << "\n";
 }
 
+static std::unique_ptr<LLVMTargetMachine> createTargetMachine() {
+  InitializeAllTargets();
+  InitializeAllTargetMCs();
+  InitializeAllAsmPrinters();
+  InitializeAllAsmParsers();
+
+  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");
 
   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<MyMachineModule> OriginalProgram;
+  if (EnableMIR) {
+    TM = createTargetMachine();
+    MMI = std::make_unique<MachineModuleInfo>(TM.get());
+    OriginalProgram = parseMyMachineModule(InputFilename, Context, *MMI);
+  } else {
+    OriginalProgram = std::make_unique<MyMachineModule>();
+    OriginalProgram->M = parseInputFile(InputFilename, Context);
+    if (!OriginalProgram->M) {
+      return 1;
+    }
+  }
 
   if (!OriginalProgram) {
     return 1;
   }
 
   // Initialize test environment
   TestRunner Tester(TestFilename, TestArguments);
   Tester.setProgram(std::move(OriginalProgram));