A word on function calls and returns

If you've read my previous post about control hazards, you may have noticed that I talked about branches and jumps, but did not write a single word about function call or return instructions. This omission may be a bit surprising if you are not familiar with RISC-V or architectures with a similar instruction set.

The reason is that JAL (jump and link) and JALR (jump and link register) already cover these use-cases, because both of them can store the address of the instruction following the jump (PC+4) into the destination register. The register x0 can be used as the destination when that return address is not needed. Remember, x0 is the zero register, it is always equal to zero and writes to it are always discarded.

start:
  jal   x0, somewhere   ; direct jump, discard return address
  ...

somewhere:
  jal   x1, f           ; call function f, save return address into x1
  ...

f:
  ...
  jalr  x0, 0(x1)       ; Return to the address x1 (and no offset)

But seriously, don't you find that a bit... unreadable?

The convention set by the proposed ABI is to use register x1 as the return address, this register being refered to as ra. There are also pseudo-instructions that the programmer can use to take advantage of these conventions.

The same code using pseudo-instructions and register alias would look like this. Note that it is 100% equivalent to the snippet above and expands to the exact same instructions.

start:
  j     somewhere       ; unconditional direct jump
  ...

somewhere:
  jal   ra, f           ; call function f
  ...

f:
  ...
  ret                   ; Return from subroutine

Using a register instead of the stack to store the return address (as is the case in the x86 family, for instance) has several advantages.

First, it simplifies the design of the processor a lot, keeping it true to the Load/Store architecture.

Second, it can make the code more efficient, as it is now up to the subroutine to determine if the return address needs to be pushed onto the stack, or if it can simply be left in a register when there are no nested calls. Especially in our case, where the Fetch and Memory units cannot both access the RAM during the same cycle.

Finally, although the convention is to use x1, nothing stops you from using any other register to save the return address. The official specification even suggests using x5 as an alternate return address for millicode routine calls to common prologue and epilogue code for functions. Of course, the subroutine that is called must also know which register has been used, in order to return to the correct address!

Now you know why I didn't mention call and ret in the previous article: they are actually just plain jumps.

Other articles

Control hazards with jumps and branches

Mon 03 April 2023
By Amand Tihon

In Electronics.

tags: RiscV

I've talked about the data hazards in a previous installment, now let's talk about control hazards. A control hazard is when we need to find the destination of a jump or a branch and can't fetch any new instruction until this destination is known.

When a branch instruction is fetched …
read more
I want a hardware multiplier

Tue 05 July 2022
By Amand Tihon

In Electronics.

tags: RiscV

I'm currently working on the data multiplexer, the part that comes between the CPU and the memory and is responsible for putting the right byte at the right place, but I can't stop thinking about what comes next.

And let me tell you, there's still quite a lot of development …
read more
Of data hazards, bypasses and stalls
Tue 28 June 2022
By Amand Tihon

In Electronics.

tags: RiscV

Remember that a data hazard occurs when an instruction waits for the result of a previous instruction.

In the following example:
```
        add a0, t0, t1         ; a0  ←  t0 + t1
        sub a1, a0, t2         ; a1  ←  a0 + t2
```
the add instruction stores the result into register a0 when it reaches the Writeback stage …
read more
Astorisc: The simulation begins

Mon 09 May 2022
By Amand Tihon

In Electronics.

tags: RiscV

These last few weeks, I've been working on implementing the CPU in Digital.

My initial intention was to stay as close as possible to what will be the actual implementation, but in practice, it may not have been a good idea, because it didn't always play well with the simulation …
read more
Just a few components ordered

Thu 14 April 2022
By Amand Tihon

In Electronics.

tags: RiscV

I had some components to buy at Mouser for an unrelated project, but my order wasn't going to reach 50€ and I wouldn't get free shipping...

So I added a few of nearly every logic gate from the AUC family in the basket. These are like the usual 74 LS …
read more
Astorisc: Building blocks and components

Tue 29 March 2022
By Amand Tihon

In Electronics.

tags: RiscV

Throughout the entire processor, there are a few basic building blocks that will be used in various places. Let's have a look at some of them.

Registers

By far, the block that we'll use the most is the register. Not only in the register file, but also between each stage …
read more
Astorisc: The pipeline stages and hazards

Tue 18 January 2022
By Amand Tihon

In Electronics.

tags: RiscV

I would like to go more into detail about each stage of the pipeline, what they do and how they work. I know I said in the previous installment that I would not go into the details of hazards, but it looks like I will need it to document my …
read more
Astorisc architecture overview: pipeline

Sun 10 October 2021
By Amand Tihon

In Electronics.

tags: RiscV

This article is mostly a high-level overview of the Astorisc architecture, do not expect implementation tricks and gory details in here.

As I said in the presentation, I'd like to make Astorisc a pipelined processor. But what does this actually mean? I could send you to the article on Wikipedia …
read more
A RISC-V processor from logic circuits

Wed 22 September 2021
By Amand Tihon

In Electronics.

tags: RiscV

Now that BB-88 is more or less complete, let me tell you about another project that has been on my mind for a few years now: a homebrew computer featuring a RISC-V processor made of 74 series logic.

There are already a few projects to make a RISC-V processor from …
read more

Other articles

Registers