Drop the use of `has_sufficient_progbuf()` with `riscv_program_exec()`

[en-sc]

Having a program buffer that fits at least one instruction allows to execute any number of consecutive instructions (with no control flow changes).
You can see an example in execute_autofence():

riscv-openocd/src/target/riscv/riscv-013.c

Lines 3077 to 3118 in 060a08b

	if (has_sufficient_progbuf(target, 3)) {
	riscv_program_init(&program, target);
	riscv_program_fence_i(&program);
	riscv_program_fence_rw_rw(&program);
	if (riscv_program_exec(&program, target) != ERROR_OK) {
	if (program.execution_result != RISCV_PROGBUF_EXEC_RESULT_EXCEPTION) {
	LOG_TARGET_ERROR(target, "Unexpected error during fence execution");
	return ERROR_FAIL;
	}
	LOG_TARGET_DEBUG(target, "Unable to execute fence.i and fence rw, rw");
	}
	LOG_TARGET_DEBUG(target, "Successfully executed fence.i and fence rw, rw");
	return ERROR_OK;
	}
	if (has_sufficient_progbuf(target, 2)) {
	riscv_program_init(&program, target);
	riscv_program_fence_i(&program);
	if (riscv_program_exec(&program, target) != ERROR_OK) {
	if (program.execution_result != RISCV_PROGBUF_EXEC_RESULT_EXCEPTION) {
	LOG_TARGET_ERROR(target, "Unexpected error during fence.i execution");
	return ERROR_FAIL;
	}
	LOG_TARGET_DEBUG(target, "Unable to execute fence.i");
	}
	LOG_TARGET_DEBUG(target, "Successfully executed fence.i");
	riscv_program_init(&program, target);
	riscv_program_fence_rw_rw(&program);
	if (riscv_program_exec(&program, target) != ERROR_OK) {
	if (program.execution_result != RISCV_PROGBUF_EXEC_RESULT_EXCEPTION) {
	LOG_TARGET_ERROR(target, "Unexpected error during fence rw, rw execution");
	return ERROR_FAIL;
	}
	LOG_TARGET_DEBUG(target, "Unable to execute fence rw, rw");
	}
	LOG_TARGET_DEBUG(target, "Successfully executed fence rw, rw");
	return ERROR_OK;
	}
	return ERROR_FAIL;
	}

Here the debugger attempts to execute two consecutive fences. However, if both fences do not fit into the program buffer, it executes one fence after another with two calls to riscv_program_exec().

This approach can be generalized to any program. If the size of a program is grater than the size of the Program Buffer the debugger can:

• Fill the Program Buffer with the instructions until it is full.
• Execute the Program Buffer.
• If the execution is successful, fill the program buffer with the next batch of instructions
• Loop until all the instructions are executed or an execution fails.

[Biancaa-R]

@en-sc So you want to totally remove the has_sufficient_progbuf() function and replace it with riscv_program_exec() in case the size is 3 ?
so
Initializes a program.

Adds as many operations as fit in the available program buffer.

Executes it.

Repeats for the rest if the buffer is not too small.

or also have the check for not equal to 2 and print a log_debug message in that case?

[en-sc]

In general, I suggest the following approach:
The instructions are written to the struct riscv_program via riscv_program_<instruction>(). The user of the API should not care about the progbuf size at this point -- just insert everything you need. (We can leave the hard cap of 16 instructions for now -- it seems reasonable).
Then the riscv_program_exec() internally splits the program into chunks that are written to the target's program buffer (via riscv_program_write()) and executed (via riscv_execute_progbuf()).

has_sufficient_progbuf() will still be necessary since there are cases when the program is being executed not through riscv_program_exec() (see write/read_memory_progbuf()).

[Biancaa-R]

In general, I suggest the following approach: The instructions are written to the struct riscv_program via riscv_program_<instruction>(). The user of the API should not care about the progbuf size at this point -- just insert everything you need. (We can leave the hard cap of 16 instructions for now -- it seems reasonable). Then the riscv_program_exec() internally splits the program into chunks that are written to the target's program buffer (via riscv_program_write()) and executed (via riscv_execute_progbuf()).

has_sufficient_progbuf() will still be necessary since there are cases when the program is being executed not through riscv_program_exec() (see write/read_memory_progbuf()).

ok thanks understood :)

• And if it falls below the 2 threshold -> then jump out of execution also right?

[Biancaa-R]

Will fix this after the base pr #1300 gets merged.