109467b48Spatrick //===- lib/CodeGen/GlobalISel/LegalizerInfo.cpp - Legalizer ---------------===//
209467b48Spatrick //
309467b48Spatrick // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
409467b48Spatrick // See https://llvm.org/LICENSE.txt for license information.
509467b48Spatrick // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
609467b48Spatrick //
709467b48Spatrick //===----------------------------------------------------------------------===//
809467b48Spatrick //
909467b48Spatrick // Implement an interface to specify and query how an illegal operation on a
1009467b48Spatrick // given type should be expanded.
1109467b48Spatrick //
1209467b48Spatrick //===----------------------------------------------------------------------===//
1309467b48Spatrick
1409467b48Spatrick #include "llvm/CodeGen/GlobalISel/LegalizerInfo.h"
1509467b48Spatrick #include "llvm/ADT/SmallBitVector.h"
1609467b48Spatrick #include "llvm/CodeGen/MachineInstr.h"
1709467b48Spatrick #include "llvm/CodeGen/MachineOperand.h"
1809467b48Spatrick #include "llvm/CodeGen/MachineRegisterInfo.h"
1909467b48Spatrick #include "llvm/CodeGen/TargetOpcodes.h"
2009467b48Spatrick #include "llvm/MC/MCInstrDesc.h"
2109467b48Spatrick #include "llvm/MC/MCInstrInfo.h"
2209467b48Spatrick #include "llvm/Support/Debug.h"
2309467b48Spatrick #include "llvm/Support/ErrorHandling.h"
2409467b48Spatrick #include "llvm/Support/LowLevelTypeImpl.h"
2509467b48Spatrick #include <algorithm>
2609467b48Spatrick
2709467b48Spatrick using namespace llvm;
2809467b48Spatrick using namespace LegalizeActions;
2909467b48Spatrick
3009467b48Spatrick #define DEBUG_TYPE "legalizer-info"
3109467b48Spatrick
3209467b48Spatrick cl::opt<bool> llvm::DisableGISelLegalityCheck(
3309467b48Spatrick "disable-gisel-legality-check",
3409467b48Spatrick cl::desc("Don't verify that MIR is fully legal between GlobalISel passes"),
3509467b48Spatrick cl::Hidden);
3609467b48Spatrick
operator <<(raw_ostream & OS,LegalizeAction Action)3709467b48Spatrick raw_ostream &llvm::operator<<(raw_ostream &OS, LegalizeAction Action) {
3809467b48Spatrick switch (Action) {
3909467b48Spatrick case Legal:
4009467b48Spatrick OS << "Legal";
4109467b48Spatrick break;
4209467b48Spatrick case NarrowScalar:
4309467b48Spatrick OS << "NarrowScalar";
4409467b48Spatrick break;
4509467b48Spatrick case WidenScalar:
4609467b48Spatrick OS << "WidenScalar";
4709467b48Spatrick break;
4809467b48Spatrick case FewerElements:
4909467b48Spatrick OS << "FewerElements";
5009467b48Spatrick break;
5109467b48Spatrick case MoreElements:
5209467b48Spatrick OS << "MoreElements";
5309467b48Spatrick break;
54097a140dSpatrick case Bitcast:
55097a140dSpatrick OS << "Bitcast";
56097a140dSpatrick break;
5709467b48Spatrick case Lower:
5809467b48Spatrick OS << "Lower";
5909467b48Spatrick break;
6009467b48Spatrick case Libcall:
6109467b48Spatrick OS << "Libcall";
6209467b48Spatrick break;
6309467b48Spatrick case Custom:
6409467b48Spatrick OS << "Custom";
6509467b48Spatrick break;
6609467b48Spatrick case Unsupported:
6709467b48Spatrick OS << "Unsupported";
6809467b48Spatrick break;
6909467b48Spatrick case NotFound:
7009467b48Spatrick OS << "NotFound";
7109467b48Spatrick break;
7209467b48Spatrick case UseLegacyRules:
7309467b48Spatrick OS << "UseLegacyRules";
7409467b48Spatrick break;
7509467b48Spatrick }
7609467b48Spatrick return OS;
7709467b48Spatrick }
7809467b48Spatrick
print(raw_ostream & OS) const7909467b48Spatrick raw_ostream &LegalityQuery::print(raw_ostream &OS) const {
8009467b48Spatrick OS << Opcode << ", Tys={";
8109467b48Spatrick for (const auto &Type : Types) {
8209467b48Spatrick OS << Type << ", ";
8309467b48Spatrick }
8409467b48Spatrick OS << "}, Opcode=";
8509467b48Spatrick
8609467b48Spatrick OS << Opcode << ", MMOs={";
8709467b48Spatrick for (const auto &MMODescr : MMODescrs) {
8873471bf0Spatrick OS << MMODescr.MemoryTy << ", ";
8909467b48Spatrick }
9009467b48Spatrick OS << "}";
9109467b48Spatrick
9209467b48Spatrick return OS;
9309467b48Spatrick }
9409467b48Spatrick
9509467b48Spatrick #ifndef NDEBUG
9609467b48Spatrick // Make sure the rule won't (trivially) loop forever.
hasNoSimpleLoops(const LegalizeRule & Rule,const LegalityQuery & Q,const std::pair<unsigned,LLT> & Mutation)9709467b48Spatrick static bool hasNoSimpleLoops(const LegalizeRule &Rule, const LegalityQuery &Q,
9809467b48Spatrick const std::pair<unsigned, LLT> &Mutation) {
9909467b48Spatrick switch (Rule.getAction()) {
10073471bf0Spatrick case Legal:
10109467b48Spatrick case Custom:
10209467b48Spatrick case Lower:
10309467b48Spatrick case MoreElements:
10409467b48Spatrick case FewerElements:
10509467b48Spatrick break;
10609467b48Spatrick default:
10709467b48Spatrick return Q.Types[Mutation.first] != Mutation.second;
10809467b48Spatrick }
10909467b48Spatrick return true;
11009467b48Spatrick }
11109467b48Spatrick
11209467b48Spatrick // Make sure the returned mutation makes sense for the match type.
mutationIsSane(const LegalizeRule & Rule,const LegalityQuery & Q,std::pair<unsigned,LLT> Mutation)11309467b48Spatrick static bool mutationIsSane(const LegalizeRule &Rule,
11409467b48Spatrick const LegalityQuery &Q,
11509467b48Spatrick std::pair<unsigned, LLT> Mutation) {
11609467b48Spatrick // If the user wants a custom mutation, then we can't really say much about
11709467b48Spatrick // it. Return true, and trust that they're doing the right thing.
11873471bf0Spatrick if (Rule.getAction() == Custom || Rule.getAction() == Legal)
11909467b48Spatrick return true;
12009467b48Spatrick
12109467b48Spatrick const unsigned TypeIdx = Mutation.first;
12209467b48Spatrick const LLT OldTy = Q.Types[TypeIdx];
12309467b48Spatrick const LLT NewTy = Mutation.second;
12409467b48Spatrick
12509467b48Spatrick switch (Rule.getAction()) {
12609467b48Spatrick case FewerElements:
12709467b48Spatrick if (!OldTy.isVector())
12809467b48Spatrick return false;
129*d415bd75Srobert [[fallthrough]];
13009467b48Spatrick case MoreElements: {
13109467b48Spatrick // MoreElements can go from scalar to vector.
132*d415bd75Srobert const ElementCount OldElts = OldTy.isVector() ?
133*d415bd75Srobert OldTy.getElementCount() : ElementCount::getFixed(1);
13409467b48Spatrick if (NewTy.isVector()) {
13509467b48Spatrick if (Rule.getAction() == FewerElements) {
13609467b48Spatrick // Make sure the element count really decreased.
137*d415bd75Srobert if (ElementCount::isKnownGE(NewTy.getElementCount(), OldElts))
13809467b48Spatrick return false;
13909467b48Spatrick } else {
14009467b48Spatrick // Make sure the element count really increased.
141*d415bd75Srobert if (ElementCount::isKnownLE(NewTy.getElementCount(), OldElts))
14209467b48Spatrick return false;
14309467b48Spatrick }
14473471bf0Spatrick } else if (Rule.getAction() == MoreElements)
14573471bf0Spatrick return false;
14609467b48Spatrick
14709467b48Spatrick // Make sure the element type didn't change.
14809467b48Spatrick return NewTy.getScalarType() == OldTy.getScalarType();
14909467b48Spatrick }
15009467b48Spatrick case NarrowScalar:
15109467b48Spatrick case WidenScalar: {
15209467b48Spatrick if (OldTy.isVector()) {
15309467b48Spatrick // Number of elements should not change.
15409467b48Spatrick if (!NewTy.isVector() || OldTy.getNumElements() != NewTy.getNumElements())
15509467b48Spatrick return false;
15609467b48Spatrick } else {
15709467b48Spatrick // Both types must be vectors
15809467b48Spatrick if (NewTy.isVector())
15909467b48Spatrick return false;
16009467b48Spatrick }
16109467b48Spatrick
16209467b48Spatrick if (Rule.getAction() == NarrowScalar) {
16309467b48Spatrick // Make sure the size really decreased.
16409467b48Spatrick if (NewTy.getScalarSizeInBits() >= OldTy.getScalarSizeInBits())
16509467b48Spatrick return false;
16609467b48Spatrick } else {
16709467b48Spatrick // Make sure the size really increased.
16809467b48Spatrick if (NewTy.getScalarSizeInBits() <= OldTy.getScalarSizeInBits())
16909467b48Spatrick return false;
17009467b48Spatrick }
17109467b48Spatrick
17209467b48Spatrick return true;
17309467b48Spatrick }
174097a140dSpatrick case Bitcast: {
175097a140dSpatrick return OldTy != NewTy && OldTy.getSizeInBits() == NewTy.getSizeInBits();
176097a140dSpatrick }
17709467b48Spatrick default:
17809467b48Spatrick return true;
17909467b48Spatrick }
18009467b48Spatrick }
18109467b48Spatrick #endif
18209467b48Spatrick
apply(const LegalityQuery & Query) const18309467b48Spatrick LegalizeActionStep LegalizeRuleSet::apply(const LegalityQuery &Query) const {
18409467b48Spatrick LLVM_DEBUG(dbgs() << "Applying legalizer ruleset to: "; Query.print(dbgs());
18509467b48Spatrick dbgs() << "\n");
18609467b48Spatrick if (Rules.empty()) {
18709467b48Spatrick LLVM_DEBUG(dbgs() << ".. fallback to legacy rules (no rules defined)\n");
18809467b48Spatrick return {LegalizeAction::UseLegacyRules, 0, LLT{}};
18909467b48Spatrick }
19009467b48Spatrick for (const LegalizeRule &Rule : Rules) {
19109467b48Spatrick if (Rule.match(Query)) {
19209467b48Spatrick LLVM_DEBUG(dbgs() << ".. match\n");
19309467b48Spatrick std::pair<unsigned, LLT> Mutation = Rule.determineMutation(Query);
19409467b48Spatrick LLVM_DEBUG(dbgs() << ".. .. " << Rule.getAction() << ", "
19509467b48Spatrick << Mutation.first << ", " << Mutation.second << "\n");
19609467b48Spatrick assert(mutationIsSane(Rule, Query, Mutation) &&
19709467b48Spatrick "legality mutation invalid for match");
19809467b48Spatrick assert(hasNoSimpleLoops(Rule, Query, Mutation) && "Simple loop detected");
19909467b48Spatrick return {Rule.getAction(), Mutation.first, Mutation.second};
20009467b48Spatrick } else
20109467b48Spatrick LLVM_DEBUG(dbgs() << ".. no match\n");
20209467b48Spatrick }
20309467b48Spatrick LLVM_DEBUG(dbgs() << ".. unsupported\n");
20409467b48Spatrick return {LegalizeAction::Unsupported, 0, LLT{}};
20509467b48Spatrick }
20609467b48Spatrick
verifyTypeIdxsCoverage(unsigned NumTypeIdxs) const20709467b48Spatrick bool LegalizeRuleSet::verifyTypeIdxsCoverage(unsigned NumTypeIdxs) const {
20809467b48Spatrick #ifndef NDEBUG
20909467b48Spatrick if (Rules.empty()) {
21009467b48Spatrick LLVM_DEBUG(
21109467b48Spatrick dbgs() << ".. type index coverage check SKIPPED: no rules defined\n");
21209467b48Spatrick return true;
21309467b48Spatrick }
21409467b48Spatrick const int64_t FirstUncovered = TypeIdxsCovered.find_first_unset();
21509467b48Spatrick if (FirstUncovered < 0) {
21609467b48Spatrick LLVM_DEBUG(dbgs() << ".. type index coverage check SKIPPED:"
21709467b48Spatrick " user-defined predicate detected\n");
21809467b48Spatrick return true;
21909467b48Spatrick }
22009467b48Spatrick const bool AllCovered = (FirstUncovered >= NumTypeIdxs);
22109467b48Spatrick if (NumTypeIdxs > 0)
22209467b48Spatrick LLVM_DEBUG(dbgs() << ".. the first uncovered type index: " << FirstUncovered
22309467b48Spatrick << ", " << (AllCovered ? "OK" : "FAIL") << "\n");
22409467b48Spatrick return AllCovered;
22509467b48Spatrick #else
22609467b48Spatrick return true;
22709467b48Spatrick #endif
22809467b48Spatrick }
22909467b48Spatrick
verifyImmIdxsCoverage(unsigned NumImmIdxs) const23009467b48Spatrick bool LegalizeRuleSet::verifyImmIdxsCoverage(unsigned NumImmIdxs) const {
23109467b48Spatrick #ifndef NDEBUG
23209467b48Spatrick if (Rules.empty()) {
23309467b48Spatrick LLVM_DEBUG(
23409467b48Spatrick dbgs() << ".. imm index coverage check SKIPPED: no rules defined\n");
23509467b48Spatrick return true;
23609467b48Spatrick }
23709467b48Spatrick const int64_t FirstUncovered = ImmIdxsCovered.find_first_unset();
23809467b48Spatrick if (FirstUncovered < 0) {
23909467b48Spatrick LLVM_DEBUG(dbgs() << ".. imm index coverage check SKIPPED:"
24009467b48Spatrick " user-defined predicate detected\n");
24109467b48Spatrick return true;
24209467b48Spatrick }
24309467b48Spatrick const bool AllCovered = (FirstUncovered >= NumImmIdxs);
24409467b48Spatrick LLVM_DEBUG(dbgs() << ".. the first uncovered imm index: " << FirstUncovered
24509467b48Spatrick << ", " << (AllCovered ? "OK" : "FAIL") << "\n");
24609467b48Spatrick return AllCovered;
24709467b48Spatrick #else
24809467b48Spatrick return true;
24909467b48Spatrick #endif
25009467b48Spatrick }
25109467b48Spatrick
25209467b48Spatrick /// Helper function to get LLT for the given type index.
getTypeFromTypeIdx(const MachineInstr & MI,const MachineRegisterInfo & MRI,unsigned OpIdx,unsigned TypeIdx)25309467b48Spatrick static LLT getTypeFromTypeIdx(const MachineInstr &MI,
25409467b48Spatrick const MachineRegisterInfo &MRI, unsigned OpIdx,
25509467b48Spatrick unsigned TypeIdx) {
25609467b48Spatrick assert(TypeIdx < MI.getNumOperands() && "Unexpected TypeIdx");
25709467b48Spatrick // G_UNMERGE_VALUES has variable number of operands, but there is only
25809467b48Spatrick // one source type and one destination type as all destinations must be the
25909467b48Spatrick // same type. So, get the last operand if TypeIdx == 1.
26009467b48Spatrick if (MI.getOpcode() == TargetOpcode::G_UNMERGE_VALUES && TypeIdx == 1)
26109467b48Spatrick return MRI.getType(MI.getOperand(MI.getNumOperands() - 1).getReg());
26209467b48Spatrick return MRI.getType(MI.getOperand(OpIdx).getReg());
26309467b48Spatrick }
26409467b48Spatrick
getOpcodeIdxForOpcode(unsigned Opcode) const26509467b48Spatrick unsigned LegalizerInfo::getOpcodeIdxForOpcode(unsigned Opcode) const {
26609467b48Spatrick assert(Opcode >= FirstOp && Opcode <= LastOp && "Unsupported opcode");
26709467b48Spatrick return Opcode - FirstOp;
26809467b48Spatrick }
26909467b48Spatrick
getActionDefinitionsIdx(unsigned Opcode) const27009467b48Spatrick unsigned LegalizerInfo::getActionDefinitionsIdx(unsigned Opcode) const {
27109467b48Spatrick unsigned OpcodeIdx = getOpcodeIdxForOpcode(Opcode);
27209467b48Spatrick if (unsigned Alias = RulesForOpcode[OpcodeIdx].getAlias()) {
27309467b48Spatrick LLVM_DEBUG(dbgs() << ".. opcode " << Opcode << " is aliased to " << Alias
27409467b48Spatrick << "\n");
27509467b48Spatrick OpcodeIdx = getOpcodeIdxForOpcode(Alias);
27609467b48Spatrick assert(RulesForOpcode[OpcodeIdx].getAlias() == 0 && "Cannot chain aliases");
27709467b48Spatrick }
27809467b48Spatrick
27909467b48Spatrick return OpcodeIdx;
28009467b48Spatrick }
28109467b48Spatrick
28209467b48Spatrick const LegalizeRuleSet &
getActionDefinitions(unsigned Opcode) const28309467b48Spatrick LegalizerInfo::getActionDefinitions(unsigned Opcode) const {
28409467b48Spatrick unsigned OpcodeIdx = getActionDefinitionsIdx(Opcode);
28509467b48Spatrick return RulesForOpcode[OpcodeIdx];
28609467b48Spatrick }
28709467b48Spatrick
getActionDefinitionsBuilder(unsigned Opcode)28809467b48Spatrick LegalizeRuleSet &LegalizerInfo::getActionDefinitionsBuilder(unsigned Opcode) {
28909467b48Spatrick unsigned OpcodeIdx = getActionDefinitionsIdx(Opcode);
29009467b48Spatrick auto &Result = RulesForOpcode[OpcodeIdx];
29109467b48Spatrick assert(!Result.isAliasedByAnother() && "Modifying this opcode will modify aliases");
29209467b48Spatrick return Result;
29309467b48Spatrick }
29409467b48Spatrick
getActionDefinitionsBuilder(std::initializer_list<unsigned> Opcodes)29509467b48Spatrick LegalizeRuleSet &LegalizerInfo::getActionDefinitionsBuilder(
29609467b48Spatrick std::initializer_list<unsigned> Opcodes) {
29709467b48Spatrick unsigned Representative = *Opcodes.begin();
29809467b48Spatrick
299*d415bd75Srobert assert(Opcodes.size() >= 2 &&
30009467b48Spatrick "Initializer list must have at least two opcodes");
30109467b48Spatrick
30273471bf0Spatrick for (unsigned Op : llvm::drop_begin(Opcodes))
30373471bf0Spatrick aliasActionDefinitions(Representative, Op);
30409467b48Spatrick
30509467b48Spatrick auto &Return = getActionDefinitionsBuilder(Representative);
30609467b48Spatrick Return.setIsAliasedByAnother();
30709467b48Spatrick return Return;
30809467b48Spatrick }
30909467b48Spatrick
aliasActionDefinitions(unsigned OpcodeTo,unsigned OpcodeFrom)31009467b48Spatrick void LegalizerInfo::aliasActionDefinitions(unsigned OpcodeTo,
31109467b48Spatrick unsigned OpcodeFrom) {
31209467b48Spatrick assert(OpcodeTo != OpcodeFrom && "Cannot alias to self");
31309467b48Spatrick assert(OpcodeTo >= FirstOp && OpcodeTo <= LastOp && "Unsupported opcode");
31409467b48Spatrick const unsigned OpcodeFromIdx = getOpcodeIdxForOpcode(OpcodeFrom);
31509467b48Spatrick RulesForOpcode[OpcodeFromIdx].aliasTo(OpcodeTo);
31609467b48Spatrick }
31709467b48Spatrick
31809467b48Spatrick LegalizeActionStep
getAction(const LegalityQuery & Query) const31909467b48Spatrick LegalizerInfo::getAction(const LegalityQuery &Query) const {
32009467b48Spatrick LegalizeActionStep Step = getActionDefinitions(Query.Opcode).apply(Query);
32109467b48Spatrick if (Step.Action != LegalizeAction::UseLegacyRules) {
32209467b48Spatrick return Step;
32309467b48Spatrick }
32409467b48Spatrick
32573471bf0Spatrick return getLegacyLegalizerInfo().getAction(Query);
32609467b48Spatrick }
32709467b48Spatrick
32809467b48Spatrick LegalizeActionStep
getAction(const MachineInstr & MI,const MachineRegisterInfo & MRI) const32909467b48Spatrick LegalizerInfo::getAction(const MachineInstr &MI,
33009467b48Spatrick const MachineRegisterInfo &MRI) const {
33173471bf0Spatrick SmallVector<LLT, 8> Types;
33209467b48Spatrick SmallBitVector SeenTypes(8);
333*d415bd75Srobert ArrayRef<MCOperandInfo> OpInfo = MI.getDesc().operands();
33409467b48Spatrick // FIXME: probably we'll need to cache the results here somehow?
33509467b48Spatrick for (unsigned i = 0; i < MI.getDesc().getNumOperands(); ++i) {
33609467b48Spatrick if (!OpInfo[i].isGenericType())
33709467b48Spatrick continue;
33809467b48Spatrick
33909467b48Spatrick // We must only record actions once for each TypeIdx; otherwise we'd
34009467b48Spatrick // try to legalize operands multiple times down the line.
34109467b48Spatrick unsigned TypeIdx = OpInfo[i].getGenericTypeIndex();
34209467b48Spatrick if (SeenTypes[TypeIdx])
34309467b48Spatrick continue;
34409467b48Spatrick
34509467b48Spatrick SeenTypes.set(TypeIdx);
34609467b48Spatrick
34709467b48Spatrick LLT Ty = getTypeFromTypeIdx(MI, MRI, i, TypeIdx);
34809467b48Spatrick Types.push_back(Ty);
34909467b48Spatrick }
35009467b48Spatrick
35109467b48Spatrick SmallVector<LegalityQuery::MemDesc, 2> MemDescrs;
35209467b48Spatrick for (const auto &MMO : MI.memoperands())
353*d415bd75Srobert MemDescrs.push_back({*MMO});
35409467b48Spatrick
35509467b48Spatrick return getAction({MI.getOpcode(), Types, MemDescrs});
35609467b48Spatrick }
35709467b48Spatrick
isLegal(const MachineInstr & MI,const MachineRegisterInfo & MRI) const35809467b48Spatrick bool LegalizerInfo::isLegal(const MachineInstr &MI,
35909467b48Spatrick const MachineRegisterInfo &MRI) const {
36009467b48Spatrick return getAction(MI, MRI).Action == Legal;
36109467b48Spatrick }
36209467b48Spatrick
isLegalOrCustom(const MachineInstr & MI,const MachineRegisterInfo & MRI) const36309467b48Spatrick bool LegalizerInfo::isLegalOrCustom(const MachineInstr &MI,
36409467b48Spatrick const MachineRegisterInfo &MRI) const {
36509467b48Spatrick auto Action = getAction(MI, MRI).Action;
36609467b48Spatrick // If the action is custom, it may not necessarily modify the instruction,
36709467b48Spatrick // so we have to assume it's legal.
36809467b48Spatrick return Action == Legal || Action == Custom;
36909467b48Spatrick }
37009467b48Spatrick
getExtOpcodeForWideningConstant(LLT SmallTy) const37109467b48Spatrick unsigned LegalizerInfo::getExtOpcodeForWideningConstant(LLT SmallTy) const {
37209467b48Spatrick return SmallTy.isByteSized() ? TargetOpcode::G_SEXT : TargetOpcode::G_ZEXT;
37309467b48Spatrick }
37409467b48Spatrick
37509467b48Spatrick /// \pre Type indices of every opcode form a dense set starting from 0.
verify(const MCInstrInfo & MII) const37609467b48Spatrick void LegalizerInfo::verify(const MCInstrInfo &MII) const {
37709467b48Spatrick #ifndef NDEBUG
37809467b48Spatrick std::vector<unsigned> FailedOpcodes;
37909467b48Spatrick for (unsigned Opcode = FirstOp; Opcode <= LastOp; ++Opcode) {
38009467b48Spatrick const MCInstrDesc &MCID = MII.get(Opcode);
38109467b48Spatrick const unsigned NumTypeIdxs = std::accumulate(
382*d415bd75Srobert MCID.operands().begin(), MCID.operands().end(), 0U,
38309467b48Spatrick [](unsigned Acc, const MCOperandInfo &OpInfo) {
38409467b48Spatrick return OpInfo.isGenericType()
38509467b48Spatrick ? std::max(OpInfo.getGenericTypeIndex() + 1U, Acc)
38609467b48Spatrick : Acc;
38709467b48Spatrick });
38809467b48Spatrick const unsigned NumImmIdxs = std::accumulate(
389*d415bd75Srobert MCID.operands().begin(), MCID.operands().end(), 0U,
39009467b48Spatrick [](unsigned Acc, const MCOperandInfo &OpInfo) {
39109467b48Spatrick return OpInfo.isGenericImm()
39209467b48Spatrick ? std::max(OpInfo.getGenericImmIndex() + 1U, Acc)
39309467b48Spatrick : Acc;
39409467b48Spatrick });
39509467b48Spatrick LLVM_DEBUG(dbgs() << MII.getName(Opcode) << " (opcode " << Opcode
39609467b48Spatrick << "): " << NumTypeIdxs << " type ind"
39709467b48Spatrick << (NumTypeIdxs == 1 ? "ex" : "ices") << ", "
39809467b48Spatrick << NumImmIdxs << " imm ind"
39909467b48Spatrick << (NumImmIdxs == 1 ? "ex" : "ices") << "\n");
40009467b48Spatrick const LegalizeRuleSet &RuleSet = getActionDefinitions(Opcode);
40109467b48Spatrick if (!RuleSet.verifyTypeIdxsCoverage(NumTypeIdxs))
40209467b48Spatrick FailedOpcodes.push_back(Opcode);
40309467b48Spatrick else if (!RuleSet.verifyImmIdxsCoverage(NumImmIdxs))
40409467b48Spatrick FailedOpcodes.push_back(Opcode);
40509467b48Spatrick }
40609467b48Spatrick if (!FailedOpcodes.empty()) {
40709467b48Spatrick errs() << "The following opcodes have ill-defined legalization rules:";
40809467b48Spatrick for (unsigned Opcode : FailedOpcodes)
40909467b48Spatrick errs() << " " << MII.getName(Opcode);
41009467b48Spatrick errs() << "\n";
41109467b48Spatrick
41209467b48Spatrick report_fatal_error("ill-defined LegalizerInfo"
41309467b48Spatrick ", try -debug-only=legalizer-info for details");
41409467b48Spatrick }
41509467b48Spatrick #endif
41609467b48Spatrick }
41709467b48Spatrick
41809467b48Spatrick #ifndef NDEBUG
41909467b48Spatrick // FIXME: This should be in the MachineVerifier, but it can't use the
42009467b48Spatrick // LegalizerInfo as it's currently in the separate GlobalISel library.
42109467b48Spatrick // Note that RegBankSelected property already checked in the verifier
42209467b48Spatrick // has the same layering problem, but we only use inline methods so
42309467b48Spatrick // end up not needing to link against the GlobalISel library.
machineFunctionIsIllegal(const MachineFunction & MF)42409467b48Spatrick const MachineInstr *llvm::machineFunctionIsIllegal(const MachineFunction &MF) {
42509467b48Spatrick if (const LegalizerInfo *MLI = MF.getSubtarget().getLegalizerInfo()) {
42609467b48Spatrick const MachineRegisterInfo &MRI = MF.getRegInfo();
42709467b48Spatrick for (const MachineBasicBlock &MBB : MF)
42809467b48Spatrick for (const MachineInstr &MI : MBB)
42909467b48Spatrick if (isPreISelGenericOpcode(MI.getOpcode()) &&
43009467b48Spatrick !MLI->isLegalOrCustom(MI, MRI))
43109467b48Spatrick return &MI;
43209467b48Spatrick }
43309467b48Spatrick return nullptr;
43409467b48Spatrick }
43509467b48Spatrick #endif
436