From 69fa84a6e95f66719263342f308b1389eeb5275f Mon Sep 17 00:00:00 2001
From: Tim Northover <tnorthover@apple.com>
Date: Fri, 14 Oct 2016 22:18:18 +0000
Subject: [PATCH] GlobalISel: rename legalizer components to match others.

The previous names were both misleading (the MachineLegalizer actually
contained the info tables) and inconsistent with the selector & translator (in
having a "Machine") prefix. This should make everything sensible again.

The only functional change is the name of a couple of command-line options.

llvm-svn: 284287
---
 .../llvm/CodeGen/GlobalISel/GISelAccessor.h        |   6 +-
 .../{MachineLegalizePass.h => Legalizer.h}         |   8 +-
 .../{MachineLegalizeHelper.h => LegalizerHelper.h} |  16 +--
 .../{MachineLegalizer.h => LegalizerInfo.h}        |   6 +-
 llvm/include/llvm/InitializePasses.h               |   2 +-
 llvm/include/llvm/Target/TargetSubtargetInfo.h     |   6 +-
 llvm/lib/CodeGen/GlobalISel/CMakeLists.txt         |   6 +-
 llvm/lib/CodeGen/GlobalISel/GlobalISel.cpp         |   2 +-
 llvm/lib/CodeGen/GlobalISel/InstructionSelect.cpp  |   6 +-
 .../{MachineLegalizePass.cpp => Legalizer.cpp}     |  45 ++++----
 ...chineLegalizeHelper.cpp => LegalizerHelper.cpp} |  67 ++++++------
 .../{MachineLegalizer.cpp => LegalizerInfo.cpp}    |  26 ++---
 llvm/lib/CodeGen/GlobalISel/RegBankSelect.cpp      |   6 +-
 ...chineLegalizer.cpp => AArch64LegalizerInfo.cpp} |   6 +-
 ...64MachineLegalizer.h => AArch64LegalizerInfo.h} |   8 +-
 llvm/lib/Target/AArch64/AArch64Subtarget.cpp       |   4 +-
 llvm/lib/Target/AArch64/AArch64Subtarget.h         |   2 +-
 llvm/lib/Target/AArch64/AArch64TargetMachine.cpp   |  12 +--
 llvm/lib/Target/AArch64/CMakeLists.txt             |   2 +-
 .../CodeGen/AArch64/GlobalISel/legalize-add.mir    |   2 +-
 .../CodeGen/AArch64/GlobalISel/legalize-and.mir    |   2 +-
 .../CodeGen/AArch64/GlobalISel/legalize-cmp.mir    |   2 +-
 .../AArch64/GlobalISel/legalize-combines.mir       |   2 +-
 .../AArch64/GlobalISel/legalize-constant.mir       |   2 +-
 .../CodeGen/AArch64/GlobalISel/legalize-div.mir    |   2 +-
 .../CodeGen/AArch64/GlobalISel/legalize-ext.mir    |   2 +-
 .../CodeGen/AArch64/GlobalISel/legalize-fcmp.mir   |   2 +-
 .../CodeGen/AArch64/GlobalISel/legalize-gep.mir    |   2 +-
 .../GlobalISel/legalize-ignore-non-generic.mir     |   2 +-
 .../AArch64/GlobalISel/legalize-load-store.mir     |   2 +-
 .../CodeGen/AArch64/GlobalISel/legalize-mul.mir    |   2 +-
 .../CodeGen/AArch64/GlobalISel/legalize-or.mir     |   2 +-
 .../AArch64/GlobalISel/legalize-property.mir       |   2 +-
 .../CodeGen/AArch64/GlobalISel/legalize-rem.mir    |   2 +-
 .../CodeGen/AArch64/GlobalISel/legalize-simple.mir |   2 +-
 .../CodeGen/AArch64/GlobalISel/legalize-sub.mir    |   2 +-
 .../CodeGen/AArch64/GlobalISel/legalize-xor.mir    |   2 +-
 .../AArch64/arm64-AnInfiniteLoopInDAGCombine.ll    |   2 +-
 .../test/CodeGen/AArch64/arm64-fp-contract-zero.ll |   2 +-
 llvm/test/CodeGen/AArch64/arm64-subsections.ll     |   2 +-
 .../test/CodeGen/AArch64/branch-relax-alignment.ll |   2 +-
 llvm/test/CodeGen/AArch64/simple-macho.ll          |   2 +-
 llvm/unittests/CodeGen/GlobalISel/CMakeLists.txt   |   2 +-
 .../CodeGen/GlobalISel/LegalizerInfoTest.cpp       | 120 +++++++++++++++++++++
 .../CodeGen/GlobalISel/MachineLegalizerTest.cpp    | 120 ---------------------
 45 files changed, 259 insertions(+), 265 deletions(-)
 rename llvm/include/llvm/CodeGen/GlobalISel/{MachineLegalizePass.h => Legalizer.h} (88%)
 rename llvm/include/llvm/CodeGen/GlobalISel/{MachineLegalizeHelper.h => LegalizerHelper.h} (89%)
 rename llvm/include/llvm/CodeGen/GlobalISel/{MachineLegalizer.h => LegalizerInfo.h} (98%)
 rename llvm/lib/CodeGen/GlobalISel/{MachineLegalizePass.cpp => Legalizer.cpp} (78%)
 rename llvm/lib/CodeGen/GlobalISel/{MachineLegalizeHelper.cpp => LegalizerHelper.cpp} (85%)
 rename llvm/lib/CodeGen/GlobalISel/{MachineLegalizer.cpp => LegalizerInfo.cpp} (88%)
 rename llvm/lib/Target/AArch64/{AArch64MachineLegalizer.cpp => AArch64LegalizerInfo.cpp} (97%)
 rename llvm/lib/Target/AArch64/{AArch64MachineLegalizer.h => AArch64LegalizerInfo.h} (77%)
 create mode 100644 llvm/unittests/CodeGen/GlobalISel/LegalizerInfoTest.cpp
 delete mode 100644 llvm/unittests/CodeGen/GlobalISel/MachineLegalizerTest.cpp

diff --git a/llvm/include/llvm/CodeGen/GlobalISel/GISelAccessor.h b/llvm/include/llvm/CodeGen/GlobalISel/GISelAccessor.h
index 848864c..8dea380 100644
--- a/llvm/include/llvm/CodeGen/GlobalISel/GISelAccessor.h
+++ b/llvm/include/llvm/CodeGen/GlobalISel/GISelAccessor.h
@@ -18,7 +18,7 @@
 namespace llvm {
 class CallLowering;
 class InstructionSelector;
-class MachineLegalizer;
+class LegalizerInfo;
 class RegisterBankInfo;
 
 /// The goal of this helper class is to gather the accessor to all
@@ -32,9 +32,7 @@ struct GISelAccessor {
   virtual const InstructionSelector *getInstructionSelector() const {
     return nullptr;
   }
-  virtual const MachineLegalizer *getMachineLegalizer() const {
-    return nullptr;
-  }
+  virtual const LegalizerInfo *getLegalizerInfo() const { return nullptr; }
   virtual const RegisterBankInfo *getRegBankInfo() const { return nullptr;}
 };
 } // End namespace llvm;
diff --git a/llvm/include/llvm/CodeGen/GlobalISel/MachineLegalizePass.h b/llvm/include/llvm/CodeGen/GlobalISel/Legalizer.h
similarity index 88%
rename from llvm/include/llvm/CodeGen/GlobalISel/MachineLegalizePass.h
rename to llvm/include/llvm/CodeGen/GlobalISel/Legalizer.h
index 633d4be..8284ab6 100644
--- a/llvm/include/llvm/CodeGen/GlobalISel/MachineLegalizePass.h
+++ b/llvm/include/llvm/CodeGen/GlobalISel/Legalizer.h
@@ -1,4 +1,4 @@
-//== llvm/CodeGen/GlobalISel/MachineLegalizePass.h ------------- -*- C++ -*-==//
+//== llvm/CodeGen/GlobalISel/LegalizePass.h ------------- -*- C++ -*-==//
 //
 //                     The LLVM Compiler Infrastructure
 //
@@ -28,7 +28,7 @@ namespace llvm {
 
 class MachineRegisterInfo;
 
-class MachineLegalizePass : public MachineFunctionPass {
+class Legalizer : public MachineFunctionPass {
 public:
   static char ID;
 
@@ -39,9 +39,9 @@ private:
 
 public:
   // Ctor, nothing fancy.
-  MachineLegalizePass();
+  Legalizer();
 
-  StringRef getPassName() const override { return "MachineLegalizePass"; }
+  StringRef getPassName() const override { return "Legalizer"; }
 
   void getAnalysisUsage(AnalysisUsage &AU) const override;
 
diff --git a/llvm/include/llvm/CodeGen/GlobalISel/MachineLegalizeHelper.h b/llvm/include/llvm/CodeGen/GlobalISel/LegalizerHelper.h
similarity index 89%
rename from llvm/include/llvm/CodeGen/GlobalISel/MachineLegalizeHelper.h
rename to llvm/include/llvm/CodeGen/GlobalISel/LegalizerHelper.h
index e0b2345..56c444c 100644
--- a/llvm/include/llvm/CodeGen/GlobalISel/MachineLegalizeHelper.h
+++ b/llvm/include/llvm/CodeGen/GlobalISel/LegalizerHelper.h
@@ -1,4 +1,4 @@
-//== llvm/CodeGen/GlobalISel/MachineLegalizeHelper.h ----------- -*- C++ -*-==//
+//== llvm/CodeGen/GlobalISel/LegalizerHelper.h ---------------- -*- C++ -*-==//
 //
 //                     The LLVM Compiler Infrastructure
 //
@@ -12,7 +12,7 @@
 /// occur in multiple phases, for example G_ADD <2 x i8> -> G_ADD <2 x i16> ->
 /// G_ADD <4 x i16>.
 ///
-/// The MachineLegalizeHelper class is where most of the work happens, and is
+/// The LegalizerHelper class is where most of the work happens, and is
 /// designed to be callable from other passes that find themselves with an
 /// illegal instruction.
 //
@@ -27,11 +27,11 @@
 
 namespace llvm {
 // Forward declarations.
-class MachineLegalizeInfo;
-class MachineLegalizer;
+class LegalizerInfo;
+class Legalizer;
 class MachineRegisterInfo;
 
-class MachineLegalizeHelper {
+class LegalizerHelper {
 public:
   enum LegalizeResult {
     /// Instruction was already legal and no change was made to the
@@ -46,7 +46,7 @@ public:
     UnableToLegalize,
   };
 
-  MachineLegalizeHelper(MachineFunction &MF);
+  LegalizerHelper(MachineFunction &MF);
 
   /// Replace \p MI by a sequence of legal instructions that can implement the
   /// same operation. Note that this means \p MI may be deleted, so any iterator
@@ -56,10 +56,10 @@ public:
   /// Considered as an opaque blob, the legal code will use and define the same
   /// registers as \p MI.
   LegalizeResult legalizeInstrStep(MachineInstr &MI,
-                                   const MachineLegalizer &Legalizer);
+                                   const LegalizerInfo &LegalizerInfo);
 
   LegalizeResult legalizeInstr(MachineInstr &MI,
-                               const MachineLegalizer &Legalizer);
+                               const LegalizerInfo &LegalizerInfo);
 
   /// Legalize an instruction by emiting a runtime library call instead.
   LegalizeResult libcall(MachineInstr &MI);
diff --git a/llvm/include/llvm/CodeGen/GlobalISel/MachineLegalizer.h b/llvm/include/llvm/CodeGen/GlobalISel/LegalizerInfo.h
similarity index 98%
rename from llvm/include/llvm/CodeGen/GlobalISel/MachineLegalizer.h
rename to llvm/include/llvm/CodeGen/GlobalISel/LegalizerInfo.h
index d2ba1e0..edf52da 100644
--- a/llvm/include/llvm/CodeGen/GlobalISel/MachineLegalizer.h
+++ b/llvm/include/llvm/CodeGen/GlobalISel/LegalizerInfo.h
@@ -1,4 +1,4 @@
-//==-- llvm/CodeGen/GlobalISel/MachineLegalizer.h ----------------*- C++ -*-==//
+//==-- llvm/CodeGen/GlobalISel/LegalizerInfo.h -------------------*- C++ -*-==//
 //
 //                     The LLVM Compiler Infrastructure
 //
@@ -46,7 +46,7 @@ struct InstrAspect {
   }
 };
 
-class MachineLegalizer {
+class LegalizerInfo {
 public:
   enum LegalizeAction : std::uint8_t {
     /// The operation is expected to be selectable directly by the target, and
@@ -95,7 +95,7 @@ public:
     NotFound,
   };
 
-  MachineLegalizer();
+  LegalizerInfo();
 
   /// Compute any ancillary tables needed to quickly decide how an operation
   /// should be handled. This must be called after all "set*Action"methods but
diff --git a/llvm/include/llvm/InitializePasses.h b/llvm/include/llvm/InitializePasses.h
index 604d2a5..10bb355 100644
--- a/llvm/include/llvm/InitializePasses.h
+++ b/llvm/include/llvm/InitializePasses.h
@@ -171,6 +171,7 @@ void initializeLegacyLICMPassPass(PassRegistry&);
 void initializeLazyBranchProbabilityInfoPassPass(PassRegistry&);
 void initializeLazyBlockFrequencyInfoPassPass(PassRegistry&);
 void initializeLazyValueInfoWrapperPassPass(PassRegistry&);
+void initializeLegalizerPass(PassRegistry&);
 void initializeLintPass(PassRegistry&);
 void initializeLiveDebugValuesPass(PassRegistry&);
 void initializeLiveDebugVariablesPass(PassRegistry&);
@@ -222,7 +223,6 @@ void initializeMachineCopyPropagationPass(PassRegistry&);
 void initializeMachineDominanceFrontierPass(PassRegistry&);
 void initializeMachineDominatorTreePass(PassRegistry&);
 void initializeMachineFunctionPrinterPassPass(PassRegistry&);
-void initializeMachineLegalizePassPass(PassRegistry&);
 void initializeMachineLICMPass(PassRegistry&);
 void initializeMachineLoopInfoPass(PassRegistry&);
 void initializeMachineModuleInfoPass(PassRegistry&);
diff --git a/llvm/include/llvm/Target/TargetSubtargetInfo.h b/llvm/include/llvm/Target/TargetSubtargetInfo.h
index 47f74b0..c5585c3 100644
--- a/llvm/include/llvm/Target/TargetSubtargetInfo.h
+++ b/llvm/include/llvm/Target/TargetSubtargetInfo.h
@@ -26,9 +26,9 @@ namespace llvm {
 class CallLowering;
 class DataLayout;
 class InstructionSelector;
+class LegalizerInfo;
 class MachineFunction;
 class MachineInstr;
-class MachineLegalizer;
 class RegisterBankInfo;
 class SDep;
 class SUnit;
@@ -107,9 +107,7 @@ public:
     return nullptr;
   }
 
-  virtual const MachineLegalizer *getMachineLegalizer() const {
-    return nullptr;
-  }
+  virtual const LegalizerInfo *getLegalizerInfo() const { return nullptr; }
 
   /// getRegisterInfo - If register information is available, return it.  If
   /// not, return null.
diff --git a/llvm/lib/CodeGen/GlobalISel/CMakeLists.txt b/llvm/lib/CodeGen/GlobalISel/CMakeLists.txt
index 87b4708..fe44b34 100644
--- a/llvm/lib/CodeGen/GlobalISel/CMakeLists.txt
+++ b/llvm/lib/CodeGen/GlobalISel/CMakeLists.txt
@@ -5,9 +5,9 @@ set(GLOBAL_ISEL_FILES
       InstructionSelect.cpp
       InstructionSelector.cpp
       MachineIRBuilder.cpp
-      MachineLegalizeHelper.cpp
-      MachineLegalizePass.cpp
-      MachineLegalizer.cpp
+      LegalizerHelper.cpp
+      Legalizer.cpp
+      LegalizerInfo.cpp
       RegBankSelect.cpp
       RegisterBank.cpp
       RegisterBankInfo.cpp
diff --git a/llvm/lib/CodeGen/GlobalISel/GlobalISel.cpp b/llvm/lib/CodeGen/GlobalISel/GlobalISel.cpp
index aac29f5..fcd2722 100644
--- a/llvm/lib/CodeGen/GlobalISel/GlobalISel.cpp
+++ b/llvm/lib/CodeGen/GlobalISel/GlobalISel.cpp
@@ -25,7 +25,7 @@ void llvm::initializeGlobalISel(PassRegistry &Registry) {
 
 void llvm::initializeGlobalISel(PassRegistry &Registry) {
   initializeIRTranslatorPass(Registry);
-  initializeMachineLegalizePassPass(Registry);
+  initializeLegalizerPass(Registry);
   initializeRegBankSelectPass(Registry);
   initializeInstructionSelectPass(Registry);
 }
diff --git a/llvm/lib/CodeGen/GlobalISel/InstructionSelect.cpp b/llvm/lib/CodeGen/GlobalISel/InstructionSelect.cpp
index 70d4dd7..be20355 100644
--- a/llvm/lib/CodeGen/GlobalISel/InstructionSelect.cpp
+++ b/llvm/lib/CodeGen/GlobalISel/InstructionSelect.cpp
@@ -14,7 +14,7 @@
 #include "llvm/ADT/PostOrderIterator.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/CodeGen/GlobalISel/InstructionSelector.h"
-#include "llvm/CodeGen/GlobalISel/MachineLegalizer.h"
+#include "llvm/CodeGen/GlobalISel/LegalizerInfo.h"
 #include "llvm/CodeGen/MachineRegisterInfo.h"
 #include "llvm/CodeGen/TargetPassConfig.h"
 #include "llvm/IR/Function.h"
@@ -71,12 +71,12 @@ bool InstructionSelect::runOnMachineFunction(MachineFunction &MF) {
   // Check that our input is fully legal: we require the function to have the
   // Legalized property, so it should be.
   // FIXME: This should be in the MachineVerifier, but it can't use the
-  // MachineLegalizer as it's currently in the separate GlobalISel library.
+  // LegalizerInfo as it's currently in the separate GlobalISel library.
   // The RegBankSelected property is already checked in the verifier. Note
   // that it has the same layering problem, but we only use inline methods so
   // end up not needing to link against the GlobalISel library.
   const MachineRegisterInfo &MRI = MF.getRegInfo();
-  if (const MachineLegalizer *MLI = MF.getSubtarget().getMachineLegalizer())
+  if (const LegalizerInfo *MLI = MF.getSubtarget().getLegalizerInfo())
     for (const MachineBasicBlock &MBB : MF)
       for (const MachineInstr &MI : MBB)
         if (isPreISelGenericOpcode(MI.getOpcode()) && !MLI->isLegal(MI, MRI))
diff --git a/llvm/lib/CodeGen/GlobalISel/MachineLegalizePass.cpp b/llvm/lib/CodeGen/GlobalISel/Legalizer.cpp
similarity index 78%
rename from llvm/lib/CodeGen/GlobalISel/MachineLegalizePass.cpp
rename to llvm/lib/CodeGen/GlobalISel/Legalizer.cpp
index b52cb10..e863568 100644
--- a/llvm/lib/CodeGen/GlobalISel/MachineLegalizePass.cpp
+++ b/llvm/lib/CodeGen/GlobalISel/Legalizer.cpp
@@ -1,4 +1,4 @@
-//===-- llvm/CodeGen/GlobalISel/MachineLegalizePass.cpp -------------------===//
+//===-- llvm/CodeGen/GlobalISel/Legalizer.cpp -----------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
@@ -7,49 +7,48 @@
 //
 //===----------------------------------------------------------------------===//
 //
-/// \file This file implements the LegalizeHelper class to legalize individual
-/// instructions and the MachineLegalizePass wrapper pass for the primary
+/// \file This file implements the LegalizerHelper class to legalize individual
+/// instructions and the LegalizePass wrapper pass for the primary
 /// legalization.
 //
 //===----------------------------------------------------------------------===//
 
-#include "llvm/CodeGen/GlobalISel/MachineLegalizePass.h"
-#include "llvm/CodeGen/GlobalISel/MachineLegalizeHelper.h"
-#include "llvm/CodeGen/GlobalISel/MachineLegalizer.h"
+#include "llvm/CodeGen/GlobalISel/Legalizer.h"
+#include "llvm/CodeGen/GlobalISel/LegalizerHelper.h"
+#include "llvm/CodeGen/GlobalISel/Legalizer.h"
 #include "llvm/CodeGen/MachineRegisterInfo.h"
 #include "llvm/CodeGen/TargetPassConfig.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Target/TargetInstrInfo.h"
 #include "llvm/Target/TargetSubtargetInfo.h"
 
-#define DEBUG_TYPE "legalize-mir"
+#define DEBUG_TYPE "legalizer"
 
 using namespace llvm;
 
-char MachineLegalizePass::ID = 0;
-INITIALIZE_PASS_BEGIN(MachineLegalizePass, DEBUG_TYPE,
+char Legalizer::ID = 0;
+INITIALIZE_PASS_BEGIN(Legalizer, DEBUG_TYPE,
                       "Legalize the Machine IR a function's Machine IR", false,
                       false)
 INITIALIZE_PASS_DEPENDENCY(TargetPassConfig)
-INITIALIZE_PASS_END(MachineLegalizePass, DEBUG_TYPE,
+INITIALIZE_PASS_END(Legalizer, DEBUG_TYPE,
                     "Legalize the Machine IR a function's Machine IR", false,
                     false)
 
-MachineLegalizePass::MachineLegalizePass() : MachineFunctionPass(ID) {
-  initializeMachineLegalizePassPass(*PassRegistry::getPassRegistry());
+Legalizer::Legalizer() : MachineFunctionPass(ID) {
+  initializeLegalizerPass(*PassRegistry::getPassRegistry());
 }
 
-void MachineLegalizePass::getAnalysisUsage(AnalysisUsage &AU) const {
+void Legalizer::getAnalysisUsage(AnalysisUsage &AU) const {
   AU.addRequired<TargetPassConfig>();
   MachineFunctionPass::getAnalysisUsage(AU);
 }
 
-void MachineLegalizePass::init(MachineFunction &MF) {
+void Legalizer::init(MachineFunction &MF) {
 }
 
-bool MachineLegalizePass::combineExtracts(MachineInstr &MI,
-                                          MachineRegisterInfo &MRI,
-                                          const TargetInstrInfo &TII) {
+bool Legalizer::combineExtracts(MachineInstr &MI, MachineRegisterInfo &MRI,
+                                const TargetInstrInfo &TII) {
   bool Changed = false;
   if (MI.getOpcode() != TargetOpcode::G_EXTRACT)
     return Changed;
@@ -115,7 +114,7 @@ bool MachineLegalizePass::combineExtracts(MachineInstr &MI,
   return Changed;
 }
 
-bool MachineLegalizePass::runOnMachineFunction(MachineFunction &MF) {
+bool Legalizer::runOnMachineFunction(MachineFunction &MF) {
   // If the ISel pipeline failed, do not bother running that pass.
   if (MF.getProperties().hasProperty(
           MachineFunctionProperties::Property::FailedISel))
@@ -123,8 +122,8 @@ bool MachineLegalizePass::runOnMachineFunction(MachineFunction &MF) {
   DEBUG(dbgs() << "Legalize Machine IR for: " << MF.getName() << '\n');
   init(MF);
   const TargetPassConfig &TPC = getAnalysis<TargetPassConfig>();
-  const MachineLegalizer &Legalizer = *MF.getSubtarget().getMachineLegalizer();
-  MachineLegalizeHelper Helper(MF);
+  const LegalizerInfo &LegalizerInfo = *MF.getSubtarget().getLegalizerInfo();
+  LegalizerHelper Helper(MF);
 
   // FIXME: an instruction may need more than one pass before it is legal. For
   // example on most architectures <3 x i3> is doubly-illegal. It would
@@ -144,11 +143,11 @@ bool MachineLegalizePass::runOnMachineFunction(MachineFunction &MF) {
       if (!isPreISelGenericOpcode(MI->getOpcode()))
         continue;
 
-      auto Res = Helper.legalizeInstr(*MI, Legalizer);
+      auto Res = Helper.legalizeInstr(*MI, LegalizerInfo);
 
       // Error out if we couldn't legalize this instruction. We may want to fall
       // back to DAG ISel instead in the future.
-      if (Res == MachineLegalizeHelper::UnableToLegalize) {
+      if (Res == LegalizerHelper::UnableToLegalize) {
         if (!TPC.isGlobalISelAbortEnabled()) {
           MF.getProperties().set(
               MachineFunctionProperties::Property::FailedISel);
@@ -161,7 +160,7 @@ bool MachineLegalizePass::runOnMachineFunction(MachineFunction &MF) {
         report_fatal_error(OS.str());
       }
 
-      Changed |= Res == MachineLegalizeHelper::Legalized;
+      Changed |= Res == LegalizerHelper::Legalized;
     }
 
 
diff --git a/llvm/lib/CodeGen/GlobalISel/MachineLegalizeHelper.cpp b/llvm/lib/CodeGen/GlobalISel/LegalizerHelper.cpp
similarity index 85%
rename from llvm/lib/CodeGen/GlobalISel/MachineLegalizeHelper.cpp
rename to llvm/lib/CodeGen/GlobalISel/LegalizerHelper.cpp
index d6368b3..ffb22b2 100644
--- a/llvm/lib/CodeGen/GlobalISel/MachineLegalizeHelper.cpp
+++ b/llvm/lib/CodeGen/GlobalISel/LegalizerHelper.cpp
@@ -1,4 +1,4 @@
-//===-- llvm/CodeGen/GlobalISel/MachineLegalizeHelper.cpp -----------------===//
+//===-- llvm/CodeGen/GlobalISel/LegalizerHelper.cpp -----------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
@@ -7,15 +7,15 @@
 //
 //===----------------------------------------------------------------------===//
 //
-/// \file This file implements the MachineLegalizeHelper class to legalize
+/// \file This file implements the LegalizerHelper class to legalize
 /// individual instructions and the LegalizeMachineIR wrapper pass for the
 /// primary legalization.
 //
 //===----------------------------------------------------------------------===//
 
-#include "llvm/CodeGen/GlobalISel/MachineLegalizeHelper.h"
+#include "llvm/CodeGen/GlobalISel/LegalizerHelper.h"
 #include "llvm/CodeGen/GlobalISel/CallLowering.h"
-#include "llvm/CodeGen/GlobalISel/MachineLegalizer.h"
+#include "llvm/CodeGen/GlobalISel/LegalizerInfo.h"
 #include "llvm/CodeGen/MachineRegisterInfo.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/raw_ostream.h"
@@ -28,36 +28,36 @@
 
 using namespace llvm;
 
-MachineLegalizeHelper::MachineLegalizeHelper(MachineFunction &MF)
+LegalizerHelper::LegalizerHelper(MachineFunction &MF)
   : MRI(MF.getRegInfo()) {
   MIRBuilder.setMF(MF);
 }
 
-MachineLegalizeHelper::LegalizeResult
-MachineLegalizeHelper::legalizeInstrStep(MachineInstr &MI,
-                                         const MachineLegalizer &Legalizer) {
-  auto Action = Legalizer.getAction(MI, MRI);
+LegalizerHelper::LegalizeResult
+LegalizerHelper::legalizeInstrStep(MachineInstr &MI,
+                                   const LegalizerInfo &LegalizerInfo) {
+  auto Action = LegalizerInfo.getAction(MI, MRI);
   switch (std::get<0>(Action)) {
-  case MachineLegalizer::Legal:
+  case LegalizerInfo::Legal:
     return AlreadyLegal;
-  case MachineLegalizer::Libcall:
+  case LegalizerInfo::Libcall:
     return libcall(MI);
-  case MachineLegalizer::NarrowScalar:
+  case LegalizerInfo::NarrowScalar:
     return narrowScalar(MI, std::get<1>(Action), std::get<2>(Action));
-  case MachineLegalizer::WidenScalar:
+  case LegalizerInfo::WidenScalar:
     return widenScalar(MI, std::get<1>(Action), std::get<2>(Action));
-  case MachineLegalizer::Lower:
+  case LegalizerInfo::Lower:
     return lower(MI, std::get<1>(Action), std::get<2>(Action));
-  case MachineLegalizer::FewerElements:
+  case LegalizerInfo::FewerElements:
     return fewerElementsVector(MI, std::get<1>(Action), std::get<2>(Action));
   default:
     return UnableToLegalize;
   }
 }
 
-MachineLegalizeHelper::LegalizeResult
-MachineLegalizeHelper::legalizeInstr(MachineInstr &MI,
-                                     const MachineLegalizer &Legalizer) {
+LegalizerHelper::LegalizeResult
+LegalizerHelper::legalizeInstr(MachineInstr &MI,
+                               const LegalizerInfo &LegalizerInfo) {
   SmallVector<MachineInstr *, 4> WorkList;
   MIRBuilder.recordInsertions(
       [&](MachineInstr *MI) { WorkList.push_back(MI); });
@@ -67,7 +67,7 @@ MachineLegalizeHelper::legalizeInstr(MachineInstr &MI,
   LegalizeResult Res;
   unsigned Idx = 0;
   do {
-    Res = legalizeInstrStep(*WorkList[Idx], Legalizer);
+    Res = legalizeInstrStep(*WorkList[Idx], LegalizerInfo);
     if (Res == UnableToLegalize) {
       MIRBuilder.stopRecordingInsertions();
       return UnableToLegalize;
@@ -81,8 +81,8 @@ MachineLegalizeHelper::legalizeInstr(MachineInstr &MI,
   return Changed ? Legalized : AlreadyLegal;
 }
 
-void MachineLegalizeHelper::extractParts(unsigned Reg, LLT Ty, int NumParts,
-                                         SmallVectorImpl<unsigned> &VRegs) {
+void LegalizerHelper::extractParts(unsigned Reg, LLT Ty, int NumParts,
+                                   SmallVectorImpl<unsigned> &VRegs) {
   unsigned Size = Ty.getSizeInBits();
   SmallVector<uint64_t, 4> Indexes;
   for (int i = 0; i < NumParts; ++i) {
@@ -92,8 +92,8 @@ void MachineLegalizeHelper::extractParts(unsigned Reg, LLT Ty, int NumParts,
   MIRBuilder.buildExtract(VRegs, Indexes, Reg);
 }
 
-MachineLegalizeHelper::LegalizeResult
-MachineLegalizeHelper::libcall(MachineInstr &MI) {
+LegalizerHelper::LegalizeResult
+LegalizerHelper::libcall(MachineInstr &MI) {
   LLT Ty = MRI.getType(MI.getOperand(0).getReg());
   unsigned Size = Ty.getSizeInBits();
   MIRBuilder.setInstr(MI);
@@ -119,9 +119,9 @@ MachineLegalizeHelper::libcall(MachineInstr &MI) {
   }
 }
 
-MachineLegalizeHelper::LegalizeResult
-MachineLegalizeHelper::narrowScalar(MachineInstr &MI, unsigned TypeIdx,
-                                    LLT NarrowTy) {
+LegalizerHelper::LegalizeResult LegalizerHelper::narrowScalar(MachineInstr &MI,
+                                                              unsigned TypeIdx,
+                                                              LLT NarrowTy) {
   // FIXME: Don't know how to handle secondary types yet.
   if (TypeIdx != 0)
     return UnableToLegalize;
@@ -163,9 +163,8 @@ MachineLegalizeHelper::narrowScalar(MachineInstr &MI, unsigned TypeIdx,
   }
 }
 
-MachineLegalizeHelper::LegalizeResult
-MachineLegalizeHelper::widenScalar(MachineInstr &MI, unsigned TypeIdx,
-                                   LLT WideTy) {
+LegalizerHelper::LegalizeResult
+LegalizerHelper::widenScalar(MachineInstr &MI, unsigned TypeIdx, LLT WideTy) {
   MIRBuilder.setInstr(MI);
 
   switch (MI.getOpcode()) {
@@ -293,8 +292,8 @@ MachineLegalizeHelper::widenScalar(MachineInstr &MI, unsigned TypeIdx,
   }
 }
 
-MachineLegalizeHelper::LegalizeResult
-MachineLegalizeHelper::lower(MachineInstr &MI, unsigned TypeIdx, LLT Ty) {
+LegalizerHelper::LegalizeResult
+LegalizerHelper::lower(MachineInstr &MI, unsigned TypeIdx, LLT Ty) {
   using namespace TargetOpcode;
   MIRBuilder.setInstr(MI);
 
@@ -319,9 +318,9 @@ MachineLegalizeHelper::lower(MachineInstr &MI, unsigned TypeIdx, LLT Ty) {
   }
 }
 
-MachineLegalizeHelper::LegalizeResult
-MachineLegalizeHelper::fewerElementsVector(MachineInstr &MI, unsigned TypeIdx,
-                                           LLT NarrowTy) {
+LegalizerHelper::LegalizeResult
+LegalizerHelper::fewerElementsVector(MachineInstr &MI, unsigned TypeIdx,
+                                     LLT NarrowTy) {
   // FIXME: Don't know how to handle secondary types yet.
   if (TypeIdx != 0)
     return UnableToLegalize;
diff --git a/llvm/lib/CodeGen/GlobalISel/MachineLegalizer.cpp b/llvm/lib/CodeGen/GlobalISel/LegalizerInfo.cpp
similarity index 88%
rename from llvm/lib/CodeGen/GlobalISel/MachineLegalizer.cpp
rename to llvm/lib/CodeGen/GlobalISel/LegalizerInfo.cpp
index 9844dbb..da7428d 100644
--- a/llvm/lib/CodeGen/GlobalISel/MachineLegalizer.cpp
+++ b/llvm/lib/CodeGen/GlobalISel/LegalizerInfo.cpp
@@ -1,4 +1,4 @@
-//===---- lib/CodeGen/GlobalISel/MachineLegalizer.cpp - IRTranslator -------==//
+//===---- lib/CodeGen/GlobalISel/LegalizerInfo.cpp - Legalizer -------==//
 //
 //                     The LLVM Compiler Infrastructure
 //
@@ -17,7 +17,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "llvm/CodeGen/GlobalISel/MachineLegalizer.h"
+#include "llvm/CodeGen/GlobalISel/LegalizerInfo.h"
 
 #include "llvm/ADT/SmallBitVector.h"
 #include "llvm/CodeGen/MachineInstr.h"
@@ -27,7 +27,7 @@
 #include "llvm/Target/TargetOpcodes.h"
 using namespace llvm;
 
-MachineLegalizer::MachineLegalizer() : TablesInitialized(false) {
+LegalizerInfo::LegalizerInfo() : TablesInitialized(false) {
   // FIXME: these two can be legalized to the fundamental load/store Jakob
   // proposed. Once loads & stores are supported.
   DefaultActions[TargetOpcode::G_ANYEXT] = Legal;
@@ -41,7 +41,7 @@ MachineLegalizer::MachineLegalizer() : TablesInitialized(false) {
   DefaultActions[TargetOpcode::G_BRCOND] = WidenScalar;
 }
 
-void MachineLegalizer::computeTables() {
+void LegalizerInfo::computeTables() {
   for (unsigned Opcode = 0; Opcode <= LastOp - FirstOp; ++Opcode) {
     for (unsigned Idx = 0; Idx != Actions[Opcode].size(); ++Idx) {
       for (auto &Action : Actions[Opcode][Idx]) {
@@ -63,8 +63,8 @@ void MachineLegalizer::computeTables() {
 // probably going to need specialized lookup structures for various types before
 // we have any hope of doing well with something like <13 x i3>. Even the common
 // cases should do better than what we have now.
-std::pair<MachineLegalizer::LegalizeAction, LLT>
-MachineLegalizer::getAction(const InstrAspect &Aspect) const {
+std::pair<LegalizerInfo::LegalizeAction, LLT>
+LegalizerInfo::getAction(const InstrAspect &Aspect) const {
   assert(TablesInitialized && "backend forgot to call computeTables");
   // These *have* to be implemented for now, they're the fundamental basis of
   // how everything else is transformed.
@@ -113,9 +113,9 @@ MachineLegalizer::getAction(const InstrAspect &Aspect) const {
   return findLegalAction(Aspect, FewerElements);
 }
 
-std::tuple<MachineLegalizer::LegalizeAction, unsigned, LLT>
-MachineLegalizer::getAction(const MachineInstr &MI,
-                            const MachineRegisterInfo &MRI) const {
+std::tuple<LegalizerInfo::LegalizeAction, unsigned, LLT>
+LegalizerInfo::getAction(const MachineInstr &MI,
+                         const MachineRegisterInfo &MRI) const {
   SmallBitVector SeenTypes(8);
   const MCOperandInfo *OpInfo = MI.getDesc().OpInfo;
   for (unsigned i = 0; i < MI.getDesc().getNumOperands(); ++i) {
@@ -138,13 +138,13 @@ MachineLegalizer::getAction(const MachineInstr &MI,
   return std::make_tuple(Legal, 0, LLT{});
 }
 
-bool MachineLegalizer::isLegal(const MachineInstr &MI,
-                               const MachineRegisterInfo &MRI) const {
+bool LegalizerInfo::isLegal(const MachineInstr &MI,
+                            const MachineRegisterInfo &MRI) const {
   return std::get<0>(getAction(MI, MRI)) == Legal;
 }
 
-LLT MachineLegalizer::findLegalType(const InstrAspect &Aspect,
-                                    LegalizeAction Action) const {
+LLT LegalizerInfo::findLegalType(const InstrAspect &Aspect,
+                                 LegalizeAction Action) const {
   switch(Action) {
   default:
     llvm_unreachable("Cannot find legal type");
diff --git a/llvm/lib/CodeGen/GlobalISel/RegBankSelect.cpp b/llvm/lib/CodeGen/GlobalISel/RegBankSelect.cpp
index 5b3b705..2a20e43 100644
--- a/llvm/lib/CodeGen/GlobalISel/RegBankSelect.cpp
+++ b/llvm/lib/CodeGen/GlobalISel/RegBankSelect.cpp
@@ -12,7 +12,7 @@
 
 #include "llvm/CodeGen/GlobalISel/RegBankSelect.h"
 #include "llvm/ADT/PostOrderIterator.h"
-#include "llvm/CodeGen/GlobalISel/MachineLegalizer.h"
+#include "llvm/CodeGen/GlobalISel/LegalizerInfo.h"
 #include "llvm/CodeGen/GlobalISel/RegisterBank.h"
 #include "llvm/CodeGen/MachineBlockFrequencyInfo.h"
 #include "llvm/CodeGen/MachineBranchProbabilityInfo.h"
@@ -571,9 +571,9 @@ bool RegBankSelect::runOnMachineFunction(MachineFunction &MF) {
   // Check that our input is fully legal: we require the function to have the
   // Legalized property, so it should be.
   // FIXME: This should be in the MachineVerifier, but it can't use the
-  // MachineLegalizer as it's currently in the separate GlobalISel library.
+  // LegalizerInfo as it's currently in the separate GlobalISel library.
   const MachineRegisterInfo &MRI = MF.getRegInfo();
-  if (const MachineLegalizer *MLI = MF.getSubtarget().getMachineLegalizer()) {
+  if (const LegalizerInfo *MLI = MF.getSubtarget().getLegalizerInfo()) {
     for (const MachineBasicBlock &MBB : MF) {
       for (const MachineInstr &MI : MBB) {
         if (isPreISelGenericOpcode(MI.getOpcode()) && !MLI->isLegal(MI, MRI)) {
diff --git a/llvm/lib/Target/AArch64/AArch64MachineLegalizer.cpp b/llvm/lib/Target/AArch64/AArch64LegalizerInfo.cpp
similarity index 97%
rename from llvm/lib/Target/AArch64/AArch64MachineLegalizer.cpp
rename to llvm/lib/Target/AArch64/AArch64LegalizerInfo.cpp
index 46261bc..b8f1136 100644
--- a/llvm/lib/Target/AArch64/AArch64MachineLegalizer.cpp
+++ b/llvm/lib/Target/AArch64/AArch64LegalizerInfo.cpp
@@ -1,4 +1,4 @@
-//===- AArch64MachineLegalizer.cpp -------------------------------*- C++ -*-==//
+//===- AArch64LegalizerInfo.cpp ----------------------------------*- C++ -*-==//
 //
 //                     The LLVM Compiler Infrastructure
 //
@@ -12,7 +12,7 @@
 /// \todo This should be generated by TableGen.
 //===----------------------------------------------------------------------===//
 
-#include "AArch64MachineLegalizer.h"
+#include "AArch64LegalizerInfo.h"
 #include "llvm/CodeGen/ValueTypes.h"
 #include "llvm/IR/Type.h"
 #include "llvm/IR/DerivedTypes.h"
@@ -24,7 +24,7 @@ using namespace llvm;
 #error "You shouldn't build this"
 #endif
 
-AArch64MachineLegalizer::AArch64MachineLegalizer() {
+AArch64LegalizerInfo::AArch64LegalizerInfo() {
   using namespace TargetOpcode;
   const LLT p0 = LLT::pointer(0, 64);
   const LLT s1 = LLT::scalar(1);
diff --git a/llvm/lib/Target/AArch64/AArch64MachineLegalizer.h b/llvm/lib/Target/AArch64/AArch64LegalizerInfo.h
similarity index 77%
rename from llvm/lib/Target/AArch64/AArch64MachineLegalizer.h
rename to llvm/lib/Target/AArch64/AArch64LegalizerInfo.h
index 4e8d1f2..feacbef 100644
--- a/llvm/lib/Target/AArch64/AArch64MachineLegalizer.h
+++ b/llvm/lib/Target/AArch64/AArch64LegalizerInfo.h
@@ -1,4 +1,4 @@
-//===- AArch64Machinelegalizer --------------------------------*- C++ -*-==//
+//===- AArch64LegalizerInfo --------------------------------------*- C++ -*-==//
 //
 //                     The LLVM Compiler Infrastructure
 //
@@ -15,16 +15,16 @@
 #ifndef LLVM_LIB_TARGET_AARCH64_AARCH64MACHINELEGALIZER_H
 #define LLVM_LIB_TARGET_AARCH64_AARCH64MACHINELEGALIZER_H
 
-#include "llvm/CodeGen/GlobalISel/MachineLegalizer.h"
+#include "llvm/CodeGen/GlobalISel/LegalizerInfo.h"
 
 namespace llvm {
 
 class LLVMContext;
 
 /// This class provides the information for the target register banks.
-class AArch64MachineLegalizer : public MachineLegalizer {
+class AArch64LegalizerInfo : public LegalizerInfo {
 public:
-  AArch64MachineLegalizer();
+  AArch64LegalizerInfo();
 };
 } // End llvm namespace.
 #endif
diff --git a/llvm/lib/Target/AArch64/AArch64Subtarget.cpp b/llvm/lib/Target/AArch64/AArch64Subtarget.cpp
index 61bfd7a..78a26316 100644
--- a/llvm/lib/Target/AArch64/AArch64Subtarget.cpp
+++ b/llvm/lib/Target/AArch64/AArch64Subtarget.cpp
@@ -105,9 +105,9 @@ const InstructionSelector *AArch64Subtarget::getInstructionSelector() const {
   return GISel->getInstructionSelector();
 }
 
-const MachineLegalizer *AArch64Subtarget::getMachineLegalizer() const {
+const LegalizerInfo *AArch64Subtarget::getLegalizerInfo() const {
   assert(GISel && "Access to GlobalISel APIs not set");
-  return GISel->getMachineLegalizer();
+  return GISel->getLegalizerInfo();
 }
 
 const RegisterBankInfo *AArch64Subtarget::getRegBankInfo() const {
diff --git a/llvm/lib/Target/AArch64/AArch64Subtarget.h b/llvm/lib/Target/AArch64/AArch64Subtarget.h
index a21dbd8..cdc5d74 100644
--- a/llvm/lib/Target/AArch64/AArch64Subtarget.h
+++ b/llvm/lib/Target/AArch64/AArch64Subtarget.h
@@ -147,7 +147,7 @@ public:
   }
   const CallLowering *getCallLowering() const override;
   const InstructionSelector *getInstructionSelector() const override;
-  const MachineLegalizer *getMachineLegalizer() const override;
+  const LegalizerInfo *getLegalizerInfo() const override;
   const RegisterBankInfo *getRegBankInfo() const override;
   const Triple &getTargetTriple() const { return TargetTriple; }
   bool enableMachineScheduler() const override { return true; }
diff --git a/llvm/lib/Target/AArch64/AArch64TargetMachine.cpp b/llvm/lib/Target/AArch64/AArch64TargetMachine.cpp
index f0fd054..940c239 100644
--- a/llvm/lib/Target/AArch64/AArch64TargetMachine.cpp
+++ b/llvm/lib/Target/AArch64/AArch64TargetMachine.cpp
@@ -13,14 +13,14 @@
 #include "AArch64.h"
 #include "AArch64CallLowering.h"
 #include "AArch64InstructionSelector.h"
-#include "AArch64MachineLegalizer.h"
+#include "AArch64LegalizerInfo.h"
 #include "AArch64RegisterBankInfo.h"
 #include "AArch64TargetMachine.h"
 #include "AArch64TargetObjectFile.h"
 #include "AArch64TargetTransformInfo.h"
 #include "llvm/CodeGen/GlobalISel/IRTranslator.h"
 #include "llvm/CodeGen/GlobalISel/InstructionSelect.h"
-#include "llvm/CodeGen/GlobalISel/MachineLegalizePass.h"
+#include "llvm/CodeGen/GlobalISel/Legalizer.h"
 #include "llvm/CodeGen/GlobalISel/RegBankSelect.h"
 #include "llvm/CodeGen/Passes.h"
 #include "llvm/CodeGen/RegAllocRegistry.h"
@@ -202,7 +202,7 @@ namespace {
 struct AArch64GISelActualAccessor : public GISelAccessor {
   std::unique_ptr<CallLowering> CallLoweringInfo;
   std::unique_ptr<InstructionSelector> InstSelector;
-  std::unique_ptr<MachineLegalizer> Legalizer;
+  std::unique_ptr<LegalizerInfo> Legalizer;
   std::unique_ptr<RegisterBankInfo> RegBankInfo;
   const CallLowering *getCallLowering() const override {
     return CallLoweringInfo.get();
@@ -210,7 +210,7 @@ struct AArch64GISelActualAccessor : public GISelAccessor {
   const InstructionSelector *getInstructionSelector() const override {
     return InstSelector.get();
   }
-  const class MachineLegalizer *getMachineLegalizer() const override {
+  const class LegalizerInfo *getLegalizerInfo() const override {
     return Legalizer.get();
   }
   const RegisterBankInfo *getRegBankInfo() const override {
@@ -247,7 +247,7 @@ AArch64TargetMachine::getSubtargetImpl(const Function &F) const {
         new AArch64GISelActualAccessor();
     GISel->CallLoweringInfo.reset(
         new AArch64CallLowering(*I->getTargetLowering()));
-    GISel->Legalizer.reset(new AArch64MachineLegalizer());
+    GISel->Legalizer.reset(new AArch64LegalizerInfo());
 
     auto *RBI = new AArch64RegisterBankInfo(*I->getRegisterInfo());
 
@@ -399,7 +399,7 @@ bool AArch64PassConfig::addIRTranslator() {
   return false;
 }
 bool AArch64PassConfig::addLegalizeMachineIR() {
-  addPass(new MachineLegalizePass());
+  addPass(new Legalizer());
   return false;
 }
 bool AArch64PassConfig::addRegBankSelect() {
diff --git a/llvm/lib/Target/AArch64/CMakeLists.txt b/llvm/lib/Target/AArch64/CMakeLists.txt
index 9af0ed6..300a6ea 100644
--- a/llvm/lib/Target/AArch64/CMakeLists.txt
+++ b/llvm/lib/Target/AArch64/CMakeLists.txt
@@ -20,7 +20,7 @@ add_public_tablegen_target(AArch64CommonTableGen)
 set(GLOBAL_ISEL_FILES
       AArch64CallLowering.cpp
       AArch64InstructionSelector.cpp
-      AArch64MachineLegalizer.cpp
+      AArch64LegalizerInfo.cpp
       AArch64RegisterBankInfo.cpp
       )
 
diff --git a/llvm/test/CodeGen/AArch64/GlobalISel/legalize-add.mir b/llvm/test/CodeGen/AArch64/GlobalISel/legalize-add.mir
index 6bd1aa1..c151ee6 100644
--- a/llvm/test/CodeGen/AArch64/GlobalISel/legalize-add.mir
+++ b/llvm/test/CodeGen/AArch64/GlobalISel/legalize-add.mir
@@ -1,4 +1,4 @@
-# RUN: llc -O0 -run-pass=legalize-mir -global-isel %s -o - 2>&1 | FileCheck %s
+# RUN: llc -O0 -run-pass=legalizer -global-isel %s -o - 2>&1 | FileCheck %s
 
 --- |
   target datalayout = "e-m:o-i64:64-i128:128-n32:64-S128"
diff --git a/llvm/test/CodeGen/AArch64/GlobalISel/legalize-and.mir b/llvm/test/CodeGen/AArch64/GlobalISel/legalize-and.mir
index 92f8f55..69459bf 100644
--- a/llvm/test/CodeGen/AArch64/GlobalISel/legalize-and.mir
+++ b/llvm/test/CodeGen/AArch64/GlobalISel/legalize-and.mir
@@ -1,4 +1,4 @@
-# RUN: llc -O0 -run-pass=legalize-mir -global-isel %s -o - 2>&1 | FileCheck %s
+# RUN: llc -O0 -run-pass=legalizer -global-isel %s -o - 2>&1 | FileCheck %s
 
 --- |
   target datalayout = "e-m:o-i64:64-i128:128-n32:64-S128"
diff --git a/llvm/test/CodeGen/AArch64/GlobalISel/legalize-cmp.mir b/llvm/test/CodeGen/AArch64/GlobalISel/legalize-cmp.mir
index 0ed367f..926a627 100644
--- a/llvm/test/CodeGen/AArch64/GlobalISel/legalize-cmp.mir
+++ b/llvm/test/CodeGen/AArch64/GlobalISel/legalize-cmp.mir
@@ -1,4 +1,4 @@
-# RUN: llc -O0 -run-pass=legalize-mir -global-isel %s -o - 2>&1 | FileCheck %s
+# RUN: llc -O0 -run-pass=legalizer -global-isel %s -o - 2>&1 | FileCheck %s
 
 --- |
   target datalayout = "e-m:o-i64:64-i128:128-n32:64-S128"
diff --git a/llvm/test/CodeGen/AArch64/GlobalISel/legalize-combines.mir b/llvm/test/CodeGen/AArch64/GlobalISel/legalize-combines.mir
index fc39705..cc1dc80 100644
--- a/llvm/test/CodeGen/AArch64/GlobalISel/legalize-combines.mir
+++ b/llvm/test/CodeGen/AArch64/GlobalISel/legalize-combines.mir
@@ -1,4 +1,4 @@
-# RUN: llc -O0 -run-pass=legalize-mir -global-isel %s -o - 2>&1 | FileCheck %s
+# RUN: llc -O0 -run-pass=legalizer -global-isel %s -o - 2>&1 | FileCheck %s
 
 --- |
   target datalayout = "e-m:o-i64:64-i128:128-n32:64-S128"
diff --git a/llvm/test/CodeGen/AArch64/GlobalISel/legalize-constant.mir b/llvm/test/CodeGen/AArch64/GlobalISel/legalize-constant.mir
index 1bdf43d..69a1ceb 100644
--- a/llvm/test/CodeGen/AArch64/GlobalISel/legalize-constant.mir
+++ b/llvm/test/CodeGen/AArch64/GlobalISel/legalize-constant.mir
@@ -1,4 +1,4 @@
-# RUN: llc -O0 -run-pass=legalize-mir -global-isel %s -o - 2>&1 | FileCheck %s
+# RUN: llc -O0 -run-pass=legalizer -global-isel %s -o - 2>&1 | FileCheck %s
 
 --- |
   target datalayout = "e-m:o-i64:64-i128:128-n32:64-S128"
diff --git a/llvm/test/CodeGen/AArch64/GlobalISel/legalize-div.mir b/llvm/test/CodeGen/AArch64/GlobalISel/legalize-div.mir
index f3da2cb..aaef45d 100644
--- a/llvm/test/CodeGen/AArch64/GlobalISel/legalize-div.mir
+++ b/llvm/test/CodeGen/AArch64/GlobalISel/legalize-div.mir
@@ -1,4 +1,4 @@
-# RUN: llc -O0 -run-pass=legalize-mir -global-isel %s -o - 2>&1 | FileCheck %s
+# RUN: llc -O0 -run-pass=legalizer -global-isel %s -o - 2>&1 | FileCheck %s
 
 --- |
   target datalayout = "e-m:o-i64:64-i128:128-n32:64-S128"
diff --git a/llvm/test/CodeGen/AArch64/GlobalISel/legalize-ext.mir b/llvm/test/CodeGen/AArch64/GlobalISel/legalize-ext.mir
index a826561..9907f00 100644
--- a/llvm/test/CodeGen/AArch64/GlobalISel/legalize-ext.mir
+++ b/llvm/test/CodeGen/AArch64/GlobalISel/legalize-ext.mir
@@ -1,4 +1,4 @@
-# RUN: llc -O0 -run-pass=legalize-mir -global-isel %s -o - 2>&1 | FileCheck %s
+# RUN: llc -O0 -run-pass=legalizer -global-isel %s -o - 2>&1 | FileCheck %s
 
 --- |
   target datalayout = "e-m:o-i64:64-i128:128-n32:64-S128"
diff --git a/llvm/test/CodeGen/AArch64/GlobalISel/legalize-fcmp.mir b/llvm/test/CodeGen/AArch64/GlobalISel/legalize-fcmp.mir
index 3e1722c..72bd613 100644
--- a/llvm/test/CodeGen/AArch64/GlobalISel/legalize-fcmp.mir
+++ b/llvm/test/CodeGen/AArch64/GlobalISel/legalize-fcmp.mir
@@ -1,4 +1,4 @@
-# RUN: llc -O0 -run-pass=legalize-mir -global-isel %s -o - 2>&1 | FileCheck %s
+# RUN: llc -O0 -run-pass=legalizer -global-isel %s -o - 2>&1 | FileCheck %s
 
 --- |
   target datalayout = "e-m:o-i64:64-i128:128-n32:64-S128"
diff --git a/llvm/test/CodeGen/AArch64/GlobalISel/legalize-gep.mir b/llvm/test/CodeGen/AArch64/GlobalISel/legalize-gep.mir
index 8a038f5..3f11c12 100644
--- a/llvm/test/CodeGen/AArch64/GlobalISel/legalize-gep.mir
+++ b/llvm/test/CodeGen/AArch64/GlobalISel/legalize-gep.mir
@@ -1,4 +1,4 @@
-# RUN: llc -O0 -run-pass=legalize-mir -global-isel %s -o - 2>&1 | FileCheck %s
+# RUN: llc -O0 -run-pass=legalizer -global-isel %s -o - 2>&1 | FileCheck %s
 
 --- |
   target datalayout = "e-m:o-i64:64-i128:128-n32:64-S128"
diff --git a/llvm/test/CodeGen/AArch64/GlobalISel/legalize-ignore-non-generic.mir b/llvm/test/CodeGen/AArch64/GlobalISel/legalize-ignore-non-generic.mir
index 55a12e1..43aa06b 100644
--- a/llvm/test/CodeGen/AArch64/GlobalISel/legalize-ignore-non-generic.mir
+++ b/llvm/test/CodeGen/AArch64/GlobalISel/legalize-ignore-non-generic.mir
@@ -1,4 +1,4 @@
-# RUN: llc -O0 -run-pass=legalize-mir -global-isel %s -o - | FileCheck %s
+# RUN: llc -O0 -run-pass=legalizer -global-isel %s -o - | FileCheck %s
 
 --- |
   target datalayout = "e-m:o-i64:64-i128:128-n32:64-S128"
diff --git a/llvm/test/CodeGen/AArch64/GlobalISel/legalize-load-store.mir b/llvm/test/CodeGen/AArch64/GlobalISel/legalize-load-store.mir
index 2ecb8d5..6a86686 100644
--- a/llvm/test/CodeGen/AArch64/GlobalISel/legalize-load-store.mir
+++ b/llvm/test/CodeGen/AArch64/GlobalISel/legalize-load-store.mir
@@ -1,4 +1,4 @@
-# RUN: llc -O0 -run-pass=legalize-mir -global-isel %s -o - 2>&1 | FileCheck %s
+# RUN: llc -O0 -run-pass=legalizer -global-isel %s -o - 2>&1 | FileCheck %s
 
 --- |
   target datalayout = "e-m:o-i64:64-i128:128-n32:64-S128"
diff --git a/llvm/test/CodeGen/AArch64/GlobalISel/legalize-mul.mir b/llvm/test/CodeGen/AArch64/GlobalISel/legalize-mul.mir
index 2c5c4c8..eb642d4 100644
--- a/llvm/test/CodeGen/AArch64/GlobalISel/legalize-mul.mir
+++ b/llvm/test/CodeGen/AArch64/GlobalISel/legalize-mul.mir
@@ -1,4 +1,4 @@
-# RUN: llc -O0 -run-pass=legalize-mir -global-isel %s -o - 2>&1 | FileCheck %s
+# RUN: llc -O0 -run-pass=legalizer -global-isel %s -o - 2>&1 | FileCheck %s
 
 --- |
   target datalayout = "e-m:o-i64:64-i128:128-n32:64-S128"
diff --git a/llvm/test/CodeGen/AArch64/GlobalISel/legalize-or.mir b/llvm/test/CodeGen/AArch64/GlobalISel/legalize-or.mir
index 93a1d68..edf10cd 100644
--- a/llvm/test/CodeGen/AArch64/GlobalISel/legalize-or.mir
+++ b/llvm/test/CodeGen/AArch64/GlobalISel/legalize-or.mir
@@ -1,4 +1,4 @@
-# RUN: llc -O0 -run-pass=legalize-mir -global-isel %s -o - 2>&1 | FileCheck %s
+# RUN: llc -O0 -run-pass=legalizer -global-isel %s -o - 2>&1 | FileCheck %s
 
 --- |
   target datalayout = "e-m:o-i64:64-i128:128-n32:64-S128"
diff --git a/llvm/test/CodeGen/AArch64/GlobalISel/legalize-property.mir b/llvm/test/CodeGen/AArch64/GlobalISel/legalize-property.mir
index 1551236..1381484 100644
--- a/llvm/test/CodeGen/AArch64/GlobalISel/legalize-property.mir
+++ b/llvm/test/CodeGen/AArch64/GlobalISel/legalize-property.mir
@@ -1,4 +1,4 @@
-# RUN: llc -O0 -run-pass=legalize-mir -global-isel %s -o - | FileCheck %s
+# RUN: llc -O0 -run-pass=legalizer -global-isel %s -o - | FileCheck %s
 
 --- |
   target datalayout = "e-m:o-i64:64-i128:128-n32:64-S128"
diff --git a/llvm/test/CodeGen/AArch64/GlobalISel/legalize-rem.mir b/llvm/test/CodeGen/AArch64/GlobalISel/legalize-rem.mir
index b2584e5..e77f348 100644
--- a/llvm/test/CodeGen/AArch64/GlobalISel/legalize-rem.mir
+++ b/llvm/test/CodeGen/AArch64/GlobalISel/legalize-rem.mir
@@ -1,4 +1,4 @@
-# RUN: llc -O0 -run-pass=legalize-mir -global-isel %s -o - 2>&1 | FileCheck %s
+# RUN: llc -O0 -run-pass=legalizer -global-isel %s -o - 2>&1 | FileCheck %s
 
 --- |
   target datalayout = "e-m:o-i64:64-i128:128-n32:64-S128"
diff --git a/llvm/test/CodeGen/AArch64/GlobalISel/legalize-simple.mir b/llvm/test/CodeGen/AArch64/GlobalISel/legalize-simple.mir
index c4968a9..41a9c33 100644
--- a/llvm/test/CodeGen/AArch64/GlobalISel/legalize-simple.mir
+++ b/llvm/test/CodeGen/AArch64/GlobalISel/legalize-simple.mir
@@ -1,4 +1,4 @@
-# RUN: llc -O0 -run-pass=legalize-mir -global-isel %s -o - 2>&1 | FileCheck %s
+# RUN: llc -O0 -run-pass=legalizer -global-isel %s -o - 2>&1 | FileCheck %s
 
 --- |
   target datalayout = "e-m:o-i64:64-i128:128-n32:64-S128"
diff --git a/llvm/test/CodeGen/AArch64/GlobalISel/legalize-sub.mir b/llvm/test/CodeGen/AArch64/GlobalISel/legalize-sub.mir
index c657bc3..e5403cb 100644
--- a/llvm/test/CodeGen/AArch64/GlobalISel/legalize-sub.mir
+++ b/llvm/test/CodeGen/AArch64/GlobalISel/legalize-sub.mir
@@ -1,4 +1,4 @@
-# RUN: llc -O0 -run-pass=legalize-mir -global-isel %s -o - 2>&1 | FileCheck %s
+# RUN: llc -O0 -run-pass=legalizer -global-isel %s -o - 2>&1 | FileCheck %s
 
 --- |
   target datalayout = "e-m:o-i64:64-i128:128-n32:64-S128"
diff --git a/llvm/test/CodeGen/AArch64/GlobalISel/legalize-xor.mir b/llvm/test/CodeGen/AArch64/GlobalISel/legalize-xor.mir
index 6325fbd..919e674 100644
--- a/llvm/test/CodeGen/AArch64/GlobalISel/legalize-xor.mir
+++ b/llvm/test/CodeGen/AArch64/GlobalISel/legalize-xor.mir
@@ -1,4 +1,4 @@
-# RUN: llc -O0 -run-pass=legalize-mir -global-isel %s -o - 2>&1 | FileCheck %s
+# RUN: llc -O0 -run-pass=legalizer -global-isel %s -o - 2>&1 | FileCheck %s
 
 --- |
   target datalayout = "e-m:o-i64:64-i128:128-n32:64-S128"
diff --git a/llvm/test/CodeGen/AArch64/arm64-AnInfiniteLoopInDAGCombine.ll b/llvm/test/CodeGen/AArch64/arm64-AnInfiniteLoopInDAGCombine.ll
index 378b915..226026f 100644
--- a/llvm/test/CodeGen/AArch64/arm64-AnInfiniteLoopInDAGCombine.ll
+++ b/llvm/test/CodeGen/AArch64/arm64-AnInfiniteLoopInDAGCombine.ll
@@ -20,4 +20,4 @@ entry:
   %sext = shl <4 x i32> %mul.i, <i32 16, i32 16, i32 16, i32 16>
   %vmovl.i.i = ashr <4 x i32> %sext, <i32 16, i32 16, i32 16, i32 16>
   ret <4 x i32> %vmovl.i.i
-}
\ No newline at end of file
+}
diff --git a/llvm/test/CodeGen/AArch64/arm64-fp-contract-zero.ll b/llvm/test/CodeGen/AArch64/arm64-fp-contract-zero.ll
index f982cbb..70548ca 100644
--- a/llvm/test/CodeGen/AArch64/arm64-fp-contract-zero.ll
+++ b/llvm/test/CodeGen/AArch64/arm64-fp-contract-zero.ll
@@ -11,4 +11,4 @@ define double @test_fms_fold(double %a, double %b) {
   %mul1 = fmul double %b, 0.000000e+00
   %sub = fsub double %mul, %mul1
   ret double %sub
-}
\ No newline at end of file
+}
diff --git a/llvm/test/CodeGen/AArch64/arm64-subsections.ll b/llvm/test/CodeGen/AArch64/arm64-subsections.ll
index 316e7c3..1449b85 100644
--- a/llvm/test/CodeGen/AArch64/arm64-subsections.ll
+++ b/llvm/test/CodeGen/AArch64/arm64-subsections.ll
@@ -2,4 +2,4 @@
 ; RUN: llc -mtriple=arm64-linux-gnu -o - %s | FileCheck %s --check-prefix=CHECK-ELF
 
 ; CHECK-MACHO: .subsections_via_symbols
-; CHECK-ELF-NOT: .subsections_via_symbols
\ No newline at end of file
+; CHECK-ELF-NOT: .subsections_via_symbols
diff --git a/llvm/test/CodeGen/AArch64/branch-relax-alignment.ll b/llvm/test/CodeGen/AArch64/branch-relax-alignment.ll
index d82afc1..7135dff 100644
--- a/llvm/test/CodeGen/AArch64/branch-relax-alignment.ll
+++ b/llvm/test/CodeGen/AArch64/branch-relax-alignment.ll
@@ -26,4 +26,4 @@ bb1:
   ret i32 0
 }
 
-attributes #0 = { nounwind }
\ No newline at end of file
+attributes #0 = { nounwind }
diff --git a/llvm/test/CodeGen/AArch64/simple-macho.ll b/llvm/test/CodeGen/AArch64/simple-macho.ll
index e9dd98e..2c2ad8a 100644
--- a/llvm/test/CodeGen/AArch64/simple-macho.ll
+++ b/llvm/test/CodeGen/AArch64/simple-macho.ll
@@ -9,4 +9,4 @@ define void @foo() {
 ; CHECK-OBJ: 0: c0 03 5f d6 ret
 
   ret void
-}
\ No newline at end of file
+}
diff --git a/llvm/unittests/CodeGen/GlobalISel/CMakeLists.txt b/llvm/unittests/CodeGen/GlobalISel/CMakeLists.txt
index 1669835..94e3115 100644
--- a/llvm/unittests/CodeGen/GlobalISel/CMakeLists.txt
+++ b/llvm/unittests/CodeGen/GlobalISel/CMakeLists.txt
@@ -5,6 +5,6 @@ set(LLVM_LINK_COMPONENTS
 
 if(LLVM_BUILD_GLOBAL_ISEL)
   add_llvm_unittest(GlobalISelTests
-          MachineLegalizerTest.cpp
+          LegalizerInfoTest.cpp
           )
 endif()
diff --git a/llvm/unittests/CodeGen/GlobalISel/LegalizerInfoTest.cpp b/llvm/unittests/CodeGen/GlobalISel/LegalizerInfoTest.cpp
new file mode 100644
index 0000000..882df5f
--- /dev/null
+++ b/llvm/unittests/CodeGen/GlobalISel/LegalizerInfoTest.cpp
@@ -0,0 +1,120 @@
+//===- llvm/unittest/CodeGen/GlobalISel/LegalizerInfoTest.cpp -------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/CodeGen/GlobalISel/LegalizerInfo.h"
+#include "llvm/Target/TargetOpcodes.h"
+#include "gtest/gtest.h"
+
+using namespace llvm;
+
+// Define a couple of pretty printers to help debugging when things go wrong.
+namespace llvm {
+std::ostream &
+operator<<(std::ostream &OS, const llvm::LegalizerInfo::LegalizeAction Act) {
+  switch (Act) {
+  case LegalizerInfo::Lower: OS << "Lower"; break;
+  case LegalizerInfo::Legal: OS << "Legal"; break;
+  case LegalizerInfo::NarrowScalar: OS << "NarrowScalar"; break;
+  case LegalizerInfo::WidenScalar:  OS << "WidenScalar"; break;
+  case LegalizerInfo::FewerElements:  OS << "FewerElements"; break;
+  case LegalizerInfo::MoreElements:  OS << "MoreElements"; break;
+  case LegalizerInfo::Libcall: OS << "Libcall"; break;
+  case LegalizerInfo::Custom: OS << "Custom"; break;
+  case LegalizerInfo::Unsupported: OS << "Unsupported"; break;
+  case LegalizerInfo::NotFound: OS << "NotFound";
+  }
+  return OS;
+}
+
+std::ostream &
+operator<<(std::ostream &OS, const llvm::LLT Ty) {
+  std::string Repr;
+  raw_string_ostream SS{Repr};
+  Ty.print(SS);
+  OS << SS.str();
+  return OS;
+}
+}
+
+namespace {
+
+
+TEST(LegalizerInfoTest, ScalarRISC) {
+  using namespace TargetOpcode;
+  LegalizerInfo L;
+  // Typical RISCy set of operations based on AArch64.
+  L.setAction({G_ADD, LLT::scalar(8)}, LegalizerInfo::WidenScalar);
+  L.setAction({G_ADD, LLT::scalar(16)}, LegalizerInfo::WidenScalar);
+  L.setAction({G_ADD, LLT::scalar(32)}, LegalizerInfo::Legal);
+  L.setAction({G_ADD, LLT::scalar(64)}, LegalizerInfo::Legal);
+  L.computeTables();
+
+  // Check we infer the correct types and actually do what we're told.
+  ASSERT_EQ(L.getAction({G_ADD, LLT::scalar(8)}),
+            std::make_pair(LegalizerInfo::WidenScalar, LLT::scalar(32)));
+  ASSERT_EQ(L.getAction({G_ADD, LLT::scalar(16)}),
+            std::make_pair(LegalizerInfo::WidenScalar, LLT::scalar(32)));
+  ASSERT_EQ(L.getAction({G_ADD, LLT::scalar(32)}),
+            std::make_pair(LegalizerInfo::Legal, LLT::scalar(32)));
+  ASSERT_EQ(L.getAction({G_ADD, LLT::scalar(64)}),
+            std::make_pair(LegalizerInfo::Legal, LLT::scalar(64)));
+
+  // Make sure the default for over-sized types applies.
+  ASSERT_EQ(L.getAction({G_ADD, LLT::scalar(128)}),
+            std::make_pair(LegalizerInfo::NarrowScalar, LLT::scalar(64)));
+}
+
+TEST(LegalizerInfoTest, VectorRISC) {
+  using namespace TargetOpcode;
+  LegalizerInfo L;
+  // Typical RISCy set of operations based on ARM.
+  L.setScalarInVectorAction(G_ADD, LLT::scalar(8), LegalizerInfo::Legal);
+  L.setScalarInVectorAction(G_ADD, LLT::scalar(16), LegalizerInfo::Legal);
+  L.setScalarInVectorAction(G_ADD, LLT::scalar(32), LegalizerInfo::Legal);
+
+  L.setAction({G_ADD, LLT::vector(8, 8)}, LegalizerInfo::Legal);
+  L.setAction({G_ADD, LLT::vector(16, 8)}, LegalizerInfo::Legal);
+  L.setAction({G_ADD, LLT::vector(4, 16)}, LegalizerInfo::Legal);
+  L.setAction({G_ADD, LLT::vector(8, 16)}, LegalizerInfo::Legal);
+  L.setAction({G_ADD, LLT::vector(2, 32)}, LegalizerInfo::Legal);
+  L.setAction({G_ADD, LLT::vector(4, 32)}, LegalizerInfo::Legal);
+  L.computeTables();
+
+  // Check we infer the correct types and actually do what we're told for some
+  // simple cases.
+  ASSERT_EQ(L.getAction({G_ADD, LLT::vector(2, 8)}),
+            std::make_pair(LegalizerInfo::MoreElements, LLT::vector(8, 8)));
+  ASSERT_EQ(L.getAction({G_ADD, LLT::vector(8, 8)}),
+            std::make_pair(LegalizerInfo::Legal, LLT::vector(8, 8)));
+  ASSERT_EQ(
+      L.getAction({G_ADD, LLT::vector(8, 32)}),
+      std::make_pair(LegalizerInfo::FewerElements, LLT::vector(4, 32)));
+}
+
+TEST(LegalizerInfoTest, MultipleTypes) {
+  using namespace TargetOpcode;
+  LegalizerInfo L;
+  LLT p0 = LLT::pointer(0, 64);
+  LLT s32 = LLT::scalar(32);
+  LLT s64 = LLT::scalar(64);
+
+  // Typical RISCy set of operations based on AArch64.
+  L.setAction({G_PTRTOINT, 0, s64}, LegalizerInfo::Legal);
+  L.setAction({G_PTRTOINT, 1, p0}, LegalizerInfo::Legal);
+
+  L.setAction({G_PTRTOINT, 0, s32}, LegalizerInfo::WidenScalar);
+  L.computeTables();
+
+  // Check we infer the correct types and actually do what we're told.
+  ASSERT_EQ(L.getAction({G_PTRTOINT, 0, s64}),
+            std::make_pair(LegalizerInfo::Legal, s64));
+  ASSERT_EQ(L.getAction({G_PTRTOINT, 1, p0}),
+            std::make_pair(LegalizerInfo::Legal, p0));
+}
+}
diff --git a/llvm/unittests/CodeGen/GlobalISel/MachineLegalizerTest.cpp b/llvm/unittests/CodeGen/GlobalISel/MachineLegalizerTest.cpp
deleted file mode 100644
index f4f61c2..0000000
--- a/llvm/unittests/CodeGen/GlobalISel/MachineLegalizerTest.cpp
+++ /dev/null
@@ -1,120 +0,0 @@
-//===- llvm/unittest/CodeGen/GlobalISel/MachineLegalizerTest.cpp ----------===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#include "llvm/CodeGen/GlobalISel/MachineLegalizer.h"
-#include "llvm/Target/TargetOpcodes.h"
-#include "gtest/gtest.h"
-
-using namespace llvm;
-
-// Define a couple of pretty printers to help debugging when things go wrong.
-namespace llvm {
-std::ostream &
-operator<<(std::ostream &OS, const llvm::MachineLegalizer::LegalizeAction Act) {
-  switch (Act) {
-  case MachineLegalizer::Lower: OS << "Lower"; break;
-  case MachineLegalizer::Legal: OS << "Legal"; break;
-  case MachineLegalizer::NarrowScalar: OS << "NarrowScalar"; break;
-  case MachineLegalizer::WidenScalar:  OS << "WidenScalar"; break;
-  case MachineLegalizer::FewerElements:  OS << "FewerElements"; break;
-  case MachineLegalizer::MoreElements:  OS << "MoreElements"; break;
-  case MachineLegalizer::Libcall: OS << "Libcall"; break;
-  case MachineLegalizer::Custom: OS << "Custom"; break;
-  case MachineLegalizer::Unsupported: OS << "Unsupported"; break;
-  case MachineLegalizer::NotFound: OS << "NotFound";
-  }
-  return OS;
-}
-
-std::ostream &
-operator<<(std::ostream &OS, const llvm::LLT Ty) {
-  std::string Repr;
-  raw_string_ostream SS{Repr};
-  Ty.print(SS);
-  OS << SS.str();
-  return OS;
-}
-}
-
-namespace {
-
-
-TEST(MachineLegalizerTest, ScalarRISC) {
-  using namespace TargetOpcode;
-  MachineLegalizer L;
-  // Typical RISCy set of operations based on AArch64.
-  L.setAction({G_ADD, LLT::scalar(8)}, MachineLegalizer::WidenScalar);
-  L.setAction({G_ADD, LLT::scalar(16)}, MachineLegalizer::WidenScalar);
-  L.setAction({G_ADD, LLT::scalar(32)}, MachineLegalizer::Legal);
-  L.setAction({G_ADD, LLT::scalar(64)}, MachineLegalizer::Legal);
-  L.computeTables();
-
-  // Check we infer the correct types and actually do what we're told.
-  ASSERT_EQ(L.getAction({G_ADD, LLT::scalar(8)}),
-            std::make_pair(MachineLegalizer::WidenScalar, LLT::scalar(32)));
-  ASSERT_EQ(L.getAction({G_ADD, LLT::scalar(16)}),
-            std::make_pair(MachineLegalizer::WidenScalar, LLT::scalar(32)));
-  ASSERT_EQ(L.getAction({G_ADD, LLT::scalar(32)}),
-            std::make_pair(MachineLegalizer::Legal, LLT::scalar(32)));
-  ASSERT_EQ(L.getAction({G_ADD, LLT::scalar(64)}),
-            std::make_pair(MachineLegalizer::Legal, LLT::scalar(64)));
-
-  // Make sure the default for over-sized types applies.
-  ASSERT_EQ(L.getAction({G_ADD, LLT::scalar(128)}),
-            std::make_pair(MachineLegalizer::NarrowScalar, LLT::scalar(64)));
-}
-
-TEST(MachineLegalizerTest, VectorRISC) {
-  using namespace TargetOpcode;
-  MachineLegalizer L;
-  // Typical RISCy set of operations based on ARM.
-  L.setScalarInVectorAction(G_ADD, LLT::scalar(8), MachineLegalizer::Legal);
-  L.setScalarInVectorAction(G_ADD, LLT::scalar(16), MachineLegalizer::Legal);
-  L.setScalarInVectorAction(G_ADD, LLT::scalar(32), MachineLegalizer::Legal);
-
-  L.setAction({G_ADD, LLT::vector(8, 8)}, MachineLegalizer::Legal);
-  L.setAction({G_ADD, LLT::vector(16, 8)}, MachineLegalizer::Legal);
-  L.setAction({G_ADD, LLT::vector(4, 16)}, MachineLegalizer::Legal);
-  L.setAction({G_ADD, LLT::vector(8, 16)}, MachineLegalizer::Legal);
-  L.setAction({G_ADD, LLT::vector(2, 32)}, MachineLegalizer::Legal);
-  L.setAction({G_ADD, LLT::vector(4, 32)}, MachineLegalizer::Legal);
-  L.computeTables();
-
-  // Check we infer the correct types and actually do what we're told for some
-  // simple cases.
-  ASSERT_EQ(L.getAction({G_ADD, LLT::vector(2, 8)}),
-            std::make_pair(MachineLegalizer::MoreElements, LLT::vector(8, 8)));
-  ASSERT_EQ(L.getAction({G_ADD, LLT::vector(8, 8)}),
-            std::make_pair(MachineLegalizer::Legal, LLT::vector(8, 8)));
-  ASSERT_EQ(
-      L.getAction({G_ADD, LLT::vector(8, 32)}),
-      std::make_pair(MachineLegalizer::FewerElements, LLT::vector(4, 32)));
-}
-
-TEST(MachineLegalizerTest, MultipleTypes) {
-  using namespace TargetOpcode;
-  MachineLegalizer L;
-  LLT p0 = LLT::pointer(0, 64);
-  LLT s32 = LLT::scalar(32);
-  LLT s64 = LLT::scalar(64);
-
-  // Typical RISCy set of operations based on AArch64.
-  L.setAction({G_PTRTOINT, 0, s64}, MachineLegalizer::Legal);
-  L.setAction({G_PTRTOINT, 1, p0}, MachineLegalizer::Legal);
-
-  L.setAction({G_PTRTOINT, 0, s32}, MachineLegalizer::WidenScalar);
-  L.computeTables();
-
-  // Check we infer the correct types and actually do what we're told.
-  ASSERT_EQ(L.getAction({G_PTRTOINT, 0, s64}),
-            std::make_pair(MachineLegalizer::Legal, s64));
-  ASSERT_EQ(L.getAction({G_PTRTOINT, 1, p0}),
-            std::make_pair(MachineLegalizer::Legal, p0));
-}
-}
-- 
2.7.4