Lines Matching refs:st

48  * The second pass is all possible path descent from the 1st insn.

71  * 1st insn copies R10 (which has FRAME_PTR) type into R1

103  * function expects 1st argument to be a const pointer to 'struct bpf_map' and

165     /* verifer state is 'st'

169     struct bpf_verifier_state st;

903 static void update_branch_counts(struct bpf_verifier_env *env, struct bpf_verifier_state *st)

905     while (st) {

906         u32 br = --st->branches;

915         st = st->parent;

930         err = copy_verifier_state(cur, &head->st);

945     free_verifier_state(&head->st, false);

970     err = copy_verifier_state(&elem->st, cur);

974     elem->st.speculative |= speculative;

979     if (elem->st.parent) {

980         ++elem->st.parent->branches;

991     return &elem->st;

1778 static int get_prev_insn_idx(struct bpf_verifier_state *st, int i, u32 *history)

1782     if (cnt && st->jmp_history[cnt - 1].idx == i) {

1783         i = st->jmp_history[cnt - 1].prev_idx;

1883             /* stx & st shouldn't be using _scalar_ dst_reg

1967  * It's possible that this backtracking will go all the way till 1st insn.

1996 static void mark_all_scalars_precise(struct bpf_verifier_env *env, struct bpf_verifier_state *st)

2005     for (; st; st = st->parent) {

2006         for (i = 0; i <= st->curframe; i++) {

2007             func = st->frame[i];

2031     struct bpf_verifier_state *st = env->cur_state;

2032     int first_idx = st->first_insn_idx;

2046     func = st->frame[st->curframe];

2088         u32 history = st->jmp_history_cnt;

2101                 mark_all_scalars_precise(env, st);

2116             i = get_prev_insn_idx(st, i, &history);

2129         st = st->parent;

2130         if (!st) {

2135         func = st->frame[st->curframe];

2167                 mark_all_scalars_precise(env, st);

2198         last_idx = st->last_insn_idx;

2199         first_idx = st->first_insn_idx;

8419     insn_state[0] = DISCOVERED; /* mark 1st insn as discovered */

8882 static void clean_func_state(struct bpf_verifier_env *env, struct bpf_func_state *st)

8888         live = st->regs[i].live;

8890         st->regs[i].live |= REG_LIVE_DONE;

8895             verifier_mark_reg_not_init(env, &st->regs[i]);

8899     for (i = 0; i < st->allocated_stack / BPF_REG_SIZE; i++) {

8900         live = st->stack[i].spilled_ptr.live;

8902         st->stack[i].spilled_ptr.live |= REG_LIVE_DONE;

8904             verifier_mark_reg_not_init(env, &st->stack[i].spilled_ptr);

8906                 st->stack[i].slot_type[j] = STACK_INVALID;

8912 static void clean_verifier_state(struct bpf_verifier_env *env, struct bpf_verifier_state *st)

8916     if (st->frame[0]->regs[0].live & REG_LIVE_DONE) {

8921     for (i = 0; i <= st->curframe; i++) {

8922         clean_func_state(env, st->frame[i]);

11625         /* 1st arg to a function */