Interpreting Floating Binary for Printing in Assembly
Post
Cancel

# Interpreting Floating Binary for Printing in Assembly

### Splitting of REAL4 Binary

As we know that the binary of single precision float contains 1 sign bit, 8 exponent bit and 22 mantissa bit.

### Sign Bit

For extracting sign bit we have to shift number, 31 times to right.

``````.data
num REAL4 -1.5
.code
mov eax, num
shr eax, 31
; eax = 1 then num is negative
; eax = 0 then num is positive.
``````

### Exponent

For extracting exponent from REAL4 binary, we will first shift the number 23 times to right and then we will set all other bit to 0 except bit 0-7, with the help of AND instruction.

``````.data
num REAL4 -1.5
.code
mov eax, num
shr eax, 23
and eax, 0FFh
; Now eax will contain exponent
; you can access it in al as well.

sub al, 127 ; for further processing
``````

For getting appropriate value from these bit you would have to subtract -127 from the extracted exponent bits.

### Mantissa

We can extract mantissa from the number, with the help of a simple AND instruction, then we will set all the bit from 22-31 by 0 and keep the rest of the mantissa bits as it is.
In this case we won’t need shifting.

``````.data
num REAL4 -1.5
.code
mov eax, num
and eax, 07FFFFFh
; eax not contain 22 bit mantissa
``````

### Printing of floating

Sign: You must be kidding. (Print ‘+’ if sign bit is 0 else print ‘-‘)

#### Calculating Mantissa value (Value after point)

Let say we have 8 bit REAL number, with 3 exponent bit and 4 bits mantissa. In this case we will have exponent max value of 7 and mid value 3

Num = 1 100 0100 (-3.50000)
Sign = 1
Exp = 100
Mantissa = 0100

Getting integer value from mantissa
Exp = 4 – 3 = 1

Now for further processing we will add 1 in starting of mantissa like this: 1.0100
And then move point as per exponent value, then we will get 11.100, then
We can simply print left value of mantissa which is equal to 3 but the problem is with 100 right bit in mantissa which is 100, if we simply look at them, then they are equal to 4 but this is not the case. It is equal to 0.5000

For solving this issue we calculate in a following way:
We will first take the right most bit then get its power of 2 which is in this case equal to 2^1 = 2.
You should know that REAL4 numbers can only give precise 10 digit value and others are in power. That is why our dividend will be 1000000000

Mantissa Right Bit 1 0 0 0
Power 2 (2^1) 4 (2^2) 8 (2^3) 16 (2^4)

Note: We are not dealing with 2^-1 which is the normally we do on paper.

1000/2 = 500
We can print it like .500
We can change value of dividend to 1000000 for REAL4 case. Or equal to 2^22 aligned to zero like 4194304 to 1000000.

Let say we have mantissa: 1110

Mantissa Right Bit 1 1 1 0
Power 2 (2^1) 4 (2^2) 8 (2^3) 16 (2^4)

1000/2 = 500
1000/4 = 250
1000/8 = 125

Result = 500 + 250 + 125 = 875
Which we can write as 0.875

#### Example Comparision Table

Power of 2 Division by 1 (floating number) Division by 1000 (integer number)
2 1/2 = 0.5000 1000/2 = 500
4 1/4 = 0.2500 1000/2 = 250
8 1/8 = 0.1250 1000/2 = 125

Hope I conveyed the logic behind the printing of Floating number. I had spend two days to grab this concept. I would love to hear from you.

There are more thing to handle like Infinity, NAN and exceeding exponent but those can be deal later.

My Implementation:
https://gist.github.com/soachishti/b4bf2f55b99ef123a1a3

Irvine Lib Implementation (WriteFloat):
https://gist.github.com/soachishti/a4d7bb15ee6519f61c0a