Add --dump-info command line argument (#307)

* Add --dump-info command line argument to obtain information about choicepoints and primitives

* clang-format + vector include

* Fix missing vector include

* [[maybe_unused]]

* Add functional and string includes

* Make find_choice_points (and others) a util function instead of a Module member

* All primitives that return something now result in a choice point

Author: MaartenS11

platforms/CLI-Emulator/binary-info.h

@@ -0,0 +1,58 @@
+#pragma once
+#include <functional>
+#include <vector>
+
+#include "../../src/WARDuino.h"
+
+inline std::vector<uint8_t *> find_prim_calls(
+    const Module *m, const std::function<bool(Block *)> &cond,
+    const bool after = false) {
+    std::vector<uint8_t *> call_sites;
+    for (size_t i = m->import_count; i < m->function_count; i++) {
+        Block *func = &m->functions[i];
+        uint8_t *pc = func->start_ptr;
+        while (pc < func->end_ptr) {
+            uint8_t opcode = *pc;
+            uint8_t *instruction_start_pc = pc;
+            if (opcode == 0x10) {  // TODO: Support other call instructions
+                pc++;
+                uint32_t fidx = read_LEB_32(&pc);
+                if (fidx < m->import_count) {
+                    const char *module_name = m->functions[fidx].import_module;
+                    if (!strcmp(module_name, "env") &&
+                        cond(&m->functions[fidx])) {
+                        if (!after) {
+                            call_sites.push_back(instruction_start_pc);
+                        } else {
+                            // NOTE: Only works because this is a primitive
+                            // call, if it was a regular call the vm would jump
+                            // into a function and not just to the instruction
+                            // after the call instruction.
+                            call_sites.push_back(pc);
+                        }
+                    }
+                }
+                continue;
+            }
+            skip_immediates(&pc);
+        }
+    }
+    return call_sites;
+}
+
+inline std::vector<uint8_t *> find_choice_points(const Module *m,
+                                                 const bool after = false) {
+    return find_prim_calls(
+        m, [](const Block *prim) { return prim->type->result_count > 0; },
+        after);
+}
+
+inline std::vector<uint8_t *> find_pc_before_primitive_calls(const Module *m) {
+    return find_prim_calls(
+        m, []([[maybe_unused]] const Block *prim) { return true; });
+}
+
+inline std::vector<uint8_t *> find_pc_after_primitive_calls(const Module *m) {
+    return find_prim_calls(
+        m, []([[maybe_unused]] const Block *prim) { return true; }, true);
+}

platforms/CLI-Emulator/main.cpp

@@ -8,11 +8,14 @@
 #include <cstdio>
 #include <cstdlib>
 #include <cstring>
+#include <iostream>
 #include <stdexcept>
 #include <thread>
 
 #include "../../src/Debug/debugger.h"
 #include "../../src/Utils/macros.h"
+#include "../../src/Utils/util.h"
+#include "binary-info.h"
 #include "warduino/config.h"
 
 // Constants
@@ -267,6 +270,7 @@ int main(int argc, const char *argv[]) {
     const char *proxy = nullptr;
     const char *baudrate = nullptr;
     const char *mode = "interpreter";
+    bool dump_info = false;
 
     const char *fname = nullptr;
     std::vector<StackValue> arguments = std::vector<StackValue>();
@@ -337,6 +341,8 @@ int main(int argc, const char *argv[]) {
                 arguments.push_back(
                     parseParameter(number, function.type->params[i]));
             }
+        } else if (!strcmp("--dump-info", arg)) {
+            dump_info = true;
         }
     }
 
@@ -352,6 +358,40 @@ int main(int argc, const char *argv[]) {
     }
 
     if (m) {
+        if (dump_info) {
+            auto choicepoints = std::vector<uint32_t>();
+            for (uint8_t *choice_point : find_choice_points(m)) {
+                choicepoints.push_back(toVirtualAddress(choice_point, m));
+            }
+            auto after_choicepoints = std::vector<uint32_t>();
+            for (uint8_t *choice_point : find_choice_points(m, true)) {
+                after_choicepoints.push_back(toVirtualAddress(choice_point, m));
+            }
+            auto primitive_calls = std::vector<uint32_t>();
+            for (uint8_t *call_site : find_pc_before_primitive_calls(m)) {
+                primitive_calls.push_back(toVirtualAddress(call_site, m));
+            }
+            auto after_primitive_calls = std::vector<uint32_t>();
+            for (uint8_t *call_site : find_pc_after_primitive_calls(m)) {
+                after_primitive_calls.push_back(toVirtualAddress(call_site, m));
+            }
+            nlohmann::json json;
+            json["choicepoints"] = choicepoints;
+            json["after_choicepoints"] = after_choicepoints;
+            json["primitive_calls"] = primitive_calls;
+            json["after_primitive_calls"] = after_primitive_calls;
+
+            std::vector<std::string> fidx_mapping = std::vector<std::string>();
+            for (uint32_t fidx = 0; fidx < m->import_count; fidx++) {
+                fidx_mapping.emplace_back(m->functions[fidx].import_field);
+            }
+            json["primitive_fidx_mapping"] = fidx_mapping;
+
+            std::cout << json << std::endl;
+            wac->unload_module(m);
+            exit(0);
+        }
+
         if (strcmp(mode, "proxy") == 0) {
             // Run in proxy mode
             wac->debugger->proxify();

src/WARDuino.h

@@ -61,6 +61,8 @@
 
 extern char exception[512];
 
+void skip_immediates(uint8_t **pos);
+
 typedef bool (*Primitive)(Module *);
 
 struct IOStateElement {