Function branch analysis

PowerAnalyse/function.cpp

@@ -0,0 +1,138 @@
+#include "function.h"
+#include <disasm.h>
+#include <vector>
+#include <bit>
+
+size_t function::SearchBlock(size_t address) const
+{
+    if (address < base)
+    {
+        return -1;
+    }
+
+    for (size_t i = 0; i < blocks.size(); i++)
+    {
+        const auto& block = blocks[i];
+        const auto begin = base + block.base;
+        const auto end = begin + size;
+
+        if (address >= begin && address <= end)
+        {
+            return i;
+        }
+    }
+
+    return -1;
+}
+
+function function::Analyze(const void* code, size_t size, size_t base)
+{
+    function fn{ base, 0 };
+    auto& blocks = fn.blocks;
+    blocks.emplace_back();
+
+    const auto* data = (uint32_t*)code;
+    const auto* dataStart = data;
+    const auto* dataEnd = (uint32_t*)((uint8_t*)code + size);
+    std::vector<size_t> blockStack{};
+    blockStack.emplace_back();
+
+    // TODO: Branch fallthrough
+    for (; data <= dataEnd ; ++data)
+    {
+        const auto addr = base + ((data - dataStart) * sizeof(*data));
+        if (blockStack.empty())
+        {
+            break; // it's hideover
+        }
+
+        const auto instruction = std::byteswap(*data);
+
+        const auto op = PPC_OP(instruction);
+        const auto xop = PPC_XOP(instruction);
+        const auto isLink = instruction & 1; // call
+
+        ppc_insn insn;
+        ppc::Disassemble(data, addr, insn);
+
+        blocks[blockStack.back()].size += 4;
+        if (op == PPC_OP_BC) // conditional branches all originate from one opcode, thanks RISC
+        {
+            // this one ends here
+            blockStack.pop_back();
+
+            // true/false paths
+            // left block: false case
+            // right block: true case
+
+            const auto lBase = (addr - base) + 4;
+            const auto rBase = insn.operands[1] - base;
+
+            // these will be -1 if it's our first time seeing these blocks
+            auto lBlock = fn.SearchBlock(base + lBase);
+
+            if (lBlock == -1)
+            {
+                blocks.emplace_back(lBase, 0);
+                lBlock = blocks.size() - 1;
+            }
+
+            // push this first, this gets overriden by the true case as it'd be further away
+            if (lBlock != -1)
+            {
+                blockStack.emplace_back(lBlock);
+            }
+
+            if (!isLink) // not a call, scan this too
+            {
+                auto rBlock = fn.SearchBlock(base + rBase);
+                if (rBlock == -1)
+                {
+                    blocks.emplace_back(insn.operands[1] - base, 0);
+                    rBlock = blocks.size() - 1;
+
+                    blockStack.emplace_back(rBlock);
+                }
+            }
+
+            if (!blockStack.empty())
+            {
+                data = (dataStart + (blocks[blockStack.back()].base / sizeof(*data))) - 1; // loop will add one
+            }
+        }
+        else if (op == PPC_OP_B || (op == PPC_OP_CTR && xop == 16) || instruction == 0) // b, blr, end padding
+        {
+            if (!isLink)
+            {
+                blockStack.pop_back();
+
+                // single block with a branch means it'd be a tail call
+                // we don't have to analyze the target in that case
+                if (op == PPC_OP_B && blocks.size() != 1)
+                {
+                    const auto branchBase = insn.operands[0] - base;
+                    const auto branchBlock = fn.SearchBlock(insn.operands[0]);
+
+                    if (branchBlock == -1)
+                    {
+                        blocks.emplace_back(branchBase, 0);
+                        blockStack.emplace_back(blocks.size() - 1);
+                    }
+                }
+
+                if (!blockStack.empty())
+                {
+                    data = (dataStart + (blocks[blockStack.back()].base / sizeof(*data))) - 1;
+                }
+            }
+        }
+    }
+    
+    for (const auto& block : blocks)
+    {
+        // pick the block furthest away
+        fn.size = std::max(fn.size, block.base + block.size);
+    }
+    
+    return fn;
+}