Department of Computer Science

Institute of Business Administration, Karachi

Lab #7: Floating Point Instructions in RISC-V

Assembly

Computer Architecture & Assembly Language

March 18, 2024

Course Instructor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Salman Zaffar

Lab Instructor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Mehwish Zafar
Week Performed . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . : Week 10
Room . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . MTL4

1 Introduction
This lab introduces the floating point instructions available in RISC-V instruction set ar-
chitecture and how it works in number system.

2 Introduction to Floating-Point Numbers

Floating-point numbers are a way to represent real numbers in computers. Unlike integers,
which can represent whole numbers, floating-point numbers allow representation of fractional
numbers and very large or very small numbers with a high degree of precision. Floating-
point numbers are widely used in scientific and engineering applications where precision and
a wide range of values are required.

2.1 How floating-point numbers work:

The idea is to compose a number of two main parts:

• A significand that contains the number’s digits. Negative significands represent nega-
tive numbers.

1
 • An exponent that says where the decimal (or binary) point is placed relative to the
beginning of the significand. Negative exponents represent numbers that are very
small (i.e. close to zero).
Such a format satisfies all the requirements:
• It can represent numbers at wildly different magnitudes (limited by the length of the
exponent).
• It provides the same relative accuracy at all magnitudes (limited by the length of the
significand).
• It allows calculations across magnitudes: multiplying a very large and a very small
number preserves the accuracy of both in the result.

2.2 Representation of Floating-Point Numbers:

Floating-point numbers are typically represented using three components: sign, exponent,
and mantissa (also known as significand or fraction). The general form of a floating-point
number is:

1. Sign: Represents the sign of the number (positive or negative). It is usually repre-
sented using one bit, where 0 represents positive and 1 represents negative.
2. Mantissa: Represents the significant digits of the number. It is a binary fraction
that follows the sign bit. The mantissa contains the significant digits of the number,
including the fractional part.
3. Exponent: Represents the scale or magnitude of the number. It determines the
position of the decimal point relative to the beginning of the mantissa. The exponent
is usually biased to allow for both positive and negative exponents.

2.3 IEEE 754 Standard:

Nearly all hardware and programming languages use floating-point numbers in the same
binary formats, which are defined in the IEEE 754 standard. The usual formats are 32 or
64 bits in total length:

2
 Note that there are some peculiarities:
• The actual bit sequence is the sign bit first, followed by the exponent and finally the
significand bits.
• The exponent does not have a sign; instead an exponent bias is subtracted from it
(127 for single and 1023 for double precision). This, and the bit sequence, allows
floating-point numbers to be compared and sorted correctly even when interpreting
them as integers.
• The significand’s most significant digit is omitted and assumed to be 1, except for
subnormal numbers which are marked by an all-0 exponent and allow a number range
beyond the smallest numbers given in the table above, at the cost of precision.
• There are separate positive and a negative zero values, differing in the sign bit, where
all other bits are 0. These must be considered equal even though their bit patterns
are different.
• There are special positive and negative infinity values, where the exponent is all 1-bits
and the significand is all 0-bits. These are the results of calculations where the positive
range of the exponent is exceeded, or division of a regular number by zero.
• There are special not a number (or NaN) values where the exponent is all 1-bits
and the significand is not all 0-bits. These represent the result of various undefined
calculations (like multiplying 0 and infinity, any calculation involving a NaN value,
or application-specific cases). Even bit-identical NaN values must not be considered
equal.
If this seems too abstract and you want to see how some specific values look like in IEE 754,
try the Float Toy, or the IEEE 754 Visualization.

2.4 Example:
Let’s consider the single-precision floating-point number format. Suppose we have the fol-
lowing binary representation:

Sign bit: 0, Exponent: 10000010, Mantissa: 11010011000000000000000

Given Binary Representation:

• Sign bit: 0 (positive)

• Exponent: 100000102 = 13010 (biased by 127)
• Mantissa: 1.110100110000000000000002 (leading bit implied)

Interpretation:
• Sign bit: Since the sign bit is 0, the number is positive.

• Exponent: The exponent value is 130 - 127 = 3.

3
 • Mantissa: The value of mantissa is 1.110100110000000000000002 , including the im-
plied leading bit.
• Final Value: 1.110100110000000000000002 ×2(130−127) = 1.110100110000000000000002 ×
23 = 14.5937510

This example demonstrates how a floating-point number is represented and interpreted

according to the IEEE 754 standard.

3 RISC-V Floating Point Extension

The RISC-V architecture defines optional floating-point extensions called RVF, RVD, and
RVQ for operating on single-, double-, and quad-precision floating-point numbers, respec-
tively. RVF/D/Q define 32 floating-point registers, f0 to f31, with a width of 32, 64, or
128 bits, respectively. When a processor implements multiple floating-point extensions, it
uses the lower part of the floating-point register for lower-precision instructions. f0 to f31
are separate from the program (also called integer) registers, x0 to x31. As with program
registers, floating-point registers are reserved for certain purposes by convention, as given in
Figure 1. Figure 3 lists all of the floating-point instructions. Computation and comparison
instructions use the same mnemonics for all precisions, with .s, .d, or .q appended at the end
to indicate precision. For example, fadd.s, fadd.d, and fadd.q perform single-, double-, and
quad-precision addition, respectively. Other floating-point instructions include fsub, fmul,
fdiv, fsqrt, fmadd (multiply-add), and fmin. Memory accesses use separate instructions for
each precision. Loads are flw, fld, and flq, and stores are fsw, fsd, and fsq.

4
Figure 1: Floating-Point Register Set

Figure 2: Coding Example

5
 Figure 3: RISC-V Floating Point Extension

4 Laboratory Tasks
Write a RISC-V code to calculate the value Pi using Nilkantha’s series using floating-point
instructions.

4.1 Task Explanation

Pi is an irrational number having non-recurring decimal values. We commonly know Pi =
3.14 or Pi = 22/7, but it is just an approximation for our ease. One way to calculate it can
be given using Nilkantha’s series. It is given by:
4 4 4
π =3+ − + − ...
2×3×4 4×5×6 6×7×8

6
Below is example C code for the calculation of PI using Nilkantha’s series.

// C code to implement the above approach

# include < stdio .h >

// Function to calculate PI
double calculatePI ( double PI , double n ,
double sign )
{
// Add for 1000000 terms
for ( int i = 0; i <= 1000000; i ++) {
PI = PI + ( sign * (4 / (( n ) * ( n + 1)
* ( n + 2) ) ) ) ;

// Addition and subtraction

// of alternate sequences
sign = sign * ( -1) ;

// Increment by 2 according to formula

n += 2;
}

// Return the value of Pi

return PI ;
}

// Driver code
void main ()
{

// Initialise sum =3 , n =2 , and sign =1

double PI = 3 , n = 2 , sign = 1;

// Function call
printf (" The approximation of Pi is %0.8 lf \ n " , calculatePI ( PI , n ,
sign ) ) ;
}

// OUTPUT
// The approximation of Pi is 3.14159265

7
4.2 RISC-V Equivalent Code
4.2.1 Write an equivalent RISC-V code in Venus and try to get as many correct
decimal digits as possible through efficient coding. Refer to the exam-
ple given in lab along with single and double precision floating point
instructions table.

/***** Code in RISC - v ****/

addi t0, zero, 3

addi t1, zero, 2
addi t2, zero, 1
#PI=3, n = 2, sign = 1
addi s0, zero, 0
li s1, 10000
addi s2, zero, 4
fcvt.s.w fs2, s2
addi t3, zero, -1
fcvt.s.w ft3, t3
fcvt.s.w ft2, t2
fcvt.s.w ft0, t0

for:
bge s0, s1, end
addi t3, t1, 2
addi t4, t1, 1
mul t5, t3, t4
mul t6, t5, t1
fcvt.s.w ft6, t6
fdiv.s fs0, fs2, ft6
fmul.s fs1, ft2, fs0
fadd.s ft0, ft0, fs1
fmul.s ft2, ft2, ft3
addi t1, t1, 2
addi s0, s0, 1
j for
end:

8
 /**********************************************************/

4.2.2 Paste the screenshots of both Integer and Floating Registers Section
highlighting the values of used registers.