utils/TableGen/GlobalISelEmitter.cpp

71 static cl::opt<std::string> UseCoverageFile(
85 std::string getEnumNameForPredicate(const TreePredicateFn &Predicate) {
93 std::string getMatchOpcodeForPredicate(const TreePredicateFn &Predicate) {
107   std::string getCxxEnumValue() const {
108     std::string Str;
153   /// This ordering is used for std::unique() and llvm::sort(). There's no
182 std::set<LLTCodeGen> KnownTypes;
199 static std::string explainPredicates(const TreePatternNode *N) {
200   std::string Explanation = "";
278 std::string explainOperator(Record *Operator) {
304   std::string Explanation = "";
305   std::string Separator = "";
384 std::string
385 getNameForFeatureBitset(const std::vector<Record *> &FeatureBitset) {
386   std::string Name = "GIFBS";
430   std::string EmitStr;
447                    int64_t RawValue = std::numeric_limits<int64_t>::min())
486   std::vector<MatchTableRecord> Contents;
563     LabelMap.insert(std::make_pair(LabelID, CurrentSize));
578     OS << std::string(Indentation, ' ');
583       const auto &NextI = std::next(I);
596         OS << std::string(Indentation, ' ');
662   virtual std::unique_ptr<PredicateMatcher> popFirstCondition() = 0;
676   SmallVector<std::unique_ptr<PredicateMatcher>, 1> Conditions;
679   std::vector<Matcher *> Matchers;
683   std::vector<std::unique_ptr<Matcher>> MatcherStorage;
719   iterator_range<std::vector<Matcher *>::iterator> matchers() {
725   std::unique_ptr<PredicateMatcher> popFirstCondition() override {
728     std::unique_ptr<PredicateMatcher> P = std::move(Conditions.front());
751   std::vector<Matcher *> Matchers;
755   std::unique_ptr<PredicateMatcher> Condition = nullptr;
759   std::set<MatchTableRecord> Values;
763   std::vector<std::unique_ptr<Matcher>> MatcherStorage;
771   iterator_range<std::vector<Matcher *>::iterator> matchers() {
777   std::unique_ptr<PredicateMatcher> popFirstCondition() override {
802   using ActionList = std::list<std::unique_ptr<MatchAction>>;
810   using MatchersTy = std::vector<std::unique_ptr<InstructionMatcher>> ;
817   using DefinedInsnVariablesMap = std::map<InstructionMatcher *, unsigned>;
845   std::vector<Record *> RequiredFeatures;
846   std::vector<std::unique_ptr<PredicateMatcher>> EpilogueMatchers;
850   typedef std::tuple<Record *, unsigned, unsigned>
873   const std::vector<Record *> &getRequiredFeatures() const;
928         std::make_tuple(ComplexPattern, RendererID, SubOperandID);
957   std::unique_ptr<PredicateMatcher> popFirstCondition() override;
985   std::string getNoPredicateComment() const;
988   using PredicatesTy = std::deque<std::unique_ptr<PredicateTy>>;
1014   std::unique_ptr<PredicateTy> predicates_pop_front() {
1015     std::unique_ptr<PredicateTy> Front = std::move(Predicates.front());
1021   void prependPredicate(std::unique_ptr<PredicateTy> &&Predicate) {
1022     Predicates.push_front(std::move(Predicate));
1027         std::stable_partition(Predicates.begin(), Predicates.end(),
1028                               std::logical_not<std::unique_ptr<PredicateTy>>());
1045       Predicate->emitPredicateOpcodes(Table, std::forward<Args>(args)...);
1144 std::string
1152   std::string MatchingName;
1178   static std::map<LLTCodeGen, unsigned> TypeIDValues;
1223 std::map<LLTCodeGen, unsigned> LLTOperandMatcher::TypeIDValues;
1421   std::string PredName;
1425                              std::string P)
1483   std::string SymbolicName;
1492                  const std::string &SymbolicName,
1509     Predicates.emplace_back(std::make_unique<Kind>(
1510         getInsnVarID(), getOpIdx(), std::forward<Args>(args)...));
1517   std::string getOperandExpr(unsigned InsnVarID) const {
1531       std::string Comment;
1556       if (std::get<0>(Predicate)->isHigherPriorityThan(*std::get<1>(Predicate)))
1558       if (std::get<1>(Predicate)->isHigherPriorityThan(*std::get<0>(Predicate)))
1568     return std::accumulate(
1571            const std::unique_ptr<OperandPredicateMatcher> &Predicate) {
1637 std::string
2034   typedef std::vector<std::unique_ptr<OperandMatcher>> OperandVec;
2043   std::string SymbolicName;
2049   SmallVector<std::pair<Record *, unsigned>, 2> PhysRegInputs;
2063         std::make_unique<Kind>(getInsnVarID(), std::forward<Args>(args)...));
2072   OperandMatcher &addOperand(unsigned OpIdx, const std::string &SymbolicName,
2083     auto I = std::find_if(Operands.begin(), Operands.end(),
2084                           [&OpIdx](const std::unique_ptr<OperandMatcher> &X) {
2102   ArrayRef<std::pair<Record *, unsigned>> getPhysRegInputs() const {
2148       auto L = static_cast<InstructionPredicateMatcher *>(std::get<0>(P).get());
2149       auto R = static_cast<InstructionPredicateMatcher *>(std::get<1>(P).get());
2157       if (std::get<0>(Operand)->isHigherPriorityThan(*std::get<1>(Operand)))
2159       if (std::get<1>(Operand)->isHigherPriorityThan(*std::get<0>(Operand)))
2169     return std::accumulate(
2172                   const std::unique_ptr<PredicateMatcher> &Predicate) {
2175            std::accumulate(
2177                [](unsigned A, const std::unique_ptr<OperandMatcher> &Operand) {
2225   std::unique_ptr<InstructionMatcher> InsnMatcher;
2271   SmallVector<std::unique_ptr<PredicateMatcher>, 8> Stash;
2284           Stash.push_back(std::move(OP));
2299         Stash.push_back(std::move(OP));
2449   const std::string SymbolicName;
2481   const std::string SymbolicName;
2704   const std::string SymbolicName;
2735   const std::string SymbolicName;
2779   std::string S;
2796   std::vector<std::unique_ptr<OperandRenderer>> OperandRenderers;
2840         std::make_unique<Kind>(InsnID, std::forward<Args>(args)...));
2902       std::vector<unsigned> MergeInsnIDs;
2990 const std::vector<Record *> &RuleMatcher::getRequiredFeatures() const {
2998 // Like std::vector::emplace_back(), may invalidate all iterators if the new
3003   Actions.emplace_back(std::make_unique<Kind>(std::forward<Args>(args)...));
3011 // Like std::vector::insert(), may invalidate all iterators if the new size
3018                          std::make_unique<Kind>(std::forward<Args>(args)...));
3196     if (std::get<0>(Matcher)->isHigherPriorityThan(*std::get<1>(Matcher)))
3198     if (std::get<1>(Matcher)->isHigherPriorityThan(*std::get<0>(Matcher)))
3206   return std::accumulate(
3208       [](unsigned A, const std::unique_ptr<InstructionMatcher> &Matcher) {
3344                              const std::vector<Record *> &ImplicitDefs) const;
3349                            std::function<bool(const Record *R)> Filter);
3352                            std::function<bool(const Record *R)> Filter);
3417   static std::vector<Matcher *> optimizeRules(
3419       std::vector<std::unique_ptr<Matcher>> &MatcherStorage);
3532       return failedImport(toString(std::move(Error)) +
3794         return std::move(Error);
3869       return failedImport(toString(std::move(Error)) + " for Src operand (" +
3988         *std::get<0>(*SubOperand), DstChild->getName(),
3989         std::get<1>(*SubOperand), std::get<2>(*SubOperand));
4062         return std::move(Error);
4141     return std::move(Error);
4161     return std::move(Error);
4175     return std::move(Error);
4186     return std::move(Error);
4358           return std::move(Error);
4419         return std::move(Error);
4427       return std::move(Error);
4492     const std::vector<Record *> &ImplicitDefs) const {
4628     return std::move(Error);
4637                         toString(std::move(Err)) + ")");
4640                         toString(std::move(Err)) + ")");
4668     return std::move(Error);
4696       return std::move(M);
4786     return std::move(Error);
4792     return std::move(Error);
4813     return std::move(M);
4844     return std::move(M);
4865     return std::move(M);
4889     return std::move(M);
4896   return std::move(M);
4905     std::function<bool(const Record *R)> Filter) {
4906   std::vector<const Record *> MatchedRecords;
4908   std::copy_if(Defs.begin(), Defs.end(), std::back_inserter(MatchedRecords),
4917     std::string EnumeratorSeparator =
4953     std::function<bool(const Record *R)> Filter) {
4968 std::vector<Matcher *> GlobalISelEmitter::optimizeRules(
4970     std::vector<std::unique_ptr<Matcher>> &MatcherStorage) {
4972   std::vector<Matcher *> OptRules;
4973   std::unique_ptr<GroupT> CurrentGroup = std::make_unique<GroupT>();
4991       MatcherStorage.emplace_back(std::move(CurrentGroup));
4994     CurrentGroup = std::make_unique<GroupT>();
5020   std::vector<Matcher *> InputRules;
5036   std::stable_sort(InputRules.begin(), InputRules.end(),
5040                      return std::make_tuple(OpcodeOrder[L->getOpcode()],
5042                             std::make_tuple(OpcodeOrder[R->getOpcode()],
5049   std::vector<std::unique_ptr<Matcher>> MatcherStorage;
5050   std::vector<Matcher *> OptRules =
5074     std::stable_sort(F, T, [](Matcher *A, Matcher *B) {
5114   std::vector<RuleMatcher> Rules;
5126                      "Skipped pattern: " + toString(std::move(Err)));
5128         consumeError(std::move(Err));
5141     Rules.push_back(std::move(MatcherOrErr.get()));
5149   std::vector<Record *> ComplexPredicates =
5153   std::vector<Record *> CustomRendererFns =
5159     MaxTemporaries = std::max(MaxTemporaries, Rule.countRendererFns());
5209   std::copy_if(SubtargetFeatures.begin(), SubtargetFeatures.end(),
5210                std::inserter(ModuleFeatures, ModuleFeatures.end()),
5215   std::copy_if(SubtargetFeatures.begin(), SubtargetFeatures.end(),
5216                std::inserter(FunctionFeatures, FunctionFeatures.end()),
5246   std::vector<LLTCodeGen> TypeObjects;
5269   std::vector<std::vector<Record *>> FeatureBitsets;
5272   llvm::sort(FeatureBitsets, [&](const std::vector<Record *> &A,
5273                                  const std::vector<Record *> &B) {
5279       if (std::get<0>(Pair)->getName() < std::get<1>(Pair)->getName())
5281       if (std::get<0>(Pair)->getName() > std::get<1>(Pair)->getName())
5287       std::unique(FeatureBitsets.begin(), FeatureBitsets.end()),
5445           EpilogueMatchers.emplace_back(std::move(OP));
5450   llvm::sort(EpilogueMatchers, [](const std::unique_ptr<PredicateMatcher> &L,
5451                                   const std::unique_ptr<PredicateMatcher> &R) {
5452     return std::make_tuple(L->getKind(), L->getInsnVarID(), L->getOpIdx()) <
5453            std::make_tuple(R->getKind(), R->getInsnVarID(), R->getOpIdx());
5488 std::unique_ptr<PredicateMatcher> RuleMatcher::popFirstCondition() {
5500         std::unique_ptr<PredicateMatcher> Result = std::move(OP);
5643   std::stable_sort(Matchers.begin(), Matchers.end(),
5681   std::vector<unsigned> LabelIDs(Values.size());
5682   std::generate(LabelIDs.begin(), LabelIDs.end(),