Fixes in type-checking; parameter removal for actions

Author: mbudiu-vmw

backends/bmv2/jsonconverter.cpp

@@ -1142,9 +1142,12 @@ JsonConverter::convertTable(const CFG::TableNode* node, Util::JsonArray* counter
 
     std::map<cstring, cstring> useActionName;
     for (auto a : *al->actionList) {
-        if (a->arguments != nullptr && a->arguments->size() > 0)
-            ::error("%1%: Actions in action list with arguments not supported", a);
-        auto decl = refMap->getDeclaration(a->name->path, true);
+        if (a->expression->is<IR::MethodCallExpression>()) {
+            auto mce = a->expression->to<IR::MethodCallExpression>();
+            if (mce->arguments->size() > 0)
+                ::error("%1%: Actions in action list with arguments not supported", a);
+        }
+        auto decl = refMap->getDeclaration(a->getPath(), true);
         BUG_CHECK(decl->is<IR::P4Action>(), "%1%: should be an action name", a);
         auto action = decl->to<IR::P4Action>();
         unsigned id = get(structure.ids, action);
@@ -1203,7 +1206,7 @@ JsonConverter::convertTable(const CFG::TableNode* node, Util::JsonArray* counter
     // the nextLabel.
     if (!hitMiss) {
         for (auto a : *al->actionList) {
-            cstring name = a->name->path->name;
+            cstring name = a->getName().name;
             cstring label = ::get(useActionName, name);
             if (labelsDone.find(label) == labelsDone.end())
                 next_tables->emplace(label, nextLabel);

backends/ebpf/ebpfTable.cpp

@@ -109,7 +109,7 @@ void EBPFTable::emitValueType(CodeBuilder* builder) {
     builder->blockStart();
 
     for (auto a : *actionList->actionList) {
-        auto adecl = program->refMap->getDeclaration(a->name->path, true);
+        auto adecl = program->refMap->getDeclaration(a->getPath(), true);
         auto action = adecl->getNode()->to<IR::P4Action>();
         cstring name = nameFromAnnotation(action->annotations, action->name);
         builder->emitIndent();
@@ -135,7 +135,7 @@ void EBPFTable::emitValueType(CodeBuilder* builder) {
     builder->blockStart();
 
     for (auto a : *actionList->actionList) {
-        auto adecl = program->refMap->getDeclaration(a->name->path, true);
+        auto adecl = program->refMap->getDeclaration(a->getPath(), true);
         auto action = adecl->getNode()->to<IR::P4Action>();
         cstring name = nameFromAnnotation(action->annotations, action->name);
         emitActionArguments(builder, action, name);
@@ -236,7 +236,7 @@ void EBPFTable::runAction(CodeBuilder* builder, cstring valueName) {
     builder->blockStart();
 
     for (auto a : *actionList->actionList) {
-        auto adecl = program->refMap->getDeclaration(a->name->path, true);
+        auto adecl = program->refMap->getDeclaration(a->getPath(), true);
         auto action = adecl->getNode()->to<IR::P4Action>();
         builder->emitIndent();
         cstring name = nameFromAnnotation(action->annotations, action->name);

backends/v12test/midend.cpp

@@ -89,8 +89,7 @@ IR::ToplevelBlock* MidEnd::process(CompilerOptions& options, const IR::P4Program
         new P4::UniqueParameters(&refMap, isv1),
         new P4::TypeChecking(&refMap, &typeMap, isv1),
         new P4::SimplifyControlFlow(&refMap, &typeMap),
-        new P4::TypeChecking(&refMap, &typeMap, isv1),
-        new P4::RemoveTableParameters(&refMap, &typeMap),
+        new P4::RemoveParameters(&refMap, &typeMap, isv1),
         // Exit statements are transformed into control-flow
         new P4::TypeChecking(&refMap, &typeMap, isv1),
         new P4::RemoveExits(&refMap, &typeMap),

backends/v12test/run-v12-sample.py

@@ -1,10 +1,10 @@
 #!/usr/bin/env python
-# Copyright 2013-present Barefoot Networks, Inc. 
-# 
+# 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
@@ -175,7 +175,7 @@ def process_file(options, argv):
     if options.verbose:
         print("Writing temporary files into ", tmpdir)
     ppfile = tmpdir + "/" + basename                  # after parsing
-    referenceOutputs = "FrontEnd_11,FrontEnd_12,MidEnd_28_Evaluator"
+    referenceOutputs = "FrontEnd_11,FrontEnd_12,MidEnd_27_Evaluator"
     stderr = tmpdir + "/" + basename + "-stderr"
 
     if not os.path.isfile(options.p4filename):
@@ -210,7 +210,7 @@ def process_file(options, argv):
         newName = file_name(tmpdir, base, "-frontend", ext)
         os.rename(midFile, newName)
         lastFile = newName
-    endFile = file_name(tmpdir, base, "-MidEnd_28_Evaluator", ext)
+    endFile = file_name(tmpdir, base, "-MidEnd_27_Evaluator", ext)
     if os.path.isfile(endFile):
         newName = file_name(tmpdir, base, "-midend", ext)
         os.rename(endFile, newName)

frontends/Makefile.am

@@ -1,9 +1,9 @@
-# Copyright 2013-present Barefoot Networks, Inc. 
-# 
+# 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

frontends/common/typeMap.cpp

@@ -3,8 +3,6 @@
 
 namespace P4 {
 
-const IR::Type_InfInt* TypeMap::canonInfInt = new IR::Type_InfInt();
-
 void TypeMap::dbprint(std::ostream& out) const {
     out << "TypeMap for " << dbp(program);
     for (auto it : typeMap)

frontends/common/typeMap.h

@@ -1,5 +1,5 @@
 /*
-Copyright 2013-present Barefoot Networks, Inc. 
+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.
@@ -49,8 +49,6 @@ class TypeMap final : public ProgramMap {
     // checks some preconditions before setting the type
     void checkPrecondition(const IR::Node* element, const IR::Type* type) const;
 
-    static const IR::Type_InfInt* canonInfInt;
-
     friend class TypeInference;
     friend class ConstantTypeSubstitution;
 
@@ -72,8 +70,6 @@ class TypeMap final : public ProgramMap {
     // The following are only used by TypeInference
     void setLeftValue(const IR::Expression* expression);
     void setCompileTimeConstant(const IR::Expression* expression);
-    const IR::Type_InfInt* canonicalInfInt() const
-    { return TypeMap::canonInfInt; }
 };
 }  // namespace P4
 

frontends/p4/cloner.cpp

@@ -0,0 +1,37 @@
+#include "cloner.h"
+
+namespace P4 {
+
+const IR::Node* DeepCloner::postorder(IR::Declaration_Variable* decl) {
+    return new IR::Declaration_Variable(decl->srcInfo, decl->name, decl->annotations,
+                                        decl->type, decl->initializer); }
+
+const IR::Node* DeepCloner::postorder(IR::Declaration_Instance* decl) {
+    return new IR::Declaration_Instance(decl->srcInfo, decl->name, decl->type,
+                                        decl->annotations, decl->initializer); }
+
+const IR::Node* DeepCloner::postorder(IR::ParserState* decl) {
+    return new IR::ParserState(decl->srcInfo, decl->name, decl->annotations,
+                               decl->components, decl->selectExpression); }
+
+const IR::Node* DeepCloner::postorder(IR::P4Parser* decl) {
+    return new IR::P4Parser(decl->srcInfo, decl->name, decl->type, decl->constructorParams,
+                            decl->stateful, decl->states); }
+
+const IR::Node* DeepCloner::postorder(IR::P4Control* decl) {
+        return new IR::P4Control(decl->srcInfo, decl->name, decl->type,
+                                 decl->constructorParams, decl->stateful, decl->body); }
+
+const IR::Node* DeepCloner::postorder(IR::P4Action* decl)  {}
+
+const IR::Node* DeepCloner::postorder(IR::ActionListElement* decl)  {}
+
+const IR::Node* DeepCloner::postorder(IR::TableProperty* decl)  {}
+
+const IR::Node* DeepCloner::postorder(IR::P4Table* decl)  {}
+
+const IR::Node* DeepCloner::postorder(IR::Function* decl)  {}
+
+const IR::Node* DeepCloner::postorder(IR::Parameter* decl)  {}
+
+}  // namespace P4

frontends/p4/cloner.h

@@ -1,5 +1,5 @@
 /*
-Copyright 2013-present Barefoot Networks, Inc. 
+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.
@@ -27,10 +27,12 @@ namespace P4 {
 class Cloner : public Transform {
  public:
     Cloner() { setName("Cloner"); }
-    const IR::Node* clone(const IR::Node* node)
-    { return node->apply(*this); }
     const IR::Node* postorder(IR::PathExpression* path) override
     { return new IR::PathExpression(path->path->clone()); }
+
+    template<typename T>
+    const T* clone(const IR::Node* node)
+    { return node->apply(*this)->to<T>(); }
 };
 
 }  // namespace P4

frontends/p4/createBuiltins.cpp

@@ -18,4 +18,28 @@ void CreateBuiltins::postorder(IR::P4Parser* parser) {
     newStates->push_back(rj);
     parser->states = newStates;
 }
+
+void CreateBuiltins::postorder(IR::ActionListElement* element) {
+    // convert path expressions to method calls
+    // actions = { a; b; }
+    // becomes
+    // action = { a(); b(); }
+    if (element->expression->is<IR::PathExpression>())
+        element->expression = new IR::MethodCallExpression(
+            element->expression->srcInfo, element->expression,
+            new IR::Vector<IR::Type>(), new IR::Vector<IR::Expression>());
+}
+
+void CreateBuiltins::postorder(IR::ExpressionValue* expression) {
+    // convert a default_action = a; into
+    // default_action = a();
+    auto prop = findContext<IR::TableProperty>();
+    if (prop != nullptr &&
+        prop->name == IR::TableProperties::defaultActionPropertyName &&
+        expression->expression->is<IR::PathExpression>())
+        expression->expression = new IR::MethodCallExpression(
+            expression->expression->srcInfo, expression->expression,
+            new IR::Vector<IR::Type>(), new IR::Vector<IR::Expression>());
+}
+
 }  // namespace P4

frontends/p4/createBuiltins.h

@@ -1,5 +1,5 @@
 /*
-Copyright 2013-present Barefoot Networks, Inc. 
+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.
@@ -25,6 +25,8 @@ class CreateBuiltins final : public Modifier {
     using Modifier::postorder;
     CreateBuiltins() { setName("CreateBuiltins"); }
     void postorder(IR::P4Parser* parser) override;
+    void postorder(IR::ActionListElement* element) override;
+    void postorder(IR::ExpressionValue* property) override;
 };
 }  // namespace P4
 

frontends/p4/fromv1.0/programStructure.cpp

@@ -588,11 +588,11 @@ ProgramStructure::convertTable(const IR::V1Table* table, cstring newName,
             newname = actions.get(action);
         }
         auto ale = new IR::ActionListElement(a.srcInfo, IR::Annotations::empty,
-                                             new IR::PathExpression(newname), nullptr);
+                                             new IR::PathExpression(newname));
         actVect->push_back(ale);
     }
     auto nop = new IR::ActionListElement(Util::SourceInfo(), IR::Annotations::empty,
-                                         new IR::PathExpression(p4lib.noAction.Id()), nullptr);
+                                         new IR::PathExpression(p4lib.noAction.Id()));
     actVect->push_back(nop);
     propvec->push_back(new IR::TableProperty(Util::SourceInfo(),
                                              IR::ID(IR::TableProperties::actionsPropertyName),

frontends/p4/p4-parse.ypp

@@ -758,10 +758,12 @@ actionList
 
 actionRef
     : optAnnotations name                { auto expr = new IR::PathExpression(*$2);
-                                           $$ = new IR::ActionListElement(@2, $1, expr, nullptr);}
+                                           $$ = new IR::ActionListElement(@2, $1, expr);}
     | optAnnotations name '(' argumentList ')'
-                                         { auto expr = new IR::PathExpression(*$2);
-                                           $$ = new IR::ActionListElement(@2, $1, expr, $4); }
+                                         { auto method = new IR::PathExpression(*$2);
+                                           auto mce = new IR::MethodCallExpression(
+                                               @2+@4, method, new IR::Vector<IR::Type>(), $4);
+                                           $$ = new IR::ActionListElement(@2, $1, mce); }
     ;
 
 /************************* ACTION ********************************/

frontends/p4/toP4/toP4.cpp

@@ -1048,14 +1048,7 @@ bool ToP4::preorder(const IR::ExpressionValue* v) {
 bool ToP4::preorder(const IR::ActionListElement* ale) {
     dump(3);
     visit(ale->annotations);
-    visit(ale->name);
-    if (ale->arguments != nullptr) {
-        builder.append("(");
-        setVecSep(", ");
-        visit(ale->arguments);
-        doneVec();
-        builder.append(")");
-    }
+    visit(ale->expression);
     return false;
 }