Detect unused ops

llvm/lib/CodeGen/GlobalISel/PatternGen.cpp

@@ -1,3 +1,3 @@
 //===- llvm/CodeGen/GlobalISel/PatternGen.cpp - PatternGen ---==//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
@@ -65,6 +65,8 @@
 STATISTIC(PatternGenNumErrorFormatImm, "Errors of type: FORMAT_IMM");
 STATISTIC(PatternGenNumErrorFormat, "Errors of type: FORMAT");
 STATISTIC(PatternGenNumErrorMultipleStores, "Errors of type: MULTIPLE STORES");
+STATISTIC(PatternGenNumErrorUnusedOperand, "Errors of type: UNUSED_OPERAND");
+STATISTIC(PatternGenNumErrorOperandMissmatch, "Errors of type: OPERAND_MISSMATCH");
 
 #ifdef LLVM_GISEL_COV_PREFIX
 static cl::opt<std::string>
@@ -142,7 +144,8 @@
   FORMAT_LOAD,
   FORMAT_IMM,
   FORMAT,
-  MULTIPLE_STORES
+  MULTIPLE_STORES,
+  UNUSED_OPERANDS
 };
 struct PatternError {
   PatternErrorT Type;
@@ -163,7 +166,8 @@
                                  &PatternGenNumErrorFormatLoad,
                                  &PatternGenNumErrorFormatImm,
                                  &PatternGenNumErrorFormat,
-                                 &PatternGenNumErrorMultipleStores};
+                                 &PatternGenNumErrorMultipleStores,
+                                 &PatternGenNumErrorUnusedOperand};
 
 static const std::unordered_map<unsigned, std::string> CmpStr = {
     {CmpInst::Predicate::ICMP_EQ, "SETEQ"},
@@ -697,7 +701,7 @@
     abort();
   }
 
   static bool classof(const PatternNode *p) { return p->getKind() == PN_Load; }
 };
 
 struct CastNode : public PatternNode {
@@ -711,7 +715,7 @@
     return "(" + LLTString + " " + Value->patternString() + ")";
   }
 
   static bool classof(const PatternNode *p) { return p->getKind() == PN_Cast; }
 };
 
 struct StoreNode : public PatternNode {
@@ -739,20 +743,20 @@
     abort();
   }
 
   static bool classof(const PatternNode *p) { return p->getKind() == PN_Cast; }
 };
 
 using PatternOrError = std::pair<PatternError, std::unique_ptr<PatternNode>>;
 static PatternOrError pError(PatternErrorT Type, MachineInstr *Inst) {
   return std::make_pair(PatternError(Type, Inst), nullptr);
 }
 static PatternOrError PError(PatternError Error) {
   return std::make_pair(Error, nullptr);
 }
 static PatternOrError PError(PatternErrorT Type) {
   return std::make_pair(PatternError(Type), nullptr);
 }
 static PatternOrError PPattern(std::unique_ptr<PatternNode> Pattern) {
   return std::make_pair(PatternError(SUCCESS), std::move(Pattern));
 }
 
@@ -1366,6 +1370,30 @@
   std::string OutsString;
   std::string InsString;
   for (size_t I = 0; I < CurInstr->fields.size() - 1; I++) {
+    // TODO: move to helper func
+
+    // handle unused operands
+    if (!PatternArgs[I].In && !PatternArgs[I].Out) {
+        llvm::errs() << "Pattern Generation failed for " << MF.getName() << ": "
+                     << "Operand '" << CurInstr->fields[I].ident << "' not used in pattern!\n";
+        ++PatternGenNumErrorUnusedOperand;
+        return true;
+    }
+
+    // check for missmatches between operands
+    if ((CurInstr->fields[I].type & CDSLInstr::IN) && !PatternArgs[I].In) {
+      llvm::errs() << "Pattern Generation failed for " << MF.getName() << ": "
+                   << "Operand '" << CurInstr->fields[I].ident << "' should be an input!\n";
+      ++PatternGenNumErrorOperandMissmatch;
+      return true;
+    }
+    if ((CurInstr->fields[I].type & CDSLInstr::OUT) && !PatternArgs[I].Out) {
+      llvm::errs() << "Pattern Generation failed for " << MF.getName() << ": "
+                   << "Operand '" << CurInstr->fields[I].ident << "' should be an output!\n";
+      ++PatternGenNumErrorOperandMissmatch;
+      return true;
+    }
+
     if (PatternArgs[I].In) {
       InsString += PatternArgs[I].ArgTypeStr + ":$" +
                    std::string(CurInstr->fields[I].ident) + ", ";

llvm/tools/pattern-gen/lib/Parser.cpp

@@ -1,3 +1,3 @@
 #include "Parser.hpp"
 #include "InstrInfo.hpp"
 #include "Token.hpp"
@@ -40,10 +40,10 @@
 using namespace std::placeholders;
 
 struct Value {
   llvm::Value *ll;
   int bitWidth;
   bool isSigned;
   bool isLValue;
 
   Value(llvm::Value *llvalue, bool isSigned = false)
       : ll(llvalue), isSigned(isSigned) {
@@ -1371,7 +1371,7 @@
     strNew =
         std::regex_replace(str, std::regex("\\{" + fstr + "\\}"), "$" + fstr);
     if (strNew != str)
-      f.type = (CDSLInstr::FieldType)(f.type | CDSLInstr::FieldType::IMM);
+      f.type = (CDSLInstr::FieldType)(f.type | CDSLInstr::FieldType::IMM | CDSLInstr::FieldType::IN);
     str = strNew;
   }