[GlobalISel] Cleanup Combine.td

[Pierre-vh]

Summary

Now that the old backend is gone, clean-up a few things that no longer make sense and tidy up the file a bit.

Depends on D158710

llvm/include/llvm/Target/GlobalISel/Combine.td

 //===- Combine.td - Combine rule definitions ---------------*- tablegen -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // Declare GlobalISel combine rules and provide mechanisms to opt-out.
 //
 //===----------------------------------------------------------------------===//
 
+
+//===----------------------------------------------------------------------===//
+// Base Classes
+//
+// These are the core classes that the combiner backend relies on.
+//===----------------------------------------------------------------------===//
+
+/// All arguments of the defs operator must be subclasses of GIDefKind or
+/// sub-dags whose operator is GIDefKindWithArgs.
+class GIDefKind;
+class GIDefKindWithArgs;
+
+/// Declare a root node. There must be at least one of these in every combine
+/// rule.
+def root : GIDefKind;
+
+def defs;
+
+def pattern;
+def match;
+def apply;
+
+def wip_match_opcode;
+
 // Common base class for GICombineRule and GICombineGroup.
 class GICombine {
   // See GICombineGroup. We only declare it here to make the tablegen pass
   // simpler.
   list<GICombine> Rules = ?;
 }
 
 // A group of combine rules that can be added to a GICombiner or another group.
 class GICombineGroup<list<GICombine> rules> : GICombine {
   // The rules contained in this group. The rules in a group are flattened into
   // a single list and sorted into whatever order is most efficient. However,
   // they will never be re-ordered such that behaviour differs from the
   // specified order. It is therefore possible to use the order of rules in this
   // list to describe priorities.
   let Rules = rules;
 }
 
-class GICombinerHelperArg<string type, string name> {
-  string Type = type;
-  string Name = name;
-}
-
-// Declares a combiner helper class
-class GICombinerHelper<string classname, list<GICombine> rules>
+// Declares a combiner implementation class
+class GICombiner<string classname, list<GICombine> rules>
     : GICombineGroup<rules> {
   // The class name to use in the generated output.
   string Classname = classname;
   // Combiners can use this so they're free to define tryCombineAll themselves
   // and do extra work before/after calling the TableGen-erated code.
   string CombineAllMethodName = "tryCombineAll";
-  // The name of a run-time compiler option that will be generated to disable
-  // specific rules within this combiner.
-  string DisableRuleOption = ?;
-  // The state class to inherit from (if any). The generated helper will inherit
-  // from this class and will forward arguments to its constructors.
-  string StateClass = "";
-  // Any additional arguments that should be appended to the tryCombine*().
-  list<GICombinerHelperArg> AdditionalArguments =
-      [GICombinerHelperArg<"CombinerHelper &", "Helper">];
 }
+
+/// Declares data that is passed from the match stage to the apply stage.
+class GIDefMatchData<string type>  {
+  /// A C++ type name indicating the storage type.
+  string Type = type;
+}
+
 class GICombineRule<dag defs, dag match, dag apply> : GICombine {
   /// Defines the external interface of the match rule. This includes:
   /// * The names of the root nodes (requires at least one)
   /// See GIDefKind for details.
   dag Defs = defs;
 
   /// Defines the things which must be true for the pattern to match
-  /// See GIMatchKind for details.
   dag Match = match;
 
   /// Defines the things which happen after the decision is made to apply a
   /// combine rule.
-  /// See GIApplyKind for details.
   dag Apply = apply;
 
   /// Defines the predicates that are checked before the match function
   /// is called. Targets can use this to, for instance, check Subtarget
   /// features.
   list<Predicate> Predicates = [];
 
   // Maximum number of permutations of this rule that can be emitted.
   // Set to -1 to disable the limit.
   int MaxPermutations = 16;
 }
 
-/// All arguments of the defs operator must be subclasses of GIDefKind or
-/// sub-dags whose operator is GIDefKindWithArgs.
-class GIDefKind;
-class GIDefKindWithArgs;
-/// Declare a root node. There must be at least one of these in every combine
-/// rule.
-/// TODO: The plan is to elide `root` definitions and determine it from the DAG
-///       itself with an overide for situations where the usual determination
-///       is incorrect.
-def root : GIDefKind;
-
 def gi_mo;
 def gi_imm;
-def pattern;
 
 // This is an equivalent of PatFrags but for MIR Patterns.
 //
 // GICombinePatFrags can be used in place of instructions for 'match' patterns.
 // Much like normal instructions, the defs (outs) come first, and the ins second
 //
 // Out operands can only be of type "root" or "gi_mo", and they must be defined
 // by an instruction pattern in all alternatives.
 //
 // In operands can be gi_imm or gi_mo. They cannot be redefined in any alternative
 // pattern and may only appear in the C++ code, or in the output operand of an
 // instruction pattern.
 class GICombinePatFrag<dag outs, dag ins, list<dag> alts> {
   dag InOperands = ins;
   dag OutOperands = outs;
   list<dag> Alternatives = alts;
 }
 
-/// The operator at the root of a GICombineRule.Defs dag.
-def defs;
-
-/// Declares data that is passed from the match stage to the apply stage.
-class GIDefMatchData<string type> : GIDefKind {
-  /// A C++ type name indicating the storage type.
-  string Type = type;
-}
+//===----------------------------------------------------------------------===//
 
 def extending_load_matchdata : GIDefMatchData<"PreferredTuple">;
 def indexed_load_store_matchdata : GIDefMatchData<"IndexedLoadStoreMatchInfo">;
 def instruction_steps_matchdata: GIDefMatchData<"InstructionStepsMatchInfo">;
 
-/// The operator at the root of a GICombineRule.Match dag.
-def match;
-/// All arguments of the match operator must be either:
-/// * A subclass of GIMatchKind
-/// * A subclass of GIMatchKindWithArgs
-/// * A subclass of Instruction
-/// * A MIR code block (deprecated)
-/// The GIMatchKind and GIMatchKindWithArgs cases are described in more detail
-/// in their definitions below.
-/// For the Instruction case, these are collected into a DAG where operand names
-/// that occur multiple times introduce edges.
-class GIMatchKind;
-class GIMatchKindWithArgs;
-
-/// In lieu of having proper macro support. Trivial one-off opcode checks can be
-/// performed with this.
-def wip_match_opcode : GIMatchKindWithArgs;
-
-/// The operator at the root of a GICombineRule.Apply dag.
-def apply;
-/// All arguments of the apply operator must be subclasses of GIApplyKind, or
-/// sub-dags whose operator is GIApplyKindWithArgs, or an MIR block
-/// (deprecated).
-class GIApplyKind;
-class GIApplyKindWithArgs;
-
 def register_matchinfo: GIDefMatchData<"Register">;
 def int64_matchinfo: GIDefMatchData<"int64_t">;
 def apint_matchinfo : GIDefMatchData<"APInt">;
 def build_fn_matchinfo :
 GIDefMatchData<"std::function<void(MachineIRBuilder &)>">;
 def unsigned_matchinfo: GIDefMatchData<"unsigned">;
 
 def copy_prop : GICombineRule<

llvm/lib/Target/AArch64/AArch64Combine.td

 def fold_global_offset_matchdata : GIDefMatchData<"std::pair<uint64_t, uint64_t>">;
 def fold_global_offset : GICombineRule<
   (defs root:$root, fold_global_offset_matchdata:$matchinfo),
   (match (wip_match_opcode G_GLOBAL_VALUE):$root,
           [{ return matchFoldGlobalOffset(*${root}, MRI, ${matchinfo}); }]),
   (apply [{ applyFoldGlobalOffset(*${root}, MRI, B, Observer, ${matchinfo});}])
 >;
 
-def AArch64PreLegalizerCombiner: GICombinerHelper<
+def AArch64PreLegalizerCombiner: GICombiner<
   "AArch64PreLegalizerCombinerImpl", [all_combines,
                                       fconstant_to_constant,
                                       icmp_redundant_trunc,
                                       fold_global_offset]> {
   let CombineAllMethodName = "tryCombineAllImpl";
 }
 
-def AArch64O0PreLegalizerCombiner: GICombinerHelper<
+def AArch64O0PreLegalizerCombiner: GICombiner<
   "AArch64O0PreLegalizerCombinerImpl", [optnone_combines]> {
   let CombineAllMethodName = "tryCombineAllImpl";
 }
 
 // Matchdata for combines which replace a G_SHUFFLE_VECTOR with a
 // target-specific opcode.
 def shuffle_matchdata : GIDefMatchData<"ShuffleVectorPseudo">;
 
(match (wip_match_opcode G_SEXT_INREG):$d,
           [{ return matchVectorSextInReg(*${d}, MRI); }]),
   (apply [{ applyVectorSextInReg(*${d}, MRI, B, Observer); }])
 >;
 
 // Post-legalization combines which should happen at all optimization levels.
 // (E.g. ones that facilitate matching for the selector) For example, matching
 // pseudos.
 def AArch64PostLegalizerLowering
-    : GICombinerHelper<"AArch64PostLegalizerLoweringImpl",
+    : GICombiner<"AArch64PostLegalizerLoweringImpl",
                        [shuffle_vector_lowering, vashr_vlshr_imm,
                         icmp_lowering, build_vector_lowering,
                         lower_vector_fcmp, form_truncstore,
                         vector_sext_inreg_to_shift]> {
 }
 
 // Post-legalization combines which are primarily optimizations.
 def AArch64PostLegalizerCombiner
-    : GICombinerHelper<"AArch64PostLegalizerCombinerImpl",
+    : GICombiner<"AArch64PostLegalizerCombinerImpl",
                        [copy_prop, combines_for_extload,
                         sext_trunc_sextload, mutate_anyext_to_zext,
                         hoist_logic_op_with_same_opcode_hands,
                         redundant_and, xor_of_and_with_same_reg,
                         extractvecelt_pairwise_add, redundant_or,
                         mul_const, redundant_sext_inreg,
                         form_bitfield_extract, rotate_out_of_range,
                         icmp_to_true_false_known_bits, merge_unmerge,
                         select_combines, fold_merge_to_zext,
                         constant_fold_binop, identity_combines,
                         ptr_add_immed_chain, overlapping_and,
                         split_store_zero_128, undef_combines,
                         select_to_minmax]> {
 }

llvm/lib/Target/AMDGPU/AMDGPUCombine.td

 } // End Predicates = [NotHasMed3_16]
 
 // Combines which should only apply on SI/CI
 def gfx6gfx7_combines : GICombineGroup<[fcmp_select_to_fmin_fmax_legacy]>;
 
 // Combines which should only apply on VI
 def gfx8_combines : GICombineGroup<[expand_promoted_fmed3]>;
 
-def AMDGPUPreLegalizerCombiner: GICombinerHelper<
+def AMDGPUPreLegalizerCombiner: GICombiner<
   "AMDGPUPreLegalizerCombinerImpl",
   [all_combines, clamp_i64_to_i16, foldable_fneg]> {
   let CombineAllMethodName = "tryCombineAllImpl";
 }
 
-def AMDGPUPostLegalizerCombiner: GICombinerHelper<
+def AMDGPUPostLegalizerCombiner: GICombiner<
   "AMDGPUPostLegalizerCombinerImpl",
   [all_combines, gfx6gfx7_combines, gfx8_combines,
    uchar_to_float, cvt_f32_ubyteN, remove_fcanonicalize, foldable_fneg,
    rcp_sqrt_to_rsq, sign_extension_in_reg]> {
   let CombineAllMethodName = "tryCombineAllImpl";
 }
 
-def AMDGPURegBankCombiner : GICombinerHelper<
+def AMDGPURegBankCombiner : GICombiner<
   "AMDGPURegBankCombinerImpl",
   [unmerge_merge, unmerge_cst, unmerge_undef,
    zext_trunc_fold, int_minmax_to_med3, ptr_add_immed_chain,
    fp_minmax_to_clamp, fp_minmax_to_med3, fmed3_intrinsic_to_clamp]> {
 }

llvm/lib/Target/Mips/MipsCombine.td

 //=- MipsCombine.td - Define Mips Combine Rules --------------*- tablegen -*-=//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 include "llvm/Target/GlobalISel/Combine.td"
 
-def MipsPostLegalizerCombiner: GICombinerHelper<
+def MipsPostLegalizerCombiner: GICombiner<
   "MipsPostLegalizerCombinerImpl", []> {
 }

llvm/test/TableGen/GlobalISelCombinerEmitter/match-table-imms.td

def InstTest1 : GICombineRule<
   (apply (COPY $a, (i32 0)))>;
 
 // emits a CImm because G_CONSTANT is a special case.
 def CImmInstTest1 : GICombineRule<
   (defs root:$a),
   (match (G_CONSTANT $a, (i32 0))),
   (apply (G_CONSTANT $a, (i32 42)))>;
 
-def MyCombiner: GICombinerHelper<"GenMyCombiner", [
+def MyCombiner: GICombiner<"GenMyCombiner", [
   InstTest0,
   InstTest1,
   CImmInstTest1
 ]>;
 
 // CHECK:      const int64_t *GenMyCombiner::getMatchTable() const {
 // CHECK-NEXT:   constexpr static int64_t MatchTable0[] = {
 // CHECK-NEXT:     GIM_Try, /*On fail goto*//*Label 0*/ 28, // Rule ID 0 //

llvm/test/TableGen/GlobalISelCombinerEmitter/match-table-operand-types.td

 
 def InstTest0 : GICombineRule<
   (defs root:$a),
   (match  (G_MUL i32:$x, i32:$b, i32:$c),
           (G_MUL $a, i32:$b, i32:$x)),
   (apply  (G_ADD i64:$tmp, $b, i32:$c),
           (G_ADD i8:$a, $b, i64:$tmp))>;
 
-def MyCombiner: GICombinerHelper<"GenMyCombiner", [
+def MyCombiner: GICombiner<"GenMyCombiner", [
   InstTest0,
 ]>;
 
 // CHECK:       const int64_t *GenMyCombiner::getMatchTable() const {
 // CHECK-NEXT:   constexpr static int64_t MatchTable0[] = {
 // CHECK-NEXT:     GIM_Try, /*On fail goto*//*Label 0*/ 73, // Rule ID 0 //
 // CHECK-NEXT:       GIM_CheckSimplePredicate, GICXXPred_Simple_IsRule0Enabled,
 // CHECK-NEXT:       GIM_CheckOpcode, /*MI*/0, TargetOpcode::G_MUL,

llvm/test/TableGen/GlobalISelCombinerEmitter/match-table-patfrag-root.td

[
       (pattern (G_FPEXT $foo, $z):$dbg1)
     ]>;
 
 def Test0 : GICombineRule<
   (defs root:$root),
   (match (MatchFooPerms $root, (i32 10))),
   (apply (COPY $root, (i32 0)))>;
 
-def MyCombiner: GICombinerHelper<"GenMyCombiner", [
+def MyCombiner: GICombiner<"GenMyCombiner", [
   Test0
 ]>;
 
 // CHECK:      const int64_t *GenMyCombiner::getMatchTable() const {
 // CHECK-NEXT:   constexpr static int64_t MatchTable0[] = {
 // CHECK-NEXT:     GIM_Try, /*On fail goto*//*Label 0*/ 44, // Rule ID 0 //
 // CHECK-NEXT:       GIM_CheckSimplePredicate, GICXXPred_Simple_IsRule0Enabled,
 // CHECK-NEXT:       GIM_CheckOpcode, /*MI*/0, TargetOpcode::G_ZEXT,

llvm/test/TableGen/GlobalISelCombinerEmitter/match-table-permutations.td

def Test0 : GICombineRule<
   (match (G_AND $dst, $cst0, $tmp),
          (G_AND $tmp, $cst1, $cst2),
          (MatchFooPerms $cst0, (i32 10)):$a,
          (MatchFooPerms $cst1, (i32 20)):$b,
          (MatchFooPerms $cst2, (i32 30)):$c
   ),
   (apply (COPY $dst, (i32 0)), "APPLY ${cst0}")>;
 
-def MyCombiner: GICombinerHelper<"GenMyCombiner", [
+def MyCombiner: GICombiner<"GenMyCombiner", [
   Test0
 ]>;
 
 // CHECK:      bool GenMyCombiner::testMIPredicate_MI(unsigned PredicateID, const MachineInstr & MI, const MatcherState &State) const {
 // CHECK-NEXT:   switch (PredicateID) {
 // CHECK-NEXT:   case GICXXPred_MI_Predicate_GICombiner0: {
 // CHECK-NEXT:     // Pattern Alternatives: [a[0], b[0], c[0]]
 // CHECK-NEXT:     return foo(State.MIs[2]->getOperand(1), 10)

llvm/test/TableGen/GlobalISelCombinerEmitter/match-table-variadics.td

def InstTest2 : GICombineRule<
   (match (G_UNMERGE_VALUES $a, $b)),
   (apply [{ APPLY }])>;
 
 def InstTest3 : GICombineRule<
   (defs root:$a),
   (match (G_UNMERGE_VALUES $a, $b, $c, $d)),
   (apply [{ APPLY }])>;
 
-def MyCombiner: GICombinerHelper<"GenMyCombiner", [
+def MyCombiner: GICombiner<"GenMyCombiner", [
   InstTest0,
   InstTest1,
   InstTest2,
   InstTest3
 ]>;
 
 // CHECK:      const int64_t *GenMyCombiner::getMatchTable() const {
 // CHECK-NEXT:   constexpr static int64_t MatchTable0[] = {

llvm/test/TableGen/GlobalISelCombinerEmitter/match-table.td

 
 def PatFragTest0 : GICombineRule<
   (defs root:$dst),
   (match (G_ZEXT $dst, $cst), (MatchICst $cst, (i32 0))),
   (apply (COPY $dst, (i32 0)))>;
 
 // TODO: add test with temp reg use
 
-def MyCombiner: GICombinerHelper<"GenMyCombiner", [
+def MyCombiner: GICombiner<"GenMyCombiner", [
   WipOpcodeTest0,
   WipOpcodeTest1,
   InstTest0,
   InstTest1,
   InOutInstTest0,
   InOutInstTest1,
   PatFragTest0
 ]>;

llvm/test/TableGen/GlobalISelCombinerEmitter/operand-types.td

[
       (pattern (G_BUILD_VECTOR i64:$cst, $y, $x), (G_BUILD_VECTOR $x, i8:$y, $w)),
       (pattern (G_BUILD_VECTOR i32:$cst, $y, i16:$x), (G_BUILD_VECTOR $x, i32:$y, $w)),
     ]>;
 def PatFragTest0 : GICombineRule<
   (defs root:$dst),
   (match (FooPF $dst)),
   (apply (COPY $dst, (i32 0)))>;
 
-def MyCombiner: GICombinerHelper<"GenMyCombiner", [
+def MyCombiner: GICombiner<"GenMyCombiner", [
   InstTest0,
   PatFragTest0
 ]>;

llvm/test/TableGen/GlobalISelCombinerEmitter/patfrag-errors.td

 // CHECK: :[[@LINE+1]]:{{[0-9]+}}: error: Failed to parse pattern: '(RootDefHasMultiDefs ?:$root, (i32 10))'
 def root_def_has_multi_defs : GICombineRule<
   (defs root:$root),
   (match (RootDefHasMultiDefs $root, (i32 10))),
   (apply (COPY $root, (i32 0)))>;
 
 // CHECK: error: Failed to parse one or more rules
 
-def MyCombiner: GICombinerHelper<"GenMyCombiner", [
+def MyCombiner: GICombiner<"GenMyCombiner", [
   too_many_perms,
   undef_livein,
   out_must_be_root,
   bad_out_type,
   unreachable_pat,
   wip_match_opcode_patfrag,
   nest_pat_frag,
   dup_params_in,

llvm/test/TableGen/GlobalISelCombinerEmitter/pattern-errors.td

 def def_named_imm_apply : GICombineRule<
   (defs root:$x),
   (match (G_FNEG $x, $y)),
   (apply (COPY i32:$tmp, $y),
          (COPY $x, (i32 0):$tmp):$foo)>;
 
 // CHECK: error: Failed to parse one or more rules
 
-def MyCombiner: GICombinerHelper<"GenMyCombiner", [
+def MyCombiner: GICombiner<"GenMyCombiner", [
   root_not_found,
   misleading_root,
   cxx_root,
   livein_root,
   not_enough_operands,
   too_many_operands,
   multi_defs,
   multi_defs_2,

llvm/test/TableGen/GlobalISelCombinerEmitter/pattern-parsing.td

 // CHECK-NEXT:   )
 // CHECK-NEXT: )
 def VariadicsOutTest : GICombineRule<
   (defs root:$a),
   (match (G_UNMERGE_VALUES $a, $b, $src)),
   (apply (COPY $a, (i32 0)),
          (COPY $b, (i32 0)))>;
 
-def MyCombiner: GICombinerHelper<"GenMyCombiner", [
+def MyCombiner: GICombiner<"GenMyCombiner", [
   WipOpcodeTest0,
   WipOpcodeTest1,
   InstTest0,
   InstTest1,
   InstTest2,
   InOutInstTest0,
   PatFragTest0,
   PatFragTest1,
   VariadicsInTest,
   VariadicsOutTest
 ]>;

llvm/utils/TableGen/GlobalISel/CombinerUtils.h

inline bool isSpecificDef(const Init &N, StringRef Def) {
   if (const DefInit *OpI = dyn_cast<DefInit>(&N))
     if (OpI->getDef()->getName() == Def)
       return true;
   return false;
 }
 
 /// A convenience function to check that an Init refers to a def that is a
 /// subclass of the given class and coerce it to a def if it is. This is
-/// primarily useful for testing for subclasses of GIMatchKind and similar in
+/// primarily useful for testing for subclasses of GIDefKind and similar in
 /// DagInit's since DagInit's support any type inside them.
 inline Record *getDefOfSubClass(const Init &N, StringRef Cls) {
   if (const DefInit *OpI = dyn_cast<DefInit>(&N))
     if (OpI->getDef()->isSubClassOf(Cls))
       return OpI->getDef();
   return nullptr;
 }
 
 /// A convenience function to check that an Init refers to a dag whose operator
 /// is a specific def and coerce it to a dag if it is. This is primarily useful
-/// for testing for subclasses of GIMatchKind and similar in DagInit's since
+/// for testing for subclasses of GIDefKind and similar in DagInit's since
 /// DagInit's support any type inside them.
 inline const DagInit *getDagWithSpecificOperator(const Init &N,
                                                  StringRef Name) {
   if (const DagInit *I = dyn_cast<DagInit>(&N))
     if (I->getNumArgs() > 0)
       if (const DefInit *OpI = dyn_cast<DefInit>(I->getOperator()))
         if (OpI->getDef()->getName() == Name)
           return I;
   return nullptr;
 }
 
 /// A convenience function to check that an Init refers to a dag whose operator
 /// is a def that is a subclass of the given class and coerce it to a dag if it
-/// is. This is primarily useful for testing for subclasses of GIMatchKind and
+/// is. This is primarily useful for testing for subclasses of GIDefKind and
 /// similar in DagInit's since DagInit's support any type inside them.
 inline const DagInit *getDagWithOperatorOfSubClass(const Init &N,
                                                    StringRef Cls) {
   if (const DagInit *I = dyn_cast<DagInit>(&N))
     if (const DefInit *OpI = dyn_cast<DefInit>(I->getOperator()))
       if (OpI->getDef()->isSubClassOf(Cls))
         return I;
   return nullptr;
 }
 } // namespace llvm
 
 #endif