Implement some simple IR optimizations (get/set eliminiation and DCE)

src/frontend/ir/ir.cpp

@@ -8,6 +8,7 @@
 #include <map>
 
 #include "common/assert.h"
+#include "common/string_util.h"
 #include "frontend/ir/ir.h"
 
 namespace Dynarmic {
@@ -52,10 +53,10 @@ const char* GetNameOf(Opcode op) {
 // Value class member definitions
 
 void Value::ReplaceUsesWith(ValuePtr replacement) {
-    for (const auto& use : uses) {
+    while (!uses.empty()) {
+        auto use = uses.front();
         use.use_owner.lock()->ReplaceUseOfXWithY(use.value.lock(), replacement);
     }
-    assert(uses.empty());
 }
 
 std::vector<ValuePtr> Value::GetUses() const {
@@ -81,6 +82,10 @@ void Value::ReplaceUseOfXWithY(ValuePtr x, ValuePtr y) {
     ASSERT_MSG(false, "This Value type doesn't use any values. Bug in use management code.");
 }
 
+void Value::AssertValid() {
+    ASSERT(std::all_of(uses.begin(), uses.end(), [](const auto& use) { return !use.use_owner.expired(); }));
+}
+
 // Inst class member definitions
 
 Inst::Inst(Opcode op_) : Value(op_) {
@@ -105,8 +110,19 @@ ValuePtr Inst::GetArg(size_t index) const {
     return args.at(index).lock();
 }
 
+void Inst::Invalidate() {
+    AssertValid();
+    ASSERT(!HasUses());
+
+    auto this_ = shared_from_this();
+    for (auto& arg : args) {
+        arg.lock()->RemoveUse(this_);
+    }
+}
+
 void Inst::AssertValid() {
     ASSERT(std::all_of(args.begin(), args.end(), [](const auto& arg) { return !arg.expired(); }));
+    Value::AssertValid();
 }
 
 void Inst::ReplaceUseOfXWithY(ValuePtr x, ValuePtr y) {
@@ -126,5 +142,87 @@ void Inst::ReplaceUseOfXWithY(ValuePtr x, ValuePtr y) {
     ASSERT_MSG(has_use, "This Inst doesn't have x. Bug in use management code.");
 }
 
+std::string DumpBlock(const IR::Block& block) {
+    std::string ret;
+
+    const auto loc_to_string = [](Arm::LocationDescriptor loc) -> std::string {
+        return Common::StringFromFormat("{%u,%s,%s}",
+                                        loc.arm_pc,
+                                        loc.TFlag ? "T" : "!T",
+                                        loc.EFlag ? "E" : "!E");
+    };
+
+    ret += Common::StringFromFormat("Block: location=%s\n", loc_to_string(block.location).c_str());
+    ret += Common::StringFromFormat("cycles=%zu", block.cycle_count);
+    ret += Common::StringFromFormat(", entry_cond=%s", Arm::CondToString(block.cond, true));
+    if (block.cond != Arm::Cond::AL) {
+        ret += Common::StringFromFormat(", cond_fail=%s", loc_to_string(block.cond_failed.get()).c_str());
+    }
+    ret += "\n";
+
+    std::map<IR::Value*, size_t> value_to_index;
+    size_t index = 0;
+
+    const auto arg_to_string = [&value_to_index](IR::ValuePtr arg) -> std::string {
+        if (!arg) {
+            return "<null>";
+        }
+        switch (arg->GetOpcode()) {
+            case Opcode::ImmU1: {
+                auto inst = reinterpret_cast<ImmU1*>(arg.get());
+                return Common::StringFromFormat("#%s", inst->value ? "1" : "0");
+            }
+            case Opcode::ImmU8: {
+                auto inst = reinterpret_cast<ImmU8*>(arg.get());
+                return Common::StringFromFormat("#%u", inst->value);
+            }
+            case Opcode::ImmU32: {
+                auto inst = reinterpret_cast<ImmU32*>(arg.get());
+                return Common::StringFromFormat("#%#x", inst->value);
+            }
+            case Opcode::ImmRegRef: {
+                auto inst = reinterpret_cast<ImmRegRef*>(arg.get());
+                return Arm::RegToString(inst->value);
+            }
+            default: {
+                return Common::StringFromFormat("%%%zu", value_to_index.at(arg.get()));
+            }
+        }
+    };
+
+    for (const auto& inst_ptr : block.instructions) {
+        const Opcode op = inst_ptr->GetOpcode();
+        switch (op) {
+            case Opcode::ImmU1:
+            case Opcode::ImmU8:
+            case Opcode::ImmU32:
+            case Opcode::ImmRegRef:
+                break;
+            default: {
+                if (GetTypeOf(op) != Type::Void) {
+                    ret += Common::StringFromFormat("%%%-5zu = ", index);
+                } else {
+                    ret += "         "; // '%00000 = ' -> 1 + 5 + 3 = 9 spaces
+                }
+
+                ret += GetNameOf(op);
+
+                const size_t arg_count = GetNumArgsOf(op);
+                const auto inst = reinterpret_cast<Inst*>(inst_ptr.get());
+                for (size_t arg_index = 0; arg_index < arg_count; arg_index++) {
+                    ret += arg_index != 0 ? ", " : " ";
+                    ret += arg_to_string(inst->GetArg(arg_index));
+                }
+
+                ret += "\n";
+                value_to_index[inst_ptr.get()] = index++;
+                break;
+            }
+        }
+    }
+
+    return ret;
+}
+
 } // namespace IR
 } // namespace Dynarmic

src/frontend/ir/ir.h

@@ -75,6 +75,11 @@ public:
 
     std::vector<ValuePtr> GetUses() const;
 
+    /// Prepare this Value for removal from the instruction stream.
+    virtual void Invalidate() {}
+    /// Assert that this Value is valid.
+    virtual void AssertValid();
+
     intptr_t GetTag() const { return tag; }
     void SetTag(intptr_t tag_) { tag = tag_; }
 
@@ -151,7 +156,8 @@ public:
     /// Get argument number `index`.
     ValuePtr GetArg(size_t index) const;
 
-    void AssertValid();
+    void Invalidate() override;
+    void AssertValid() override;
 protected:
     void ReplaceUseOfXWithY(ValuePtr x, ValuePtr y) override;
 
@@ -263,6 +269,8 @@ public:
     size_t cycle_count = 0;
 };
 
+/// Returns a string representation of the contents of block. Intended for debugging.
+std::string DumpBlock(const IR::Block& block);
 
 } // namespace IR
 } // namespace Dynarmic