scope analysis: cleanup

Author: Hugobros3

src/shady/analysis/scope.c

@@ -40,32 +40,39 @@ typedef struct {
     struct Dict* join_point_values;
 } ScopeBuildContext;
 
-CFNode* scope_lookup(Scope* scope, const Node* block) {
-    CFNode** found = find_value_dict(const Node*, CFNode*, scope->map, block);
+CFNode* scope_lookup(Scope* scope, const Node* abs) {
+    CFNode** found = find_value_dict(const Node*, CFNode*, scope->map, abs);
     if (found) {
-        assert((*found)->node);
-        return *found;
+        CFNode* cfnode = *found;
+        assert(cfnode->node);
+        assert(cfnode->node == abs);
+        return cfnode;
     }
     assert(false);
     return NULL;
 }
 
-static CFNode* get_or_enqueue(ScopeBuildContext* ctx, const Node* abs) {
-    assert(is_abstraction(abs));
-    assert(!is_function(abs) || abs == ctx->entry);
-    CFNode** found = find_value_dict(const Node*, CFNode*, ctx->nodes, abs);
-    if (found) return *found;
-
-    CFNode* new = arena_alloc(ctx->arena, sizeof(CFNode));
+static CFNode* new_cfnode(Arena* a) {
+    CFNode* new = arena_alloc(a, sizeof(CFNode));
     *new = (CFNode) {
-        .node = abs,
         .succ_edges = new_list(CFEdge),
         .pred_edges = new_list(CFEdge),
         .rpo_index = SIZE_MAX,
         .idom = NULL,
         .dominates = NULL,
         .structurally_dominates = new_set(const Node*, (HashFn) hash_node, (CmpFn) compare_node),
     };
+    return new;
+}
+
+static CFNode* get_or_enqueue(ScopeBuildContext* ctx, const Node* abs) {
+    assert(is_abstraction(abs));
+    assert(!is_function(abs) || abs == ctx->entry);
+    CFNode** found = find_value_dict(const Node*, CFNode*, ctx->nodes, abs);
+    if (found) return *found;
+
+    CFNode* new = new_cfnode(ctx->arena);
+    new->node = abs;
     assert(abs && new->node);
     insert_dict(const Node*, CFNode*, ctx->nodes, abs, new);
     append_list(Node*, ctx->queue, new);
@@ -101,8 +108,9 @@ static void add_edge(ScopeBuildContext* ctx, const Node* src, const Node* dst, C
     assert(is_structural_edge(type) == (bool) is_case(dst));
     if (ctx->lt && !in_loop(ctx->lt, ctx->entry, dst))
         return;
-    if (ctx->lt && dst == ctx->entry)
+    if (ctx->lt && dst == ctx->entry) {
         return;
+    }
 
     CFNode* src_node = get_or_enqueue(ctx, src);
     CFNode* dst_node = get_or_enqueue(ctx, dst);
@@ -200,7 +208,9 @@ static void process_cf_node(ScopeBuildContext* ctx, CFNode* node) {
         case MergeBreak_TAG: {
             break; // TODO i guess
         }
-        case TailCall_TAG:
+        case TailCall_TAG: {
+
+        }
         case Return_TAG:
         case Unreachable_TAG: break;
         case NotATerminator: if (terminator->arena->config.check_types) { error("Grammar problem"); } break;
@@ -214,7 +224,7 @@ static void flip_scope(Scope* scope) {
     scope->entry = NULL;
 
     for (size_t i = 0; i < scope->size; i++) {
-        CFNode * cur = read_list(CFNode*, scope->contents)[i];
+        CFNode* cur = read_list(CFNode*, scope->contents)[i];
 
         struct List* tmp = cur->succ_edges;
         cur->succ_edges = cur->pred_edges;
@@ -223,32 +233,23 @@ static void flip_scope(Scope* scope) {
         for (size_t j = 0; j < entries_count_list(cur->succ_edges); j++) {
             CFEdge* edge = &read_list(CFEdge, cur->succ_edges)[j];
 
-            CFNode* tmp = edge->dst;
+            CFNode* tmp2 = edge->dst;
             edge->dst = edge->src;
-            edge->src = tmp;
+            edge->src = tmp2;
         }
 
         for (size_t j = 0; j < entries_count_list(cur->pred_edges); j++) {
             CFEdge* edge = &read_list(CFEdge, cur->pred_edges)[j];
 
-            CFNode* tmp = edge->dst;
+            CFNode* tmp2 = edge->dst;
             edge->dst = edge->src;
-            edge->src = tmp;
+            edge->src = tmp2;
         }
 
         if (entries_count_list(cur->pred_edges) == 0) {
             if (scope->entry != NULL) {
                 if (scope->entry->node) {
-                    CFNode* new_entry = arena_alloc(scope->arena, sizeof(CFNode));
-                    *new_entry = (CFNode) {
-                        .node = NULL,
-                        .succ_edges = new_list(CFEdge),
-                        .pred_edges = new_list(CFEdge),
-                        .rpo_index = SIZE_MAX,
-                        .idom = NULL,
-                        .dominates = NULL,
-                    };
-
+                    CFNode* new_entry = new_cfnode(scope->arena);
                     CFEdge prev_entry_edge = {
                         .type = JumpEdge,
                         .src = new_entry,
@@ -272,6 +273,7 @@ static void flip_scope(Scope* scope) {
         }
     }
 
+    assert(scope->entry);
     if (!scope->entry->node) {
         scope->size += 1;
         append_list(Node*, scope->contents, scope->entry);
@@ -396,7 +398,7 @@ static size_t post_order_visit(Scope* scope, CFNode* n, size_t i) {
 
 void compute_rpo(Scope* scope) {
     scope->rpo = malloc(sizeof(const CFNode*) * scope->size);
-    size_t index = post_order_visit(scope,  scope->entry, scope->size);
+    size_t index = post_order_visit(scope, scope->entry, scope->size);
     assert(index == 0);
 
     // debug_print("RPO: ");
@@ -422,9 +424,9 @@ void compute_domtree(Scope* scope) {
             continue;
         for (size_t j = 0; j < entries_count_list(n->pred_edges); j++) {
             CFEdge e = read_list(CFEdge, n->pred_edges)[j];
-            CFNode* p = e.src;
-            if (p->rpo_index < n->rpo_index) {
-                n->idom = p;
+            CFNode* pred = e.src;
+            if (pred->rpo_index < n->rpo_index) {
+                n->idom = pred;
                 goto outer_loop;
             }
         }
@@ -464,37 +466,3 @@ void compute_domtree(Scope* scope) {
         append_list(CFNode*, n->idom->dominates, n);
     }
 }
-
-/**
- * @param node: Start node.
- * @param target: List to extend. @ref List of @ref CFNode*
- */
-static void get_undominated_children(const CFNode* node, struct List* target) {
-    for (size_t i = 0; i < entries_count_list(node->succ_edges); i++) {
-        CFEdge edge = read_list(CFEdge, node->succ_edges)[i];
-
-        bool contained = false;
-        for (size_t j = 0; j < entries_count_list(node->dominates); j++) {
-            CFNode* dominated = read_list(CFNode*, node->dominates)[j];
-            if (edge.dst == dominated) {
-                contained = true;
-                break;
-            }
-        }
-        if (!contained)
-            append_list(CFNode*, target, edge.dst);
-    }
-}
-
-//TODO: this function can produce duplicates.
-struct List* scope_get_dom_frontier(Scope* scope, const CFNode* node) {
-    struct List* dom_frontier = new_list(CFNode*);
-
-    get_undominated_children(node, dom_frontier);
-    for (size_t i = 0; i < entries_count_list(node->dominates); i++) {
-        CFNode* dom = read_list(CFNode*, node->dominates)[i];
-        get_undominated_children(dom, dom_frontier);
-    }
-
-    return dom_frontier;
-}

src/shady/analysis/scope.h

@@ -99,7 +99,7 @@ Scope* new_scope_lt_impl(const Node* entry, LoopTree* lt, bool flipped);
  */
 #define new_scope_flipped(node) new_scope_impl(node, NULL, true);
 
-CFNode* scope_lookup(Scope*, const Node* block);
+CFNode* scope_lookup(Scope*, const Node* abs);
 void compute_rpo(Scope*);
 void compute_domtree(Scope*);