Fix lir::Rewrite using std::forward twice on the same value

Summary: Happens to work today because the value is always copied, but it's sketchy.

Reviewed By: yoney

Differential Revision: D81813071

fbshipit-source-id: b5a32d805409a6cab37fc3167c82c6e5e0872edc

Author: alexmalyshev

cinderx/Jit/lir/postalloc.cpp

@@ -5,6 +5,7 @@
 #include "cinderx/Jit/codegen/x86_64.h"
 #include "cinderx/Jit/containers.h"
 #include "cinderx/Jit/jit_rt.h"
+#include "cinderx/Jit/lir/function.h"
 #include "cinderx/Jit/lir/operand.h"
 
 #include <optional>

cinderx/Jit/lir/postgen.cpp

@@ -3,6 +3,7 @@
 #include "cinderx/Jit/lir/postgen.h"
 
 #include "cinderx/Jit/lir/inliner.h"
+#include "cinderx/Jit/lir/printer.h"
 
 using namespace jit::codegen;
 

cinderx/Jit/lir/rewrite.cpp

@@ -2,14 +2,33 @@
 
 #include "cinderx/Jit/lir/rewrite.h"
 
-#include "cinderx/Common/log.h"
 #include "cinderx/Jit/lir/block.h"
+#include "cinderx/Jit/lir/function.h"
 #include "cinderx/Jit/lir/operand.h"
 
 #include <set>
 
 namespace jit::lir {
 
+Rewrite::Rewrite(Function* func, codegen::Environ* env)
+    : function_(func), env_(env) {}
+
+Function* Rewrite::function() {
+  return function_;
+}
+
+const Function* Rewrite::function() const {
+  return function_;
+}
+
+codegen::Environ* Rewrite::environment() {
+  return env_;
+}
+
+const codegen::Environ* Rewrite::environment() const {
+  return env_;
+}
+
 void Rewrite::run() {
   // collect all stages
   std::set<int> stages;

cinderx/Jit/lir/rewrite.h

@@ -5,10 +5,8 @@
 #include "cinderx/Common/concepts.h"
 #include "cinderx/Jit/codegen/environ.h"
 #include "cinderx/Jit/lir/block.h"
-#include "cinderx/Jit/lir/printer.h"
 
 #include <functional>
-#include <memory>
 #include <type_traits>
 #include <utility>
 #include <vector>
@@ -42,23 +40,15 @@ using instruction_rewrite_t = function_type_t<instruction_rewrite_arg_t>;
 // This class implements a framework for LIR rewrites.
 class Rewrite {
  public:
-  Rewrite(Function* func, codegen::Environ* env) : function_(func), env_(env) {}
+  Rewrite(Function* func, codegen::Environ* env);
 
-  Function* function() {
-    return function_;
-  }
-
-  const Function* function() const {
-    return function_;
-  }
+  // Get the function being rewritten.
+  Function* function();
+  const Function* function() const;
 
-  codegen::Environ* environment() {
-    return env_;
-  }
-
-  const codegen::Environ* environment() const {
-    return env_;
-  }
+  // Get the codegen environment.
+  codegen::Environ* environment();
+  const codegen::Environ* environment() const;
 
   template <typename T>
   void registerOneRewriteFunction(RewriteResult (*rewrite)(T), int stage = 0) {
@@ -114,14 +104,14 @@ class Rewrite {
   template <
       AnyOf<function_rewrite_t, basic_block_rewrite_t, instruction_rewrite_t> T,
       typename V>
-  bool runOneTypeRewrites(const std::vector<T>& rewrites, V&& arg) {
+  bool runOneTypeRewrites(const std::vector<T>& rewrites, const V& arg) {
     bool changed = false;
     bool loop_changed = false;
 
     do {
       loop_changed = false;
       for (auto& rewrite : rewrites) {
-        auto r = rewrite(std::forward<V>(arg));
+        auto r = rewrite(arg);
         loop_changed |= (r != kUnchanged);
 
         if (r == kRemoved) {