Return address prediction stack buffer vs stack-stored return address?

by

Predictors are normally part of the fetch stage, in order to determine which instructions to fetch next. This takes place before the processor has decoded the instructions, and therefore doesn’t even know with certainty that a branch instruction exists. Like all predictors, the intent of the return address predictor is to get the direction / target of the branch faster. A return instruction is a branch, and so it would normally have a branch predictor entry to determine whether it is taken and where the target is. The return address predictor is consulted in lieu of the normal branch target buffer.

So perhaps 50 instructions before the return statement is actually “executed”, the fetch stage predicts a return instruction and the instruction address to fetch next. Later, when the return is executed, the address is read from the stack and compared with where the return was predicted to go. If they are the same, execution continues, else execution is rolled back to use the proper return address.

Why store on the stack? First, the processor does not know if the predictor has worked without comparing against the address stored on the stack. Second, the stack is the “official” return address, which might be changed for legitimate reasons. Third, the return address predictor has a limited number of entries. The stack is needed for the return instructions for which there was not room to store the addresses in the predictor.

More Related Contents:

  1. Why is the loop instruction slow? Couldn’t Intel have implemented it efficiently?
  2. Why is Skylake so much better than Broadwell-E for single-threaded memory throughput?
  3. Why is this SSE code 6 times slower without VZEROUPPER on Skylake?
  4. How are x86 uops scheduled, exactly?
  5. What happens after a L2 TLB miss?
  6. Branch alignment for loops involving micro-coded instructions on Intel SnB-family CPUs
  7. Why is XCHG reg, reg a 3 micro-op instruction on modern Intel architectures?
  8. 32-byte aligned routine does not fit the uops cache
  9. Size of store buffers on Intel hardware? What exactly is a store buffer?
  10. Which Intel microarchitecture introduced the ADC reg,0 single-uop special case?
  11. Why can’t my ultraportable laptop CPU maintain peak performance in HPC
  12. How are cache memories shared in multicore Intel CPUs?
  13. Do 128bit cross lane operations in AVX512 give better performance?
  14. What is the best way to set a register to zero in x86 assembly: xor, mov or and?
  15. Enhanced REP MOVSB for memcpy
  16. INC instruction vs ADD 1: Does it matter?
  17. Understanding the impact of lfence on a loop with two long dependency chains, for increasing lengths
  18. Is there a penalty when base+offset is in a different page than the base?
  19. What methods can be used to efficiently extend instruction length on modern x86?
  20. Are there any modern CPUs where a cached byte store is actually slower than a word store?
  21. Non-temporal loads and the hardware prefetcher, do they work together?
  22. Lost Cycles on Intel? An inconsistency between rdtsc and CPU_CLK_UNHALTED.REF_TSC
  23. Is using double faster than float?
  24. What’s the actual effect of successful unaligned accesses on x86?
  25. Assembly – How to score a CPU instruction by latency and throughput
  26. Unexpectedly poor and weirdly bimodal performance for store loop on Intel Skylake
  27. When should we use prefetch?
  28. Relative performance of x86 inc vs. add instruction
  29. Efficient sse shuffle mask generation for left-packing byte elements
  30. How can the rep stosb instruction execute faster than the equivalent loop?

Leave a Comment