• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
2|*                                                                            *|
3|* Global Combiner                                                            *|
4|*                                                                            *|
5|* Automatically generated file, do not edit!                                 *|
6|*                                                                            *|
7\*===----------------------------------------------------------------------===*/
8
9#ifdef MIPSPOSTLEGALIZERCOMBINERHELPER_GENCOMBINERHELPER_DEPS
10#include "llvm/ADT/SparseBitVector.h"
11namespace llvm {
12extern cl::OptionCategory GICombinerOptionCategory;
13} // end namespace llvm
14#endif // ifdef MIPSPOSTLEGALIZERCOMBINERHELPER_GENCOMBINERHELPER_DEPS
15
16#ifdef MIPSPOSTLEGALIZERCOMBINERHELPER_GENCOMBINERHELPER_H
17class MipsGenPostLegalizerCombinerHelperRuleConfig {
18  SparseBitVector<> DisabledRules;
19
20public:
21  bool parseCommandLineOption();
22  bool isRuleDisabled(unsigned ID) const;
23  bool setRuleEnabled(StringRef RuleIdentifier);
24  bool setRuleDisabled(StringRef RuleIdentifier);
25};
26
27class MipsGenPostLegalizerCombinerHelper {
28  const MipsGenPostLegalizerCombinerHelperRuleConfig *RuleConfig;
29
30public:
31  template <typename... Args>MipsGenPostLegalizerCombinerHelper(const MipsGenPostLegalizerCombinerHelperRuleConfig &RuleConfig, Args &&... args) : RuleConfig(&RuleConfig) {}
32
33  bool tryCombineAll(
34    GISelChangeObserver &Observer,
35    MachineInstr &MI,
36    MachineIRBuilder &B,
37    CombinerHelper & Helper) const;
38};
39
40static std::optional<uint64_t> getRuleIdxForIdentifier(StringRef RuleIdentifier) {
41  uint64_t I;
42  // getAtInteger(...) returns false on success
43  bool Parsed = !RuleIdentifier.getAsInteger(0, I);
44  if (Parsed)
45    return I;
46
47#ifndef NDEBUG
48#endif // ifndef NDEBUG
49
50  return std::nullopt;
51}
52static std::optional<std::pair<uint64_t, uint64_t>> getRuleRangeForIdentifier(StringRef RuleIdentifier) {
53  std::pair<StringRef, StringRef> RangePair = RuleIdentifier.split('-');
54  if (!RangePair.second.empty()) {
55    const auto First = getRuleIdxForIdentifier(RangePair.first);
56    const auto Last = getRuleIdxForIdentifier(RangePair.second);
57    if (!First || !Last)
58      return std::nullopt;
59    if (First >= Last)
60      report_fatal_error("Beginning of range should be before end of range");
61    return {{*First, *Last + 1}};
62  }
63  if (RangePair.first == "*") {
64    return {{0, 0}};
65  }
66  const auto I = getRuleIdxForIdentifier(RangePair.first);
67  if (!I)
68    return std::nullopt;
69  return {{*I, *I + 1}};
70}
71
72bool MipsGenPostLegalizerCombinerHelperRuleConfig::setRuleEnabled(StringRef RuleIdentifier) {
73  auto MaybeRange = getRuleRangeForIdentifier(RuleIdentifier);
74  if (!MaybeRange)
75    return false;
76  for (auto I = MaybeRange->first; I < MaybeRange->second; ++I)
77    DisabledRules.reset(I);
78  return true;
79}
80
81bool MipsGenPostLegalizerCombinerHelperRuleConfig::setRuleDisabled(StringRef RuleIdentifier) {
82  auto MaybeRange = getRuleRangeForIdentifier(RuleIdentifier);
83  if (!MaybeRange)
84    return false;
85  for (auto I = MaybeRange->first; I < MaybeRange->second; ++I)
86    DisabledRules.set(I);
87  return true;
88}
89
90bool MipsGenPostLegalizerCombinerHelperRuleConfig::isRuleDisabled(unsigned RuleID) const {
91  return DisabledRules.test(RuleID);
92}
93#endif // ifdef MIPSPOSTLEGALIZERCOMBINERHELPER_GENCOMBINERHELPER_H
94
95#ifdef MIPSPOSTLEGALIZERCOMBINERHELPER_GENCOMBINERHELPER_CPP
96
97std::vector<std::string> MipsPostLegalizerCombinerHelperOption;
98cl::list<std::string> MipsPostLegalizerCombinerHelperDisableOption(
99    "mipspostlegalizercombinerhelper-disable-rule",
100    cl::desc("Disable one or more combiner rules temporarily in the MipsPostLegalizerCombinerHelper pass"),
101    cl::CommaSeparated,
102    cl::Hidden,
103    cl::cat(GICombinerOptionCategory),
104    cl::callback([](const std::string &Str) {
105      MipsPostLegalizerCombinerHelperOption.push_back(Str);
106    }));
107cl::list<std::string> MipsPostLegalizerCombinerHelperOnlyEnableOption(
108    "mipspostlegalizercombinerhelper-only-enable-rule",
109    cl::desc("Disable all rules in the MipsPostLegalizerCombinerHelper pass then re-enable the specified ones"),
110    cl::Hidden,
111    cl::cat(GICombinerOptionCategory),
112    cl::callback([](const std::string &CommaSeparatedArg) {
113      StringRef Str = CommaSeparatedArg;
114      MipsPostLegalizerCombinerHelperOption.push_back("*");
115      do {
116        auto X = Str.split(",");
117        MipsPostLegalizerCombinerHelperOption.push_back(("!" + X.first).str());
118        Str = X.second;
119      } while (!Str.empty());
120    }));
121
122bool MipsGenPostLegalizerCombinerHelperRuleConfig::parseCommandLineOption() {
123  for (StringRef Identifier : MipsPostLegalizerCombinerHelperOption) {
124    bool Enabled = Identifier.consume_front("!");
125    if (Enabled && !setRuleEnabled(Identifier))
126      return false;
127    if (!Enabled && !setRuleDisabled(Identifier))
128      return false;
129  }
130  return true;
131}
132
133bool MipsGenPostLegalizerCombinerHelper::tryCombineAll(
134    GISelChangeObserver &Observer,
135    MachineInstr &MI,
136    MachineIRBuilder &B,
137    CombinerHelper & Helper) const {
138  MachineBasicBlock *MBB = MI.getParent();
139  MachineFunction *MF = MBB->getParent();
140  MachineRegisterInfo &MRI = MF->getRegInfo();
141  SmallVector<MachineInstr *, 8> MIs = {&MI};
142
143  (void)MBB; (void)MF; (void)MRI; (void)RuleConfig;
144
145  // Match data
146
147  int Partition = -1;
148  Partition = 0;
149  // Default case but without conflicting with potential default case in selection.
150  if (Partition == -1) return false;
151  if (Partition == 0 /* * or nullptr */) {
152    return false;
153  }
154
155  return false;
156}
157#endif // ifdef MIPSPOSTLEGALIZERCOMBINERHELPER_GENCOMBINERHELPER_CPP
158