Floating Point Numbers

We will use RARS for this lab. Working with floating numbers is quite different than working with integers. In RISC-V, the F extension adds support for 32 bit floating point numbers (single precision). There is also an extension (D) that supports 64 bit floating point numbers (double precision). The simulator (RARS) implements commands from both extensions. Thus, for the lab, we have 64 bit registers available and can refer to them as 32 or 64 bit values. The registers are named f0, f1, ... f31, but also have aliases such as argument registers fa0, fa1, saved registers fs0, fs1, and temporary registers ft0, ft1. Below, you will see how we load, store, and manipulate floating point numbers.

Part 1

The following line shows how we would assign a label to a floating point value. Notice that the value contains a decimal point.


    FP_value: .float  1.23

We have seen how to print integer values, such as this code:


    # Load the value at my_value, then print it
    la    x10, my_value
    lw    a0, 0(x10)
    li    a7, 1
    ecall

You might expect that printing floating point values is a matter of simply loading "FP_value" into a0 and using ecall 1, as we did with an integer, but that does not give a correct result. We need to use the flw command, and load the value into fa0. Notice that the ecall number is 2 now.


    # Load the value at FP_value, then print it
    la      x10, FP_value
    flw     fa0, 0(x10)     # Load 32-bit F.P. number into fa0
    li       a7, 2          # print a float
    ecall

Implement the code from above, try it out, and verify that it works.

Questions

What are the differences in the commands between specifying and printing a floating-point value ("FP_value") versus an integer (called "my_value")? Explain what is the same and what is different, line by line.
Suppose that we use dlw in place of flw. Do we get the same result? Explain.
If you load the value at FP_value as an integer, then print it out as an integer, what happens? Explain what you observe.

Part 2

Put two float values (2.15 and 3.35) in registers, add them, and display the result. Recall the flw command from the previous example. Then, use the fadd.s command to add two floating numbers. Finally, to print the result you need to follow the ecall of previous example.


    fadd.s f2, f0, f1  # f2 = f0 + f1, single precision
    # ...
    fmv.s  fa0, f2    # copy the value to print

Before printing the value, write it to memory with the fsw command. Implement this, and show that it works.

Questions

Why is the fadd.s command different from add? Why do we have ".s" after it, and what does it stand for?
When you use the store command (fsw), how does it know the number of bits to write? Experiment with this by putting non-zero values in neighboring memory locations, and testing if the values are changed.

Part 3

Load 2 FP values (1.7 and 32.4), add them together, and print the result.


    .data       # Data section, initialized variables
    FP_values: .float  1.7, 32.4
    FP_result: .word  0

Implement this code, and run it. Verify that it works.

Questions

Why do you think the result is 34.100002 instead of 34.1?

Part 4

Next, add "val1" to "val2", store the result in "result", and display the result.


    val1:   .float 3.64
    val2:   .word  5
    result: .word  0

To accomplish this, you will need to convert a floating point value to an integer. Use a size with the larger range (float) for the calculations, then convert the result to an int. This means that you will need to convert the val2 integer to a floating point value.


    fcvt.s.w  fa0, a1        # convert a1's int value to FP 
    # ...
    fcvt.w.s   a0, fa0       # convert fa0's FP value to int

Questions

Use the "fmv.x.w" command (which is the same as the "fmv.x.s" command) for moving an integer value to a floating-point register, then print it as shown below.
```
        li      x11, 2
        fmv.s.x fa0, x11    # Move x11's value to fa0
        li       a7, 2      # print a float
        ecall
```
What result do you get, and why?
MATLAB shows that value 5.6 has an internal representation of 0x40b33333. Suppose that you define a floating point value as:
```
    hex_value: .word 0x40b33333
```
If you load that as a floating point value and print it out, do you get 5.6? Why or why not?

In this lab, we have learned:

how we store and manipulate the floating point numbers
that there is a special "mv" command for floating point numbers
that there are special commands for adding (and subtracting) floating point numbers
that the computer cannot perform arithmetic operations with an integer and a floating point value directly
how to convert integer and floating point values