[TableGen] Generate LegalizerInfo

[paperchalice]

Summary

Just reexport some method from LegalizerInfo.h. Not sure this diff is mean meaningful, because using C++ looks better than using tablegen.

[RKSimon]

Not sure if I'm the best person to review this - adding some others who might have a better idea (or know someone who does....)

[Paul-C-Anagnostopoulos]

@paperchalice: I don't understand the purpose of this revision. Could you explain in more detail?

[paperchalice]

I just see the TODO comment in XLegalizerInfo.cpp, but I'm not sure whether this is the right place to generate this. Maybe deduction from the selection pattern is a better choice.

llvm/include/llvm/Target/GlobalISel/LegalizerInfo.td

+//===- LegalizerInfo.td - Export legalizer 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
+//
+//===----------------------------------------------------------------------===//
+//
+// This file reexport some rules from llvm/CodeGen/GlobalISel/LegalizerInfo.h
+//
+//===----------------------------------------------------------------------===//
+
+// Mutations
+class LIMutation<string m> {
+  string Method = m;
+  string Arg = "";
+  string Stmt = Method # Arg;
+}
+
+class LIMChangeTo<int i, LLT t> : LIMutation<"changeTo"> {
+  let Arg = "(" # i # ", " # t # ")";
+}
+
+class LIMChangeToIdx<int typeIdx, int fromTypeIdx> : LIMutation<"changeTo"> {
+  let Arg = "(" # typeIdx # ", " # fromTypeIdx # ")";
+}
+
+class LIMChangeElementSizeTo<int typeIdx, LLT ty> : LIMutation<"changeElementSizeTo"> {
+  let Arg = "(" # typeIdx # ", " # ty # ")";
+}
+
+class LIMChangeElementSizeToIdx<int typeIdx, int fromTypeIdx> : LIMutation<"changeElementSizeTo"> {
+  let Arg = "(" # typeIdx # ", " # fromTypeIdx # ")";
+}
+
+
+class LIMWidenScalarOrEltToNextPow2<int typeIdx, int min = 0> : LIMutation<"widenScalarOrEltToNextPow2"> {
+  let Arg = "(" # typeIdx # ", " # min # ")";
+}
+
+class LIMMoreElementsToNextPow2<int typeIdx, int min = 0> : LIMutation<"moreElementsToNextPow2"> {
+  let Arg = "(" # typeIdx # ", " # min # ")";
+}
+
+class LIMScalarize<int typeIdx> : LIMutation<"scalarize"> {
+  let Arg = "(" # typeIdx # ")";
+}
+
+
+def LIM_none : LIMutation<"">; // placeholder
+
+// Predicates
+class LIPredicate<string m> {
+  string Method = m;
+  string Arg = "";
+  string Stmt = Method # Arg;
+}
+
+class LIPTypeIs<int i, LLT ty> : LIPredicate<"typeIs"> {
+  let Arg = "(" # i # ", " # ty # ")";
+}
+
+class LIPTypeInSet<int i, list<LLT> types> : LIPredicate<"typeInSet"> {
+  let Arg = "(" # i # ", " # !foldl("{", types, l, t, l#t#",") # "})";
+}
+
+class LIPTypeIsNot<int i, LLT ty> : LIPredicate<"typeIsNot"> {
+  let Arg = "(" # i # ", " # ty # ")";
+}
+
+class LIPIsScalar<int n>:LIPredicate<"isScalar"> {
+  let Arg = "("#n#")";
+}
+
+class LIPIsVector<int n>:LIPredicate<"isVector"> {
+  let Arg = "("#n#")";
+}
+
+class LIPIsPointer<int n>:LIPredicate<"isPointer"> {
+  let Arg = "("#n#")";
+}
+
+class LIPIsPointerInAddrSpace<int n, int as>:LIPredicate<"isPointer"> {
+  let Arg = "(" # n # ", " # as #")";
+}
+
+class LIPElementTypeIs<int i, LLT ty> : LIPredicate<"elementTypeIs"> {
+  let Arg = "(" # i # ", " # ty # ")";
+}
+
+class LIPScalarNarrowerThan<int i, int sz> : LIPredicate<"scalarNarrowerThan"> {
+  let Arg = "(" # i # ", " # sz # ")";
+}
+
+class LIPScalarWiderThan<int i, int sz> : LIPredicate<"scalarWiderThan"> {
+  let Arg = "(" # i # ", " # sz # ")";
+}
+
+class LIPScalarOrEltNarrowerThan<int i, int sz> : LIPredicate<"scalarOrEltNarrowerThan"> {
+  let Arg = "(" # i # ", " # sz # ")";
+}
+
+class LIPScalarOrEltWiderThan<int i, int sz> : LIPredicate<"scalarOrEltWiderThan"> {
+  let Arg = "(" # i # ", " # sz # ")";
+}
+
+class LIPSizeNotPow2<int i> : LIPredicate<"sizeNotPow2"> {
+  let Arg = "(" # i # ")";
+}
+
+class LIPScalarOrEltSizeNotPow2<int i> : LIPredicate<"scalarOrEltSizeNotPow2"> {
+  let Arg = "(" # i # ")";
+}
+
+class LIPSizeIs<int idx, int sz> : LIPredicate<"sizeIs"> {
+  let Arg = "(" # idx # ", " # sz # ")";
+}
+
+class LIPSameSize<int idx0, int idx1> : LIPredicate<"sameSize"> {
+  let Arg = "(" # idx0 # ", " # idx1 # ")";
+}
+
+class LIPLargerThan<int idx0, int idx1> : LIPredicate<"largerThan"> {
+  let Arg = "(" # idx0 # ", " # idx1 # ")";
+}
+
+class LIPSmallerThan<int idx0, int idx1> : LIPredicate<"smallerThan"> {
+  let Arg = "(" # idx0 # ", " # idx1 # ")";
+}
+
+class LIPMemSizeInBytesNotPow2<int idx> : LIPredicate<"memSizeInBytesNotPow2"> {
+  let Arg = "(" # idx # ")";
+}
+
+class LIPNumElementsNotPow2<int idx> : LIPredicate<"numElementsNotPow2"> {
+  let Arg = "(" # idx # ")";
+}
+
+// Rules
+class LIRule<string m> {
+  string Method = m;
+  string Arg = "()";
+  string Stmt = Method # Arg;
+}
+
+def LIAlwaysLegal:LIRule<"alwaysLegal">;
+def LILower:LIRule<"lower">;
+def LILibcall:LIRule<"libcall">;
+def LIUnsupported:LIRule<"unsupported">;
+def LICustom:LIRule<"custom">;
+def LIFallback:LIRule<"fallback">;
+def LIUnsupportedIfMemSizeNotPow2:LIRule<"unsupportedIfMemSizeNotPow2">;
+def LILowerIfMemSizeNotPow2:LIRule<"lowerIfMemSizeNotPow2">;
+
+class LILegalIf<LIPredicate p> : LIRule<"legalIf"> {
+  let Arg = "(" # p.Stmt # ")";
+}
+
+class LILegalFor<list<LLT> types> : LIRule<"legalFor"> {
+  let Arg = !foldl("({", types, l, t, l#t#",")#"})";
+}
+
+class LILegalForTypeWithAnyImm<list<LLT> types> : LIRule<"legalForTypeWithAnyImm"> {
+  let Arg = !foldl("({", types, l, t, l#t#",")#"})";
+}
+
+class LILegalForCartesianProduct<list<LLT> types0,
+  list<LLT> types1 = [],
+  list<LLT> types2 = []> : LIRule<"legalForCartesianProduct"> {
+  let Arg = !foldl("({", types0, l, t, l#t#",")#"}" #
+            !cond(!not(!empty(types1)) : !foldl(", {", types1, l, t, l#t#",")#"}", 1:"") #
+            !cond(!not(!empty(types2)) : !foldl(", {", types2, l, t, l#t#","#"}"), 1:"") # ")";
+}
+
+class LIBitcastIf<LIPredicate p, LIMutation m> : LIRule<"bitcastIf"> {
+  let Arg = "(" # p.Stmt # ", "#m.Stmt#")";
+}
+
+class LILowerIf<LIPredicate p, LIMutation m = LIM_none> : LIRule<"lowerIf"> {
+  let Arg = "(" # p.Stmt # !cond(!ne(m, LIM_none) : ", " # m.Stmt, 1 : "") # ")";
+}
+
+class LILowerFor<list<LLT> types, LIMutation m = LIM_none> : LIRule<"lowerFor"> {
+  let Arg = "(" # !foldl("{", types, l, t, l # t # ",") # "}" #
+                  !cond(!ne(m, LIM_none) : ", " # m.Stmt, 1 : "") # ")";
+}
+
+class LILowerForCartesianProduct<list<LLT> types0,
+  list<LLT> types1 = [],
+  list<LLT> types2 = []> : LIRule<"lowerForCartesianProduct"> {
+  let Arg = !foldl("({", types0, l, t, l#t#",")#"}" #
+            !cond(!not(!empty(types1)) : !foldl(", {", types1, l, t, l#t#",")#"}", 1:"") #
+            !cond(!not(!empty(types2)) : !foldl(", {", types2, l, t, l # t # "," # "}"), 1:"") # ")";
+}
+
+class LILibcallIf<LIPredicate p> : LIRule<"libcallIf"> {
+  let Arg = "(" # p.Stmt # ")";
+}
+
+class LILibcallFor<list<LLT> types> : LIRule<"libcallFor"> {
+  let Arg = !foldl("({", types, l, t, l # t # ",") # "})";
+}
+
+class LILibcallForCartesianProduct<list<LLT> types0,
+  list<LLT> types1 = []> : LIRule<"libcallForCartesianProduct"> {
+  let Arg = !foldl("({", types0, l, t, l#t#",")#"}" #
+            !cond(!not(!empty(types1)) : !foldl(", {", types1, l, t, l # t # "," # "}"), 1:"") # ")";
+}
+
+class LIWidenScalarIf<LIPredicate p, LIMutation m> : LIRule<"widenScalarIf"> {
+  let Arg = "(" # p.Stmt # ", " # m.Stmt # ")";
+}
+
+class LINarrowScalarIf<LIPredicate p, LIMutation m> : LIRule<"narrowScalarIf"> {
+  let Arg = "(" # p.Stmt # ", " # m.Stmt # ")";
+}
+
+class LINarrowScalarFor<LIPredicate p, LIMutation m> : LIRule<"narrowScalarFor"> {
+  let Arg = "(" # p.Stmt # ", " # m.Stmt # ")";
+}
+
+class LIMoreElementsIf<LIPredicate p, LIMutation m> : LIRule<"moreElementsIf"> {
+  let Arg = "(" # p.Stmt # ", " # m.Stmt # ")";
+}
+
+class LIFewerElementsIf<LIPredicate p, LIMutation m> : LIRule<"fewerElementsIf"> {
+  let Arg = "(" # p.Stmt # ", " # m.Stmt # ")";
+}
+
+class LIUnsupportedIf<LIPredicate p> : LIRule<"unsupportedIf"> {
+  let Arg = "(" # p.Stmt # ")";
+}
+
+class LIUnsupportedFor<list<LLT> types> : LIRule<"UnsupportedFor"> {
+  let Arg = !foldl("({", types, l, t, l#t#",")#"})";
+}
+
+class LICustomIf<LIPredicate p> : LIRule<"libcallIf"> {
+  let Arg = "(" # p.Stmt # ")";
+}
+
+class LICustomFor<list<LLT> types> : LIRule<"libcallFor"> {
+  let Arg = !foldl("({", types, l, t, l#t#",")#"})";
+}
+
+class LICustomForCartesianProduct<list<LLT> types0,
+  list<LLT> types1 = []> : LIRule<"customForCartesianProduct"> {
+  let Arg = !foldl("({", types0, l, t, l#t#",")#"}" #
+            !cond(!not(!empty(types1)) : !foldl(", {", types1, l, t, l # t # "," # "}"), 1:"") # ")";
+}
+
+class LIWidenScalarToNextPow2<int i, int minSize = 0> : LIRule <"widenScalarToNextPow2"> {
+  let Arg = "(" # ", " # minSize # ")";
+}
+
+class LIWidenScalarOrEltToNextPow2<int i, int minSize = 0> : LIRule <"widenScalarOrEltToNextPow2"> {
+  let Arg = "(" # ", " # minSize # ")";
+}
+
+class LINarrowScalar<int i, LIMutation m> : LIRule<"narrowScalar"> {
+  let Arg = "(" # i # ", " # m.Stmt # ")";
+}
+
+class LIScalarize<int i> : LIRule<"scalarize"> {
+  let Arg = "(" # i # ")";
+}
+
+class LIScalarizeIf<LIPredicate p, int i> : LIRule<"scalarize"> {
+  let Arg = "(" # p.Stmt # ", " # i # ")";
+}
+
+class LIMinScalarOrElt<int i, LLT t> : LIRule<"minScalarOrElt"> {
+  let Arg =  "(" # i # ", " # t # ")";
+}
+
+class LIMinScalarOrEltIf<LIPredicate p, int i, LLT t> : LIRule<"minScalarOrEltIf"> {
+  let Arg =  "(" # p.Stmt # ", " # i # ", " # t # ")";
+}
+
+class LIMinScalar<int i, LLT t> : LIRule<"minScalar"> {
+  let Arg =  "(" # i # ", " # t # ")";
+}
+
+class LIMaxScalarOrElt<int i, LLT t> : LIRule<"maxScalarOrElt"> {
+  let Arg =  "(" # i # ", " # t # ")";
+}
+
+class LIMaxScalar<int i, LLT t> : LIRule<"maxScalar"> {
+  let Arg =  "(" # i # ", " # t # ")";
+}
+
+class LIMaxScalarIf<LIPredicate p, int i, LLT t> : LIRule<"maxScalarIf"> {
+  let Arg =  "(" # p.Stmt # ", " # i # ", " # t # ")";
+}
+
+class LIClampScalar<int i, LLT min, LLT max> : LIRule<"clampScalar"> {
+  let Arg = "(" # i # ", " # min # ", " # max # ")";
+}
+
+class LIClampScalarOrElt<int i, LLT min, LLT max> : LIRule<"clampScalarOrElt"> {
+  let Arg = "(" # i # ", " # min # ", " # max # ")";
+}
+
+class LIMinScalarSameAs<int typeIdx, int largeTypeIdx> : LIRule<"minScalarSameAs"> {
+  let Arg = "(" # typeIdx # ", " # largeTypeIdx # ")";
+}
+
+class LIMaxScalarSameAs<int typeIdx, int narrowTypeIdx> : LIRule<"maxScalarSameAs"> {
+  let Arg = "(" # typeIdx # ", " # narrowTypeIdx # ")";
+}
+
+class LIScalarSameSizeAs<int typeIdx, int sameSizeIdx> : LIRule<"scalarSameSizeAs"> {
+  let Arg = "(" # typeIdx # ", " # sameSizeIdx # ")";
+}
+
+class LIMinScalarEltSameAsIf<LIPredicate p, int typeIdx, int largeTypeIdx> : LIRule<"minScalarEltSameAsIf"> {
+  let Arg = "(" # p.Stmt # ", " # typeIdx # ", " # largeTypeIdx;
+}
+
+class LIMoreElementsToNextPow2<int typeIdx> : LIRule<"moreElementsToNextPow2"> {
+  let Arg = "(" # typeIdx # ")";
+}
+
+class LIClampMinNumElements<int typeIdx, LLT eltTy, int minElements> :LIRule<"clampMinNumElements"> {
+  let Arg = "(" # typeIdx # ", " # eltTy # ", " # minElements # ")";
+}
+
+class LIClampMaxNumElements<int typeIdx, LLT eltTy, int maxElements> :LIRule<"clampMaxNumElements"> {
+  let Arg = "(" # typeIdx # ", " # eltTy # ", " # maxElements # ")";
+}
+
+class LIClampNumElements<int typeIdx, LLT minTy, LLT maxTy> :LIRule<"clampNumElements"> {
+  let Arg = "(" # typeIdx # ", " # minTy # ", " # maxTy # ")";
+}
+
+// final definition
+class LIActionDefinition<list<GenericInstruction> ops, list<LIRule> rules> {
+  list<SubtargetFeature> Predicates = [];
+  list<GenericInstruction> Ops = ops;
+  list<LIRule> Rules = rules;
+}
+

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

 // support.  It will eventually supersede SelectionDAG patterns.
 //
 //===----------------------------------------------------------------------===//
 
 // Definitions that inherit from LLT define types that will be used in the
 // GlobalISel matcher.
 class LLT;
 
-def s32 : LLT;
-def s64 : LLT;
+class Pointer<int as> : LLT {
+  int AddressSpace = as;
+}
+
+class Scalar<int sz> : LLT {
+  int ScalarSizeInBits = sz;
+}
+
+class Vector<int n, int sz> : LLT {
+  int NumElements = n;
+  int ScalarSizeInBits = sz;
+}
+class LLTVector<int n, LLT t> : LLT {
+  int NumElements = n;
+  LLT Ty = t;
+}
+
+def s32 : Scalar<32>;
+def s64 : Scalar<64>;
 
 // Defines a matcher for complex operands. This is analogous to ComplexPattern
 // from SelectionDAG.
 //
 // Definitions that inherit from this may also inherit from
 // GIComplexPatternEquiv to enable the import of SelectionDAG patterns involving
 // those ComplexPatterns.
 class GIComplexOperandMatcher<LLT type, string matcherfn> {

llvm/include/llvm/Target/Target.td

 include "llvm/Target/GlobalISel/Target.td"
 
 //===----------------------------------------------------------------------===//
 // Pull in the common support for the Global ISel DAG-based selector generation.
 //
 include "llvm/Target/GlobalISel/SelectionDAGCompat.td"
 
 //===----------------------------------------------------------------------===//
+// Pull in the common legalizer info generation.
+//
+include "llvm/Target/GlobalISel/LegalizerInfo.td"
+
+//===----------------------------------------------------------------------===//
 // Pull in the common support for Pfm Counters generation.
 //
 include "llvm/Target/TargetPfmCounters.td"

llvm/test/TableGen/LegalizerInfoEmitter.td

+// RUN: llvm-tblgen -gen-legalizer-info -I %p/../../include %s | FileCheck %s
+
+include "llvm/Target/Target.td"
+
+def MyTarget : Target;
+
+def FeatureFoo : SubtargetFeature<"foo", "HasFoo", "true", "">;
+
+def p0 : Pointer<0>;
+def s1 : Scalar<1>;
+def s8 : Scalar<8>;
+def s16 : Scalar<16>;
+def s128 : Scalar<128>;
+
+// CHECK: getActionDefinitionsBuilder({G_IMPLICIT_DEF,})
+// CHECK-NEXT: .legalFor({p0,s1,s8,s16,s32,})
+def : LIActionDefinition<[
+  G_IMPLICIT_DEF
+], [LILegalFor<[p0, s1, s8, s16, s32]>]>;
+
+// CHECK: if (Subtarget.hasFeature(MyTarget::FeatureFoo) && true)
+// CHECK: getActionDefinitionsBuilder({G_LOAD,G_STORE,})
+// CHECK-NEXT: .legalFor({s8,s16,s32,p0,})
+// CHECK-NEXT: .legalIf(typeIs(1, s1))
+let Predicates = [FeatureFoo] in
+def : LIActionDefinition<[
+  G_LOAD, G_STORE
+], [
+  LILegalFor<[s8, s16, s32, p0]>,
+  LILegalIf<LIPTypeIs<1, s1>>]
+>;
+
+// CHECK: getActionDefinitionsBuilder({G_FREEZE,})
+// CHECK-NEXT:  .legalFor({s8,s16,s32,p0,})
+// CHECK-NEXT:  .clampScalar(0, s1, s64)
+// CHECK-NEXT: .fewerElementsIf(
+// CHECK-NEXT: [=](const LegalityQuery &Query) {
+// CHECK: changeTo(0, s1))
+def : LIActionDefinition<[
+  G_FREEZE
+], [
+    LILegalFor<[s8, s16, s32, p0]>,
+    LIClampScalar<0, s1, s64>,
+    LIFewerElementsIf<LIPredicate<[{
+          [=](const LegalityQuery &Query) {
+            return Query.Types[0].isVector() &&
+                   (Query.Types[0].getElementType() != s64 ||
+                    Query.Types[0].getNumElements() != 2);
+          }
+          }]>, LIMChangeTo<0, s1>>
+  ]
+>;

llvm/utils/TableGen/CMakeLists.txt

add_tablegen(llvm-tblgen LLVM
   FastISelEmitter.cpp
   FixedLenDecoderEmitter.cpp
   GICombinerEmitter.cpp
   GlobalISelEmitter.cpp
   InfoByHwMode.cpp
   InstrInfoEmitter.cpp
   InstrDocsEmitter.cpp
   IntrinsicEmitter.cpp
+  LegalizerInfoEmitter.cpp
   OptEmitter.cpp
   OptParserEmitter.cpp
   OptRSTEmitter.cpp
   PredicateExpander.cpp
   PseudoLoweringEmitter.cpp
   RISCVCompressInstEmitter.cpp
   RegisterBankEmitter.cpp
   RegisterInfoEmitter.cpp

llvm/utils/TableGen/LegalizerInfoEmitter.cpp

+//===- LegalizerInfoEmitter.cpp - generate LegalizerInfo -*--------C++ -*-===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+//
+// This Tablegen backend emits LegalizerInfo
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/StringExtras.h"
+#include "llvm/Support/Format.h"
+#include "llvm/Support/MemoryBuffer.h"
+#include "llvm/Support/SourceMgr.h"
+#include "llvm/TableGen/Error.h"
+#include "llvm/TableGen/Record.h"
+#include "llvm/TableGen/TableGenBackend.h"
+#include <algorithm>
+#include <set>
+#include <string>
+#include <vector>
+
+#include "CodeGenHwModes.h"
+#include "CodeGenRegisters.h"
+#include "CodeGenTarget.h"
+
+#define DEBUG_TYPE "legalizer-info-emitter"
+
+using namespace llvm;
+
+namespace {
+
+// Any helper data structures can be defined here. Some backends use
+// structs to collect information from the records.
+
+class LegalizerInfoEmitter {
+private:
+  RecordKeeper &Records;
+  CodeGenTarget Target;
+
+  void generateLLTs(raw_ostream &OS);
+  void generateActions(raw_ostream &OS);
+  void generateRules(raw_ostream &OS, const std::vector<Record *> &Rules);
+
+public:
+  LegalizerInfoEmitter(RecordKeeper &RK) : Records(RK), Target(RK) {}
+  void emitHeader(raw_ostream &OS);
+  void emitImpl(raw_ostream &OS);
+
+  void run(raw_ostream &OS);
+}; // emitter class
+
+void LegalizerInfoEmitter::generateLLTs(raw_ostream &OS) {
+  auto LLTs = Records.getAllDerivedDefinitions("LLT");
+  for (const auto &T : LLTs) {
+    OS << "  const LLT " << T->getName() << " = LLT::";
+    if (T->isSubClassOf("Pointer")) {
+      OS << "pointer(" << T->getValueAsInt("AddressSpace")
+         << ", TM.getPointerSizeInBits(" << T->getValueAsInt("AddressSpace")
+         << "));\n";
+    }
+    if (T->isSubClassOf("Scalar")) {
+      OS << "scalar(" << T->getValueAsInt("ScalarSizeInBits") << ");\n";
+    }
+    if (T->isSubClassOf("Vector")) {
+      OS << "vector(" << T->getValueAsInt("NumElements") << ", "
+         << T->getValueAsInt("ScalarSizeInBits") << ");\n";
+    }
+    if (T->isSubClassOf("LLTVector")) {
+      OS << "vector(" << T->getValueAsInt("NumElements") << ", "
+         << T->getValueAsDef("Ty")->getName() << ");\n";
+    }
+  }
+
+  OS << "\n";
+}
+
+void LegalizerInfoEmitter::generateActions(raw_ostream &OS) {
+  OS << "  using namespace TargetOpcode;\n"
+     << "  using namespace LegalityPredicates;\n"
+     << "  using namespace LegalizeMutations;\n"
+     << "\n";
+  auto Defs = Records.getAllDerivedDefinitions("LIActionDefinition");
+  for (const auto &Def : Defs) {
+    auto Predicates = Def->getValueAsListOfDefs("Predicates");
+    OS << "  if (";
+    for (const auto &Predicate : Predicates) {
+      OS << "Subtarget.hasFeature(" << Target.getName()
+         << "::" << Predicate->getName() << ") && ";
+    }
+    // begin predicate
+    OS << "true) {\n";
+
+    auto Ops = Def->getValueAsListInit("Ops");
+    OS << "    getActionDefinitionsBuilder({";
+    for (const auto &Op : Ops->getValues()) {
+      OS << Op->getAsString() << ",";
+    }
+    OS << "})\n";
+
+    auto Rules = Def->getValueAsListOfDefs("Rules");
+    generateRules(OS, Rules);
+    OS << "    ;\n\n";
+    // end predicate
+    OS << "  } // end if\n";
+  }
+}
+
+void LegalizerInfoEmitter::generateRules(raw_ostream &OS,
+                                         const std::vector<Record *> &Rules) {
+  for (const auto &Rule : Rules) {
+    OS << "      ." << Rule->getValueAsString("Stmt") << "\n";
+  }
+}
+
+void LegalizerInfoEmitter::emitHeader(raw_ostream &OS) {
+  OS << "#include \"llvm/CodeGen/GlobalISel/LegalizerInfo.h\"\n\n";
+
+  OS << "namespace llvm {\n\n";
+  OS << "class " << Target.getName() << "Subtarget;\n"
+     << "class " << Target.getName() << "TargetMachine;\n\n";
+
+  OS << "class " << Target.getName()
+     << "GenLegalizerInfo : public LegalizerInfo {\n"
+     << "protected:\n"
+     << "  const " << Target.getName() << "Subtarget &Subtarget;"
+     << "public:\n"
+     << "  " << Target.getName() << "GenLegalizerInfo(const "
+     << Target.getName() << "Subtarget &STI"
+     << ");\n";
+
+  OS << "}; // GenLegalizerInfo\n\n";
+
+  OS << "} // namespace llvm\n\n";
+}
+
+void LegalizerInfoEmitter::emitImpl(raw_ostream &OS) {
+  auto LLTs = Records.getAllDerivedDefinitions("LLT");
+  OS << "namespace llvm {\n\n";
+  OS << Target.getName() << "GenLegalizerInfo::" << Target.getName()
+     << "GenLegalizerInfo(const " << Target.getName() << "Subtarget &STI"
+     << ") : Subtarget(STI)"
+     << " {\n"
+     << "  const auto &TM = "
+        "Subtarget.getTargetLowering()->getTargetMachine();\n\n";
+  generateLLTs(OS);
+  generateActions(OS);
+
+  OS << "}\n\n";
+  OS << "} // namespace llvm\n\n";
+}
+
+} // anonymous namespace
+
+void LegalizerInfoEmitter::run(raw_ostream &OS) {
+  emitSourceFileHeader("Generated Legalizer Info", OS);
+  OS << "#ifdef GET_LEGALIZERINFO_HEADER\n"
+     << "#undef GET_LEGALIZERINFO_HEADER\n";
+  emitHeader(OS);
+  OS << "#endif // GET_LEGALIZERINFO_HEADER\n\n";
+
+  OS << "#ifdef GET_LEGALIZERINFO_IMPL\n"
+     << "#undef GET_LEGALIZERINFO_IMPL\n\n";
+
+  OS << "#include \"llvm/CodeGen/GlobalISel/LegalizerHelper.h\"\n"
+     << "#include \"llvm/CodeGen/TargetOpcodes.h\"\n"
+     << "#include \"llvm/CodeGen/ValueTypes.h\"\n\n";
+  emitImpl(OS);
+  OS << "#endif // GET_LEGALIZERINFO_IMPL\n";
+}
+
+namespace llvm {
+
+void EmitLegalizerInfo(RecordKeeper &RK, raw_ostream &OS) {
+  LegalizerInfoEmitter(RK).run(OS);
+}
+
+} // namespace llvm

llvm/utils/TableGen/TableGen.cpp

enum ActionType {
   PrintSets,
   GenOptParserDefs,
   GenOptRST,
   GenCTags,
   GenAttributes,
   GenSearchableTables,
   GenGlobalISel,
   GenGICombiner,
+  GenLegalizerInfo,
   GenX86EVEX2VEXTables,
   GenX86FoldTables,
   GenRegisterBank,
   GenExegesis,
   GenAutomata,
   GenDirectivesEnumDecl,
   GenDirectivesEnumImpl,
   GenDirectivesEnumGen,
cl::values(
         clEnumValN(GenCTags, "gen-ctags", "Generate ctags-compatible index"),
         clEnumValN(GenAttributes, "gen-attrs", "Generate attributes"),
         clEnumValN(GenSearchableTables, "gen-searchable-tables",
                    "Generate generic binary-searchable table"),
         clEnumValN(GenGlobalISel, "gen-global-isel",
                    "Generate GlobalISel selector"),
         clEnumValN(GenGICombiner, "gen-global-isel-combiner",
                    "Generate GlobalISel combiner"),
+        clEnumValN(GenLegalizerInfo, "gen-legalizer-info", "Generate LegalizerInfo"),
         clEnumValN(GenX86EVEX2VEXTables, "gen-x86-EVEX2VEX-tables",
                    "Generate X86 EVEX to VEX compress tables"),
         clEnumValN(GenX86FoldTables, "gen-x86-fold-tables",
                    "Generate X86 fold tables"),
         clEnumValN(GenRegisterBank, "gen-register-bank",
                    "Generate registers bank descriptions"),
         clEnumValN(GenExegesis, "gen-exegesis",
                    "Generate llvm-exegesis tables"),
         clEnumValN(GenAutomata, "gen-automata", "Generate generic automata"),
         clEnumValN(GenDirectivesEnumDecl, "gen-directive-decl",
case GenIntrinsicEnums:
     EmitIntrinsicEnums(Records, OS);
     break;
   case GenIntrinsicImpl:
     EmitIntrinsicImpl(Records, OS);
     break;
   case GenOptParserDefs:
     EmitOptParser(Records, OS);
     break;
+  case GenLegalizerInfo:
+    EmitLegalizerInfo(Records, OS);
+    break;
   case GenOptRST:
     EmitOptRST(Records, OS);
     break;
   case PrintEnums:
   {
     for (Record *Rec : Records.getAllDerivedDefinitions(Class))
       OS << Rec->getName() << ", ";
     OS << "\n";
     break;
   }