CMPT 295

• Lecture 16 – Midterm 1 Review Session

Go over Rounding - Lecture 6 Slide 13:

Rounding

1. Round up
2. Round down
3. Round half way -> when bits to right of rounding position are $\text{100\dots 0}_{2}$
   • Round to even number: produces 0 as the least significant bit of rounded result.

Example: Round to nearest $1/4$ (2 bits right of binary point):

The third bit after the binary point is the 24th bit. Imagine the second bit as bit 23 of frac of IEEE.

Assignment 3 Question 1 a. iii

Transcriber’s note: the rounding bit will be highlighted by spelling out the number instaed of using the 0/1 characters

frac: $1100 \space 1100 \space 1100 \space 1100 \space 1100 \space 11\text{zero}0 \space \overline{1100}$

Assignment 3 Question 1 a. iv

frac: $0101 \space 0101 \space 0101 \space 0101 \space 0101 \space 01\text{zero} \space \overline{101}$

Assignment#2 Question 2 g., h., i., k.

g. What is the “range” (not contiguous) of fractional decimal numbers that can be represented using this 6-bit floating-point representation?

“range” of real numbers $[-14.0\dots 14.0]$ not considering $\pm\infty$ and NaN (since it’s not a contiguous range)

h. What is the range of the normalized exponent E (E found in the equation $v=\text{(-1)}^{s} M 2^{E}$) which can be represented by this 6-bit floating representation?

Range of $E \rightarrow [-2\dots 5]$ is the same as $\text{exp} \rightarrow [001\dots 110]$

Denormalized exponent E:

i. Give an example of a fractional decimal number that can be represented using this 6-bit floating-point representaetion, but is within the “range” of representable values.

11.0 cannot be represented but it is within the range.

From lecture 6 Slide 15

What does Epsilon mean? A small positive quantity.

1. the 5th letter of the Greek alphabet — see Alphabet Table. 2: an arbitrarily small positive quantity in mathematical analysis.

• exp and frac: interpreted as unsigned values.
• if frac = 000…0 -> M = 1.0
• if frac = 111…1 -> $M = 2.0 - \epsilon$ (where $\epsilon$ means a very small value)

k. How close is the value of the frac of the largest normalized number to 1? In other words, how close is M to 2, i.e.What is E (epsilon) in this equation: $1\leq M \lt 2 - \epsilon$? Express E as a fractional decimal number.

First, let’s fix the above equation $1 \leq M < 2 - \epsilon$. It should be $1 \leq M < 2$.

Remember:

• $$1.0 \leq M < 2.0$$
• $$1.0 \leq M \leq 2.0 - \epsilon$$
• $$1.0 \leq (1 + \text{frac}) \leq 2.0 - \epsilon$$
• $$0.0 \leq \text{frac} \leq 1.0 - \epsilon$$

answer:

The value of “frac” of the largest denormalized number is $\text{.11} = 3/4 = \text{0.75}_{10}$

How close is the value of the “frac” of the largest normalized number to $1 = 1/4 = \text{0.25}_{10}$

Assignment#3 Question 1

1) [10 points] Memory addressing modes – Marked by Aditi

Assume the following values are stored at the indicated memory addresses and registers.

Imagine the operands in the table below are the Src (source) operands for some unspecififed assembly instructions (any instruction except lea*), fill in the following table with the appropriate answers.

Note: We do not need to know what the assembly instructions are in order to fill the table.

Still using the first table listed above displaying the value stored at various memory addresses and registers, fill in the following tables with three different Src (source) operands for some unspecififed assembly instructions (any instructions except lea*). For each row, this operand must result in the operand Value listed and must satified the Operand Form listed.

Other answers are possible!

Assignment#3 Question 2

2) [2 marks] Machine level instructions and their memory locations – Marked by Aditi

Consider a function called arith, defined in a file called arith.c and called from the main function found in the file called main.c.

This function arith, performs some arithmatic manipulation on three parameters.

Compiling main.c and arith.c files, we create an executable called ar, then we execute the command:

objdump -d ar > arith.objdump

We display the partial content of arith.objdump below. The file arith.objdump is the disassembled version of the executable file ar.

Your task is to fill in its missing parts, which have been underlined:

0000000000400527 <arith>:
  400527:   48 8d 04 37       lea   (%rdi,%rsi,1)
  40052b:   48 01 d0          add   %rdx,%rax
  40052e:   48 8d 0c 76       lea   (%rsi,%rsi,2),%rcx
  400532:   48 c1 e1 04       shl   $0x4,%rcx
  400536:   48 8d 54 0f 04    lea   0x4(%rdi,%rcx,1),%rdx
  40053b:   48 0f af c2       imul  %rdx,%rax
  40053f:   c3                retq

Assignment#4 Question 2

In the assembly code, there are a lot more steps than in the C code, so how to match them and create the C code.

Consier the following assembly code:

# long func(long x,int n)
# x in %rdi, n in %esi, result in %rax

func:
  movl %esi,%ecx
  movl $1,%edx
  movl $0,%eax
  jmp cond
loop:
  movq %rdi,%r8
  addq %rdx,%r8
  orq %r8,%rax
  salq %c1,%rdx # shift left %rdx by content of %c1*
cond:
  testq %rdx,%rdx # %rdx <- %rdx & %rdx
  jne loop # jump if not zero (when %rdx & %rdx != 0)
  ret # faill thru to ret (when %rdx & %rdx == 0)

Hand tracing code!

From our Lectures 14 and 15

Example pt.1 in C

// multstore is caller
// x is %rdi
// y is %rsi
// dest is %rdx
void multstore(long x, long y, long *dest) {
  long t = mult2(x, y);
  *dest = t;
  return;
}

Example pt.2 in C:

// mult2 callee
// a is %rdi
// b is %rsi
long mult2(long a, long b) {
  long s = a * b;
  return s;
}

Example pt.1 in assembly:

0000000000400540 <multstore>:
  400540: push %rbx # Save %rbx (1)
  400541: mov %rdx,%rbx # Save dest (2)
  400544: callq 400550 <mult2> # mult2(x,y) (3)
  400549: mov %rax,(%rbx) # Save at Dest (7)
  40054c: pop %rbx # Restore %rbx (8)
  40054d: retq # Return (9)

Example pt.2 in assembly:

0000000000400550 <mult2>:
  400550: mov %rdi,%rax # a (4)
  400553: imul %rsi,%rax # a*b (5)
  400557: retq # Return (6)

Example – Steps 1 and 2

Registers:

Example – Steps 3 and 4

Registers:

Example – Steps 5 and 6

Registers:

Example – Steps 7, 8 and 9

Registers:

Next next lecture

• Introduction
  • C program -> assembly code -> machine level code
• Assembly language basics: data, move operation
  • Memory addressing modes
• Operation leaq and Arithmetic & logical operations
• Conditional Statement – Condition Code + cmovX
• Loops
• (highlighted) Function call – Stack – Recursion
  • Overview of Function Call
  • Memory Layout and Stack - x86-64 instructions and registers
  • Passing control
  • (highlighted) Passing data – Calling Conventions
  • Managing local data
  • Recursion
• Array
• Buffer Overflow
• Floating-point operations