Rayotaku's blog

Lecture 7 - RISC-V Functions

|
|
访问

Functions in Assembly and Function Calling Conventions and other stuff.

Review of Last Lecture

1

  • RISC Design Principles
    • Smaller is faster: 32 registers, fewer instructions
    • Keep it simple: rigid syntax
  • RISC-V Registers: , ,
  • Memory is byte-addressed

2

RISC-V Instructions

i = “immediate”(constant integer)

  • -Arithmetic: add, sub, addi, mult, div
  • -Data Transfer: lw, sw, lb, sb, lbu
  • -Branching: beq, bne, bge, blt, jal, j, jalr, jr
  • -Bitwise: and, or, xor, andi, ori, xori
  • -Shifting: sll, srl, sra, slli, srli, srai

Sign Extension

  • We want to take an 8-bit two’s complement number and make it a 9-bit number

​ 0b0000 0010 (+2) -> 0b0 0000 0010 (+2)

​ 0b1111 1110 (-2) -> 0b1 1111 1110 (-2)

Here, we replicate the most significant bit.

  • When doing math, immediate values are sign extended

​ addi t0, x0, -1 == addi t0, x0, 0xFFF

​ addi t0, x0, 0x0FF t0 -> [0x0000 00FF]

​ addi t0, x0, 0xF77 t0 -> [0xFFFF FF77]

  • Loading Sign Extension

For assembly, this happens when we pull data out of memory

Byte in memory: 0b1111 1110 (-2)

load byte -> Register contents: 0b 1111 1111 1111 1111 1111 1111 1111 1110

Normal(signed) loads sign extend the most significant bit

Memory: 0b1000 1111

​ Load Byte -> 0b1111 1111 1111 1111 1111 1111 1000 1111

Memory: 0b0000 1111

​ Load Byte -> 0b0000 0000 0000 0000 0000 0000 0000 1111

Offset loads also sign extend:

​ Memory = [0x00008011] (address in s0)

​ Assume system is little endian

​ lb t0, 0(s0) -> loading 0b00010001

​ 0b 0000 0000 0000 0000 0000 0000 0001 0001

​ lb t0, 1(s0) -> loading 0b10000000

​ 0b1111 1111 1111 1111 1111 1111 1000 0000

Unsigned loads do not sign extend, but rather fill with zeros:

​ lbu t0, 1(s0) -> loading 0b10000000

​ 0b0000 0000 0000 0000 0000 0000 1000 0000

C to RISC-V Practice

C code is as follows:

1
2
3
/* Copy string from p to q */
char *p, *q;
while ((*q++ = *p++) != '\0');

RISC-V:

1
2
3
4
5
6
7
8
9
#copy String p to q
#p->s0, q->s1 (char *pointers)
Loop: lb t0 0(s0)
			sb t0 0(s1)
			addi s0 s0 1
			addi s1 s1 1
			beq t0 x0 Exit
			j Loop
Exit: # N chars in p => N*6 instructions

Functions in Assembly

Six Steps of Calling a Function

  1. Put arguments in a place where the function can access them
  2. Transfer control to the function
  3. The function will acquire any(local) storage resources it needs
  4. The function performs its desired task
  5. The function puts return value in an accessible place and “cleans up”
  6. Control is returned to you

Example

1
2
3
4
5
6
7
8
9
10
void main(void) {					main:
  a = 3;							addi a0, x0, 3
  b = a + 1;							addi a1, a0, 1
  a = add(a, b);						jal ra, add
  ...												...
}

int add(int a, int b) {					add:
  return a + b;							add a0, a0, a1
}								jr ra

More Registers

  • a0-a7: eight argument registers to pass parameters
  • a0-a1: two registers to return values
  • sp: “stack pointer”
    • — Holds the current memory address of the “bottom” of the stack

How do we Transfer Control?

  • Jump(j)
    • j label
  • Jump and Link(jal)
    • jal dst label
  • Jump and Link Register(jalr)
    • jar dst src imm
  • “and Link”: Saves the location of instruction in a register before jumping
  • Jump Register(jr)
    • jr src
  • ra = return address register, used to save where a function is called from so we can get back

Function Call Example

1
2
3
4
5
... sum(a, b); ...			/* a->s0, b->s1 */

int sum(int x, int y) {
  return x + y;
}

​ C

​ RISC-V

1
2
3
4
5
6
7
1000		addi a0 s0 0		#x = a
1004 		addi a1 s1 0		#y = b
1008		jal ra sum		#ra = 1012, goto sum
1012
...
2000		sum: add v0 a0 a1
2004 		jr ra

J is a pseudo-instruction explained

  • jal syntax: jal dst label
  • You supply the register used to link
    • When calling a function you use ra
  • What happens if you specify x0?
    • jal x0 label
    • x0 always contains 0, so attempts to write to it do nothing
    • So jal x0 label is just jumping without linking
  • j label is a pseudo-instruction for jal x0 label
    • Similarly jr is a pseudo-instruction for jalr following the same idea

Calling Convention

Example: sumSquare

1
2
3
int sumSquare(int x, int y) {
	return mult(x, x) + y;
}
  • What do we need to save?
    • Call to mult will overwrite ra, so save it
    • Reusing a1 to pass the second argument to mult, but need current value (y) later, so save a1

Calling Conventions

  • CalleR: the calling function
  • CalleE: the function being called
  • Register Conventions: A set of generally accepted rules as to which registers will be unchanged after a procedure call(jal) and which may have changed

Each register is one of the two types:

  • Caller saved
    • The callee can use them freely (if needed, the caller had to save them before invoking and will restore them afterward)
  • Callee saved
    • The callee function must save them before modifying them, and restore them before returning (avoid using them at all, and no need to save)

Saved Registers(Callee Saved)

  • These registers are expected to be the same before and after a function call

    • If calleE uses them, it must restore values before returning
    • This means save the old values, use the registers, then reload the old values back into the registers

    NOTICE: If the calleR is using the saved registers, and calleE also wants to use them. CalleE should “save” the saved registers by putting them on the stack. It’s calleE’job, not calleR’s job!!!!

  • s0-s11(saved registers)

  • sp(stack pointer)

The RISC-V assembly code implementing the example C code above:

1
2
3
4
5
6
7
8
9
10
11
12
13
sumSquare:
#push
				addi sp	sp	-8		#make space on stack
				sw	ra	4(sp)			#save ra address
				sw	a1	0(sp)			#save y
				add a1	a0	x0		#set second mult arg
				jal	mult					#call mult
#pop	
				lw	a1	0(sp)			#restore y
				add a0	a0	a1		#ret val = mult(x, x) + y
				lw 	ra	4(sp)			#get ret addr
				addi sp	sp	8			#restore stack
mult:...

Basc Structure of a Function

1
2
3
4
5
6
7
8
9
10
11
12
13
14
Prologue
			func_label:
			addi	sp,	sp,	-framesize
			sw	ra,	<framesize - 4>(sp)
			#store other callee saved registers	(by caller)
			#save other registers if need be (by callee)
Body			(call other functions)
...
Epilogue
			#restore other registers if need be (by callee)
			#restore other callee saved registers (by caller)
			lw	ra,	<framesize - 4>(sp)
			addi	sp,	sp,	framesize
			jr ra

Summary

  • One more time for luck:
    • CalleR must save any volatile registers it is using onto the stack before making a procedure call
    • CalleR can trust saved registers to maintain values
    • CalleE must “save” any saved registers it intends to use by putting them onto the stack before overwriting their values
  • Note:
    • CalleR and calleE only need to save the appropriate registers when they are using(not all!!!)
    • Don’t forget to restore the values later