[globalisel] Make LegalizerInfo::LegalizeAction available outside of LegalizerInfo. NFC

[dsanders]

Summary

The improvements to the LegalizerInfo discussed in D42244 require that
LegalizerInfo::LegalizeAction be available for use in other classes. As such,
it needs to be moved out of LegalizerInfo. This has been done separately to the
next patch to minimize the noise in that patch.

Depends on D42244

[dsanders]

Rebase and use a namespace instead of an enum class so that we can still use the shorter names with 'using namespace ...'
The type itself (but not the enumerators) is imported into the llvm namespace for the same reason.

[dsanders]

Include missing part of the updated patch

[dsanders]

D42251 has been LGTM'd and this is just moving an enum in preparation for that patch

[dsanders]

r323669

include/llvm/CodeGen/GlobalISel/LegalizationArtifactCombiner.h

if ((PrevMI == &DefMI ||
          DefMI.getOpcode() == TargetOpcode::G_MERGE_VALUES) &&
         MRI.hasOneUse(DefMI.getOperand(0).getReg()))
       DeadInsts.push_back(&DefMI);
   }
 
   /// Checks if the target legalizer info has specified anything about the
   /// instruction, or if unsupported.
   bool isInstUnsupported(const LegalityQuery &Query) const {
+    using namespace LegalizeActions;
     auto Step = LI.getAction(Query);
-    return Step.Action == LegalizerInfo::LegalizeAction::Unsupported ||
-           Step.Action == LegalizerInfo::LegalizeAction::NotFound;
+    return Step.Action == Unsupported || Step.Action == NotFound;
   }
 };
 
 } // namespace llvm

include/llvm/CodeGen/GlobalISel/LegalizerInfo.h

 #include <utility>
 
 namespace llvm {
 
 class MachineInstr;
 class MachineIRBuilder;
 class MachineRegisterInfo;
 
-/// Legalization is decided based on an instruction's opcode, which type slot
-/// we're considering, and what the existing type is. These aspects are gathered
-/// together for convenience in the InstrAspect class.
-struct InstrAspect {
-  unsigned Opcode;
-  unsigned Idx = 0;
-  LLT Type;
-
-  InstrAspect(unsigned Opcode, LLT Type) : Opcode(Opcode), Type(Type) {}
-  InstrAspect(unsigned Opcode, unsigned Idx, LLT Type)
-      : Opcode(Opcode), Idx(Idx), Type(Type) {}
-
-  bool operator==(const InstrAspect &RHS) const {
-    return Opcode == RHS.Opcode && Idx == RHS.Idx && Type == RHS.Type;
-  }
-};
-
-/// The LegalityQuery object bundles together all the information that's needed
-/// to decide whether a given operation is legal or not.
-/// For efficiency, it doesn't make a copy of Types so care must be taken not
-/// to free it before using the query.
-struct LegalityQuery {
-  unsigned Opcode;
-  ArrayRef<LLT> Types;
-
-  LegalityQuery(unsigned Opcode, ArrayRef<LLT> Types)
-      : Opcode(Opcode), Types(Types) {}
-};
-
-class LegalizerInfo {
-public:
-  enum LegalizeAction : std::uint8_t {
-    /// The operation is expected to be selectable directly by the target, and
-    /// no transformation is necessary.
-    Legal,
+namespace LegalizeActions {
 
-    /// The operation should be synthesized from multiple instructions acting on
-    /// a narrower scalar base-type. For example a 64-bit add might be
-    /// implemented in terms of 32-bit add-with-carry.
-    NarrowScalar,
 
-    /// The operation should be implemented in terms of a wider scalar
-    /// base-type. For example a <2 x s8> add could be implemented as a <2
-    /// x s32> add (ignoring the high bits).
-    WidenScalar,
 
-    /// The (vector) operation should be implemented by splitting it into
-    /// sub-vectors where the operation is legal. For example a <8 x s64> add
-    /// might be implemented as 4 separate <2 x s64> adds.
-    FewerElements,
 
-    /// The (vector) operation should be implemented by widening the input
-    /// vector and ignoring the lanes added by doing so. For example <2 x i8> is
-    /// rarely legal, but you might perform an <8 x i8> and then only look at
-    /// the first two results.
-    MoreElements,
 
-    /// The operation itself must be expressed in terms of simpler actions on
-    /// this target. E.g. a SREM replaced by an SDIV and subtraction.
-    Lower,
 
-    /// The operation should be implemented as a call to some kind of runtime
-    /// support library. For example this usually happens on machines that don't
-    /// support floating-point operations natively.
-    Libcall,
 
-    /// The target wants to do something special with this combination of
-    /// operand and type. A callback will be issued when it is needed.
-    Custom,
 
-    /// This operation is completely unsupported on the target. A programming
-    /// error has occurred.
-    Unsupported,
 
-    /// Sentinel value for when no action was found in the specified table.
-    NotFound,
-  };
+} // end namespace LegalizeActions
+
+/// Legalization is decided based on an instruction's opcode, which type slot
+/// we're considering, and what the existing type is. These aspects are gathered
+/// together for convenience in the InstrAspect class.
+struct InstrAspect {
+  unsigned Opcode;
+  unsigned Idx = 0;
+  LLT Type;
+
+  InstrAspect(unsigned Opcode, LLT Type) : Opcode(Opcode), Type(Type) {}
+  InstrAspect(unsigned Opcode, unsigned Idx, LLT Type)
+      : Opcode(Opcode), Idx(Idx), Type(Type) {}
+
+  bool operator==(const InstrAspect &RHS) const {
+    return Opcode == RHS.Opcode && Idx == RHS.Idx && Type == RHS.Type;
+  }
+};
 
+/// The LegalityQuery object bundles together all the information that's needed
+/// to decide whether a given operation is legal or not.
+/// For efficiency, it doesn't make a copy of Types so care must be taken not
+/// to free it before using the query.
+struct LegalityQuery {
+  unsigned Opcode;
+  ArrayRef<LLT> Types;
+
+  LegalityQuery(unsigned Opcode, ArrayRef<LLT> Types)
+      : Opcode(Opcode), Types(Types) {}
+};
+
+class LegalizerInfo {
+public:
   /// The result of a query. It either indicates a final answer of Legal or
   /// Unsupported or describes an action that must be taken to make an operation
   /// more legal.
   struct LegalizeActionStep {
     /// The action to take or the final answer.
-    LegalizeAction Action;
+    LegalizeActions::LegalizeAction Action;
     /// If describing an action, the type index to change. Otherwise zero.
     unsigned TypeIdx;
     /// If describing an action, the new type for TypeIdx. Otherwise LLT{}.
     LLT NewType;
 
-    LegalizeActionStep(LegalizeAction Action, unsigned TypeIdx,
+    LegalizeActionStep(LegalizeActions::LegalizeAction Action, unsigned TypeIdx,
                        const LLT &NewType)
         : Action(Action), TypeIdx(TypeIdx), NewType(NewType) {}
 
     bool operator==(const LegalizeActionStep &Other) const {
       return Action == Other.Action && TypeIdx == Other.TypeIdx &&
              NewType == Other.NewType;
     }
   };
 
   LegalizerInfo();
   virtual ~LegalizerInfo() = default;
 
   /// Compute any ancillary tables needed to quickly decide how an operation
   /// should be handled. This must be called after all "set*Action"methods but
   /// before any query is made or incorrect results may be returned.
   void computeTables();
 
-  static bool needsLegalizingToDifferentSize(const LegalizeAction Action) {
+  static bool
+  needsLegalizingToDifferentSize(const LegalizeActions::LegalizeAction Action) {
+    using namespace LegalizeActions;
     switch (Action) {
     case NarrowScalar:
     case WidenScalar:
     case FewerElements:
     case MoreElements:
     case Unsupported:
       return true;
     default:
       return false;
     }
   }
 
-  typedef std::pair<uint16_t, LegalizeAction> SizeAndAction;
+  typedef std::pair<uint16_t, LegalizeActions::LegalizeAction> SizeAndAction;
   typedef std::vector<SizeAndAction> SizeAndActionsVec;
   using SizeChangeStrategy =
       std::function<SizeAndActionsVec(const SizeAndActionsVec &v)>;
 
   /// More friendly way to set an action for common types that have an LLT
   /// representation.
   /// The LegalizeAction must be one for which NeedsLegalizingToDifferentSize
   /// returns false.
-  void setAction(const InstrAspect &Aspect, LegalizeAction Action) {
+  void setAction(const InstrAspect &Aspect,
+                 LegalizeActions::LegalizeAction Action) {
     assert(!needsLegalizingToDifferentSize(Action));
     TablesInitialized = false;
     const unsigned OpcodeIdx = Aspect.Opcode - FirstOp;
     if (SpecifiedActions[OpcodeIdx].size() <= Aspect.Idx)
       SpecifiedActions[OpcodeIdx].resize(Aspect.Idx + 1);
     SpecifiedActions[OpcodeIdx][Aspect.Idx][Aspect.Type] = Action;
   }
 
public:
   ///   setAction ({G_DIV, 0, LLT::scalar(32)}, Legal);
   ///   setAction ({G_DIV, 0, LLT::scalar(64)}, Legal);
   ///   setLegalizeScalarToDifferentSizeStrategy(
   ///     G_DIV, 0, unsupportedForDifferentSizes);
   /// will result in getAction({G_DIV, 0, T}) to return Legal for s32 and s64,
   /// and Unsupported for all other scalar types T.
   static SizeAndActionsVec
   unsupportedForDifferentSizes(const SizeAndActionsVec &v) {
+    using namespace LegalizeActions;
     return increaseToLargerTypesAndDecreaseToLargest(v, Unsupported,
-                                                        Unsupported);
   }
 
   /// A SizeChangeStrategy for the common case where legalization for a
   /// particular operation consists of widening the type to a large legal type,
   /// unless there is no such type and then instead it should be narrowed to the
   /// largest legal type.
   static SizeAndActionsVec
   widenToLargerTypesAndNarrowToLargest(const SizeAndActionsVec &v) {
+    using namespace LegalizeActions;
     assert(v.size() > 0 &&
            "At least one size that can be legalized towards is needed"
            " for this SizeChangeStrategy");
     return increaseToLargerTypesAndDecreaseToLargest(v, WidenScalar,
-                                                        NarrowScalar);
   }
 
   static SizeAndActionsVec
   widenToLargerTypesUnsupportedOtherwise(const SizeAndActionsVec &v) {
+    using namespace LegalizeActions;
     return increaseToLargerTypesAndDecreaseToLargest(v, WidenScalar,
-                                                        Unsupported);
   }
 
   static SizeAndActionsVec
   narrowToSmallerAndUnsupportedIfTooSmall(const SizeAndActionsVec &v) {
+    using namespace LegalizeActions;
     return decreaseToSmallerTypesAndIncreaseToSmallest(v, NarrowScalar,
-                                                          Unsupported);
   }
 
   static SizeAndActionsVec
   narrowToSmallerAndWidenToSmallest(const SizeAndActionsVec &v) {
+    using namespace LegalizeActions;
     assert(v.size() > 0 &&
            "At least one size that can be legalized towards is needed"
            " for this SizeChangeStrategy");
     return decreaseToSmallerTypesAndIncreaseToSmallest(v, NarrowScalar,
-                                                          WidenScalar);
   }
 
   /// A SizeChangeStrategy for the common case where legalization for a
   /// particular vector operation consists of having more elements in the
   /// vector, to a type that is legal. Unless there is no such type and then
   /// instead it should be legalized towards the widest vector that's still
   /// legal. E.g.
   ///   setAction({G_ADD, LLT::vector(8, 8)}, Legal);
   ///   setAction({G_ADD, LLT::vector(16, 8)}, Legal);
   ///   setAction({G_ADD, LLT::vector(2, 32)}, Legal);
   ///   setAction({G_ADD, LLT::vector(4, 32)}, Legal);
   ///   setLegalizeVectorElementToDifferentSizeStrategy(
   ///     G_ADD, 0, moreToWiderTypesAndLessToWidest);
   /// will result in the following getAction results:
   ///   * getAction({G_ADD, LLT::vector(8,8)}) returns
   ///       (Legal, vector(8,8)).
   ///   * getAction({G_ADD, LLT::vector(9,8)}) returns
   ///       (MoreElements, vector(16,8)).
   ///   * getAction({G_ADD, LLT::vector(8,32)}) returns
   ///       (FewerElements, vector(4,32)).
   static SizeAndActionsVec
   moreToWiderTypesAndLessToWidest(const SizeAndActionsVec &v) {
+    using namespace LegalizeActions;
     return increaseToLargerTypesAndDecreaseToLargest(v, MoreElements,
-                                                        FewerElements);
   }
 
   /// Helper function to implement many typical SizeChangeStrategy functions.
-  static SizeAndActionsVec
-  increaseToLargerTypesAndDecreaseToLargest(const SizeAndActionsVec &v,
-                                            LegalizeAction IncreaseAction,
-                                            LegalizeAction DecreaseAction);
+  static SizeAndActionsVec increaseToLargerTypesAndDecreaseToLargest(
+      const SizeAndActionsVec &v,
+      LegalizeActions::LegalizeAction IncreaseAction,
+      LegalizeActions::LegalizeAction DecreaseAction);
   /// Helper function to implement many typical SizeChangeStrategy functions.
-  static SizeAndActionsVec
-  decreaseToSmallerTypesAndIncreaseToSmallest(const SizeAndActionsVec &v,
-                                              LegalizeAction DecreaseAction,
-                                              LegalizeAction IncreaseAction);
+  static SizeAndActionsVec decreaseToSmallerTypesAndIncreaseToSmallest(
+      const SizeAndActionsVec &v,
+      LegalizeActions::LegalizeAction DecreaseAction,
+      LegalizeActions::LegalizeAction IncreaseAction);
 
   /// Determine what action should be taken to legalize the described
   /// instruction. Requires computeTables to have been called.
   ///
   /// \returns a description of the next legalization step to perform.
   LegalizeActionStep getAction(const LegalityQuery &Query) const;
 
   /// Determine what action should be taken to legalize the given generic

 
 private:
   /// Determine what action should be taken to legalize the given generic
   /// instruction opcode, type-index and type. Requires computeTables to have
   /// been called.
   ///
   /// \returns a pair consisting of the kind of legalization that should be
   /// performed and the destination type.
-  std::pair<LegalizeAction, LLT>
+  std::pair<LegalizeActions::LegalizeAction, LLT>
   getAspectAction(const InstrAspect &Aspect) const;
 
   /// The SizeAndActionsVec is a representation mapping between all natural
   /// numbers and an Action. The natural number represents the bit size of
   /// the InstrAspect. For example, for a target with native support for 32-bit
   /// and 64-bit additions, you'd express that as:
   /// setScalarAction(G_ADD, 0,
   ///           {{1, WidenScalar},  // bit sizes [ 1, 31[
void setVectorNumElementAction(const unsigned Opcode,
     SmallVector<SizeAndActionsVec, 1> &Actions =
         NumElements2Actions[OpcodeIdx].find(ElementSize)->second;
     setActions(TypeIndex, Actions, SizeAndActions);
   }
 
   /// A partial SizeAndActionsVec potentially doesn't cover all bit sizes,
   /// i.e. it's OK if it doesn't start from size 1.
   static void checkPartialSizeAndActionsVector(const SizeAndActionsVec& v) {
+    using namespace LegalizeActions;
 #ifndef NDEBUG
     // The sizes should be in increasing order
     int prev_size = -1;
     for(auto SizeAndAction: v) {
       assert(SizeAndAction.first > prev_size);
       prev_size = SizeAndAction.first;
     }
     // - for every Widen action, there should be a larger bitsize that
#endif
   /// (WidenScalar, 32). After that, findLegalAction({G_REM, 32}) will
   /// probably be called, which should return (Lower, 32).
   /// This is assuming the setScalarAction on G_REM was something like:
   /// setScalarAction(G_REM, 0,
   ///           {{1, WidenScalar},  // bit sizes [ 1, 31[
   ///            {32, Lower},       // bit sizes [32, 33[
   ///            {33, NarrowScalar} // bit sizes [65, +inf[
   ///           });
-  std::pair<LegalizeAction, LLT>
+  std::pair<LegalizeActions::LegalizeAction, LLT>
   findScalarLegalAction(const InstrAspect &Aspect) const;
 
   /// Returns the next action needed towards legalizing the vector type.
-  std::pair<LegalizeAction, LLT>
+  std::pair<LegalizeActions::LegalizeAction, LLT>
   findVectorLegalAction(const InstrAspect &Aspect) const;
 
   static const int FirstOp = TargetOpcode::PRE_ISEL_GENERIC_OPCODE_START;
   static const int LastOp = TargetOpcode::PRE_ISEL_GENERIC_OPCODE_END;
 
   // Data structures used temporarily during construction of legality data:
-  typedef DenseMap<LLT, LegalizeAction> TypeMap;
+  typedef DenseMap<LLT, LegalizeActions::LegalizeAction> TypeMap;
   SmallVector<TypeMap, 1> SpecifiedActions[LastOp - FirstOp + 1];
   SmallVector<SizeChangeStrategy, 1>
       ScalarSizeChangeStrategies[LastOp - FirstOp + 1];
   SmallVector<SizeChangeStrategy, 1>
       VectorElementSizeChangeStrategies[LastOp - FirstOp + 1];
   bool TablesInitialized;
 
   // Data structures used by getAction:

lib/CodeGen/GlobalISel/LegalizerHelper.cpp

 #include "llvm/CodeGen/TargetSubtargetInfo.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/raw_ostream.h"
 
 
 #define DEBUG_TYPE "legalizer"
 
 using namespace llvm;
+using namespace LegalizeActions;
 
 LegalizerHelper::LegalizerHelper(MachineFunction &MF)
     : MRI(MF.getRegInfo()), LI(*MF.getSubtarget().getLegalizerInfo()) {
   MIRBuilder.setMF(MF);
 }
 
 LegalizerHelper::LegalizeResult
 LegalizerHelper::legalizeInstrStep(MachineInstr &MI) {
   DEBUG(dbgs() << "Legalizing: "; MI.print(dbgs()));
 
   auto Step = LI.getAction(MI, MRI);
   switch (Step.Action) {
-  case LegalizerInfo::Legal:
+  case Legal:
     DEBUG(dbgs() << ".. Already legal\n");
     return AlreadyLegal;
-  case LegalizerInfo::Libcall:
+  case Libcall:
     DEBUG(dbgs() << ".. Convert to libcall\n");
     return libcall(MI);
-  case LegalizerInfo::NarrowScalar:
+  case NarrowScalar:
     DEBUG(dbgs() << ".. Narrow scalar\n");
     return narrowScalar(MI, Step.TypeIdx, Step.NewType);
-  case LegalizerInfo::WidenScalar:
+  case WidenScalar:
     DEBUG(dbgs() << ".. Widen scalar\n");
     return widenScalar(MI, Step.TypeIdx, Step.NewType);
-  case LegalizerInfo::Lower:
+  case Lower:
     DEBUG(dbgs() << ".. Lower\n");
     return lower(MI, Step.TypeIdx, Step.NewType);
-  case LegalizerInfo::FewerElements:
+  case FewerElements:
     DEBUG(dbgs() << ".. Reduce number of elements\n");
     return fewerElementsVector(MI, Step.TypeIdx, Step.NewType);
-  case LegalizerInfo::Custom:
+  case Custom:
     DEBUG(dbgs() << ".. Custom legalization\n");
     return LI.legalizeCustom(MI, MRI, MIRBuilder) ? Legalized
                                                   : UnableToLegalize;
   default:
     DEBUG(dbgs() << ".. Unable to legalize\n");
     return UnableToLegalize;
   }
 }
MIRBuilder.buildInstr(TargetOpcode::G_FSUB)
         .addUse(MI.getOperand(1).getReg());
     MI.eraseFromParent();
     return Legalized;
   }
   case TargetOpcode::G_FSUB: {
     // Lower (G_FSUB LHS, RHS) to (G_FADD LHS, (G_FNEG RHS)).
     // First, check if G_FNEG is marked as Lower. If so, we may
     // end up with an infinite loop as G_FSUB is used to legalize G_FNEG.
-    if (LI.getAction({G_FNEG, {Ty}}).Action == LegalizerInfo::Lower)
+    if (LI.getAction({G_FNEG, {Ty}}).Action == Lower)
       return UnableToLegalize;
     unsigned Res = MI.getOperand(0).getReg();
     unsigned LHS = MI.getOperand(1).getReg();
     unsigned RHS = MI.getOperand(2).getReg();
     unsigned Neg = MRI.createGenericVirtualRegister(Ty);
     MIRBuilder.buildInstr(TargetOpcode::G_FNEG).addDef(Neg).addUse(RHS);
     MIRBuilder.buildInstr(TargetOpcode::G_FADD)
         .addDef(Res)

lib/CodeGen/GlobalISel/LegalizerInfo.cpp

 #include "llvm/CodeGen/MachineRegisterInfo.h"
 #include "llvm/CodeGen/TargetOpcodes.h"
 #include "llvm/MC/MCInstrDesc.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/LowLevelTypeImpl.h"
 #include "llvm/Support/MathExtras.h"
 #include <algorithm>
 #include <map>
+
 using namespace llvm;
+using namespace LegalizeActions;
 
 LegalizerInfo::LegalizerInfo() : TablesInitialized(false) {
   // Set defaults.
   // FIXME: these two (G_ANYEXT and G_TRUNC?) can be legalized to the
   // fundamental load/store Jakob proposed. Once loads & stores are supported.
   setScalarAction(TargetOpcode::G_ANYEXT, 1, {{1, Legal}});
   setScalarAction(TargetOpcode::G_ZEXT, 1, {{1, Legal}});
   setScalarAction(TargetOpcode::G_SEXT, 1, {{1, Legal}});
void LegalizerInfo::computeTables() {
 
   TablesInitialized = true;
 }
 
 // FIXME: inefficient implementation for now. Without ComputeValueVTs we're
 // 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<LegalizerInfo::LegalizeAction, LLT>
+std::pair<LegalizeAction, LLT>
 LegalizerInfo::getAspectAction(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.
   if (Aspect.Type.isScalar() || Aspect.Type.isPointer())
     return findScalarLegalAction(Aspect);
   assert(Aspect.Type.isVector());
   return findVectorLegalAction(Aspect);
LegalizerInfo::findAction(const SizeAndActionsVec &Vec, const uint32_t Size) {
   case Unsupported:
     return {Size, Unsupported};
   case NotFound:
     llvm_unreachable("NotFound");
   }
   llvm_unreachable("Action has an unknown enum value");
 }
 
-std::pair<LegalizerInfo::LegalizeAction, LLT>
+std::pair<LegalizeAction, LLT>
 LegalizerInfo::findScalarLegalAction(const InstrAspect &Aspect) const {
   assert(Aspect.Type.isScalar() || Aspect.Type.isPointer());
   if (Aspect.Opcode < FirstOp || Aspect.Opcode > LastOp)
     return {NotFound, LLT()};
   const unsigned OpcodeIdx = Aspect.Opcode - FirstOp;
   if (Aspect.Type.isPointer() &&
       AddrSpace2PointerActions[OpcodeIdx].find(Aspect.Type.getAddressSpace()) ==
           AddrSpace2PointerActions[OpcodeIdx].end()) {
LegalizerInfo::findScalarLegalAction(const InstrAspect &Aspect) const {
   // queries?
   auto SizeAndAction = findAction(Vec, Aspect.Type.getSizeInBits());
   return {SizeAndAction.second,
           Aspect.Type.isScalar() ? LLT::scalar(SizeAndAction.first)
                                  : LLT::pointer(Aspect.Type.getAddressSpace(),
                                                 SizeAndAction.first)};
 }
 
-std::pair<LegalizerInfo::LegalizeAction, LLT>
+std::pair<LegalizeAction, LLT>
 LegalizerInfo::findVectorLegalAction(const InstrAspect &Aspect) const {
   assert(Aspect.Type.isVector());
   // First legalize the vector element size, then legalize the number of
   // lanes in the vector.
   if (Aspect.Opcode < FirstOp || Aspect.Opcode > LastOp)
     return {NotFound, Aspect.Type};
   const unsigned OpcodeIdx = Aspect.Opcode - FirstOp;
   const unsigned TypeIdx = Aspect.Idx;

lib/Target/AArch64/AArch64LegalizerInfo.cpp

 #include "llvm/CodeGen/MachineInstr.h"
 #include "llvm/CodeGen/MachineRegisterInfo.h"
 #include "llvm/CodeGen/TargetOpcodes.h"
 #include "llvm/CodeGen/ValueTypes.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/Type.h"
 
 using namespace llvm;
+using namespace LegalizeActions;
 
 /// FIXME: The following static functions are SizeChangeStrategy functions
 /// that are meant to temporarily mimic the behaviour of the old legalization
 /// based on doubling/halving non-legal types as closely as possible. This is
 /// not entirly possible as only legalizing the types that are exactly a power
 /// of 2 times the size of the legal types would require specifying all those
 /// sizes explicitly.
 /// In practice, not specifying those isn't a problem, and the below functions
 /// should disappear quickly as we add support for legalizing non-power-of-2
 /// sized types further.
 static void
 addAndInterleaveWithUnsupported(LegalizerInfo::SizeAndActionsVec &result,
                                 const LegalizerInfo::SizeAndActionsVec &v) {
   for (unsigned i = 0; i < v.size(); ++i) {
     result.push_back(v[i]);
     if (i + 1 < v[i].first && i + 1 < v.size() &&
         v[i + 1].first != v[i].first + 1)
-      result.push_back({v[i].first + 1, LegalizerInfo::Unsupported});
+      result.push_back({v[i].first + 1, Unsupported});
   }
 }
 
 static LegalizerInfo::SizeAndActionsVec
 widen_1_narrow_128_ToLargest(const LegalizerInfo::SizeAndActionsVec &v) {
   assert(v.size() >= 1);
   assert(v[0].first > 2);
-  LegalizerInfo::SizeAndActionsVec result = {{1, LegalizerInfo::WidenScalar},
-                                             {2, LegalizerInfo::Unsupported}};
+  LegalizerInfo::SizeAndActionsVec result = {{1, WidenScalar},
+                                             {2, Unsupported}};
   addAndInterleaveWithUnsupported(result, v);
   auto Largest = result.back().first;
   assert(Largest + 1 < 128);
-  result.push_back({Largest + 1, LegalizerInfo::Unsupported});
-  result.push_back({128, LegalizerInfo::NarrowScalar});
-  result.push_back({129, LegalizerInfo::Unsupported});
+  result.push_back({Largest + 1, Unsupported});
+  result.push_back({128, NarrowScalar});
+  result.push_back({129, Unsupported});
   return result;
 }
 
 static LegalizerInfo::SizeAndActionsVec
 widen_16(const LegalizerInfo::SizeAndActionsVec &v) {
   assert(v.size() >= 1);
   assert(v[0].first > 17);
-  LegalizerInfo::SizeAndActionsVec result = {{1, LegalizerInfo::Unsupported},
-                                             {16, LegalizerInfo::WidenScalar},
-                                             {17, LegalizerInfo::Unsupported}};
+  LegalizerInfo::SizeAndActionsVec result = {{1, Unsupported},
+                                             {16, WidenScalar},
+                                             {17, Unsupported}};
   addAndInterleaveWithUnsupported(result, v);
   auto Largest = result.back().first;
-  result.push_back({Largest + 1, LegalizerInfo::Unsupported});
+  result.push_back({Largest + 1, Unsupported});
   return result;
 }
 
 static LegalizerInfo::SizeAndActionsVec
 widen_1_8(const LegalizerInfo::SizeAndActionsVec &v) {
   assert(v.size() >= 1);
   assert(v[0].first > 9);
   LegalizerInfo::SizeAndActionsVec result = {
-      {1, LegalizerInfo::WidenScalar},  {2, LegalizerInfo::Unsupported},
-      {8, LegalizerInfo::WidenScalar},  {9, LegalizerInfo::Unsupported}};
+      {1, WidenScalar},  {2, Unsupported},
+      {8, WidenScalar},  {9, Unsupported}};
   addAndInterleaveWithUnsupported(result, v);
   auto Largest = result.back().first;
-  result.push_back({Largest + 1, LegalizerInfo::Unsupported});
+  result.push_back({Largest + 1, Unsupported});
   return result;
 }
 
 static LegalizerInfo::SizeAndActionsVec
 widen_1_8_16(const LegalizerInfo::SizeAndActionsVec &v) {
   assert(v.size() >= 1);
   assert(v[0].first > 17);
   LegalizerInfo::SizeAndActionsVec result = {
-      {1, LegalizerInfo::WidenScalar},  {2, LegalizerInfo::Unsupported},
-      {8, LegalizerInfo::WidenScalar},  {9, LegalizerInfo::Unsupported},
-      {16, LegalizerInfo::WidenScalar}, {17, LegalizerInfo::Unsupported}};
+      {1, WidenScalar},  {2, Unsupported},
+      {8, WidenScalar},  {9, Unsupported},
+      {16, WidenScalar}, {17, Unsupported}};
   addAndInterleaveWithUnsupported(result, v);
   auto Largest = result.back().first;
-  result.push_back({Largest + 1, LegalizerInfo::Unsupported});
+  result.push_back({Largest + 1, Unsupported});
   return result;
 }
 
 static LegalizerInfo::SizeAndActionsVec
 widen_1_8_16_narrowToLargest(const LegalizerInfo::SizeAndActionsVec &v) {
   assert(v.size() >= 1);
   assert(v[0].first > 17);
   LegalizerInfo::SizeAndActionsVec result = {
-      {1, LegalizerInfo::WidenScalar},  {2, LegalizerInfo::Unsupported},
-      {8, LegalizerInfo::WidenScalar},  {9, LegalizerInfo::Unsupported},
-      {16, LegalizerInfo::WidenScalar}, {17, LegalizerInfo::Unsupported}};
+      {1, WidenScalar},  {2, Unsupported},
+      {8, WidenScalar},  {9, Unsupported},
+      {16, WidenScalar}, {17, Unsupported}};
   addAndInterleaveWithUnsupported(result, v);
   auto Largest = result.back().first;
-  result.push_back({Largest + 1, LegalizerInfo::NarrowScalar});
+  result.push_back({Largest + 1, NarrowScalar});
   return result;
 }
 
 static LegalizerInfo::SizeAndActionsVec
 widen_1_8_16_32(const LegalizerInfo::SizeAndActionsVec &v) {
   assert(v.size() >= 1);
   assert(v[0].first > 33);
   LegalizerInfo::SizeAndActionsVec result = {
-      {1, LegalizerInfo::WidenScalar},  {2, LegalizerInfo::Unsupported},
-      {8, LegalizerInfo::WidenScalar},  {9, LegalizerInfo::Unsupported},
-      {16, LegalizerInfo::WidenScalar}, {17, LegalizerInfo::Unsupported},
-      {32, LegalizerInfo::WidenScalar}, {33, LegalizerInfo::Unsupported}};
+      {1, WidenScalar},  {2, Unsupported},
+      {8, WidenScalar},  {9, Unsupported},
+      {16, WidenScalar}, {17, Unsupported},
+      {32, WidenScalar}, {33, Unsupported}};
   addAndInterleaveWithUnsupported(result, v);
   auto Largest = result.back().first;
-  result.push_back({Largest + 1, LegalizerInfo::Unsupported});
+  result.push_back({Largest + 1, Unsupported});
   return result;
 }
 
 AArch64LegalizerInfo::AArch64LegalizerInfo(const AArch64Subtarget &ST) {
   using namespace TargetOpcode;
   const LLT p0 = LLT::pointer(0, 64);
   const LLT s1 = LLT::scalar(1);
   const LLT s8 = LLT::scalar(8);

unittests/CodeGen/GlobalISel/LegalizerInfoTest.cpp

 //===- 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/CodeGen/TargetOpcodes.h"
 #include "gtest/gtest.h"
 
 using namespace llvm;
+using namespace LegalizeActions;
 
 // 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) {
+operator<<(std::ostream &OS, const 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";
+  case Lower: OS << "Lower"; break;
+  case Legal: OS << "Legal"; break;
+  case NarrowScalar: OS << "NarrowScalar"; break;
+  case WidenScalar:  OS << "WidenScalar"; break;
+  case FewerElements:  OS << "FewerElements"; break;
+  case MoreElements:  OS << "MoreElements"; break;
+  case Libcall: OS << "Libcall"; break;
+  case Custom: OS << "Custom"; break;
+  case Unsupported: OS << "Unsupported"; break;
+  case 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.
   for (unsigned Op : {G_ADD, G_SUB}) {
     for (unsigned Size : {32, 64})
-      L.setAction({Op, 0, LLT::scalar(Size)}, LegalizerInfo::Legal);
+      L.setAction({Op, 0, LLT::scalar(Size)}, Legal);
     L.setLegalizeScalarToDifferentSizeStrategy(
         Op, 0, LegalizerInfo::widenToLargerTypesAndNarrowToLargest);
   }
 
   L.computeTables();
 
   for (unsigned opcode : {G_ADD, G_SUB}) {
     // Check we infer the correct types and actually do what we're told.
     ASSERT_EQ(L.getAction({opcode, {LLT::scalar(8)}}),
-              LegalizerInfo::LegalizeActionStep(LegalizerInfo::WidenScalar, 0, LLT::scalar(32)));
+              LegalizerInfo::LegalizeActionStep(WidenScalar, 0, LLT::scalar(32)));
     ASSERT_EQ(L.getAction({opcode, {LLT::scalar(16)}}),
-              LegalizerInfo::LegalizeActionStep(LegalizerInfo::WidenScalar, 0, LLT::scalar(32)));
+              LegalizerInfo::LegalizeActionStep(WidenScalar, 0, LLT::scalar(32)));
     ASSERT_EQ(L.getAction({opcode, {LLT::scalar(32)}}),
-              LegalizerInfo::LegalizeActionStep(LegalizerInfo::Legal, 0, LLT{}));
+              LegalizerInfo::LegalizeActionStep(Legal, 0, LLT{}));
     ASSERT_EQ(L.getAction({opcode, {LLT::scalar(64)}}),
-              LegalizerInfo::LegalizeActionStep(LegalizerInfo::Legal, 0, LLT{}));
+              LegalizerInfo::LegalizeActionStep(Legal, 0, LLT{}));
 
     // Make sure the default for over-sized types applies.
     ASSERT_EQ(L.getAction({opcode, {LLT::scalar(128)}}),
-              LegalizerInfo::LegalizeActionStep(LegalizerInfo::NarrowScalar, 0, LLT::scalar(64)));
+              LegalizerInfo::LegalizeActionStep(NarrowScalar, 0, LLT::scalar(64)));
     // Make sure we also handle unusual sizes
     ASSERT_EQ(L.getAction({opcode, {LLT::scalar(1)}}),
-              LegalizerInfo::LegalizeActionStep(LegalizerInfo::WidenScalar, 0, LLT::scalar(32)));
+              LegalizerInfo::LegalizeActionStep(WidenScalar, 0, LLT::scalar(32)));
     ASSERT_EQ(L.getAction({opcode, {LLT::scalar(31)}}),
-              LegalizerInfo::LegalizeActionStep(LegalizerInfo::WidenScalar, 0, LLT::scalar(32)));
+              LegalizerInfo::LegalizeActionStep(WidenScalar, 0, LLT::scalar(32)));
     ASSERT_EQ(L.getAction({opcode, {LLT::scalar(33)}}),
-              LegalizerInfo::LegalizeActionStep(LegalizerInfo::WidenScalar, 0, LLT::scalar(64)));
+              LegalizerInfo::LegalizeActionStep(WidenScalar, 0, LLT::scalar(64)));
     ASSERT_EQ(L.getAction({opcode, {LLT::scalar(63)}}),
-              LegalizerInfo::LegalizeActionStep(LegalizerInfo::WidenScalar, 0, LLT::scalar(64)));
+              LegalizerInfo::LegalizeActionStep(WidenScalar, 0, LLT::scalar(64)));
     ASSERT_EQ(L.getAction({opcode, {LLT::scalar(65)}}),
-              LegalizerInfo::LegalizeActionStep(LegalizerInfo::NarrowScalar, 0, LLT::scalar(64)));
+              LegalizerInfo::LegalizeActionStep(NarrowScalar, 0, LLT::scalar(64)));
   }
 }
 
 TEST(LegalizerInfoTest, VectorRISC) {
   using namespace TargetOpcode;
   LegalizerInfo L;
   // Typical RISCy set of operations based on ARM.
-  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.setAction({G_ADD, LLT::vector(8, 8)}, Legal);
+  L.setAction({G_ADD, LLT::vector(16, 8)}, Legal);
+  L.setAction({G_ADD, LLT::vector(4, 16)}, Legal);
+  L.setAction({G_ADD, LLT::vector(8, 16)}, Legal);
+  L.setAction({G_ADD, LLT::vector(2, 32)}, Legal);
+  L.setAction({G_ADD, LLT::vector(4, 32)}, Legal);
 
   L.setLegalizeVectorElementToDifferentSizeStrategy(
       G_ADD, 0, LegalizerInfo::widenToLargerTypesUnsupportedOtherwise);
 
-  L.setAction({G_ADD, 0, LLT::scalar(32)}, LegalizerInfo::Legal);
+  L.setAction({G_ADD, 0, LLT::scalar(32)}, 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(8, 8)}}),
-            LegalizerInfo::LegalizeActionStep(LegalizerInfo::Legal, 0, LLT{}));
+            LegalizerInfo::LegalizeActionStep(Legal, 0, LLT{}));
   ASSERT_EQ(L.getAction({G_ADD, {LLT::vector(8, 7)}}),
-            LegalizerInfo::LegalizeActionStep(LegalizerInfo::WidenScalar, 0, LLT::vector(8, 8)));
+            LegalizerInfo::LegalizeActionStep(WidenScalar, 0, LLT::vector(8, 8)));
   ASSERT_EQ(L.getAction({G_ADD, {LLT::vector(2, 8)}}),
-            LegalizerInfo::LegalizeActionStep(LegalizerInfo::MoreElements, 0, LLT::vector(8, 8)));
+            LegalizerInfo::LegalizeActionStep(MoreElements, 0, LLT::vector(8, 8)));
   ASSERT_EQ(L.getAction({G_ADD, {LLT::vector(8, 32)}}),
-            LegalizerInfo::LegalizeActionStep(LegalizerInfo::FewerElements, 0, LLT::vector(4, 32)));
+            LegalizerInfo::LegalizeActionStep(FewerElements, 0, LLT::vector(4, 32)));
   // Check a few non-power-of-2 sizes:
   ASSERT_EQ(L.getAction({G_ADD, {LLT::vector(3, 3)}}),
-            LegalizerInfo::LegalizeActionStep(LegalizerInfo::WidenScalar, 0, LLT::vector(3, 8)));
+            LegalizerInfo::LegalizeActionStep(WidenScalar, 0, LLT::vector(3, 8)));
   ASSERT_EQ(L.getAction({G_ADD, {LLT::vector(3, 8)}}),
-            LegalizerInfo::LegalizeActionStep(LegalizerInfo::MoreElements, 0, LLT::vector(8, 8)));
+            LegalizerInfo::LegalizeActionStep(MoreElements, 0, LLT::vector(8, 8)));
 }
 
 TEST(LegalizerInfoTest, MultipleTypes) {
   using namespace TargetOpcode;
   LegalizerInfo L;
   LLT p0 = LLT::pointer(0, 64);
   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, s64}, Legal);
+  L.setAction({G_PTRTOINT, 1, p0}, Legal);
 
   L.setLegalizeScalarToDifferentSizeStrategy(
       G_PTRTOINT, 0, LegalizerInfo::widenToLargerTypesAndNarrowToLargest);
 
   L.computeTables();
 
   // Check we infer the correct types and actually do what we're told.
   ASSERT_EQ(L.getAction({G_PTRTOINT, {s64, p0}}),
-            LegalizerInfo::LegalizeActionStep(LegalizerInfo::Legal, 0, LLT{}));
+            LegalizerInfo::LegalizeActionStep(Legal, 0, LLT{}));
 
   // Make sure we also handle unusual sizes
   ASSERT_EQ(
       L.getAction({G_PTRTOINT, {LLT::scalar(65), s64}}),
-      LegalizerInfo::LegalizeActionStep(LegalizerInfo::NarrowScalar, 0, s64));
+      LegalizerInfo::LegalizeActionStep(NarrowScalar, 0, s64));
   ASSERT_EQ(
       L.getAction({G_PTRTOINT, {s64, LLT::pointer(0, 32)}}),
-      LegalizerInfo::LegalizeActionStep(LegalizerInfo::Unsupported, 1, LLT::pointer(0, 32)));
+      LegalizerInfo::LegalizeActionStep(Unsupported, 1, LLT::pointer(0, 32)));
 }
 
 TEST(LegalizerInfoTest, MultipleSteps) {
   using namespace TargetOpcode;
   LegalizerInfo L;
   LLT s32 = LLT::scalar(32);
   LLT s64 = LLT::scalar(64);
 
   L.setLegalizeScalarToDifferentSizeStrategy(
       G_UREM, 0, LegalizerInfo::widenToLargerTypesUnsupportedOtherwise);
-  L.setAction({G_UREM, 0, s32}, LegalizerInfo::Lower);
-  L.setAction({G_UREM, 0, s64}, LegalizerInfo::Lower);
+  L.setAction({G_UREM, 0, s32}, Lower);
+  L.setAction({G_UREM, 0, s64}, Lower);
 
   L.computeTables();
 
   ASSERT_EQ(L.getAction({G_UREM, {LLT::scalar(16)}}),
-            LegalizerInfo::LegalizeActionStep(LegalizerInfo::WidenScalar, 0, LLT::scalar(32)));
+            LegalizerInfo::LegalizeActionStep(WidenScalar, 0, LLT::scalar(32)));
   ASSERT_EQ(L.getAction({G_UREM, {LLT::scalar(32)}}),
-            LegalizerInfo::LegalizeActionStep(LegalizerInfo::Lower, 0, LLT::scalar(32)));
+            LegalizerInfo::LegalizeActionStep(Lower, 0, LLT::scalar(32)));
 }
 
 TEST(LegalizerInfoTest, SizeChangeStrategy) {
   using namespace TargetOpcode;
   LegalizerInfo L;
   for (unsigned Size : {1, 8, 16, 32})
-    L.setAction({G_UREM, 0, LLT::scalar(Size)}, LegalizerInfo::Legal);
+    L.setAction({G_UREM, 0, LLT::scalar(Size)}, Legal);
 
   L.setLegalizeScalarToDifferentSizeStrategy(
       G_UREM, 0, LegalizerInfo::widenToLargerTypesUnsupportedOtherwise);
   L.computeTables();
 
   // Check we infer the correct types and actually do what we're told.
   for (unsigned Size : {1, 8, 16, 32}) {
     ASSERT_EQ(L.getAction({G_UREM, {LLT::scalar(Size)}}),
-              LegalizerInfo::LegalizeActionStep(LegalizerInfo::Legal, 0, LLT{}));
+              LegalizerInfo::LegalizeActionStep(Legal, 0, LLT{}));
   }
   ASSERT_EQ(L.getAction({G_UREM, {LLT::scalar(2)}}),
-            LegalizerInfo::LegalizeActionStep(LegalizerInfo::WidenScalar, 0, LLT::scalar(8)));
+            LegalizerInfo::LegalizeActionStep(WidenScalar, 0, LLT::scalar(8)));
   ASSERT_EQ(L.getAction({G_UREM, {LLT::scalar(7)}}),
-            LegalizerInfo::LegalizeActionStep(LegalizerInfo::WidenScalar, 0, LLT::scalar(8)));
+            LegalizerInfo::LegalizeActionStep(WidenScalar, 0, LLT::scalar(8)));
   ASSERT_EQ(L.getAction({G_UREM, {LLT::scalar(9)}}),
-            LegalizerInfo::LegalizeActionStep(LegalizerInfo::WidenScalar, 0, LLT::scalar(16)));
+            LegalizerInfo::LegalizeActionStep(WidenScalar, 0, LLT::scalar(16)));
   ASSERT_EQ(L.getAction({G_UREM, {LLT::scalar(17)}}),
-            LegalizerInfo::LegalizeActionStep(LegalizerInfo::WidenScalar, 0, LLT::scalar(32)));
+            LegalizerInfo::LegalizeActionStep(WidenScalar, 0, LLT::scalar(32)));
   ASSERT_EQ(L.getAction({G_UREM, {LLT::scalar(31)}}),
-            LegalizerInfo::LegalizeActionStep(LegalizerInfo::WidenScalar, 0, LLT::scalar(32)));
+            LegalizerInfo::LegalizeActionStep(WidenScalar, 0, LLT::scalar(32)));
   ASSERT_EQ(L.getAction({G_UREM, {LLT::scalar(33)}}),
-            LegalizerInfo::LegalizeActionStep(LegalizerInfo::Unsupported, 0, LLT::scalar(33)));
+            LegalizerInfo::LegalizeActionStep(Unsupported, 0, LLT::scalar(33)));
 }
 }