Function evaluate

dpdk/lib/bpf/bpf_validate.c:2385–2508

Do second pass through CFG and try to evaluate instructions * via each possible path. The verifier will try all paths, tracking types of * registers used as input to instructions, and updating resulting type via * register state values. Plus for each register and possible stack value it * tries to estimate possible max/min value. * For conditional jumps, a stack is used to save evaluation sta

 * For now, only states for JCC  targets are saved/examined.
 */
static int
evaluate(struct bpf_verifier *bvf)
{
	int32_t rc;
	uint32_t idx, op;
	const char *err;
	const struct ebpf_insn *ins;
	struct inst_node *next, *node;

	struct {
		uint32_t nb_eval;
		uint32_t nb_prune;
		uint32_t nb_save;
		uint32_t nb_restore;
	} stats;

	/* initial state of frame pointer */
	static const struct bpf_reg_val rvfp = {
		.v = {
			.type = BPF_ARG_PTR_STACK,
			.size = MAX_BPF_STACK_SIZE,
		},
		.mask = UINT64_MAX,
		.u = {.min = MAX_BPF_STACK_SIZE, .max = MAX_BPF_STACK_SIZE},
		.s = {.min = MAX_BPF_STACK_SIZE, .max = MAX_BPF_STACK_SIZE},
	};

	bvf->evst->rv[EBPF_REG_1].v = bvf->prm->prog_arg;
	bvf->evst->rv[EBPF_REG_1].mask = UINT64_MAX;
	if (bvf->prm->prog_arg.type == RTE_BPF_ARG_RAW)
		eval_max_bound(bvf->evst->rv + EBPF_REG_1, UINT64_MAX);

	bvf->evst->rv[EBPF_REG_10] = rvfp;

	ins = bvf->prm->ins;
	node = bvf->in;
	next = node;
	rc = 0;

	memset(&stats, 0, sizeof(stats));

	while (node != NULL && rc == 0) {

		/*
		 * current node evaluation, make sure we evaluate
		 * each node only once.
		 */
		if (next != NULL) {

			bvf->evin = node;
			idx = get_node_idx(bvf, node);
			op = ins[idx].code;

			/* for jcc node make a copy of evaluation state */
			if (node->nb_edge > 1) {
				rc |= save_cur_eval_state(bvf, node);
				stats.nb_save++;
			}