GlobalISel: Make default implementation of legalizeCustom unreachable

[arsenm]

Summary

If the target explicitly requested custom legalization, it should be
required to implement this. Also move default legalizeIntrinsic
implementation into the header so it's next to the related
legalizeCustom.

[arsenm]

0f2af15c1b00a08b84b780143001e04a25994628

llvm/include/llvm/CodeGen/GlobalISel/LegalizerInfo.h

public:
 
   bool isLegal(const LegalityQuery &Query) const {
     return getAction(Query).Action == LegalizeAction::Legal;
   }
   bool isLegal(const MachineInstr &MI, const MachineRegisterInfo &MRI) const;
   bool isLegalOrCustom(const MachineInstr &MI,
                        const MachineRegisterInfo &MRI) const;
 
+  /// Called for instructions with the Custom LegalizationAction.
   virtual bool legalizeCustom(MachineInstr &MI, MachineRegisterInfo &MRI,
                               MachineIRBuilder &MIRBuilder,
-                              GISelChangeObserver &Observer) const;
+                              GISelChangeObserver &Observer) const {
+    llvm_unreachable("must implement this if custom action is used");
+  }
 
-  /// Return true if MI is either legal or has been legalized and false
-  /// if not legal.
+  /// \returns true if MI is either legal or has been legalized and false if not
+  /// legal.
   virtual bool legalizeIntrinsic(MachineInstr &MI, MachineIRBuilder &MIRBuilder,
-                                 GISelChangeObserver &Observer) const;
+                                 GISelChangeObserver &Observer) const {
+    return true;
+  }
 
   /// Return the opcode (SEXT/ZEXT/ANYEXT) that should be performed while
   /// widening a constant of type SmallTy which targets can override.
   /// For eg, the DAG does (SmallTy.isByteSized() ? G_SEXT : G_ZEXT) which
   /// will be the default.
   virtual unsigned getExtOpcodeForWideningConstant(LLT SmallTy) const;
 
 private:

llvm/lib/CodeGen/GlobalISel/LegalizerInfo.cpp

 bool LegalizerInfo::isLegalOrCustom(const MachineInstr &MI,
                                     const MachineRegisterInfo &MRI) const {
   auto Action = getAction(MI, MRI).Action;
   // If the action is custom, it may not necessarily modify the instruction,
   // so we have to assume it's legal.
   return Action == Legal || Action == Custom;
 }
 
-bool LegalizerInfo::legalizeCustom(MachineInstr &MI, MachineRegisterInfo &MRI,
-                                   MachineIRBuilder &MIRBuilder,
-                                   GISelChangeObserver &Observer) const {
-  return false;
-}
-
 LegalizerInfo::SizeAndActionsVec
 LegalizerInfo::increaseToLargerTypesAndDecreaseToLargest(
     const SizeAndActionsVec &v, LegalizeAction IncreaseAction,
     LegalizeAction DecreaseAction) {
   SizeAndActionsVec result;
   unsigned LargestSizeSoFar = 0;
   if (v.size() >= 1 && v[0].first != 1)
     result.push_back({1, IncreaseAction});
LegalizerInfo::findVectorLegalAction(const InstrAspect &Aspect) const {
   const SizeAndActionsVec &NumElementsVec = (*i).second[TypeIdx];
   auto NumElementsAndAction =
       findAction(NumElementsVec, IntermediateType.getNumElements());
   return {NumElementsAndAction.second,
           LLT::vector(NumElementsAndAction.first,
                       IntermediateType.getScalarSizeInBits())};
 }
 
-bool LegalizerInfo::legalizeIntrinsic(MachineInstr &MI,
-                                      MachineIRBuilder &MIRBuilder,
-                                      GISelChangeObserver &Observer) const {
-  return true;
-}
-
 unsigned LegalizerInfo::getExtOpcodeForWideningConstant(LLT SmallTy) const {
   return SmallTy.isByteSized() ? TargetOpcode::G_SEXT : TargetOpcode::G_ZEXT;
 }
 
 /// \pre Type indices of every opcode form a dense set starting from 0.
 void LegalizerInfo::verify(const MCInstrInfo &MII) const {
 #ifndef NDEBUG
   std::vector<unsigned> FailedOpcodes;