use actual instructions when dumping the CFG

Author: Hugobros3

src/common/util.c

@@ -38,6 +38,25 @@ size_t apply_escape_codes(const char* src, size_t size, char* dst) {
     return j;
 }
 
+size_t unapply_escape_codes(const char* src, size_t size, char* dst) {
+    char c = '\0';
+    size_t j = 0;
+    for (size_t i = 0; i < size; i++) {
+        c = src[i];
+
+#define ESCAPE_CASE(m, s) if (c == s) { \
+        dst[j++] = '\\'; \
+        dst[j++] = m; \
+        continue; \
+    } \
+
+        ESCAPE_SEQS(ESCAPE_CASE)
+
+        dst[j++] = c;
+    }
+    return j;
+}
+
 static long get_file_size(FILE* f) {
     if (fseek(f, 0, SEEK_END) != 0)
         return -1;

src/common/util.h

@@ -5,6 +5,7 @@
 #include <stdbool.h>
 
 size_t apply_escape_codes(const char* src, size_t og_len, char* dst);
+size_t unapply_escape_codes(const char* src, size_t og_len, char* dst);
 
 bool read_file(const char* filename, size_t* size, char** output);
 bool write_file(const char* filename, size_t size, const char* data);

src/shady/analysis/scope_dump.c

@@ -1,10 +1,14 @@
 #include "scope.h"
-#include "../ir_private.h"
+
+#include "shady/ir_private.h"
+#include "shady/print.h"
 
 #include "list.h"
 #include "dict.h"
 #include "util.h"
+#include "printer.h"
 
+#include <string.h>
 #include <assert.h>
 
 static int extra_uniqueness = 0;
@@ -21,6 +25,26 @@ static CFNode* get_let_pred(const CFNode* n) {
     return NULL;
 }
 
+static void print_node_helper(Printer* p, const Node* n) {
+    Growy* tmp_g = new_growy();
+    Printer* tmp_p = open_growy_as_printer(tmp_g);
+
+    PrintConfig config = {
+            .color = false,
+            .in_cfg = true,
+    };
+
+    print_node(tmp_p, n, config);
+
+    String label = printer_growy_unwrap(tmp_p);
+    char* escaped_label = calloc(strlen(label) * 2, 1);
+    unapply_escape_codes(label, strlen(label), escaped_label);
+
+    print(p, "%s", escaped_label);
+    free(escaped_label);
+    free((void*)label);
+}
+
 static void dump_cf_node(FILE* output, const CFNode* n) {
     const Node* bb = n->node;
     const Node* body = get_abstraction_body(bb);
@@ -35,37 +59,38 @@ static void dump_cf_node(FILE* output, const CFNode* n) {
     else if (is_basic_block(bb))
         color = "blue";
 
-    String label = "";
+    Growy* g = new_growy();
+    Printer* p = open_growy_as_printer(g);
 
     String abs_name = get_abstraction_name_unsafe(bb);
     if (!abs_name)
         abs_name = format_string_interned(bb->arena, "%%%d", bb->id);
-    label = format_string_arena(bb->arena->arena, "%s: %s", abs_name, label);
+
+    print(p, "%s: \n%s: ", abs_name, abs_name);
 
     const CFNode* let_chain_end = n;
     while (body->tag == Let_TAG) {
-        const Node* instr = body->payload.let.instruction;
-        // label = "";
-        if (instr->tag == PrimOp_TAG)
-            label = format_string_arena(bb->arena->arena, "%slet ... = %s (...)\n", label, get_primop_name(instr->payload.prim_op.op));
-        else
-            label = format_string_arena(bb->arena->arena, "%slet ... = %s (...)\n", label, node_tags[instr->tag]);
-
-        const Node* abs = body->payload.let.tail;
-        label = format_string_arena(bb->arena->arena, "%s%%%d: ", label, abs->id);
-
         if (entries_count_list(let_chain_end->succ_edges) != 1 || read_list(CFEdge, let_chain_end->succ_edges)[0].type != LetTailEdge)
             break;
 
+        print_node_helper(p, body);
+        print(p, "\\l");
+
+        const Node* abs = body->payload.let.tail;
+        print(p, "%%%d: ", abs->id);
+
         let_chain_end = read_list(CFEdge, let_chain_end->succ_edges)[0].dst;
         assert(let_chain_end->node == abs);
         assert(is_case(abs));
         body = get_abstraction_body(abs);
     }
 
-    label = format_string_arena(bb->arena->arena, "%s%s", label, node_tags[body->tag]);
+    print_node_helper(p, body);
+    print(p, "\\l");
 
-    fprintf(output, "bb_%zu [label=\"%s\", color=\"%s\", shape=box];\n", (size_t) n, label, color);
+    String label = printer_growy_unwrap(p);
+    fprintf(output, "bb_%zu [nojustify=true, label=\"%s\", color=\"%s\", shape=box];\n", (size_t) n, label, color);
+    free((void*) label);
 
     for (size_t i = 0; i < entries_count_list(n->dominates); i++) {
         CFNode* d = read_list(CFNode*, n->dominates)[i];

src/shady/print.c

@@ -567,6 +567,8 @@ static void print_instruction(PrinterCtx* ctx, const Node* node) {
             printf("(");
             print_node(node->payload.if_instr.condition);
             printf(") ");
+            if (ctx->config.in_cfg)
+                break;
             print_case_body(ctx, node->payload.if_instr.if_true);
             if (node->payload.if_instr.if_false) {
                 printf(GREEN);
@@ -580,6 +582,8 @@ static void print_instruction(PrinterCtx* ctx, const Node* node) {
             printf("loop");
             printf(RESET);
             print_yield_types(ctx, node->payload.loop_instr.yield_types);
+            if (ctx->config.in_cfg)
+                break;
             const Node* body = node->payload.loop_instr.body;
             assert(is_case(body));
             print_param_list(ctx, body->payload.case_.params, &node->payload.loop_instr.initial_args);
@@ -593,6 +597,8 @@ static void print_instruction(PrinterCtx* ctx, const Node* node) {
             printf("(");
             print_node(node->payload.match_instr.inspect);
             printf(")");
+            if (ctx->config.in_cfg)
+                break;
             printf(" {");
             indent(ctx->printer);
             for (size_t i = 0; i < node->payload.match_instr.literals.count; i++) {
@@ -625,6 +631,8 @@ static void print_instruction(PrinterCtx* ctx, const Node* node) {
             printf("control");
             printf(RESET);
             print_yield_types(ctx, node->payload.control.yield_types);
+            if (ctx->config.in_cfg)
+                break;
             print_param_list(ctx, node->payload.control.inside->payload.case_.params, NULL);
             print_case_body(ctx, node->payload.control.inside);
             break;
@@ -681,8 +689,10 @@ static void print_terminator(PrinterCtx* ctx, const Node* node) {
                     printf(" = ");
                 }
                 print_node(instruction);
-                printf(";\n");
-                print_abs_body(ctx, tail);
+                if (!ctx->config.in_cfg) {
+                    printf(";\n");
+                    print_abs_body(ctx, tail);
+                }
             } else {
                 printf(GREEN);
                 printf("let");
@@ -973,36 +983,45 @@ void print_node(Printer* printer, const Node* node, PrintConfig config) {
     };
     print_node_impl(&ctx, node);
     flush(ctx.printer);
-    destroy_printer(ctx.printer);
 }
 
 void print_node_into_str(const Node* node, char** str_ptr, size_t* size) {
     Growy* g = new_growy();
-    print_node(open_growy_as_printer(g), node, (PrintConfig) { .reparseable = true });
+    Printer* p = open_growy_as_printer(g);
+    print_node(p, node, (PrintConfig) { .reparseable = true });
+    destroy_printer(p);
     *size = growy_size(g);
     *str_ptr = growy_deconstruct(g);
 }
 
 void print_module_into_str(Module* mod, char** str_ptr, size_t* size) {
     Growy* g = new_growy();
-    print_module(open_growy_as_printer(g), mod, (PrintConfig) { .reparseable = true, });
+    Printer* p = open_growy_as_printer(g);
+    print_module(p, mod, (PrintConfig) { .reparseable = true, });
+    destroy_printer(p);
     *size = growy_size(g);
     *str_ptr = growy_deconstruct(g);
 }
 
 void dump_node(const Node* node) {
-    print_node(open_file_as_printer(stdout), node, (PrintConfig) { .color = true });
+    Printer* p = open_file_as_printer(stdout);
+    print_node(p, node, (PrintConfig) { .color = true });
     printf("\n");
 }
 
 void dump_module(Module* mod) {
-    print_module(open_file_as_printer(stdout), mod, (PrintConfig) { .color = true });
+    Printer* p = open_file_as_printer(stdout);
+    print_module(p, mod, (PrintConfig) { .color = true });
+    destroy_printer(p);
     printf("\n");
 }
 
 void log_node(LogLevel level, const Node* node) {
-    if (level >= get_log_level())
-        print_node(open_file_as_printer(stderr), node, (PrintConfig) { .color = true });
+    if (level >= get_log_level()) {
+        Printer* p = open_file_as_printer(stderr);
+        print_node(p, node, (PrintConfig) { .color = true });
+        destroy_printer(p);
+    }
 }
 
 void log_module(LogLevel level, CompilerConfig* compiler_cfg, Module* mod) {

src/shady/print.h

@@ -12,6 +12,7 @@ typedef struct {
     bool print_ptrs;
     bool color;
     bool reparseable;
+    bool in_cfg;
 } PrintConfig;
 
 void print_module(Printer* printer, Module* mod, PrintConfig config);