Remove apply() calls to redundant parsers

A parser with an unconditional accept in its start state is effectively a redundant/dummy parser and can be eliminated when it is called as a subparser. This removes the apply() calls to these subparsers, which also removes the generation of the setInvalid() call in resetHeaders.
p4lang · mihaibudiu · Jun 25, 2022 · May 24, 2022 · Jun 3, 2022 · Jun 9, 2022
commit 7a2fa10d34fe62f04d62372a249a0a34528b09d6
diff --git a/frontends/CMakeLists.txt b/frontends/CMakeLists.txt
@@ -44,6 +44,7 @@ set (P4_FRONTEND_SRCS
   p4/parserCallGraph.cpp
   p4/parserControlFlow.cpp
   p4/reassociation.cpp
+  p4/redundantParsers.cpp
   p4/removeParameters.cpp
   p4/removeReturns.cpp
   p4/reservedWords.cpp

diff --git a/frontends/p4/frontend.cpp b/frontends/p4/frontend.cpp
@@ -48,6 +48,7 @@ limitations under the License.
 #include "parseAnnotations.h"
 #include "parserControlFlow.h"
 #include "reassociation.h"
+#include "redundantParsers.h"
 #include "removeParameters.h"
 #include "removeReturns.h"
 #include "resetHeaders.h"
@@ -219,6 +220,7 @@ const IR::P4Program *FrontEnd::run(const CompilerOptions &options, const IR::P4P
         new MoveConstructors(&refMap),
         new RemoveAllUnusedDeclarations(&refMap),
         new ClearTypeMap(&typeMap),
+        new RemoveRedundantParsers(&typeMap),
         evaluator,
         new Inline(&refMap, &typeMap, evaluator, options.optimizeParserInlining),
         new InlineActions(&refMap, &typeMap),

diff --git a/frontends/p4/redundantParsers.cpp b/frontends/p4/redundantParsers.cpp
@@ -0,0 +1,58 @@
+/*
+Copyright 2013-present Barefoot Networks, Inc.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+#include "redundantParsers.h"
+
+namespace P4 {
+bool FindRedundantParsers::preorder(const IR::P4Parser *parser) {
+    for (const IR::ParserState *state : parser->states) {
+        if (state->name != IR::ParserState::start) {
+            continue;
+        }
+        const auto *pathExpr = state->selectExpression->to<IR::PathExpression>();
+        if (!pathExpr ||
+            pathExpr->path->name != IR::ParserState::accept ||
+            !state->components.empty()) {
+            continue;
+        }
+        LOG4("Found redundant parser " << parser->name);
+        redundantParsers.insert(parser->type->name);
+    }
+    return false;
+}
+
+const IR::Node *EliminateSubparserCalls::postorder(IR::MethodCallStatement *mcs) {
+    auto method = mcs->methodCall->method;
+    auto *member = method->to<IR::Member>();
+    if (!member || member->member != IR::IApply::applyMethodName) {
+        return mcs;
+    }
+    auto type = typeMap->getType(member->expr);
+    if (!type) {
+        return mcs;
+    }
+    auto parser = type->to<IR::Type_Parser>();
+    if (!parser) {
+        return mcs;
+    }
+    if (redundantParsers.count(parser->name)) {
+        LOG4("Removing apply call to redundant parser " << parser->getName()
+             << ": " << *mcs);
+        return nullptr;
+    }
+    return mcs;
+}
+}
diff --git a/frontends/p4/redundantParsers.h b/frontends/p4/redundantParsers.h
@@ -0,0 +1,63 @@
+/*
+Copyright 2013-present Barefoot Networks, Inc.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+#ifndef _P4_REDUNDANT_PARSERS_H
+#define _P4_REDUNDANT_PARSERS_H
+
+#include "ir/ir.h"
+#include "typeMap.h"
+
+namespace P4 {
+
+/** Find parsers that have an unconditional "accept" in their start
+ *  state, and put them in redundantParsers.
+ */
+class FindRedundantParsers : public Inspector {
+    std::set<cstring> &redundantParsers;
+    bool preorder(const IR::P4Parser *parser) override;
+ public:
+    FindRedundantParsers(std::set<cstring> &redundantParsers)
+        : redundantParsers(redundantParsers) { }
+};
+
+/** Find .apply() calls on parsers that are on redundantParsers, and
+ *  eliminate them.
+ */
+class EliminateSubparserCalls : public Transform {
+    const std::set<cstring> &redundantParsers;
+    TypeMap *typeMap;
+    const IR::Node *postorder(IR::MethodCallStatement *methodCallStmt) override;
+public:
+    EliminateSubparserCalls(const std::set<cstring> &redundantParsers, TypeMap *typeMap)
+        : redundantParsers(redundantParsers), typeMap(typeMap)
+    { }
+};
+
+class RemoveRedundantParsers : public PassManager {
+    std::set<cstring> redundantParsers;
+public:
+    RemoveRedundantParsers(TypeMap *typeMap)
+        : PassManager {
+                new FindRedundantParsers(redundantParsers),
+                new EliminateSubparserCalls(redundantParsers, typeMap)
+        } {
+        setName("RemoveRedundantParsers");
+    }
+};
+
+}
+
+#endif