assembly - Why did the compiler put an instruction after the MIPS "j" instruction that returns from a function?

Question

I'm looking at some compiler output for a MIPS platform and struggling to understand how a function returns and what is allowable.

Here's a simple example:

int two_x_squared(int x)
{
    return 2*x*x;
}

If I compile it with Compiler Explorer I see

two_x_squared(int):
        sll     $2,$4,1
        mult    $2,$4
        mflo    $2
        j       $31
        nop

OK, no big deal here, I'm guessing j $31 jumps to the return address, and the nop might be something required to protect against speculative execution in the pipeline.

But then I compile with XC32 under -O2 and I get

two_x_squared:
    mul $4,$4,$4
    j   $31
    sll $2,$4,1

So... the line after the j $31 gets executed after the jump?!

Answer 1

This is called the branch delay slot.  Yes, the branch actually executes one instruction later than you would expect, and the compiler is supposed to fill the delay slot with something useful — by moving something done logically before the branch into that slot, or by moving something that would happen after the branch into that slot.

This was introduced into the original MIPS architecture (as well as HP PA RISC, others) to help with pipelined processors, as they have to drain and refill the pipeline on taken branches, which wastes instruction cycles.

The feature has been removed in later MIPS processors as well as the follow on open-source RISC V hardware.  More modern hardware uses other approaches to mitigate the wasted cycles associated pipeline refill, including branch prediction, some out of order execution, speculation, executing branches earlier in the pipeline.