[mlir][pdl][NFC] Extract the execution of each bytecode operation into its own function

[rriddle]

Summary

This makes the implementation of each bytecode operation much easier to reason about, and lets the compiler decide which implementations are beneficial to inline into the main switch.

Depends On D95715

mlir/lib/Rewrite/ByteCode.cpp

public:
   /// Start executing the code at the current bytecode index. `matches` is an
   /// optional field provided when this function is executed in a matching
   /// context.
   void execute(PatternRewriter &rewriter,
                SmallVectorImpl<PDLByteCode::MatchResult> *matches = nullptr,
                Optional<Location> mainRewriteLoc = {});
 
 private:
+  /// Internal implementation of executing each of the bytecode commands.
+  void executeApplyConstraint(PatternRewriter &rewriter);
+  void executeApplyRewrite(PatternRewriter &rewriter);
+  void executeAreEqual();
+  void executeBranch();
+  void executeCheckOperandCount();
+  void executeCheckOperationName();
+  void executeCheckResultCount();
+  void executeCreateNative(PatternRewriter &rewriter);
+  void executeCreateOperation(PatternRewriter &rewriter,
+                              Location mainRewriteLoc);
+  void executeEraseOp(PatternRewriter &rewriter);
+  void executeGetAttribute();
+  void executeGetAttributeType();
+  void executeGetDefiningOp();
+  void executeGetOperand(unsigned index);
+  void executeGetResult(unsigned index);
+  void executeGetValueType();
+  void executeIsNotNull();
+  void executeRecordMatch(PatternRewriter &rewriter,
+                          SmallVectorImpl<PDLByteCode::MatchResult> &matches);
+  void executeReplaceOp(PatternRewriter &rewriter);
+  void executeSwitchAttribute();
+  void executeSwitchOperandCount();
+  void executeSwitchOperationName();
+  void executeSwitchResultCount();
+  void executeSwitchType();
+
   /// Read a value from the bytecode buffer, optionally skipping a certain
   /// number of prefix values. These methods always update the buffer to point
   /// to the next field after the read data.
   template <typename T = ByteCodeField>
   T read(size_t skipN = 0) {
     curCodeIt += skipN;
     return readImpl<T>();
   }
private:
 
   /// Handle a switch operation with the provided value and cases.
   template <typename T, typename RangeT>
   void handleSwitch(const T &value, RangeT &&cases) {
     LLVM_DEBUG({
       llvm::dbgs() << "  * Value: " << value << "\n"
                    << "  * Cases: ";
       llvm::interleaveComma(cases, llvm::dbgs());
-      llvm::dbgs() << "\n\n";
+      llvm::dbgs() << "\n";
     });
 
     // Check to see if the attribute value is within the case list. Jump to
     // the correct successor index based on the result.
     for (auto it = cases.begin(), e = cases.end(); it != e; ++it)
       if (*it == value)
         return selectJump(size_t((it - cases.begin()) + 1));
     selectJump(size_t(0));
private:
   ArrayRef<PatternBenefit> currentPatternBenefits;
   ArrayRef<PDLByteCodePattern> patterns;
   ArrayRef<PDLConstraintFunction> constraintFunctions;
   ArrayRef<PDLCreateFunction> createFunctions;
   ArrayRef<PDLRewriteFunction> rewriteFunctions;
 };
 } // end anonymous namespace
 
-void ByteCodeExecutor::execute(
-    PatternRewriter &rewriter,
-    SmallVectorImpl<PDLByteCode::MatchResult> *matches,
-    Optional<Location> mainRewriteLoc) {
-  while (true) {
-    OpCode opCode = static_cast<OpCode>(read());
-    switch (opCode) {
-    case ApplyConstraint: {
-      LLVM_DEBUG(llvm::dbgs() << "Executing ApplyConstraint:\n");
-      const PDLConstraintFunction &constraintFn = constraintFunctions[read()];
-      ArrayAttr constParams = read<ArrayAttr>();
-      SmallVector<PDLValue, 16> args;
-      readList<PDLValue>(args);
-      LLVM_DEBUG({
-        llvm::dbgs() << "  * Arguments: ";
-        llvm::interleaveComma(args, llvm::dbgs());
-        llvm::dbgs() << "\n  * Parameters: " << constParams << "\n\n";
-      });
+void ByteCodeExecutor::executeApplyConstraint(PatternRewriter &rewriter) {
+
+    llvm::dbgs() << "\n  * Parameters: " << constParams << "\n";
 
-      // Invoke the constraint and jump to the proper destination.
-      selectJump(succeeded(constraintFn(args, constParams, rewriter)));
-      break;
-    }
-    case ApplyRewrite: {
-      LLVM_DEBUG(llvm::dbgs() << "Executing ApplyRewrite:\n");
-      const PDLRewriteFunction &rewriteFn = rewriteFunctions[read()];
-      ArrayAttr constParams = read<ArrayAttr>();
-      Operation *root = read<Operation *>();
-      SmallVector<PDLValue, 16> args;
-      readList<PDLValue>(args);
+
+void ByteCodeExecutor::executeApplyRewrite(PatternRewriter &rewriter) {
 
-      LLVM_DEBUG({
-        llvm::dbgs() << "  * Root: " << *root << "\n"
-                     << "  * Arguments: ";
-        llvm::interleaveComma(args, llvm::dbgs());
-        llvm::dbgs() << "\n  * Parameters: " << constParams << "\n\n";
-      });
-      rewriteFn(root, args, constParams, rewriter);
-      break;
-    }
-    case AreEqual: {
-      LLVM_DEBUG(llvm::dbgs() << "Executing AreEqual:\n");
-      const void *lhs = read<const void *>();
-      const void *rhs = read<const void *>();
+    llvm::dbgs() << "  * Root: " << *root << "\n  * Arguments: ";
+    llvm::dbgs() << "\n  * Parameters: " << constParams << "\n";
+
+  // Invoke the native rewrite function.
+
+void ByteCodeExecutor::executeAreEqual() {
 
-      LLVM_DEBUG(llvm::dbgs() << "  * " << lhs << " == " << rhs << "\n\n");
-      selectJump(lhs == rhs);
-      break;
-    }
-    case Branch: {
-      LLVM_DEBUG(llvm::dbgs() << "Executing Branch\n\n");
-      curCodeIt = &code[read<ByteCodeAddr>()];
-      break;
-    }
-    case CheckOperandCount: {
-      LLVM_DEBUG(llvm::dbgs() << "Executing CheckOperandCount:\n");
-      Operation *op = read<Operation *>();
-      uint32_t expectedCount = read<uint32_t>();
+  LLVM_DEBUG(llvm::dbgs() << "  * " << lhs << " == " << rhs << "\n");
+
+void ByteCodeExecutor::executeBranch() {
+  LLVM_DEBUG(llvm::dbgs() << "Executing Branch\n");
+
+void ByteCodeExecutor::executeCheckOperandCount() {
 
-      LLVM_DEBUG(llvm::dbgs() << "  * Found: " << op->getNumOperands() << "\n"
-                              << "  * Expected: " << expectedCount << "\n\n");
-      selectJump(op->getNumOperands() == expectedCount);
-      break;
-    }
-    case CheckOperationName: {
-      LLVM_DEBUG(llvm::dbgs() << "Executing CheckOperationName:\n");
-      Operation *op = read<Operation *>();
-      OperationName expectedName = read<OperationName>();
+                          << "  * Expected: " << expectedCount << "\n");
+
+void ByteCodeExecutor::executeCheckOperationName() {
 
-      LLVM_DEBUG(llvm::dbgs()
-                 << "  * Found: \"" << op->getName() << "\"\n"
-                 << "  * Expected: \"" << expectedName << "\"\n\n");
-      selectJump(op->getName() == expectedName);
-      break;
-    }
-    case CheckResultCount: {
-      LLVM_DEBUG(llvm::dbgs() << "Executing CheckResultCount:\n");
-      Operation *op = read<Operation *>();
-      uint32_t expectedCount = read<uint32_t>();
+  LLVM_DEBUG(llvm::dbgs() << "  * Found: \"" << op->getName() << "\"\n"
+                          << "  * Expected: \"" << expectedName << "\"\n");
+
+void ByteCodeExecutor::executeCheckResultCount() {
 
-      LLVM_DEBUG(llvm::dbgs() << "  * Found: " << op->getNumResults() << "\n"
-                              << "  * Expected: " << expectedCount << "\n\n");
-      selectJump(op->getNumResults() == expectedCount);
-      break;
-    }
-    case CreateNative: {
-      LLVM_DEBUG(llvm::dbgs() << "Executing CreateNative:\n");
-      const PDLCreateFunction &createFn = createFunctions[read()];
-      ByteCodeField resultIndex = read();
-      ArrayAttr constParams = read<ArrayAttr>();
-      SmallVector<PDLValue, 16> args;
-      readList<PDLValue>(args);
+                          << "  * Expected: " << expectedCount << "\n");
+
+void ByteCodeExecutor::executeCreateNative(PatternRewriter &rewriter) {
 
-      LLVM_DEBUG({
-        llvm::dbgs() << "  * Arguments: ";
-        llvm::interleaveComma(args, llvm::dbgs());
-        llvm::dbgs() << "\n  * Parameters: " << constParams << "\n";
-      });
 
-      PDLValue result = createFn(args, constParams, rewriter);
-      memory[resultIndex] = result.getAsOpaquePointer();
 
-      LLVM_DEBUG(llvm::dbgs() << "  * Result: " << result << "\n\n");
-      break;
-    }
-    case CreateOperation: {
-      LLVM_DEBUG(llvm::dbgs() << "Executing CreateOperation:\n");
-      assert(mainRewriteLoc && "expected rewrite loc to be provided when "
-                               "executing the rewriter bytecode");
+  LLVM_DEBUG(llvm::dbgs() << "  * Result: " << result << "\n");
+
+void ByteCodeExecutor::executeCreateOperation(PatternRewriter &rewriter,
+                                              Location mainRewriteLoc) {
 
-      unsigned memIndex = read();
-      OperationState state(*mainRewriteLoc, read<OperationName>());
-      readList<Value>(state.operands);
-      for (unsigned i = 0, e = read(); i != e; ++i) {
-        Identifier name = read<Identifier>();
-        if (Attribute attr = read<Attribute>())
-          state.addAttribute(name, attr);
-      }
+  OperationState state(mainRewriteLoc, read<OperationName>());
 
-      bool hasInferredTypes = false;
-      for (unsigned i = 0, e = read(); i != e; ++i) {
-        Type resultType = read<Type>();
-        hasInferredTypes |= !resultType;
-        state.types.push_back(resultType);
-      }
 
-      // Handle the case where the operation has inferred types.
-      if (hasInferredTypes) {
-        InferTypeOpInterface::Concept *concept =
-            state.name.getAbstractOperation()
-                ->getInterface<InferTypeOpInterface>();
+        state.name.getAbstractOperation()->getInterface<InferTypeOpInterface>();
 
-        // TODO: Handle failure.
-        SmallVector<Type, 2> inferredTypes;
-        if (failed(concept->inferReturnTypes(
-                state.getContext(), state.location, state.operands,
-                state.attributes.getDictionary(state.getContext()),
-                state.regions, inferredTypes)))
-          return;
+            state.attributes.getDictionary(state.getContext()), state.regions,
+            inferredTypes)))
 
-        for (unsigned i = 0, e = state.types.size(); i != e; ++i)
-          if (!state.types[i])
-            state.types[i] = inferredTypes[i];
-      }
-      Operation *resultOp = rewriter.createOperation(state);
-      memory[memIndex] = resultOp;
 
-      LLVM_DEBUG({
-        llvm::dbgs() << "  * Attributes: "
-                     << state.attributes.getDictionary(state.getContext())
-                     << "\n  * Operands: ";
-        llvm::interleaveComma(state.operands, llvm::dbgs());
-        llvm::dbgs() << "\n  * Result Types: ";
-        llvm::interleaveComma(state.types, llvm::dbgs());
-        llvm::dbgs() << "\n  * Result: " << *resultOp << "\n\n";
-      });
-      break;
-    }
-    case EraseOp: {
-      LLVM_DEBUG(llvm::dbgs() << "Executing EraseOp:\n");
-      Operation *op = read<Operation *>();
+    llvm::dbgs() << "\n  * Result: " << *resultOp << "\n";
+
+void ByteCodeExecutor::executeEraseOp(PatternRewriter &rewriter) {
 
-      LLVM_DEBUG(llvm::dbgs() << "  * Operation: " << *op << "\n\n");
-      rewriter.eraseOp(op);
-      break;
-    }
-    case Finalize: {
-      LLVM_DEBUG(llvm::dbgs() << "Executing Finalize\n\n");
-      return;
-    }
-    case GetAttribute: {
-      LLVM_DEBUG(llvm::dbgs() << "Executing GetAttribute:\n");
-      unsigned memIndex = read();
-      Operation *op = read<Operation *>();
-      Identifier attrName = read<Identifier>();
-      Attribute attr = op->getAttr(attrName);
+  LLVM_DEBUG(llvm::dbgs() << "  * Operation: " << *op << "\n");
+
+void ByteCodeExecutor::executeGetAttribute() {
 
-      LLVM_DEBUG(llvm::dbgs() << "  * Operation: " << *op << "\n"
-                              << "  * Attribute: " << attrName << "\n"
-                              << "  * Result: " << attr << "\n\n");
-      memory[memIndex] = attr.getAsOpaquePointer();
-      break;
-    }
-    case GetAttributeType: {
-      LLVM_DEBUG(llvm::dbgs() << "Executing GetAttributeType:\n");
-      unsigned memIndex = read();
-      Attribute attr = read<Attribute>();
+                          << "  * Result: " << attr << "\n");
+
+void ByteCodeExecutor::executeGetAttributeType() {
+  Type type = attr ? attr.getType() : Type();
 
-      LLVM_DEBUG(llvm::dbgs() << "  * Attribute: " << attr << "\n"
-                              << "  * Result: " << attr.getType() << "\n\n");
-      memory[memIndex] = attr.getType().getAsOpaquePointer();
-      break;
-    }
-    case GetDefiningOp: {
-      LLVM_DEBUG(llvm::dbgs() << "Executing GetDefiningOp:\n");
-      unsigned memIndex = read();
-      Value value = read<Value>();
-      Operation *op = value ? value.getDefiningOp() : nullptr;
+                          << "  * Result: " << type << "\n");
+  memory[memIndex] = type.getAsOpaquePointer();
+
+void ByteCodeExecutor::executeGetDefiningOp() {
 
-      LLVM_DEBUG(llvm::dbgs() << "  * Value: " << value << "\n"
-                              << "  * Result: " << *op << "\n\n");
-      memory[memIndex] = op;
-      break;
-    }
-    case GetOperand0:
-    case GetOperand1:
-    case GetOperand2:
-    case GetOperand3:
-    case GetOperandN: {
-      LLVM_DEBUG({
-        llvm::dbgs() << "Executing GetOperand"
-                     << (opCode == GetOperandN ? Twine("N")
-                                               : Twine(opCode - GetOperand0))
-                     << ":\n";
-      });
-      unsigned index =
-          opCode == GetOperandN ? read<uint32_t>() : (opCode - GetOperand0);
-      Operation *op = read<Operation *>();
-      unsigned memIndex = read();
-      Value operand =
-          index < op->getNumOperands() ? op->getOperand(index) : Value();
+                          << "  * Result: " << *op << "\n");
+
+void ByteCodeExecutor::executeGetOperand(unsigned index) {
 
-      LLVM_DEBUG(llvm::dbgs() << "  * Operation: " << *op << "\n"
-                              << "  * Index: " << index << "\n"
-                              << "  * Result: " << operand << "\n\n");
-      memory[memIndex] = operand.getAsOpaquePointer();
-      break;
-    }
-    case GetResult0:
-    case GetResult1:
-    case GetResult2:
-    case GetResult3:
-    case GetResultN: {
-      LLVM_DEBUG({
-        llvm::dbgs() << "Executing GetResult"
-                     << (opCode == GetResultN ? Twine("N")
-                                              : Twine(opCode - GetResult0))
-                     << ":\n";
-      });
-      unsigned index =
-          opCode == GetResultN ? read<uint32_t>() : (opCode - GetResult0);
-      Operation *op = read<Operation *>();
-      unsigned memIndex = read();
-      OpResult result =
-          index < op->getNumResults() ? op->getResult(index) : OpResult();
+                          << "  * Result: " << operand << "\n");
+
+void ByteCodeExecutor::executeGetResult(unsigned index) {
 
-      LLVM_DEBUG(llvm::dbgs() << "  * Operation: " << *op << "\n"
-                              << "  * Index: " << index << "\n"
-                              << "  * Result: " << result << "\n\n");
-      memory[memIndex] = result.getAsOpaquePointer();
-      break;
-    }
-    case GetValueType: {
-      LLVM_DEBUG(llvm::dbgs() << "Executing GetValueType:\n");
-      unsigned memIndex = read();
-      Value value = read<Value>();
+                          << "  * Result: " << result << "\n");
+
+void ByteCodeExecutor::executeGetValueType() {
+  Type type = value ? value.getType() : Type();
 
-      LLVM_DEBUG(llvm::dbgs() << "  * Value: " << value << "\n"
-                              << "  * Result: " << value.getType() << "\n\n");
-      memory[memIndex] = value.getType().getAsOpaquePointer();
-      break;
-    }
-    case IsNotNull: {
-      LLVM_DEBUG(llvm::dbgs() << "Executing IsNotNull:\n");
-      const void *value = read<const void *>();
+                          << "  * Result: " << type << "\n");
+  memory[memIndex] = type.getAsOpaquePointer();
+
+void ByteCodeExecutor::executeIsNotNull() {
 
-      LLVM_DEBUG(llvm::dbgs() << "  * Value: " << value << "\n\n");
-      selectJump(value != nullptr);
-      break;
-    }
-    case RecordMatch: {
-      LLVM_DEBUG(llvm::dbgs() << "Executing RecordMatch:\n");
-      assert(matches &&
-             "expected matches to be provided when executing the matcher");
-      unsigned patternIndex = read();
-      PatternBenefit benefit = currentPatternBenefits[patternIndex];
-      const ByteCodeField *dest = &code[read<ByteCodeAddr>()];
+  LLVM_DEBUG(llvm::dbgs() << "  * Value: " << value << "\n");
+
+void ByteCodeExecutor::executeRecordMatch(
+    PatternRewriter &rewriter,
+    SmallVectorImpl<PDLByteCode::MatchResult> &matches) {
 
-      // If the benefit of the pattern is impossible, skip the processing of the
-      // rest of the pattern.
-      if (benefit.isImpossibleToMatch()) {
-        LLVM_DEBUG(llvm::dbgs() << "  * Benefit: Impossible To Match\n\n");
-        curCodeIt = dest;
-        break;
-      }
+    LLVM_DEBUG(llvm::dbgs() << "  * Benefit: Impossible To Match\n");
+    return;
 
-      // Create a fused location containing the locations of each of the
-      // operations used in the match. This will be used as the location for
-      // created operations during the rewrite that don't already have an
-      // explicit location set.
-      unsigned numMatchLocs = read();
-      SmallVector<Location, 4> matchLocs;
-      matchLocs.reserve(numMatchLocs);
-      for (unsigned i = 0; i != numMatchLocs; ++i)
-        matchLocs.push_back(read<Operation *>()->getLoc());
-      Location matchLoc = rewriter.getFusedLoc(matchLocs);
 
-      LLVM_DEBUG(llvm::dbgs() << "  * Benefit: " << benefit.getBenefit() << "\n"
-                              << "  * Location: " << matchLoc << "\n\n");
-      matches->emplace_back(matchLoc, patterns[patternIndex], benefit);
-      readList<const void *>(matches->back().values);
-      curCodeIt = dest;
-      break;
-    }
-    case ReplaceOp: {
-      LLVM_DEBUG(llvm::dbgs() << "Executing ReplaceOp:\n");
-      Operation *op = read<Operation *>();
-      SmallVector<Value, 16> args;
-      readList<Value>(args);
+                          << "  * Location: " << matchLoc << "\n");
+  matches.emplace_back(matchLoc, patterns[patternIndex], benefit);
+  readList<const void *>(matches.back().values);
+
+void ByteCodeExecutor::executeReplaceOp(PatternRewriter &rewriter) {
 
-      LLVM_DEBUG({
-        llvm::dbgs() << "  * Operation: " << *op << "\n"
-                     << "  * Values: ";
-        llvm::interleaveComma(args, llvm::dbgs());
-        llvm::dbgs() << "\n\n";
-      });
-      rewriter.replaceOp(op, args);
-      break;
-    }
-    case SwitchAttribute: {
-      LLVM_DEBUG(llvm::dbgs() << "Executing SwitchAttribute:\n");
-      Attribute value = read<Attribute>();
-      ArrayAttr cases = read<ArrayAttr>();
-      handleSwitch(value, cases);
-      break;
-    }
-    case SwitchOperandCount: {
-      LLVM_DEBUG(llvm::dbgs() << "Executing SwitchOperandCount:\n");
-      Operation *op = read<Operation *>();
-      auto cases = read<DenseIntOrFPElementsAttr>().getValues<uint32_t>();
+    llvm::dbgs() << "\n";
+
+void ByteCodeExecutor::executeSwitchAttribute() {
+
+void ByteCodeExecutor::executeSwitchOperandCount() {
 
-      LLVM_DEBUG(llvm::dbgs() << "  * Operation: " << *op << "\n");
-      handleSwitch(op->getNumOperands(), cases);
-      break;
-    }
-    case SwitchOperationName: {
-      LLVM_DEBUG(llvm::dbgs() << "Executing SwitchOperationName:\n");
-      OperationName value = read<Operation *>()->getName();
-      size_t caseCount = read();
+
+void ByteCodeExecutor::executeSwitchOperationName() {
 
-      // The operation names are stored in-line, so to print them out for
-      // debugging purposes we need to read the array before executing the
-      // switch so that we can display all of the possible values.
-      LLVM_DEBUG({
-        const ByteCodeField *prevCodeIt = curCodeIt;
-        llvm::dbgs() << "  * Value: " << value << "\n"
-                     << "  * Cases: ";
-        llvm::interleaveComma(
-            llvm::map_range(llvm::seq<size_t>(0, caseCount),
-                            [&](size_t i) { return read<OperationName>(); }),
-            llvm::dbgs());
-        llvm::dbgs() << "\n\n";
-        curCodeIt = prevCodeIt;
-      });
+                        [&](size_t) { return read<OperationName>(); }),
+    llvm::dbgs() << "\n";
 
-      // Try to find the switch value within any of the cases.
-      size_t jumpDest = 0;
-      for (size_t i = 0; i != caseCount; ++i) {
-        if (read<OperationName>() == value) {
-          curCodeIt += (caseCount - i - 1);
-          jumpDest = i + 1;
-          break;
-        }
-      }
-      selectJump(jumpDest);
-      break;
-    }
-    case SwitchResultCount: {
-      LLVM_DEBUG(llvm::dbgs() << "Executing SwitchResultCount:\n");
-      Operation *op = read<Operation *>();
-      auto cases = read<DenseIntOrFPElementsAttr>().getValues<uint32_t>();
+      return selectJump(i + 1);
+  selectJump(size_t(0));
+
+void ByteCodeExecutor::executeSwitchResultCount() {
 
-      LLVM_DEBUG(llvm::dbgs() << "  * Operation: " << *op << "\n");
-      handleSwitch(op->getNumResults(), cases);
-      break;
-    }
-    case SwitchType: {
-      LLVM_DEBUG(llvm::dbgs() << "Executing SwitchType:\n");
-      Type value = read<Type>();
-      auto cases = read<ArrayAttr>().getAsValueRange<TypeAttr>();
-      handleSwitch(value, cases);
+
+void ByteCodeExecutor::executeSwitchType() {
+}
+
+void ByteCodeExecutor::execute(
+    PatternRewriter &rewriter,
+    SmallVectorImpl<PDLByteCode::MatchResult> *matches,
+    Optional<Location> mainRewriteLoc) {
+  while (true) {
+    OpCode opCode = static_cast<OpCode>(read());
+    switch (opCode) {
+    case ApplyConstraint:
+      executeApplyConstraint(rewriter);
+      break;
+    case ApplyRewrite:
+      executeApplyRewrite(rewriter);
+      break;
+    case AreEqual:
+      executeAreEqual();
+      break;
+    case Branch:
+      executeBranch();
+      break;
+    case CheckOperandCount:
+      executeCheckOperandCount();
+      break;
+    case CheckOperationName:
+      executeCheckOperationName();
+      break;
+    case CheckResultCount:
+      executeCheckResultCount();
+      break;
+    case CreateNative:
+      executeCreateNative(rewriter);
+      break;
+    case CreateOperation:
+      executeCreateOperation(rewriter, *mainRewriteLoc);
+      break;
+    case EraseOp:
+      executeEraseOp(rewriter);
+      break;
+    case Finalize:
+      LLVM_DEBUG(llvm::dbgs() << "Executing Finalize\n\n");
+      return;
+    case GetAttribute:
+      executeGetAttribute();
+      break;
+    case GetAttributeType:
+      executeGetAttributeType();
+      break;
+    case GetDefiningOp:
+      executeGetDefiningOp();
+      break;
+    case GetOperand0:
+    case GetOperand1:
+    case GetOperand2:
+    case GetOperand3: {
+      unsigned index = opCode - GetOperand0;
+      LLVM_DEBUG(llvm::dbgs() << "Executing GetOperand" << index << ":\n");
+      executeGetOperand(opCode - GetOperand0);
       break;
     }
+    case GetOperandN:
+      LLVM_DEBUG(llvm::dbgs() << "Executing GetOperandN:\n");
+      executeGetOperand(read<uint32_t>());
+      break;
+    case GetResult0:
+    case GetResult1:
+    case GetResult2:
+    case GetResult3: {
+      unsigned index = opCode - GetResult0;
+      LLVM_DEBUG(llvm::dbgs() << "Executing GetResult" << index << ":\n");
+      executeGetResult(opCode - GetResult0);
+      break;
+    }
+    case GetResultN:
+      LLVM_DEBUG(llvm::dbgs() << "Executing GetResultN:\n");
+      executeGetResult(read<uint32_t>());
+      break;
+    case GetValueType:
+      executeGetValueType();
+      break;
+    case IsNotNull:
+      executeIsNotNull();
+      break;
+    case RecordMatch:
+      assert(matches &&
+             "expected matches to be provided when executing the matcher");
+      executeRecordMatch(rewriter, *matches);
+      break;
+    case ReplaceOp:
+      executeReplaceOp(rewriter);
+      break;
+    case SwitchAttribute:
+      executeSwitchAttribute();
+      break;
+    case SwitchOperandCount:
+      executeSwitchOperandCount();
+      break;
+    case SwitchOperationName:
+      executeSwitchOperationName();
+      break;
+    case SwitchResultCount:
+      executeSwitchResultCount();
+      break;
+    case SwitchType:
+      executeSwitchType();
+      break;
     }
+    LLVM_DEBUG(llvm::dbgs() << "\n");
   }
 }
 
 /// Run the pattern matcher on the given root operation, collecting the matched
 /// patterns in `matches`.
 void PDLByteCode::match(Operation *op, PatternRewriter &rewriter,
                         SmallVectorImpl<MatchResult> &matches,
                         PDLByteCodeMutableState &state) const {