rename stack size primops

Author: Hugobros3

include/shady/primops.json

@@ -197,15 +197,15 @@
       "side-effects": true
     },
     {
-      "name": "get_stack_pointer",
+      "name": "get_stack_size",
       "class": "stack"
     },
     {
       "name": "get_stack_base",
       "class": "stack"
     },
     {
-      "name": "set_stack_pointer",
+      "name": "set_stack_size",
       "class": "stack",
       "side-effects": true
     },

src/shady/passes/lift_indirect_targets.c

@@ -64,7 +64,7 @@ static const Node* add_spill_instrs(Context* ctx, BodyBuilder* builder, struct L
         bind_instruction(builder, save_instruction);
     }
 
-    const Node* sp = gen_primop_ce(builder, get_stack_pointer_op, 0, NULL);
+    const Node* sp = gen_primop_ce(builder, get_stack_size_op, 0, NULL);
 
     return sp;
 }
@@ -134,7 +134,7 @@ static LiftedCont* lambda_lift(Context* ctx, const Node* cont, String given_name
 
     // Recover that stuff inside the new body
     BodyBuilder* bb = begin_body(a);
-    gen_primop(bb, set_stack_pointer_op, empty(a), singleton(payload));
+    gen_primop(bb, set_stack_size_op, empty(a), singleton(payload));
     for (size_t i = recover_context_size - 1; i < recover_context_size; i--) {
         const Node* ovar = read_list(const Node*, recover_context)[i];
         assert(ovar->tag == Variable_TAG);

src/shady/passes/lower_alloca.c

@@ -142,7 +142,7 @@ static const Node* process(Context* ctx, const Node* node) {
                 if (!ctx->entry_stack_offset) {
                     //String tmp_name = format_string_arena(a->arena, "stack_ptr_before_alloca_%s", get_abstraction_name(fun));
                     String tmp_name = "stack_ptr_before_alloca";
-                    ctx->entry_stack_offset = first(bind_instruction_named(bb, prim_op(a, (PrimOp) { .op = get_stack_pointer_op } ), (String []) { tmp_name }));
+                    ctx->entry_stack_offset = first(bind_instruction_named(bb, prim_op(a, (PrimOp) { .op = get_stack_size_op } ), (String []) { tmp_name }));
                 }
 
                 //const Node* lea_instr = prim_op_helper(a, lea_op, empty(a), mk_nodes(a, rewrite_node(&ctx->rewriter, first(node->payload.prim_op.operands)), found_slot->offset));
@@ -154,7 +154,7 @@ static const Node* process(Context* ctx, const Node* node) {
                 //bool last = found_slot->i == ctx->num_slots - 1;
                 //if (last) {
                     const Node* updated_stack_ptr = gen_primop_e(bb, add_op, empty(a), mk_nodes(a, ctx->entry_stack_offset, ctx->frame_size));
-                    gen_primop(bb, set_stack_pointer_op, empty(a), singleton(updated_stack_ptr));
+                    gen_primop(bb, set_stack_size_op, empty(a), singleton(updated_stack_ptr));
                 //}
 
                 return yield_values_and_wrap_in_block(bb, singleton(slot));

src/shady/passes/lower_stack.c

@@ -100,13 +100,13 @@ static const Node* process_let(Context* ctx, const Node* node) {
     if (old_instruction->tag == PrimOp_TAG) {
         const PrimOp* oprim_op = &old_instruction->payload.prim_op;
         switch (oprim_op->op) {
-            case get_stack_pointer_op: {
+            case get_stack_size_op: {
                 assert(ctx->stack);
                 BodyBuilder* bb = begin_body(a);
                 const Node* sp = gen_load(bb, ctx->stack_pointer);
                 return finish_body(bb, let(a, quote_helper(a, singleton(sp)), tail));
             }
-            case set_stack_pointer_op: {
+            case set_stack_size_op: {
                 assert(ctx->stack);
                 BodyBuilder* bb = begin_body(a);
                 const Node* val = rewrite_node(&ctx->rewriter, oprim_op->operands.nodes[0]);

src/shady/passes/setup_stack_frames.c

@@ -35,7 +35,7 @@ static const Node* process(Context* ctx, const Node* node) {
 
             BodyBuilder* bb = begin_body(a);
             if (!ctx2.disable_lowering) {
-                ctx2.entry_stack_offset = first(bind_instruction_named(bb, prim_op(a, (PrimOp) { .op = get_stack_pointer_op } ), (String []) {format_string_arena(a->arena, "saved_stack_ptr_entering_%s", get_abstraction_name(fun)) }));
+                ctx2.entry_stack_offset = first(bind_instruction_named(bb, prim_op(a, (PrimOp) { .op = get_stack_size_op } ), (String []) {format_string_arena(a->arena, "saved_stack_ptr_entering_%s", get_abstraction_name(fun)) }));
             }
             if (node->payload.fun.body)
                 fun->payload.fun.body = finish_body(bb, rewrite_node(&ctx2.rewriter, node->payload.fun.body));
@@ -49,7 +49,7 @@ static const Node* process(Context* ctx, const Node* node) {
                 assert(ctx->entry_stack_offset);
                 // Restore SP before calling exit
                 bind_instruction(bb, prim_op(a, (PrimOp) {
-                    .op = set_stack_pointer_op,
+                    .op = set_stack_size_op,
                     .operands = nodes(a, 1, (const Node* []) {ctx->entry_stack_offset })
                 }));
             }

src/shady/type.c

@@ -1029,7 +1029,7 @@ const Type* check_type_prim_op(IrArena* arena, PrimOp prim_op) {
             return qualified_type(arena, (QualifiedType) { .type = join_point_type(arena, (JoinPointType) { .yield_types = empty(arena) }), .is_uniform = true });
         }
         // Stack stuff
-        case get_stack_pointer_op: {
+        case get_stack_size_op: {
             assert(prim_op.type_arguments.count == 0);
             assert(prim_op.operands.count == 0);
             return qualified_type(arena, (QualifiedType) { .is_uniform = false, .type = uint32_type(arena) });
@@ -1040,7 +1040,7 @@ const Type* check_type_prim_op(IrArena* arena, PrimOp prim_op) {
             const Node* ptr = ptr_type(arena, (PtrType) { .pointed_type = uint8_type(arena), .address_space = AsPrivate});
             return qualified_type(arena, (QualifiedType) { .is_uniform = false, .type = ptr });
         }
-        case set_stack_pointer_op: {
+        case set_stack_size_op: {
             assert(prim_op.type_arguments.count == 0);
             assert(prim_op.operands.count == 1);
             assert(get_unqualified_type(prim_op.operands.nodes[0]->type) == uint32_type(arena));