Update RedundantSetElimination to work with tuples (#2688)

Also makes it work with any other constant expression such as a
ref.func or ref.null instructions. This optimization may not be very
important, but it illustrates how simple it can be to update a pass to
handle tuples (and also I was already looking at it because of the
prior changes that had to be made to it).

2 files changed, 29 insertions, 2 deletions

diff --git a/src/ir/properties.h b/src/ir/properties.h
index b14910c5b..b4dfbbd5e 100644
--- a/src/ir/properties.h
+++ b/src/ir/properties.h
@@ -85,6 +85,32 @@ inline bool isConstantExpression(const Expression* curr) {
   return false;
 }
 
+inline Literal getSingleLiteral(const Expression* curr) {
+  if (auto* c = curr->dynCast<Const>()) {
+    return c->value;
+  } else if (curr->is<RefNull>()) {
+    return Literal(Type::nullref);
+  } else if (auto* c = curr->dynCast<RefFunc>()) {
+    return Literal(c->func);
+  } else {
+    WASM_UNREACHABLE("non-constant expression");
+  }
+}
+
+inline Literals getLiterals(const Expression* curr) {
+  if (curr->is<Const>() || curr->is<RefNull>() || curr->is<RefFunc>()) {
+    return {getSingleLiteral(curr)};
+  } else if (auto* tuple = curr->dynCast<TupleMake>()) {
+    Literals literals;
+    for (auto* op : tuple->operands) {
+      literals.push_back(getSingleLiteral(op));
+    }
+    return literals;
+  } else {
+    WASM_UNREACHABLE("non-constant expression");
+  }
+}
+
 // Check if an expression is a sign-extend, and if so, returns the value
 // that is extended, otherwise nullptr
 inline Expression* getSignExtValue(Expression* curr) {
diff --git a/src/passes/RedundantSetElimination.cpp b/src/passes/RedundantSetElimination.cpp
index ab052853c..a891653df 100644
--- a/src/passes/RedundantSetElimination.cpp
+++ b/src/passes/RedundantSetElimination.cpp
@@ -35,6 +35,7 @@
 
 #include <cfg/cfg-traversal.h>
 #include <ir/literal-utils.h>
+#include <ir/properties.h>
 #include <ir/utils.h>
 #include <pass.h>
 #include <support/unique_deferring_queue.h>
@@ -159,9 +160,9 @@ struct RedundantSetElimination
   }
 
   Index getValue(Expression* value, LocalValues& currValues) {
-    if (auto* c = value->dynCast<Const>()) {
+    if (Properties::isConstantExpression(value)) {
       // a constant
-      return getLiteralValue({c->value});
+      return getLiteralValue(Properties::getLiterals(value));
     } else if (auto* get = value->dynCast<LocalGet>()) {
       // a copy of whatever that was
       return currValues[get->index];