Buses and the ALU in the 8086
If there was a parallel set of ALU bus line, they would be shown.

The 8086 is a Complex Instruction Set Computer (CISC), where microcode inside processor is multi-purposed to get as much done using minimal memory.  Everything is operating in parallel.  It's not a matter of efficiency, but rather the decisions made by the designers within the technology of the day (1979).  No cache, no cores, 29000 transistors.

Prefetch/Execute queue:  Prefetch next sequential (n+1) instruction and execute present (n) instruction.

From MP and MC 8086 Microprocessor  



The 8086 uses pipelining with instruction fetching and execution running in parallel.

On the Execution side, published execution cycles refer to execution. 

Once it is in the 8086, a register-to-register ADD executes in 3  machine cycles.

ADD AX, BX

Clock Cycle 1: 16-bit AX transferred to Temp registers.

Clock Cycle 2: BX transferred to Temp registers.

Clock Cycle 3: ALU adds AX to BX and transfers result back to AX.  Flags are set based on result.

On the Bus Interface Unit: While the ADD instruction is being processed the BIU is attempting to fetch the next instruction, which is completely dependent on memory timing.

The 16-bit IP and the Code Segment Register work together to point to a 20-bit address in a 64kbyte segment in memory to fill up the instruction queue.

Due to locality, the next instruction should be sequential.  But any branch will trash the queue because it is fetching the next sequential instruction, which is not correct.  Once the queue is trashed, the processor stalls while the next instruction is fetched.

Essentially, all Instruction Pointers are +1 counters.  This has to be the case since the Prefetch queue has to fetch the n+1 instruction.

But there are two types of math involved with the IP.  


Precompiled math from the program compiler (Call sub-routine), where address is hard-coded in advanced (no ALU).  
Relative branching, where the execution of the instruction requires math (BNE +3) so IP is loaded into ALU, math is performed, result is loaded into IP.  The Prefetched instruction is ignored (pipeline stalls - no execution) and next instruction pointed to by new IP is loaded into pipeline. 


The flags are set by the contents of the present ALU calculation.  So they have to be available to be tested by the ALU (in the next cycle).

CMP AX, 10  // Flags are set.

BNE Here    // Check flags and Branch if AX &lt;> 10, 

// otherwise continue to next instruction.