bpf: refactor propagate_liveness to eliminate code redundance

Access to reg states were not factored out, the consequence is long code
for dereferencing them which made the indentation not good for reading.

This patch factor out these code so the core code in the loop could be
easier to follow.

Reviewed-by: Jakub Kicinski <jakub.kicinski@netronome.com>
Signed-off-by: Jiong Wang <jiong.wang@netronome.com>
Signed-off-by: Alexei Starovoitov <ast@kernel.org>

diff --git a/kernel/bpf/verifier.c b/kernel/bpf/verifier.c
index da285df492fda1995865726af9e970bf4b626edb..6fd36a8ba1a0a8c992b969fd8c583c2d5040ce01 100644 (file)
--- a/kernel/bpf/verifier.c
+++ b/kernel/bpf/verifier.c
@@ -6232,8 +6232,9 @@ static int propagate_liveness(struct bpf_verifier_env *env,
                              const struct bpf_verifier_state *vstate,
                              struct bpf_verifier_state *vparent)
 {
-       int i, frame, err = 0;
+       struct bpf_reg_state *state_reg, *parent_reg;
        struct bpf_func_state *state, *parent;
+       int i, frame, err = 0;
 
        if (vparent->curframe != vstate->curframe) {
                WARN(1, "propagate_live: parent frame %d current frame %d\n",
@@ -6243,28 +6244,33 @@ static int propagate_liveness(struct bpf_verifier_env *env,
        /* Propagate read liveness of registers... */
        BUILD_BUG_ON(BPF_REG_FP + 1 != MAX_BPF_REG);
        for (frame = 0; frame <= vstate->curframe; frame++) {
+               parent = vparent->frame[frame];
+               state = vstate->frame[frame];
+               parent_reg = parent->regs;
+               state_reg = state->regs;
                /* We don't need to worry about FP liveness, it's read-only */
                for (i = frame < vstate->curframe ? BPF_REG_6 : 0; i < BPF_REG_FP; i++) {
-                       if (vparent->frame[frame]->regs[i].live & REG_LIVE_READ)
+                       if (parent_reg[i].live & REG_LIVE_READ)
                                continue;
-                       if (vstate->frame[frame]->regs[i].live & REG_LIVE_READ) {
-                               err = mark_reg_read(env, &vstate->frame[frame]->regs[i],
-                                                   &vparent->frame[frame]->regs[i]);
-                               if (err)
-                                       return err;
-                       }
+                       if (!(state_reg[i].live & REG_LIVE_READ))
+                               continue;
+                       err = mark_reg_read(env, &state_reg[i], &parent_reg[i]);
+                       if (err)
+                               return err;
                }
 
                /* Propagate stack slots. */
-               state = vstate->frame[frame];
-               parent = vparent->frame[frame];
                for (i = 0; i < state->allocated_stack / BPF_REG_SIZE &&
                            i < parent->allocated_stack / BPF_REG_SIZE; i++) {
-                       if (parent->stack[i].spilled_ptr.live & REG_LIVE_READ)
+                       parent_reg = &parent->stack[i].spilled_ptr;
+                       state_reg = &state->stack[i].spilled_ptr;
+                       if (parent_reg->live & REG_LIVE_READ)
                                continue;
-                       if (state->stack[i].spilled_ptr.live & REG_LIVE_READ)
-                               mark_reg_read(env, &state->stack[i].spilled_ptr,
-                                             &parent->stack[i].spilled_ptr);
+                       if (!(state_reg->live & REG_LIVE_READ))
+                               continue;
+                       err = mark_reg_read(env, state_reg, parent_reg);
+                       if (err)
+                               return err;
                }
        }
        return err;