Update to upstream changes. (#17)

Author: fruffy

CMakeLists.txt

@@ -48,7 +48,6 @@ foreach(ext ${rtsmith_targets})
       set(include_statements_var
           "${include_statements_var}#include \"backends/p4tools/modules/p4rtsmith/targets/${ext}/register.h\"\n"
       )
-      set(compiler_targets_var "${compiler_targets_var}    ${ext}_registerCompilerTarget();\n")
       set(rtsmith_targets_var "${rtsmith_targets_var}    ${ext}_registerRtSmithTarget();\n")
     endif()
   endif()

core/target.cpp

@@ -1,11 +1,11 @@
 #include "backends/p4tools/modules/p4rtsmith/core/target.h"
 
 #include <string>
-#include <utility>
 
 #include "backends/p4tools/common/compiler/compiler_target.h"
 #include "backends/p4tools/common/core/target.h"
 #include "backends/p4tools/modules/p4rtsmith/core/program_info.h"
+#include "backends/p4tools/modules/p4rtsmith/toolname.h"
 #include "ir/declaration.h"
 #include "ir/ir.h"
 #include "ir/node.h"
@@ -14,8 +14,8 @@
 
 namespace P4Tools::RTSmith {
 
-RtSmithTarget::RtSmithTarget(std::string deviceName, std::string archName)
-    : Target("rtsmith", std::move(deviceName), std::move(archName)) {}
+RtSmithTarget::RtSmithTarget(const std::string &deviceName, const std::string &archName)
+    : CompilerTarget(TOOL_NAME, deviceName, archName) {}
 
 const ProgramInfo *RtSmithTarget::produceProgramInfoImpl(
     const CompilerResult &compilerResult) const {
@@ -41,7 +41,7 @@ P4RuntimeFuzzer &RtSmithTarget::getFuzzer(const ProgramInfo &programInfo) {
     return get().getFuzzerImpl(programInfo);
 }
 
-const RtSmithTarget &RtSmithTarget::get() { return Target::get<RtSmithTarget>("rtsmith"); }
+const RtSmithTarget &RtSmithTarget::get() { return Target::get<RtSmithTarget>(TOOL_NAME); }
 
 const ProgramInfo *RtSmithTarget::produceProgramInfo(const CompilerResult &compilerResult) {
     return get().produceProgramInfoImpl(compilerResult);

core/target.h

@@ -4,14 +4,13 @@
 #include <string>
 
 #include "backends/p4tools/common/compiler/compiler_target.h"
-#include "backends/p4tools/common/core/target.h"
 #include "backends/p4tools/modules/p4rtsmith/core/fuzzer.h"
 #include "backends/p4tools/modules/p4rtsmith/core/program_info.h"
 #include "ir/ir.h"
 
 namespace P4Tools::RTSmith {
 
-class RtSmithTarget : public Target {
+class RtSmithTarget : public CompilerTarget {
  public:
     /// @returns the singleton instance for the current target.
     static const RtSmithTarget &get();
@@ -37,7 +36,7 @@ class RtSmithTarget : public Target {
     /// @see @getStepper.
     [[nodiscard]] virtual P4RuntimeFuzzer &getFuzzerImpl(const ProgramInfo &programInfo) const = 0;
 
-    explicit RtSmithTarget(std::string deviceName, std::string archName);
+    explicit RtSmithTarget(const std::string &deviceName, const std::string &archName);
 
  private:
 };

main.cpp

@@ -8,6 +8,7 @@
 
 #include "backends/p4tools/common/lib/logging.h"
 #include "backends/p4tools/modules/p4rtsmith/rtsmith.h"
+#include "backends/p4tools/modules/p4rtsmith/toolname.h"
 #include "lib/crash.h"
 #include "lib/exceptions.h"
 
@@ -22,7 +23,7 @@ int main(int argc, char **argv) {
     int result = EXIT_SUCCESS;
     try {
         Util::ScopedTimer timer("P4RuntimeSmith Main");
-        result = P4Tools::RTSmith::RtSmith().main(args);
+        result = P4Tools::RTSmith::RtSmith().main(P4Tools::RTSmith::TOOL_NAME, args);
     } catch (const Util::CompilerBug &e) {
         std::cerr << "Internal error: " << e.what() << '\n';
         std::cerr << "Please submit a bug report with your code." << '\n';

options.cpp

@@ -1,6 +1,7 @@
 #include "backends/p4tools/modules/p4rtsmith/options.h"
 
 #include "backends/p4tools/common/options.h"
+#include "backends/p4tools/modules/p4rtsmith/toolname.h"
 #include "lib/cstring.h"
 #include "lib/exceptions.h"
 
@@ -16,7 +17,8 @@ const char *RtSmithOptions::getIncludePath() {
 }
 
 RtSmithOptions::RtSmithOptions()
-    : AbstractP4cToolOptions("Remove control-plane dead code from a P4 program.") {
+    : AbstractP4cToolOptions(RTSmith::TOOL_NAME,
+                             "Remove control-plane dead code from a P4 program.") {
     registerOption(
         "--print-to-stdout", nullptr,
         [this](const char *) {

register.h.in

@@ -5,9 +5,6 @@
 
 namespace P4Tools::RTSmith {
 
-inline void registerCompilerTargets() {
-@compiler_targets_var@}
-
 inline void registerRtSmithTargets() {
 @rtsmith_targets_var@}
 

rtsmith.cpp

@@ -10,6 +10,7 @@
 #include "backends/p4tools/modules/p4rtsmith/core/target.h"
 #include "backends/p4tools/modules/p4rtsmith/core/util.h"
 #include "backends/p4tools/modules/p4rtsmith/register.h"
+#include "backends/p4tools/modules/p4rtsmith/toolname.h"
 #include "control-plane/p4RuntimeSerializer.h"
 #include "lib/error.h"
 #include "lib/nullstream.h"
@@ -19,7 +20,7 @@ namespace P4Tools::RTSmith {
 void RtSmith::registerTarget() {
     // Register all available compiler targets.
     // These are discovered by CMAKE, which fills out the register.h.in file.
-    registerCompilerTargets();
+    registerRtSmithTargets();
 }
 
 int RtSmith::mainImpl(const CompilerResult &compilerResult) {
@@ -104,9 +105,6 @@ int RtSmith::mainImpl(const CompilerResult &compilerResult) {
 std::optional<RtSmithResult> generateConfigImpl(
     std::optional<std::reference_wrapper<const std::string>> program,
     const CompilerOptions &compilerOptions, const RtSmithOptions & /*rtSmithOptions*/) {
-    // Register supported compiler targets.
-    registerCompilerTargets();
-
     // Register supported P4RTSmith targets.
     registerRtSmithTargets();
 
@@ -121,12 +119,14 @@ std::optional<RtSmithResult> generateConfigImpl(
     if (program.has_value()) {
         // Run the compiler to get an IR and invoke the tool.
         ASSIGN_OR_RETURN(compilerResult,
-                         P4Tools::CompilerTarget::runCompiler(program.value().get()), std::nullopt);
+                         P4Tools::CompilerTarget::runCompiler(TOOL_NAME, program.value().get()),
+                         std::nullopt);
     } else {
         RETURN_IF_FALSE_WITH_MESSAGE(!compilerOptions.file.isNullOrEmpty(), std::nullopt,
                                      ::error("Expected a file input."));
         // Run the compiler to get an IR and invoke the tool.
-        ASSIGN_OR_RETURN(compilerResult, P4Tools::CompilerTarget::runCompiler(), std::nullopt);
+        ASSIGN_OR_RETURN(compilerResult, P4Tools::CompilerTarget::runCompiler(TOOL_NAME),
+                         std::nullopt);
     }
 
     const auto *programInfo = RtSmithTarget::produceProgramInfo(compilerResult.value());

targets/bmv2/CMakeLists.txt

@@ -5,7 +5,6 @@ set(RTSMITH_SOURCES
     ${CMAKE_CURRENT_SOURCE_DIR}/fuzzer.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/program_info.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/target.cpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/v1model.cpp
     PARENT_SCOPE
 )
 

targets/bmv2/register.h

@@ -2,13 +2,9 @@
 #define BACKENDS_P4TOOLS_MODULES_P4RTSMITH_TARGETS_BMV2_REGISTER_H_
 
 #include "backends/p4tools/modules/p4rtsmith/targets/bmv2/target.h"
-#include "backends/p4tools/modules/p4rtsmith/targets/bmv2/v1model.h"
 
 namespace P4Tools::RTSmith {
 
-/// Register the V1Model compiler target with the tools framework.
-inline void bmv2_registerCompilerTarget() { V1Model::Bmv2V1ModelCompilerTarget::make(); }
-
 /// Register the V1Model RtSmith target with the P4RuntimeSmith framework.
 inline void bmv2_registerRtSmithTarget() { V1Model::Bmv2V1ModelRtSmithTarget::make(); }
 

targets/bmv2/target.cpp

@@ -19,6 +19,13 @@ void Bmv2V1ModelRtSmithTarget::make() {
     }
 }
 
+MidEnd Bmv2V1ModelRtSmithTarget::mkMidEnd(const CompilerOptions &options) const {
+    MidEnd midEnd(options);
+    // Currently a no-op because we have all the necessary information from the front-end.
+    midEnd.addPasses({});
+    return midEnd;
+}
+
 const ProgramInfo *Bmv2V1ModelRtSmithTarget::produceProgramInfoImpl(
     const CompilerResult &compilerResult, const IR::Declaration_Instance * /*mainDecl*/) const {
     return new Bmv2V1ModelProgramInfo(compilerResult);