GCC Pass

while (cond) {
    /* ... */
}

do {
    /*  */
} while (cond)

// 2023-03-30 10:22
#include <stdio.h>
#include <string.h>
volatile int data[3] = {1, 2, 3};
int main(int argc, char *argv[]) {
    volatile int *x = data;
    int a = 0x1;
    int b = 0x2;
    int c = 0x3;
    for (int i = 0; i < 3; i++) {
        *x = a;
        if (*x != data[0]) {
            return 1;
        }
        *x = b;
        if (*x != data[1]) {
            return 1;
        }
        *x = c;
        if (*x != data[2]) {
            return 1;
        }
    }
    return 0;
}

for (int i = 1; i < argc; i++) {
}

#include <stdint.h>
void matrix_mul_vect(int32_t N, int32_t *C, int32_t *A, int32_t *B) {
    int32_t i, j;
    for (i = 0; i < N; i++) {
        C[i] = 0;
    }
}

matrix_mul_vect:
.LFB0:
    mv      a2,a0
    mv      a0,a1
    ble     a2,zero,.L1
    slli    a5,a2,32
    srli    a2,a5,30
    li      a1,0
    tail    memset
.L1:
    ret

rtx
gen_prologue (void)
{
  rtx_insn *_val = 0;
  start_sequence ();
  {
#define FAIL return (end_sequence (), _val)
#define DONE return (_val = get_insns (), end_sequence (), _val)
#line 2202 "../.././riscv-gcc/gcc/config/riscv/riscv.md"
{
  riscv_expand_prologue ();
  DONE;
}
#undef DONE
#undef FAIL
  }
  emit_insn (const1_rtx);
  _val = get_insns ();
  end_sequence ();
  return _val;
}

addi sp, sp , xxx
sw ra, (4)sp
sw s0, (8)sp
## ...

/* NOTE: 这段代码负责生成函数开头的
 * addi sp, sp , xxx
 * sw ra, (4)sp
 * sw s0, (8)sp
 * ...
 * */
void riscv_expand_prologue(void) {
    struct riscv_frame_info *frame = &cfun->machine->frame;
    /* NOTE: frame->total_size 在 pass_ira 时确定下来 */
    HOST_WIDE_INT size = frame->total_size;
    unsigned mask = frame->mask;
    rtx insn;

    if (flag_stack_usage_info) current_function_static_stack_size = size;

    /* Save the registers.  */
    /* NOTE: frame->mask 指哪些寄存器需要保存, 也是 pass_ira 时确定的 */
    if ((frame->mask | frame->fmask) != 0) {
        /* NOTE: 这里并没有直接使用 frame->total_size, 是因为 total_size 很大时
         * 会无法通过一个 addi 完成, 所以可以先分配足够存放 saved reg 的小一点的
         * `step`*/
        HOST_WIDE_INT step1 = MIN(size, riscv_first_stack_step(frame));

        /* NOTE: addi sp, sp, -step1 */
        insn = gen_add3_insn(
            stack_pointer_rtx, stack_pointer_rtx, GEN_INT(-step1));
        size -= step1;
        riscv_for_each_saved_reg(size, riscv_save_reg, false, false);
    }

    frame->mask = mask; /* Undo the above fib.  */

    /* NOTE: 需要保存 fp, 例如存在 alloca  */
    if (frame_pointer_needed) {
        insn = gen_add3_insn(
            hard_frame_pointer_rtx, stack_pointer_rtx,
            GEN_INT(frame->hard_frame_pointer_offset - size));
        RTX_FRAME_RELATED_P(emit_insn(insn)) = 1;

        riscv_emit_stack_tie();
    }

    /* NOTE: frame->total_size 剩下的部分 */
    if (size > 0) {
        /* NOTE: SMALL_OPERAND 是指 12 bit 能表示的立即数 */
        if (SMALL_OPERAND(-size)) {
            insn = gen_add3_insn(
                stack_pointer_rtx, stack_pointer_rtx, GEN_INT(-size));
            RTX_FRAME_RELATED_P(emit_insn(insn)) = 1;
        } else {
            riscv_emit_move(RISCV_PROLOGUE_TEMP(Pmode), GEN_INT(-size));
            emit_insn(gen_add3_insn(
                stack_pointer_rtx, stack_pointer_rtx,
                RISCV_PROLOGUE_TEMP(Pmode)));

            /* Describe the effect of the previous instructions.  */
            insn = plus_constant(Pmode, stack_pointer_rtx, -size);
            insn = gen_rtx_SET(stack_pointer_rtx, insn);
            riscv_set_frame_expr(insn);
        }
    }
}

#0  gen_prologue () at ../.././riscv-gcc/gcc/config/riscv/riscv.md:2202
#1  0x000000000153aada in target_gen_prologue () at ../.././riscv-gcc/gcc/config/riscv/sync.md:558
#2  0x0000000000d017d6 in make_prologue_seq () at ../.././riscv-gcc/gcc/function.c:5801
#3  0x0000000000d01d8b in thread_prologue_and_epilogue_insns () at ../.././riscv-gcc/gcc/function.c:6019
#4  0x0000000000d02cbb in rest_of_handle_thread_prologue_and_epilogue () at ../.././riscv-gcc/gcc/function.c:6510
#5  0x0000000000d02ecf in (anonymous namespace)::pass_thread_prologue_and_epilogue::execute (this=0x23416c0) at ../.././riscv-gcc/gcc/function.c:6586
#6  0x0000000000fdd7d1 in execute_one_pass (pass=0x23416c0) at ../.././riscv-gcc/gcc/passes.c:2567
#7  0x0000000000fddb1e in execute_pass_list_1 (pass=0x23416c0) at ../.././riscv-gcc/gcc/passes.c:2656
#8  0x0000000000fddb4f in execute_pass_list_1 (pass=0x2341480) at ../.././riscv-gcc/gcc/passes.c:2657
#9  0x0000000000fddb4f in execute_pass_list_1 (pass=0x2340220) at ../.././riscv-gcc/gcc/passes.c:2657
#10 0x0000000000fddbab in execute_pass_list (fn=0x7ffff777e000, pass=0x233c270) at ../.././riscv-gcc/gcc/passes.c:2667
#11 0x0000000000b6f617 in cgraph_node::expand (this=0x7ffff7780000) at ../.././riscv-gcc/gcc/cgraphunit.c:1830
#12 0x0000000000b6fd15 in cgraph_order_sort::process (this=0x2333788) at ../.././riscv-gcc/gcc/cgraphunit.c:2069
#13 0x0000000000b6ffce in output_in_order () at ../.././riscv-gcc/gcc/cgraphunit.c:2137
#14 0x0000000000b705a6 in symbol_table::compile (this=0x7ffff7670000) at ../.././riscv-gcc/gcc/cgraphunit.c:2355
#15 0x0000000000b709d2 in symbol_table::finalize_compilation_unit (this=0x7ffff7670000) at ../.././riscv-gcc/gcc/cgraphunit.c:2539
#16 0x000000000110d05f in compile_file () at ../.././riscv-gcc/gcc/toplev.c:482
#17 0x00000000011100c6 in do_compile () at ../.././riscv-gcc/gcc/toplev.c:2201
#18 0x00000000011103e8 in toplev::main (this=0x7fffffffc176, argc=14, argv=0x7fffffffc288) at ../.././riscv-gcc/gcc/toplev.c:2340
#19 0x0000000001bf4bf5 in main (argc=14, argv=0x7fffffffc288) at ../.././riscv-gcc/gcc/main.c:39

static void riscv_compute_frame_info(void) {
    struct riscv_frame_info *frame;
    HOST_WIDE_INT offset;
    bool interrupt_save_prologue_temp = false;
    unsigned int regno, i, num_x_saved = 0, num_f_saved = 0;

    frame = &cfun->machine->frame;
    memset(frame, 0, sizeof(*frame));

    /* NOTE: naked function */
    if (!cfun->machine->naked_p) {
        for (regno = GP_REG_FIRST; regno <= GP_REG_LAST; regno++)
            /* NOTE: riscv_save_reg_p 用来确定寄存器是否需要保存, 例如:
             * 如果 regno 是 s0~ */
            if (riscv_save_reg_p(regno))
                frame->mask |= 1 << (regno - GP_REG_FIRST), num_x_saved++;

        /* Find out which FPRs we need to save.  This loop must iterate over
           the same space as its companion in riscv_for_each_saved_reg.  */
        if (TARGET_HARD_FLOAT)
            for (regno = FP_REG_FIRST; regno <= FP_REG_LAST; regno++)
                if (riscv_save_reg_p(regno))
                    frame->fmask |= 1 << (regno - FP_REG_FIRST), num_f_saved++;
    }

    /* NOTE: 计算 offset 时是按照 stack 从低到高的顺序 */
    /* NOTE: 1. 栈顶是 outgoing args, 即 spill 到栈上的 args */
    offset = RISCV_STACK_ALIGN(crtl->outgoing_args_size);
    /* NOTE: 2. 然后是 local variable */
    offset += RISCV_STACK_ALIGN(get_frame_size());
    /* The virtual frame pointer points above the local variables. */
    frame->frame_pointer_offset = offset;
    /* NOTE: 3. 需要保存的 fp */
    if (frame->fmask)
        offset += RISCV_STACK_ALIGN(num_f_saved * UNITS_PER_FP_REG);
    frame->fp_sp_offset = offset - UNITS_PER_FP_REG;
    /* NOTE: 4. 需要保存的 gp */
    if (frame->mask) {
        unsigned x_save_size = RISCV_STACK_ALIGN(num_x_saved * UNITS_PER_WORD);
        offset += x_save_size;
    }
    frame->gp_sp_offset = offset - UNITS_PER_WORD;
    frame->hard_frame_pointer_offset = offset;
    frame->total_size = offset;
}