Introduce llc/ExecuteTestCommands pass

[MatzeB]

Summary

Putting this up for early review to get some of the bikeshedding done while I am finishing this up:

We sometimes want to test a specific codegen API rather than a whole pass.

This adds a special pass to llc that features a minimalistic scripting language to
call some predefined API functions so we can test the API with the usual lit+FileCheck tools.

The first implementation allows moving an instruction to a different
place and updating liveness information with the handleMove() API. This
obsoletes the previously existing unittest for this.

[kristof.beyls]

test/CodeGen/AMDGPU/handlemove.mir

2–13

Without reading the source of the rest of this patch, I find it hard to guess exactly what this is testing.
Maybe before committing, also some documentation should be written on how to use this new feature?
I'm not sure where the best place would be for that documentation to live. Maybe http://llvm.org/docs/MIRLangRef.html?

[MatzeB]

test/CodeGen/AMDGPU/handlemove.mir

2–13

This means: "In basic block 0, take the 2nd instruction and move it before the first instruction". This will use the LiveIntervalAnalysis::handleMove() function which updates live intervals after moving an instruction around in a basic block, which was notoriously buggy and at the same time it was hard to created directed tests for it.

Yes, this is far from a clear and obvious solution. In an ideal solution we would have a way to name instructions instead of refering to them by the numbers 2 and 1. So there is room for further improvements, but that is for another patch.

This patch is about replacing the unittest code written in C++ which today looks like this:

TEST(LiveIntervalTest, MoveUpDef) {
  // Value defined.
  liveIntervalTest(R"MIR(
    S_NOP 0
    S_NOP 0
    early-clobber %0 = IMPLICIT_DEF
    S_NOP 0, implicit %0
)MIR", [](MachineFunction &MF, LiveIntervals &LIS) {
    testHandleMove(MF, LIS, 2, 1);
  });
}

which is not clearer but instead has more C++ boilerplate noise (and no FileCheck available).

I will add more documentation in the next iterations of this patch.

[kparzysz]

This is really nice, but I have a few questions:

• Will the testCommands be limited to functions that can take immediate values (i.e no functions taking pointers to MachineInstr or MachineBasicBlock)?
• Are users expected to be adding more functions to ExecuteTestCommands.cpp as they create new tests?

test/CodeGen/AMDGPU/handlemove.mir

55

Is the " at the end a typo?

[MatzeB]

In D30521#691568, @kparzysz wrote:

This is really nice, but I have a few questions:

• Will the testCommands be limited to functions that can take immediate values (i.e no functions taking pointers to MachineInstr or MachineBasicBlock)?

In general I think it would be wrong to put too much effort into this language, if this becomes more than invocing a few functions then we should probably go back to writing unit tests.
That said there is already getMBB(number) and getMI(number) implemented in the current pass which allows you to pass an instr or block as the "this" parameter to the next function.

• Are users expected to be adding more functions to ExecuteTestCommands.cpp as they create new tests?

Yes.

test/CodeGen/AMDGPU/handlemove.mir

55

Yes (a previous version was using a special instruction to carry the commands in a string, I forgot to remove this when I switched to the testCommands: version).

[MatzeB]

• Use bb()/insn() functions more consistenly to make the intention of the commands more clear.
• Use C++ template magic to make adding new functions to the language easy.
• Add some documentation.
• Various fixes/improvements to the parser.

[qcolombet]

Hi Matthias,

I have mixed feeling on the approach. I like being able to use lite and the .mir format to specify the test, but one the other hand I feel like the ExecuteTestCommand pass will become big and hard to understand.
The unittests had this nice property that they are not mixed together (i.e., we shouldn't have a scheduler test with a coalescer test). Here every functionalities will end up in one place and that's what I don't like.

The bottom line is that I like the approach and I would be fine with this as a first step, but we need to think about a way to compartment the different functionalities (e.g., live range testing vs. scheduling testing).
Maybe we could have a high level class test command with bb and insn functionalities and specialization classes for LIS and so on?

Cheers,
-Quentin

tools/llc/ExecuteTestCommands.cpp

248

*instruction

[chandlerc]

Currently, I really don't understand why this is the right approach...

We sometimes want to test a specific codegen API rather than a whole pass.

This adds a special pass to llc that features a minimalistic scripting language to
call some predefined API functions so we can test the API with the usual lit+FileCheck tools.

If you're actually trying to test a specific API, why aren't unittests the correct approach?

If the problem is that the unittests are hard to write, why not write libraries to make authoring the unittest easier?

Essentially, I totally understand prefering FileCheck and friends when testing something that is reasonably cohesive as a *pass*. But I feel like the point at which a scripting language or other things are being used to handle the fact that we're actually testing a specific API, I would *much rather* just write a unittest against that API directly.

[MatzeB]

In D30521#698029, @qcolombet wrote:

Hi Matthias,

I have mixed feeling on the approach. I like being able to use lite and the .mir format to specify the test, but one the other hand I feel like the ExecuteTestCommand pass will become big and hard to understand.
The unittests had this nice property that they are not mixed together (i.e., we shouldn't have a scheduler test with a coalescer test). Here every functionalities will end up in one place and that's what I don't like.

The bottom line is that I like the approach and I would be fine with this as a first step, but we need to think about a way to compartment the different functionalities (e.g., live range testing vs. scheduling testing).
Maybe we could have a high level class test command with bb and insn functionalities and specialization classes for LIS and so on?

Fair enough. I think in any case this should be split into some files to have the command implementations separate from the rest and then maybe split it into more files for separate sets of commands. I am less enthusiastic (though also not strictly against), about actually splitting this into separate classes so that we would end up with -run-pass=live-interval-tests or -run-pass=bundling-tests and actually restricting the set of commands available at the same time in a single test.

[MatzeB]

In D30521#698048, @chandlerc wrote:

Currently, I really don't understand why this is the right approach...

We sometimes want to test a specific codegen API rather than a whole pass.

This adds a special pass to llc that features a minimalistic scripting language to
call some predefined API functions so we can test the API with the usual lit+FileCheck tools.

If you're actually trying to test a specific API, why aren't unittests the correct approach?

If the problem is that the unittests are hard to write, why not write libraries to make authoring the unittest easier?

I think there is something fundamental about how we write tests in llvm, and why we do not write pass tests in a unit testing framework because hey, who stops us implementing llc/opt as some functions in a unit testing library, they mostly have trivial APIs:

I think there is a beauty and we are hitting a sweet spot in the way most of our testing works in llvm: Forcing tests to be a simple human readable text file keeps things approachable and understandable. Understanding the basics of lit, llc, opt and FileCheck is easy. Having the full power of C++ in a unit test library on the other hand makes it way too easy do "fancy" stuff that is harder to understand because it happens to abstracted away in generic code and multiple layers of APIs that you have to learn and dig through when you actually have to understand a bug.

Essentially, I totally understand prefering FileCheck and friends when testing something that is reasonably cohesive as a *pass*. But I feel like the point at which a scripting language or other things are being used to handle the fact that we're actually testing a specific API, I would *much rather* just write a unittest against that API directly.

I don't see why wanting FileCheck for things that aren't a pass isn't valid. Admittedly I am not happy to introduce a scripting language here, but it seemed like the pragmatic choice compared with the alternative of building up a pile of small passes for every test or putting .mir code into C++ string literals in a unittest and still lacking all the llc mechanics for bringing up a target or having the nice matching capabilities of FileCheck.

[MatzeB]

New version separating the implementation of the actual commands to TestCommands.cpp so it becomes clear that it is easy to introduce new ones or split it further into multiple files for multiple areas of the backend in the future.

[MatzeB]

ping

[chandlerc]

In D30521#698089, @MatzeB wrote:

In D30521#698048, @chandlerc wrote:

Currently, I really don't understand why this is the right approach...

We sometimes want to test a specific codegen API rather than a whole pass.

This adds a special pass to llc that features a minimalistic scripting language to
call some predefined API functions so we can test the API with the usual lit+FileCheck tools.

If you're actually trying to test a specific API, why aren't unittests the correct approach?

If the problem is that the unittests are hard to write, why not write libraries to make authoring the unittest easier?

I think there is something fundamental about how we write tests in llvm, and why we do not write pass tests in a unit testing framework because hey, who stops us implementing llc/opt as some functions in a unit testing library, they mostly have trivial APIs:

I think there is a beauty and we are hitting a sweet spot in the way most of our testing works in llvm: Forcing tests to be a simple human readable text file keeps things approachable and understandable. Understanding the basics of lit, llc, opt and FileCheck is easy. Having the full power of C++ in a unit test library on the other hand makes it way too easy do "fancy" stuff that is harder to understand because it happens to abstracted away in generic code and multiple layers of APIs that you have to learn and dig through when you actually have to understand a bug.

I don't see how things being abstracted away in a scripting language and complex fake "pass" infrastructure is going to be substantially better here.

Essentially, I totally understand prefering FileCheck and friends when testing something that is reasonably cohesive as a *pass*. But I feel like the point at which a scripting language or other things are being used to handle the fact that we're actually testing a specific API, I would *much rather* just write a unittest against that API directly.

I don't see why wanting FileCheck for things that aren't a pass isn't valid.

I don't think that pass vs. non-pass is the right distinction.

I think FileCheck makes sense when there is already a fundamental reason to have textual output that is sufficiently stable to use in tests. This can be everything from having an IR to having a clear and precise printing structure for an analysis. Those have utility *outside* of tests and also are great tools for testing.

But when the thing we are testing, fundamentally, is *an API*, I think we should test it *by calling that API*.

Admittedly I am not happy to introduce a scripting language here, but it seemed like the pragmatic choice compared with the alternative of building up a pile of small passes for every test or putting .mir code into C++ string literals in a unittest and still lacking all the llc mechanics for bringing up a target or having the nice matching capabilities of FileCheck.

Again, I am very much in favor of having the facilities from 'llc' or 'FileCheck' in useful APIs for unittests to leverage. But I don't think we should be adding a scripting language in order to write tests in a language other than C++ to exercise C++ API calls. I think this is significantly more burdensome than just writing unittests.

Sorry for the slow response, I think we may just fundamentally disagree about the right approach here. Currently, the approach you are proposing would make the resulting tests nearly incomprehensible to me... On the other hand, I think unittests (which are "just" C++ code even if sometimes non-obvious C++ code) *when used well* are much more friendly to people outside of the particular area than a MIR-specific scripting framework.

[kristof.beyls]

In D30521#726797, @chandlerc wrote:

In D30521#698089, @MatzeB wrote:

In D30521#698048, @chandlerc wrote:

Currently, I really don't understand why this is the right approach...

We sometimes want to test a specific codegen API rather than a whole pass.

This adds a special pass to llc that features a minimalistic scripting language to
call some predefined API functions so we can test the API with the usual lit+FileCheck tools.

If you're actually trying to test a specific API, why aren't unittests the correct approach?

If the problem is that the unittests are hard to write, why not write libraries to make authoring the unittest easier?

I think there is something fundamental about how we write tests in llvm, and why we do not write pass tests in a unit testing framework because hey, who stops us implementing llc/opt as some functions in a unit testing library, they mostly have trivial APIs:

I think there is a beauty and we are hitting a sweet spot in the way most of our testing works in llvm: Forcing tests to be a simple human readable text file keeps things approachable and understandable. Understanding the basics of lit, llc, opt and FileCheck is easy. Having the full power of C++ in a unit test library on the other hand makes it way too easy do "fancy" stuff that is harder to understand because it happens to abstracted away in generic code and multiple layers of APIs that you have to learn and dig through when you actually have to understand a bug.

I don't see how things being abstracted away in a scripting language and complex fake "pass" infrastructure is going to be substantially better here.

Essentially, I totally understand prefering FileCheck and friends when testing something that is reasonably cohesive as a *pass*. But I feel like the point at which a scripting language or other things are being used to handle the fact that we're actually testing a specific API, I would *much rather* just write a unittest against that API directly.

I don't see why wanting FileCheck for things that aren't a pass isn't valid.

I don't think that pass vs. non-pass is the right distinction.

I think FileCheck makes sense when there is already a fundamental reason to have textual output that is sufficiently stable to use in tests. This can be everything from having an IR to having a clear and precise printing structure for an analysis. Those have utility *outside* of tests and also are great tools for testing.

But when the thing we are testing, fundamentally, is *an API*, I think we should test it *by calling that API*.

Admittedly I am not happy to introduce a scripting language here, but it seemed like the pragmatic choice compared with the alternative of building up a pile of small passes for every test or putting .mir code into C++ string literals in a unittest and still lacking all the llc mechanics for bringing up a target or having the nice matching capabilities of FileCheck.

Again, I am very much in favor of having the facilities from 'llc' or 'FileCheck' in useful APIs for unittests to leverage. But I don't think we should be adding a scripting language in order to write tests in a language other than C++ to exercise C++ API calls. I think this is significantly more burdensome than just writing unittests.

Sorry for the slow response, I think we may just fundamentally disagree about the right approach here. Currently, the approach you are proposing would make the resulting tests nearly incomprehensible to me... On the other hand, I think unittests (which are "just" C++ code even if sometimes non-obvious C++ code) *when used well* are much more friendly to people outside of the particular area than a MIR-specific scripting framework.

FWIW, Chandler here put into words what my feeling is too, better than I could have done myself.

[MatzeB]

I'm still not convinced unittests are the best tool for the job when most of what you are doing is constructing a function, calling a simple API and then checking the resulting function.

Anyway seems this is getting no support, abandoning.

docs/MIRLangRef.rst

 below can be used:
 
     ``# RUN: llc -run-pass postrapseudos -march=x86-64 %s -o /dev/null | FileCheck %s``
 
 The MIR files are target dependent, so they have to be placed in the target
 specific test directories. They also need to specify a target triple or a
 target architecture either in the run line or in the embedded LLVM IR module.
 
+Testing Individual APIs
+-----------------------
+
+Generally APIs should be tested with unit tests. However for cases that require
+a specific machine intermediate representation as input and only test simple
+calls ``llc`` supports the ``execute-test-commands`` pass.
+
+This pass takes a sequence of expressions specified with the test and executes
+them. Example:
+
+.. code-block:: text
+
+    # RUN: llc -o - %s -mtarget=x86_64-- -run-pass=execute-test-commands | FileCheck %s
+    ---
+    name: func
+    body: |
+      bb.0:
+        %eax = MOV32i 7
+        %ebx = MOV32i 42
+        %ecx = MOV32i 5
+    testCommands: move(bb(0).insn(0), bb(0).insn(2))
+    ...
+
+The example executes the ``move`` command; taking the first basic block
+(``bb(0)``) and the first instruction in it (``.insn(0)``) and moving it in
+front of the third instruction (``bb(0).insn(2)``).
+
+The list of available functions can be found in the pass implementation in
+:file:`tools/llc/ExecuteTestCommands.cpp`. It is easy to add more functions.
+
 Limitations
 -----------
 
 Currently the MIR format has several limitations in terms of which state it
 can serialize:
 
 - The target-specific state in the target-specific ``MachineFunctionInfo``
   subclasses isn't serialized at the moment.

include/llvm/CodeGen/MIRYamlMapping.h

struct MachineFunction {
   // TODO: Serialize the various register masks.
   // Frame information
   MachineFrameInfo FrameInfo;
   std::vector<FixedMachineStackObject> FixedStackObjects;
   std::vector<MachineStackObject> StackObjects;
   std::vector<MachineConstantPoolValue> Constants; /// Constant pool.
   MachineJumpTable JumpTableInfo;
   BlockStringValue Body;
+  /// The testCommands block is syntactic sugar to produce an llc-test-commands
+  /// function attribute for the llc ExecutTestCommands pass.
+  BlockStringValue TestCommands;
 };
 
 template <> struct MappingTraits<MachineFunction> {
   static void mapping(IO &YamlIO, MachineFunction &MF) {
     YamlIO.mapRequired("name", MF.Name);
     YamlIO.mapOptional("alignment", MF.Alignment);
     YamlIO.mapOptional("exposesReturnsTwice", MF.ExposesReturnsTwice);
     YamlIO.mapOptional("noVRegs", MF.NoVRegs);
     YamlIO.mapOptional("legalized", MF.Legalized);
     YamlIO.mapOptional("regBankSelected", MF.RegBankSelected);
     YamlIO.mapOptional("selected", MF.Selected);
     YamlIO.mapOptional("tracksRegLiveness", MF.TracksRegLiveness);
     YamlIO.mapOptional("registers", MF.VirtualRegisters);
     YamlIO.mapOptional("liveins", MF.LiveIns);
     YamlIO.mapOptional("calleeSavedRegisters", MF.CalleeSavedRegisters);
     YamlIO.mapOptional("frameInfo", MF.FrameInfo);
     YamlIO.mapOptional("fixedStack", MF.FixedStackObjects);
     YamlIO.mapOptional("stack", MF.StackObjects);
     YamlIO.mapOptional("constants", MF.Constants);
     if (!YamlIO.outputting() || !MF.JumpTableInfo.Entries.empty())
       YamlIO.mapOptional("jumpTable", MF.JumpTableInfo);
     YamlIO.mapOptional("body", MF.Body);
+    if (!YamlIO.outputting())
+      YamlIO.mapOptional("testCommands", MF.TestCommands);
   }
 };
 
 } // end namespace yaml
 } // end namespace llvm
 
 #endif

lib/CodeGen/MIRParser/MIRParser.cpp

SMDiagnostic diagFromMIStringDiag(const SMDiagnostic &Error,
                                     SMRange SourceRange);
 
   /// Return a MIR diagnostic converted from a diagnostic located in a YAML
   /// block scalar string.
   SMDiagnostic diagFromBlockStringDiag(const SMDiagnostic &Error,
                                        SMRange SourceRange);
 
   /// Create an empty function with the given name.
-  void createDummyFunction(StringRef Name, Module &M);
+  Function &createDummyFunction(StringRef Name, Module &M);
 
   void initNames2RegClasses(const MachineFunction &MF);
   void initNames2RegBanks(const MachineFunction &MF);
 
   /// Check if the given identifier is a name of a register class.
   ///
   /// Return null if the name isn't a register class.
   const TargetRegisterClass *getRegClass(const MachineFunction &MF,
bool MIRParserImpl::parseMachineFunction(yaml::Input &In, Module &M,
   yaml::EmptyContext Ctx;
   yaml::yamlize(In, *MF, false, Ctx);
   if (In.error())
     return true;
   auto FunctionName = MF->Name;
   if (Functions.find(FunctionName) != Functions.end())
     return error(Twine("redefinition of machine function '") + FunctionName +
                  "'");
-  Functions.insert(std::make_pair(FunctionName, std::move(MF)));
+
+  Function *F;
   if (NoLLVMIR)
-    createDummyFunction(FunctionName, M);
-  else if (!M.getFunction(FunctionName))
+    F = &createDummyFunction(FunctionName, M);
+  else if (!(F = M.getFunction(FunctionName)))
     return error(Twine("function '") + FunctionName +
                  "' isn't defined in the provided LLVM IR");
+
+  // Syntactic sugar for lit/llc tests.
+  const std::string &TestCommands = MF->TestCommands.Value.Value;
+  if (!TestCommands.empty())
+    F->addFnAttr("llc-test-commands", TestCommands);
+
+  Functions.insert(std::make_pair(FunctionName, std::move(MF)));
   return false;
 }
 
-void MIRParserImpl::createDummyFunction(StringRef Name, Module &M) {
+Function &MIRParserImpl::createDummyFunction(StringRef Name, Module &M) {
   auto &Context = M.getContext();
   Function *F = cast<Function>(M.getOrInsertFunction(
       Name, FunctionType::get(Type::getVoidTy(Context), false)));
   BasicBlock *BB = BasicBlock::Create(Context, "entry", F);
   new UnreachableInst(Context, BB);
+  return *F;
 }
 
 static bool isSSA(const MachineFunction &MF) {
   const MachineRegisterInfo &MRI = MF.getRegInfo();
   for (unsigned I = 0, E = MRI.getNumVirtRegs(); I != E; ++I) {
     unsigned Reg = TargetRegisterInfo::index2VirtReg(I);
     if (!MRI.hasOneDef(Reg) && !MRI.def_empty(Reg))
       return false;

test/CodeGen/AMDGPU/handlemove.mir

+# RUN: llc -o - %s -mtriple=amdgcn -verify-machineinstrs -run-pass=execute-test-commands | FileCheck %s
+...
+# CHECK-LABEL: name: MoveUpDef
+# CHECK: S_NOP 0
+# CHECK: early-clobber %0 = IMPLICIT_DEF
+# CHECK: S_NOP 0
+# CHECK: S_NOP 0, implicit %0
+name: MoveUpDef
+body: |
+  bb.0:
+    S_NOP 0
+    S_NOP 0
+    early-clobber %0 : sreg_64 = IMPLICIT_DEF
+    S_NOP 0, implicit %0
+testCommands: move(bb(0).insn(2), bb(0).insn(1))
+---
+...
+# CHECK-LABEL: name: MoveUpRedef
+# CHECK: %0 = IMPLICIT_DEF
+# CHECK: %0 = IMPLICIT_DEF implicit %0(tied-def 0)
+# CHECK: S_NOP 0
+# CHECK: S_NOP 0, implicit %0
+name: MoveUpRedef
+body: |
+  bb.0:
+    %0 : sreg_64 = IMPLICIT_DEF
+    S_NOP 0
+    %0 = IMPLICIT_DEF implicit %0(tied-def 0)
+    S_NOP 0, implicit %0
+testCommands: move(bb(0).insn(2), bb(0).insn(1))
+---
+...
+# CHECK-LABEL: MoveUpEarlyDef
+# CHECK: %0 = IMPLICIT_DEF
+# CHECK: early-clobber %0 = IMPLICIT_DEF implicit %0(tied-def 0)
+# CHECK: S_NOP 0
+# CHECK: S_NOP 0, implicit %0
+name: MoveUpEarlyDef
+body: |
+  bb.0:
+    %0 : sreg_64 = IMPLICIT_DEF
+    S_NOP 0
+    early-clobber %0 = IMPLICIT_DEF implicit %0(tied-def 0)
+    S_NOP 0, implicit %0
+testCommands: move(bb(0).insn(2), bb(0).insn(1))
+---
+...
+# CHECK-LABEL: MoveUpKill
+# CHECK: %0 = IMPLICIT_DEF
+# CHECK: S_NOP 0, implicit %0
+# CHECK: S_NOP 0
+name: MoveUpKill
+body: |
+  bb.0:
+    %0 : sreg_64 = IMPLICIT_DEF
+    S_NOP 0
+    S_NOP 0, implicit %0
+testCommands: move(bb(0).insn(2), bb(0).insn(1))
+---
+...
+# CHECK-LABEL: MoveUpKillFollowing
+# CHECK: %0 = IMPLICIT_DEF
+# CHECK: S_NOP 0, implicit %0
+# CHECK: S_NOP 0
+# CHECK: S_NOP 0, implicit %0
+name: MoveUpKillFollowing
+body: |
+  bb.0:
+    %0 : sreg_64 = IMPLICIT_DEF
+    S_NOP 0
+    S_NOP 0, implicit %0
+    S_NOP 0, implicit %0
+testCommands: move(bb(0).insn(2), bb(0).insn(1))
+---
+...
+# CHECK-LABEL: MoveDownDef
+# CHECK: S_NOP 0
+# CHECK: S_NOP 0
+# CHECK: early-clobber %0 = IMPLICIT_DEF
+# CHECK: S_NOP 0, implicit %0
+name: MoveDownDef
+body: |
+  bb.0:
+    S_NOP 0
+    early-clobber %0 : sreg_64 = IMPLICIT_DEF
+    S_NOP 0
+    S_NOP 0, implicit %0
+testCommands: move(bb(0).insn(1), bb(0).insn(3))
+---
+...
+# CHECK-LABEL: MoveDownRedef
+# CHECK: %0 = IMPLICIT_DEF
+# CHECK: S_NOP 0
+# CHECK: %0 = IMPLICIT_DEF implicit %0(tied-def 0)
+# CHECK: S_NOP 0, implicit %0
+name: MoveDownRedef
+body: |
+  bb.0:
+    %0 : sreg_64 = IMPLICIT_DEF
+    %0 = IMPLICIT_DEF implicit %0(tied-def 0)
+    S_NOP 0
+    S_NOP 0, implicit %0
+testCommands: move(bb(0).insn(1), bb(0).insn(3))
+---
+...
+# CHECK-LABEL: MoveDownEarlyDef
+# CHECK: S_NOP 0
+# CHECK: S_NOP 0
+# CHECK: early-clobber %0 = IMPLICIT_DEF
+# CHECK: S_NOP 0, implicit %0
+name: MoveDownEarlyDef
+body: |
+  bb.0:
+    S_NOP 0
+    early-clobber %0 : sreg_64 = IMPLICIT_DEF
+    S_NOP 0
+    S_NOP 0, implicit %0
+testCommands: move(bb(0).insn(1), bb(0).insn(3))
+---
+...
+# CHECK-LABEL: MoveDownEarlyRedef
+# CHECK: %0 = IMPLICIT_DEF
+# CHECK: S_NOP 0
+# CHECK: early-clobber %0 = IMPLICIT_DEF implicit %0(tied-def 0)
+# CHECK: S_NOP 0, implicit %0
+name: MoveDownEarlyRedef
+body: |
+  bb.0:
+    %0 : sreg_64 = IMPLICIT_DEF
+    early-clobber %0 = IMPLICIT_DEF implicit %0(tied-def 0)
+    S_NOP 0
+    S_NOP 0, implicit %0
+testCommands: move(bb(0).insn(1), bb(0).insn(3))
+---
+...
+# CHECK-LABEL: MoveDownKill
+# CHECK: %0 = IMPLICIT_DEF
+# CHECK: S_NOP 0
+# CHECK: S_NOP 0, implicit %0
+# CHECK: S_NOP 0
+name: MoveDownKill
+body: |
+  bb.0:
+    %0 : sreg_64 = IMPLICIT_DEF
+    S_NOP 0, implicit %0
+    S_NOP 0
+    S_NOP 0
+testCommands: move(bb(0).insn(1), bb(0).insn(3))
+---
+...
+# CHECK-LABEL: MoveDownKillFollowing
+# CHECK: %0 = IMPLICIT_DEF
+# CHECK: S_NOP 0
+# CHECK: S_NOP 0, implicit %0
+# CHECK: S_NOP 0, implicit %0
+name: MoveDownKillFollowing
+body: |
+  bb.0:
+    %0 : sreg_64 = IMPLICIT_DEF
+    S_NOP 0, implicit %0
+    S_NOP 0
+    S_NOP 0, implicit %0
+testCommands: move(bb(0).insn(1), bb(0).insn(3))
+---
+...
+# CHECK-LABEL: MoveUndefUse
+# CHECK: %0 = IMPLICIT_DEF
+# CHECK: S_NOP 0, implicit %0
+# CHECK: S_NOP 0, implicit undef %0
+# CHECK: S_NOP 0
+name: MoveUndefUse
+body: |
+  bb.0:
+    %0 : sreg_64 = IMPLICIT_DEF
+    S_NOP 0, implicit undef %0
+    S_NOP 0, implicit %0
+    S_NOP 0
+testCommands: move(bb(0).insn(1), bb(0).insn(3))
+---
+...
+# CHECK-LABEL: MoveOverUndefUse0
+# CHECK: %0 = IMPLICIT_DEF
+# CHECK: dead %0 = IMPLICIT_DEF implicit %0(tied-def 0)
+# CHECK: S_NOP 0
+# CHECK: S_NOP 0, implicit undef %0
+name: MoveOverUndefUse0
+body: |
+  bb.0:
+    %0 : sreg_64 = IMPLICIT_DEF
+    S_NOP 0
+    S_NOP 0, implicit undef %0
+    %0 = IMPLICIT_DEF implicit %0(tied-def 0)
+testCommands: move(bb(0).insn(3), bb(0).insn(1))
+---
+...
+# CHECK-LABEL: MoveOverUndefUse1
+# CHECK: %sgpr0 = IMPLICIT_DEF
+# CHECK: %sgpr0 = IMPLICIT_DEF implicit %sgpr0(tied-def 0)
+# CHECK: S_NOP 0
+# CHECK: S_NOP 0, implicit undef %sgpr0
+name: MoveOverUndefUse1
+body: |
+  bb.0:
+    %sgpr0 = IMPLICIT_DEF
+    S_NOP 0
+    S_NOP 0, implicit undef %sgpr0
+    %sgpr0 = IMPLICIT_DEF implicit %sgpr0(tied-def 0)
+testCommands: move(bb(0).insn(3), bb(0).insn(1))
+...
+---
+# CHECK-LABEL: MoveUpValNos
+# CHECK: %0 = IMPLICIT_DEF implicit %0(tied-def 0)
+# CHECK-NEXT: %0 = IMPLICIT_DEF implicit %0(tied-def 0)
+# CHECK-NEXT: %0 = IMPLICIT_DEF implicit %0(tied-def 0)
+name: MoveUpValNos
+body: |
+  bb.0:
+    successors: %bb.1, %bb.2
+    %0 : sreg_64 = IMPLICIT_DEF
+    S_CBRANCH_VCCNZ %bb.1, implicit undef %vcc
+    S_BRANCH %bb.2
+  bb.1:
+    S_NOP 0, implicit %0
+  bb.2:
+    successors: %bb.1
+    %0 = IMPLICIT_DEF implicit %0(tied-def 0)
+    %0 = IMPLICIT_DEF implicit %0(tied-def 0)
+    %0 = IMPLICIT_DEF implicit %0(tied-def 0)
+    S_BRANCH %bb.1
+
+  bb.3:
+
+testCommands: move(bb(2).insn(2), bb(2).insn(0))
+...
+---
+# CHECK-LABEL: SubRegMoveDown
+# CHECK: S_NOP 0, implicit %0.sub0
+# CHECK-NEXT: S_NOP 0
+# CHECK-NEXT: %0.sub0 = IMPLICIT_DEF
+# CHECK-NEXT: S_NOP 0, implicit %0.sub1
+# CHECK-NEXT: %0.sub1 = IMPLICIT_DEF
+name: SubRegMoveDown
+body: |
+  bb.0:
+    successors: %bb.1, %bb.2
+    %0 : sreg_64 = IMPLICIT_DEF
+    S_CBRANCH_VCCNZ %bb.1, implicit undef %vcc
+    S_BRANCH %bb.2
+  bb.1:
+    successors: %bb.2
+    S_NOP 0, implicit %0.sub0
+    S_NOP 0, implicit %0.sub1
+    S_NOP 0
+    undef %0.sub0 = IMPLICIT_DEF
+    %0.sub1 = IMPLICIT_DEF
+  bb.2:
+    S_NOP 0, implicit %0
+
+testCommands: |
+    bb(1).insn(3).setIsUndef(0, 0)
+    ; The scheduler is in the situation where we compute liveness with the
+    ; undef flag present, but then clear it.
+    move(bb(1).insn(1), bb(1).insn(4))
+...

tools/llc/CMakeLists.txt

set(LLVM_LINK_COMPONENTS
   TransformUtils
   Vectorize
   )
 
 # Support plugins.
 set(LLVM_NO_DEAD_STRIP 1)
 
 add_llvm_tool(llc
+  ExecuteTestCommands.cpp
+  TestCommands.cpp
   llc.cpp
 
   DEPENDS
   intrinsics_gen
   )
 export_executable_symbols(llc)

tools/llc/ExecuteTestCommands.h

+//===- ExecuteTestCommands.h - Test Command Execution Pass ------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#ifndef LLVM_LLC_EXECUTETESTCOMMANDS_H
+#define LLVM_LLC_EXECUTETESTCOMMANDS_H
+
+namespace llvm {
+class PassRegistry;
+
+void initializeExecuteTestCommandsPass(PassRegistry &Registry);
+} // End llvm namespace
+
+#endif

tools/llc/ExecuteTestCommands.cpp

+//===-- ExecuteTestCommands.cpp - Test Command Execution Pass -------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+/// \file Implements a that executes a simple scripting language to perform
+/// user specified transformation on a machine function. This enables testing
+/// of single transformation APIs without relying on a complete pass with
+/// related anlysis.
+///
+/// The supported functions in a script can be found in \see ScriptFunctions.
+///
+/// This is how to add a new function:
+///
+/// - Implement the new function (look for "ScriptFunctions" in this file)
+/// - If it does not exist, implement a call_XXX marshalling function matching
+///   the return and argument types of your function.
+/// - Add the function to executeFunction()
+//
+//===----------------------------------------------------------------------===//
+
+#include "ExecuteTestCommands.h"
+
+#include "TestCommands.h"
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/CodeGen/LiveIntervalAnalysis.h"
+#include "llvm/CodeGen/MachineFunctionPass.h"
+#include "llvm/Pass.h"
+#include "llvm/PassRegistry.h"
+#include "llvm/Support/Debug.h"
+
+#define DEBUG_TYPE "execute-test-commands"
+
+using namespace llvm::testcommands;
+using namespace llvm;
+
+namespace {
+
+using Value = llvm::testcommands::Value;
+
+/// Pass that executes simple user provided commands on a machine function.
+class ExecuteTestCommands : public MachineFunctionPass {
+public:
+  static char ID;
+  ExecuteTestCommands() : MachineFunctionPass(ID) {}
+
+  StringRef getPassName() const override { return "Execute Test Commands"; }
+
+  void getAnalysisUsage(AnalysisUsage &AU) const override {
+    AU.setPreservesCFG();
+    AU.addRequired<LiveIntervals>();
+    AU.addPreserved<LiveIntervals>();
+    AU.addPreserved<SlotIndexes>();
+    MachineFunctionPass::getAnalysisUsage(AU);
+  }
+
+  bool runOnMachineFunction(MachineFunction &MF) override;
+};
+
+char ExecuteTestCommands::ID;
+
+bool executeFunction(ExecContext &Context, StringRef FunctionName,
+                     ArrayRef<Value> Args) {
+  FuncMap::iterator I = Funcs.find(FunctionName);
+  if (I == Funcs.end()) {
+    errs() << "Error: Unknown function \"" << FunctionName << "\"\n";
+    return false;
+  }
+
+  CallableFunc Func = I->second;
+  return Func(Context, FunctionName, Args);
+}
+
+/// \defgroup ParsingHelpers   Helper functions to facility parsing.
+/// The functions detect elements at the beginning of the Input StringRef
+/// parameter and update the StringRef to a later position when consuming the
+/// input. Elements are separated by spaces, all parsing functions skip spaces
+/// before looking for the elements.
+/// The tryXXX() functions check for a given sequence and if it is present
+/// consume it and return true, otherwise false.
+/// The expectXXX() functions check for a given sequence and if it is present
+/// consume it and return true, otherwise they print and error message and
+/// return false.
+/// \{
+
+/// Advances \p Input until it points past whitespace and comments.
+void skipWS(StringRef &Input) {
+  Input = Input.ltrim();
+  // Skip comment
+  if (!Input.empty() && Input[0] == ';') {
+    Input = Input.drop_until([](char c) { return c == '\n'; });
+    if (!Input.empty())
+      Input = Input.drop_front(1); // skip '\n'
+  }
+}
+
+bool tryIdentifier(StringRef &Input, StringRef &Result) {
+  skipWS(Input);
+  Result = Input.take_while([](char c) {
+    return ('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z') || c == '_';
+  });
+  if (Result.empty())
+    return false;
+  Input = Input.drop_front(Result.size());
+  return true;
+}
+
+bool tryNumber(StringRef &Input, unsigned &Result) {
+  skipWS(Input);
+  unsigned long long a0;
+  if (consumeUnsignedInteger(Input, 10, a0))
+    return false;
+  Result = (unsigned)a0;
+  if ((unsigned long long)Result != a0) {
+    errs() << "Number overflow\n";
+    return false;
+  }
+  return true;
+}
+
+bool tryChar(StringRef &Input, char C) {
+  skipWS(Input);
+  if (Input.empty() || Input[0] != C)
+    return false;
+  Input = Input.drop_front(1);
+  return true;
+}
+
+bool expectChar(StringRef &Input, char C) {
+  if (!tryChar(Input, C)) {
+    errs() << "Expected '" << C << "', got \"" << Input << "\"\n";
+    return false;
+  }
+  return true;
+}
+
+/// \}
+
+bool parseExpression(ExecContext &Context, StringRef &Input);
+
+bool tryCallExpression(ExecContext &Context, StringRef &Input, Value FirstArg,
+                       bool &Found) {
+  StringRef FunctionName;
+  if (!tryIdentifier(Input, FunctionName)) {
+    Found = false;
+    return true;
+  }
+  Found = true;
+  if (!expectChar(Input, '('))
+    return false;
+
+  SmallVector<Value, 4> Args;
+  if (!FirstArg.is<void>())
+    Args.push_back(FirstArg);
+
+  while (!tryChar(Input, ')')) {
+    if (!parseExpression(Context, Input))
+      return false;
+    Args.push_back(Context.Result);
+    tryChar(Input, ',');
+  }
+
+  if (!executeFunction(Context, FunctionName, Args))
+    return false;
+
+  if (tryChar(Input, '.')) {
+    bool Found;
+    if (!tryCallExpression(Context, Input, Context.Result, Found))
+      return false;
+    if (!Found) {
+      errs() << "Expect call after '.'\n";
+      return false;
+    }
+  }
+
+  return true;
+}
+
+bool parseExpression(ExecContext &Context, StringRef &Input) {
+  bool Found;
+  if (!tryCallExpression(Context, Input, Value::make(), Found))
+    return false;
+  if (Found)
+    return true;
+  unsigned Number;
+  if (tryNumber(Input, Number)) {
+    Context.Result = Value::make<unsigned>(Number);
+    return true;
+  }
+  errs() << "Expected expression, got \"" << Input << "\"\n";
+  return false;
+}
+
+bool ExecuteTestCommands::runOnMachineFunction(MachineFunction &MF) {
+  const llvm::Function &F = *MF.getFunction();
+  if (!F.hasFnAttribute("llc-test-commands")) {
+    errs() << "Warning: No test commands for function " << MF.getName() << '\n';
+    return false;
+  }
+  StringRef Commands = F.getFnAttribute("llc-test-commands").getValueAsString();
+
+  DEBUG(dbgs() << "Execute commands on function " << MF.getName() << ":\n"
+        << Commands << '\n');
+
+  ExecContext Context(MF, getAnalysis<LiveIntervals>());
+  StringRef Input = Commands;
+  while (!Input.empty()) {
+    StringRef Begin = Input;
+    if (!parseExpression(Context, Input)) {
+      skipWS(Begin);
+      errs() << "While parsing '" << Begin << "'\n";
+      break;
+    }
+  }
+  return true;
+}
+
+} // end anonymous namespace
+
+INITIALIZE_PASS_BEGIN(ExecuteTestCommands, "execute-test-commands",
+                      "Execute Test Commands", false, false)
+INITIALIZE_PASS_DEPENDENCY(LiveIntervals)
+INITIALIZE_PASS_END(ExecuteTestCommands, "execute-test-commands",
+                    "Execute Test Commands", false, false)

tools/llc/TestCommands.h

+//===- TestCommands.h - Test Command Definition Tools -----------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+/// \file Provides tools to implement test commands.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/CodeGen/LiveIntervalAnalysis.h"
+#include "llvm/CodeGen/MachineBasicBlock.h"
+#include "llvm/CodeGen/MachineOperand.h"
+
+namespace llvm {
+namespace testcommands {
+
+/// A dynamically typed value.
+struct Value {
+public:
+  Value() = delete;
+  /// Creates a new Value with type \p T.
+  template<typename T> static Value make(T Val);
+  /// Creates a new Value with type void.
+  static Value make() { return Value(VOID); }
+  /// Returns true if dynamic value is of type \p T.
+  template<typename T> bool is() const;
+  /// Returns stored value. Undefined if stored value does not have type \p T.
+  template<typename T> T get() const;
+
+private:
+  enum Type { UNSIGNED, MACHINE_INSTR, MACHINE_BASIC_BLOCK, VOID };
+  Value(Type ValueType) : ValueType(ValueType) {}
+  Type ValueType;
+  union ValueData {
+    unsigned Number;
+    MachineInstr *MI;
+    MachineBasicBlock *MBB;
+  } D;
+};
+
+template<> inline Value Value::make<unsigned>(unsigned Val) {
+  Value Res(UNSIGNED);
+  Res.D.Number = Val;
+  return Res;
+}
+template<> inline Value
+Value::make<MachineBasicBlock&>(MachineBasicBlock &Val) {
+  Value Res(MACHINE_BASIC_BLOCK);
+  Res.D.MBB = &Val;
+  return Res;
+}
+template<> inline Value Value::make<MachineInstr&>(MachineInstr &Val) {
+  Value Res(MACHINE_INSTR);
+  Res.D.MI = &Val;
+  return Res;
+}
+
+template<> inline bool Value::is<void>() const { return ValueType == VOID; }
+template<> inline bool Value::is<unsigned>() const {
+  return ValueType == UNSIGNED;
+}
+template<> inline bool Value::is<MachineBasicBlock&>() const {
+  return ValueType == MACHINE_BASIC_BLOCK;
+}
+template<> inline bool Value::is<MachineInstr&>() const {
+  return ValueType == MACHINE_INSTR;
+}
+
+template<> inline unsigned Value::get<unsigned>() const {
+  assert(is<unsigned>());
+  return D.Number;
+}
+template<> inline MachineBasicBlock &Value::get<MachineBasicBlock&>() const {
+  assert(is<MachineBasicBlock&>());
+  return *D.MBB;
+}
+template<> inline MachineInstr &Value::get<MachineInstr&>() const {
+  assert(is<MachineInstr&>());
+  return *D.MI;
+}
+
+/// Execution context for the scripting language.
+struct ExecContext {
+  ExecContext(MachineFunction &MF, LiveIntervals &LIS)
+    : MF(MF), LIS(LIS), Result(Value::make()) {}
+  MachineFunction &MF;
+  LiveIntervals &LIS;
+
+  /// Used to store the result after executing an expression.
+  Value Result;
+};
+
+/// \defgroup marshalling Marshalling support.
+/// \{
+
+template<typename ResT>
+ResT callArgs(ResT(*Func)(ExecContext&), ExecContext &Context,
+              ArrayRef<Value> Args) {
+  return Func(Context);
+}
+template<typename ResT, typename T0>
+ResT callArgs(ResT(*Func)(ExecContext&,T0), ExecContext &Context,
+              ArrayRef<Value> Args) {
+  return Func(Context, Args[0].get<T0>());
+}
+template<typename ResT, typename T0, typename T1>
+ResT callArgs(ResT(*Func)(ExecContext&,T0,T1), ExecContext &Context,
+              ArrayRef<Value> Args) {
+  return Func(Context, Args[0].get<T0>(), Args[1].get<T1>());
+}
+template<typename ResT, typename T0, typename T1, typename T2>
+ResT callArgs(ResT(*Func)(ExecContext&,T0,T1,T2), ExecContext &Context,
+              ArrayRef<Value> Args) {
+  return Func(Context, Args[0].get<T0>(), Args[1].get<T1>(), Args[2].get<T2>());
+}
+// Add more callArgs variants as needed. Or find a solution that works with
+// variadic templates/parameter packs if you can :)
+
+template<typename ResT, typename... ArgTs>
+struct callSetResult {
+  static void call(ResT(*Func)(ExecContext&, ArgTs...), ExecContext &Context,
+                   ArrayRef<Value> Args) {
+    ResT Result = callArgs<ResT, ArgTs...>(Func, Context, Args);
+    Context.Result = Value::make<ResT>(Result);
+  }
+};
+template<typename... ArgTs>
+struct callSetResult<void, ArgTs...> {
+  static void call(void(*Func)(ExecContext&, ArgTs...), ExecContext &Context,
+                   ArrayRef<Value> Args) {
+    callArgs<void, ArgTs...>(Func, Context, Args);
+    Context.Result = Value::make();
+  }
+};
+
+typedef bool (*CallableFunc)(ExecContext &Context, StringRef Name,
+                             ArrayRef<Value> Args);
+typedef std::map<StringRef, CallableFunc> FuncMap;
+extern FuncMap Funcs;
+
+template<typename FuncT> struct Function; ///< undefined.
+
+template<typename ResT, typename... ArgTs>
+struct Function<ResT(ArgTs...)> {
+  template<ResT(*Func)(ExecContext&,ArgTs...)>
+  struct Register {
+    /// Creates new Callable helper and registers it with the global map of
+    /// available functions.
+    Register(StringRef Name) {
+      Funcs.insert(std::make_pair(Name, checkAndCall));
+    }
+    static bool checkAndCall(ExecContext &Context, StringRef Name,
+                             ArrayRef<Value> Args) {
+      // Check number of arguments.
+      const unsigned NArgs = sizeof...(ArgTs);
+      if (Args.size() != NArgs) {
+        errs() << "Function '" << Name << " expects " << NArgs
+               << " arguments, got " << Args.size() << '\n';
+        return false;
+      }
+      // Check argument types.
+      unsigned N = 0;
+      bool TypeChecks[] = { (Args[N++].is<ArgTs>())... };
+      for (bool C : TypeChecks) {
+        if (!C) {
+          errs() << "Arguments for function '" << Name
+                 << "' have the wrong type\n";
+          return false;
+        }
+      }
+      callSetResult<ResT, ArgTs...>::call(Func, Context, Args);
+      return true;
+    }
+  };
+};
+
+/// \}
+
+} // end namespace testcommands
+} // end namespace llvm

tools/llc/TestCommands.cpp

+//===-- TestCommands.cpp - Test Commands ----------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+/// \file Implements commands available to the ExecuteTestCommands pass.
+//
+//===----------------------------------------------------------------------===//
+
+#include "TestCommands.h"
+
+#include "llvm/ADT/Twine.h"
+#include "llvm/Support/Debug.h"
+#include "llvm/Support/ErrorHandling.h"
+
+#define DEBUG_TYPE "execute-test-commands"
+
+namespace llvm {
+namespace testcommands {
+
+FuncMap Funcs;
+
+/// @defgroup ScriptFunctions
+/// Functions available for calling from scripts.
+/// \{
+
+/// Returns machine basic block with number \p N.
+MachineBasicBlock &bb(ExecContext &Context, unsigned N) {
+  DEBUG(dbgs() << "bb(" << N << ")\n");
+  if (N > Context.MF.getNumBlockIDs())
+    report_fatal_error(Twine("Invalid block index ") + Twine(N));
+  return *Context.MF.getBlockNumbered(N);
+}
+Function<MachineBasicBlock&(unsigned)>::Register<bb> bbFunc("bb");
+
+/// Returns instruction number \p N (counting from 0) in machine basic block
+/// \p MBB.
+MachineInstr &insn(ExecContext &Context, MachineBasicBlock &MBB, unsigned N) {
+  DEBUG(dbgs() << "insn(" << N << ")\n");
+  unsigned I = 0;
+  for (MachineInstr &MI : MBB) {
+    if (I == N)
+      return MI;
+    ++I;
+  }
+  report_fatal_error(Twine("Invalid instructio index ") + Twine(N));
+}
+Function<MachineInstr&(MachineBasicBlock&,unsigned)>::Register<insn>
+insnFunc("insn");
+
+/// Sets the undef flag on machine operand number \p OperandNum of MachineInstr
+/// \p MI to value \p Val.
+void setIsUndef(ExecContext &Context, MachineInstr &MI, unsigned OperandNum,
+                unsigned Val) {
+  DEBUG(dbgs() << "setIsUndef(" << MI << ", " << OperandNum << ","
+        << (Val ? "true" : "false") << ")\n");
+  MI.getOperand(OperandNum).setIsUndef(Val);
+}
+Function<void(MachineInstr&,unsigned,unsigned)>::Register<setIsUndef>
+setIsUndefFunc("setIsUndef");
+
+/// Moves instruction \p From in front of instruction \p To and updates
+/// liveness information with LiveIntervalAnalysis::handleMove().
+void move(ExecContext &Context, MachineInstr &From, MachineInstr &To) {
+  DEBUG(dbgs() << "move:\n"
+        << "\tInstruction: " << From
+        << "\tto Before: " << To);
+
+  MachineBasicBlock &MBB = *From.getParent();
+  if (To.getParent() != &MBB)
+    report_fatal_error("Arguments to move must be in the same block");
+  // Move the instruction.
+  MBB.splice(To.getIterator(), &MBB, From.getIterator());
+  // Update liveness with handleMove().
+  Context.LIS.handleMove(From, true);
+}
+Function<void(MachineInstr&,MachineInstr&)>::Register<move> moveFunc("move");
+
+/// \}
+
+} // end namespace testcommands
+} // end namespace llvm

tools/llc/llc.cpp

 //===-- llc.cpp - Implement the LLVM Native Code Generator ----------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This is the llc code generator driver. It provides a convenient
 // command-line interface for generating native assembly-language code
 // or C code, given LLVM bitcode.
 //
 //===----------------------------------------------------------------------===//
 
-
+#include "ExecuteTestCommands.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/Analysis/TargetLibraryInfo.h"
 #include "llvm/CodeGen/CommandFlags.h"
 #include "llvm/CodeGen/LinkAllAsmWriterComponents.h"
 #include "llvm/CodeGen/LinkAllCodegenComponents.h"
 #include "llvm/CodeGen/MIRParser/MIRParser.h"
 #include "llvm/CodeGen/MachineFunctionPass.h"
int main(int argc, char **argv) {
   initializeCodeGen(*Registry);
   initializeLoopStrengthReducePass(*Registry);
   initializeLowerIntrinsicsPass(*Registry);
   initializeCountingFunctionInserterPass(*Registry);
   initializeUnreachableBlockElimLegacyPassPass(*Registry);
   initializeConstantHoistingLegacyPassPass(*Registry);
   initializeScalarOpts(*Registry);
   initializeVectorization(*Registry);
+  initializeExecuteTestCommandsPass(*Registry);
 
   // Register the target printer for --version.
   cl::AddExtraVersionPrinter(TargetRegistry::printRegisteredTargetsForVersion);
 
   cl::ParseCommandLineOptions(argc, argv, "llvm system compiler\n");
 
   Context.setDiscardValueNames(DiscardValueNames);
 

unittests/MI/LiveIntervalTest.cpp

-#include "gtest/gtest.h"
-#include "llvm/ADT/STLExtras.h"
-#include "llvm/CodeGen/LiveIntervalAnalysis.h"
-#include "llvm/CodeGen/MIRParser/MIRParser.h"
-#include "llvm/CodeGen/MachineFunction.h"
-#include "llvm/CodeGen/MachineModuleInfo.h"
-#include "llvm/CodeGen/MachineRegisterInfo.h"
-#include "llvm/CodeGen/Passes.h"
-#include "llvm/Support/MemoryBuffer.h"
-#include "llvm/Support/SourceMgr.h"
-#include "llvm/Support/TargetRegistry.h"
-#include "llvm/Support/TargetSelect.h"
-#include "llvm/Target/TargetMachine.h"
-#include "llvm/Target/TargetOptions.h"
-#include "llvm/Target/TargetRegisterInfo.h"
-#include "llvm/IR/LegacyPassManager.h"
-
-using namespace llvm;
-
-namespace llvm {
-  void initializeTestPassPass(PassRegistry &);
-}
-
-namespace {
-
-void initLLVM() {
-  InitializeAllTargets();
-  InitializeAllTargetMCs();
-  InitializeAllAsmPrinters();
-  InitializeAllAsmParsers();
-
-  PassRegistry *Registry = PassRegistry::getPassRegistry();
-  initializeCore(*Registry);
-  initializeCodeGen(*Registry);
-}
-
-/// Create a TargetMachine. As we lack a dedicated always available target for
-/// unittests, we go for "AMDGPU" to be able to test normal and subregister
-/// liveranges.
-std::unique_ptr<TargetMachine> createTargetMachine() {
-  Triple TargetTriple("amdgcn--");
-  std::string Error;
-  const Target *T = TargetRegistry::lookupTarget("", TargetTriple, Error);
-  if (!T)
-    return nullptr;
-
-  TargetOptions Options;
-  return std::unique_ptr<TargetMachine>(
-      T->createTargetMachine("AMDGPU", "", "", Options, None,
-                             CodeModel::Default, CodeGenOpt::Aggressive));
-}
-
-std::unique_ptr<Module> parseMIR(LLVMContext &Context,
-    legacy::PassManagerBase &PM, std::unique_ptr<MIRParser> &MIR,
-    const TargetMachine &TM, StringRef MIRCode, const char *FuncName) {
-  SMDiagnostic Diagnostic;
-  std::unique_ptr<MemoryBuffer> MBuffer = MemoryBuffer::getMemBuffer(MIRCode);
-  MIR = createMIRParser(std::move(MBuffer), Context);
-  if (!MIR)
-    return nullptr;
-
-  std::unique_ptr<Module> M = MIR->parseLLVMModule();
-  if (!M)
-    return nullptr;
-
-  M->setDataLayout(TM.createDataLayout());
-
-  Function *F = M->getFunction(FuncName);
-  if (!F)
-    return nullptr;
-
-  MachineModuleInfo *MMI = new MachineModuleInfo(&TM);
-  MMI->setMachineFunctionInitializer(MIR.get());
-  PM.add(MMI);
-
-  return M;
-}
-
-typedef std::function<void(MachineFunction&,LiveIntervals&)> LiveIntervalTest;
-
-struct TestPass : public MachineFunctionPass {
-  static char ID;
-  TestPass() : MachineFunctionPass(ID) {
-    // We should never call this but always use PM.add(new TestPass(...))
-    abort();
-  }
-  TestPass(LiveIntervalTest T) : MachineFunctionPass(ID), T(T) {
-    initializeTestPassPass(*PassRegistry::getPassRegistry());
-  }
-
-  bool runOnMachineFunction(MachineFunction &MF) override {
-    LiveIntervals &LIS = getAnalysis<LiveIntervals>();
-    T(MF, LIS);
-    EXPECT_TRUE(MF.verify(this));
-    return true;
-  }
-
-  void getAnalysisUsage(AnalysisUsage &AU) const override {
-    AU.setPreservesAll();
-    AU.addRequired<LiveIntervals>();
-    AU.addPreserved<LiveIntervals>();
-    MachineFunctionPass::getAnalysisUsage(AU);
-  }
-private:
-  LiveIntervalTest T;
-};
-
-static MachineInstr &getMI(MachineFunction &MF, unsigned At,
-                           unsigned BlockNum) {
-  MachineBasicBlock &MBB = *MF.getBlockNumbered(BlockNum);
-
-  unsigned I = 0;
-  for (MachineInstr &MI : MBB) {
-    if (I == At)
-      return MI;
-    ++I;
-  }
-  llvm_unreachable("Instruction not found");
-}
-
-/**
- * Move instruction number \p From in front of instruction number \p To and
- * update affected liveness intervals with LiveIntervalAnalysis::handleMove().
- */
-static void testHandleMove(MachineFunction &MF, LiveIntervals &LIS,
-                           unsigned From, unsigned To, unsigned BlockNum = 0) {
-  MachineInstr &FromInstr = getMI(MF, From, BlockNum);
-  MachineInstr &ToInstr = getMI(MF, To, BlockNum);
-
-  MachineBasicBlock &MBB = *FromInstr.getParent();
-  MBB.splice(ToInstr.getIterator(), &MBB, FromInstr.getIterator());
-  LIS.handleMove(FromInstr, true);
-}
-
-static void liveIntervalTest(StringRef MIRFunc, LiveIntervalTest T) {
-  LLVMContext Context;
-  std::unique_ptr<TargetMachine> TM = createTargetMachine();
-  // This test is designed for the X86 backend; stop if it is not available.
-  if (!TM)
-    return;
-
-  legacy::PassManager PM;
-
-  SmallString<160> S;
-  StringRef MIRString = (Twine(R"MIR(
----
-...
-name: func
-registers:
-  - { id: 0, class: sreg_64 }
-body: |
-  bb.0:
-)MIR") + Twine(MIRFunc) + Twine("...\n")).toNullTerminatedStringRef(S);
-  std::unique_ptr<MIRParser> MIR;
-  std::unique_ptr<Module> M = parseMIR(Context, PM, MIR, *TM, MIRString,
-                                       "func");
-
-  PM.add(new TestPass(T));
-
-  PM.run(*M);
-}
-
-} // End of anonymous namespace.
-
-char TestPass::ID = 0;
-INITIALIZE_PASS(TestPass, "testpass", "testpass", false, false)
-
-TEST(LiveIntervalTest, MoveUpDef) {
-  // Value defined.
-  liveIntervalTest(R"MIR(
-    S_NOP 0
-    S_NOP 0
-    early-clobber %0 = IMPLICIT_DEF
-    S_NOP 0, implicit %0
-)MIR", [](MachineFunction &MF, LiveIntervals &LIS) {
-    testHandleMove(MF, LIS, 2, 1);
-  });
-}
-
-TEST(LiveIntervalTest, MoveUpRedef) {
-  liveIntervalTest(R"MIR(
-    %0 = IMPLICIT_DEF
-    S_NOP 0
-    %0 = IMPLICIT_DEF implicit %0(tied-def 0)
-    S_NOP 0, implicit %0
-)MIR", [](MachineFunction &MF, LiveIntervals &LIS) {
-    testHandleMove(MF, LIS, 2, 1);
-  });
-}
-
-TEST(LiveIntervalTest, MoveUpEarlyDef) {
-  liveIntervalTest(R"MIR(
-    S_NOP 0
-    S_NOP 0
-    early-clobber %0 = IMPLICIT_DEF
-    S_NOP 0, implicit %0
-)MIR", [](MachineFunction &MF, LiveIntervals &LIS) {
-    testHandleMove(MF, LIS, 2, 1);
-  });
-}
-
-TEST(LiveIntervalTest, MoveUpEarlyRedef) {
-  liveIntervalTest(R"MIR(
-    %0 = IMPLICIT_DEF
-    S_NOP 0
-    early-clobber %0 = IMPLICIT_DEF implicit %0(tied-def 0)
-    S_NOP 0, implicit %0
-)MIR", [](MachineFunction &MF, LiveIntervals &LIS) {
-    testHandleMove(MF, LIS, 2, 1);
-  });
-}
-
-TEST(LiveIntervalTest, MoveUpKill) {
-  liveIntervalTest(R"MIR(
-    %0 = IMPLICIT_DEF
-    S_NOP 0
-    S_NOP 0, implicit %0
-)MIR", [](MachineFunction &MF, LiveIntervals &LIS) {
-    testHandleMove(MF, LIS, 2, 1);
-  });
-}
-
-TEST(LiveIntervalTest, MoveUpKillFollowing) {
-  liveIntervalTest(R"MIR(
-    %0 = IMPLICIT_DEF
-    S_NOP 0
-    S_NOP 0, implicit %0
-    S_NOP 0, implicit %0
-)MIR", [](MachineFunction &MF, LiveIntervals &LIS) {
-    testHandleMove(MF, LIS, 2, 1);
-  });
-}
-
-// TODO: Construct a situation where we have intervals following a hole
-// while still having connected components.
-
-TEST(LiveIntervalTest, MoveDownDef) {
-  // Value defined.
-  liveIntervalTest(R"MIR(
-    S_NOP 0
-    early-clobber %0 = IMPLICIT_DEF
-    S_NOP 0
-    S_NOP 0, implicit %0
-)MIR", [](MachineFunction &MF, LiveIntervals &LIS) {
-    testHandleMove(MF, LIS, 1, 2);
-  });
-}
-
-TEST(LiveIntervalTest, MoveDownRedef) {
-  liveIntervalTest(R"MIR(
-    %0 = IMPLICIT_DEF
-    %0 = IMPLICIT_DEF implicit %0(tied-def 0)
-    S_NOP 0
-    S_NOP 0, implicit %0
-)MIR", [](MachineFunction &MF, LiveIntervals &LIS) {
-    testHandleMove(MF, LIS, 1, 2);
-  });
-}
-
-TEST(LiveIntervalTest, MoveDownEarlyDef) {
-  liveIntervalTest(R"MIR(
-    S_NOP 0
-    early-clobber %0 = IMPLICIT_DEF
-    S_NOP 0
-    S_NOP 0, implicit %0
-)MIR", [](MachineFunction &MF, LiveIntervals &LIS) {
-    testHandleMove(MF, LIS, 1, 2);
-  });
-}
-
-TEST(LiveIntervalTest, MoveDownEarlyRedef) {
-  liveIntervalTest(R"MIR(
-    %0 = IMPLICIT_DEF
-    early-clobber %0 = IMPLICIT_DEF implicit %0(tied-def 0)
-    S_NOP 0
-    S_NOP 0, implicit %0
-)MIR", [](MachineFunction &MF, LiveIntervals &LIS) {
-    testHandleMove(MF, LIS, 1, 2);
-  });
-}
-
-TEST(LiveIntervalTest, MoveDownKill) {
-  liveIntervalTest(R"MIR(
-    %0 = IMPLICIT_DEF
-    S_NOP 0, implicit %0
-    S_NOP 0
-)MIR", [](MachineFunction &MF, LiveIntervals &LIS) {
-    testHandleMove(MF, LIS, 1, 2);
-  });
-}
-
-TEST(LiveIntervalTest, MoveDownKillFollowing) {
-  liveIntervalTest(R"MIR(
-    %0 = IMPLICIT_DEF
-    S_NOP 0
-    S_NOP 0, implicit %0
-    S_NOP 0, implicit %0
-)MIR", [](MachineFunction &MF, LiveIntervals &LIS) {
-    testHandleMove(MF, LIS, 1, 2);
-  });
-}
-
-TEST(LiveIntervalTest, MoveUndefUse) {
-  liveIntervalTest(R"MIR(
-    %0 = IMPLICIT_DEF
-    S_NOP 0, implicit undef %0
-    S_NOP 0, implicit %0
-    S_NOP 0
-)MIR", [](MachineFunction &MF, LiveIntervals &LIS) {
-    testHandleMove(MF, LIS, 1, 3);
-  });
-}
-
-TEST(LiveIntervalTest, MoveUpValNos) {
-  // handleMoveUp() had a bug where it would reuse the value number of the
-  // destination segment, even though we have no guarntee that this valno wasn't
-  // used in other segments.
-  liveIntervalTest(R"MIR(
-    successors: %bb.1, %bb.2
-    %0 = IMPLICIT_DEF
-    S_CBRANCH_VCCNZ %bb.2, implicit undef %vcc
-    S_BRANCH %bb.1
-  bb.2:
-    S_NOP 0, implicit %0
-  bb.1:
-    successors: %bb.2
-    %0 = IMPLICIT_DEF implicit %0(tied-def 0)
-    %0 = IMPLICIT_DEF implicit %0(tied-def 0)
-    %0 = IMPLICIT_DEF implicit %0(tied-def 0)
-    S_BRANCH %bb.2
-)MIR", [](MachineFunction &MF, LiveIntervals &LIS) {
-    testHandleMove(MF, LIS, 2, 0, 2);
-  });
-}
-
-TEST(LiveIntervalTest, MoveOverUndefUse0) {
-  // findLastUseBefore() used by handleMoveUp() must ignore undef operands.
-  liveIntervalTest(R"MIR(
-    %0 = IMPLICIT_DEF
-    S_NOP 0
-    S_NOP 0, implicit undef %0
-    %0 = IMPLICIT_DEF implicit %0(tied-def 0)
-)MIR", [](MachineFunction &MF, LiveIntervals &LIS) {
-    testHandleMove(MF, LIS, 3, 1);
-  });
-}
-
-TEST(LiveIntervalTest, MoveOverUndefUse1) {
-  // findLastUseBefore() used by handleMoveUp() must ignore undef operands.
-  liveIntervalTest(R"MIR(
-    %sgpr0 = IMPLICIT_DEF
-    S_NOP 0
-    S_NOP 0, implicit undef %sgpr0
-    %sgpr0 = IMPLICIT_DEF implicit %sgpr0(tied-def 0)
-)MIR", [](MachineFunction &MF, LiveIntervals &LIS) {
-    testHandleMove(MF, LIS, 3, 1);
-  });
-}
-
-TEST(LiveIntervalTest, SubRegMoveDown) {
-  // Subregister ranges can have holes inside a basic block. Check for a
-  // movement of the form 32->150 in a liverange [16, 32) [100,200).
-  liveIntervalTest(R"MIR(
-    successors: %bb.1, %bb.2
-    %0 = IMPLICIT_DEF
-    S_CBRANCH_VCCNZ %bb.2, implicit undef %vcc
-    S_BRANCH %bb.1
-  bb.2:
-    successors: %bb.1
-    S_NOP 0, implicit %0.sub0
-    S_NOP 0, implicit %0.sub1
-    S_NOP 0
-    undef %0.sub0 = IMPLICIT_DEF
-    %0.sub1 = IMPLICIT_DEF
-  bb.1:
-    S_NOP 0, implicit %0
-)MIR", [](MachineFunction &MF, LiveIntervals &LIS) {
-    // Scheduler behaviour: Clear def,read-undef flag and move.
-    MachineInstr &MI = getMI(MF, 3, /*BlockNum=*/1);
-    MI.getOperand(0).setIsUndef(false);
-    testHandleMove(MF, LIS, 1, 4, /*BlockNum=*/1);
-  });
-}
+// Empty program. This is a hack to not fail incremental builders.
+// Would we just remove this program then the incremental builders would keep
+// executing an old version of the test (tests are discovered by search for
+// executables, they are not defined based on CMakeLists.txt).
 
 TEST(LiveIntervalTest, SubRegMoveUp) {
   // handleMoveUp had a bug not updating valno of segment incoming to bb.2
   // after swapping subreg definitions.
   liveIntervalTest(R"MIR(
     successors: %bb.1, %bb.2
     undef %0.sub0 = IMPLICIT_DEF
     %0.sub1 = IMPLICIT_DEF
     S_CBRANCH_VCCNZ %bb.2, implicit undef %vcc
     S_BRANCH %bb.1
   bb.1:
     S_NOP 0, implicit %0.sub1
   bb.2:
     S_NOP 0, implicit %0.sub1
 )MIR", [](MachineFunction &MF, LiveIntervals &LIS) {
     testHandleMove(MF, LIS, 1, 0);
   });
 }
 
 int main(int argc, char **argv) {
-  ::testing::InitGoogleTest(&argc, argv);
-  initLLVM();
-  return RUN_ALL_TESTS();
+  return 0;
 }