Microsoft Word - Document1

Que 1:
    stack address
    stack value
    iteration
    rsp
    rbx
    rdi
    eax
    80
    U
    Initial
    80
    
    5
    
    78
    A
    1
    78
    5
    2
    
    70
    B
    2
    70
    2
    1
    
    68
    W
    3
    68
    1
    0
    1
    60
    X
    4
    60
    0
    0
    0
    58
    Y
    5
    58
    0
    0
    0
    50
    N
    6
    50
    0
    0
    0
    48
    P
    7
    48
    0
    0
    1
    40
    H
    8
    40
    0
    1
    0
    38
    I
    9
    38
    1
    2
    1
    30
    J
    10
    30
    2
    5
    2
    28
    K
    11
    28
    5
    U
    3
    20
    L
    final
    20
    
    
    
Explanation:
1. The initial values of the stack pointer (rsp) and the register rdi are set to 0x80 and 5, respectively.
2. The function enters the first iteration of the recursion with x equal to 5. The current values of the stack pointer, rbx, and rdi are pushed onto the stack. rbx is set to x (i.e., 5), and the least significant bit of x (i.e., 1) is obtained and stored in eax. Then, x is shifted one bit to the right.
3. The function recursively calls pcount_r with the new value of x (i.e., 2). When this call returns, the result (i.e., 1) is added to eax.
4. The function returns to the previous iteration, and the stack pointer, rbx, and rdi are restored to their previous values.
5. The value of eax is returned to the caller of pcount_r(5), which is the initial call.
Steps 2-4 are repeated for the remaining values of x until the function reaches the base case where x is equal to 0. At this point, the function returns 0 and the recursion unwinds.
The table values are obtained by tracing the values of the stack pointer, rbx, rdi, and eax as the function executes. The iteration column indicates the number of times the function has recursively called itself. The stack value column shows the value of the memory location pointed to by the stack pointer. The final value of eax is the return value of the function.
Que 2:
(i)
When x = 4, the unknown function is called twice with the following parameters:
· The first time it's called with the parameter 4.
· The second time it's called with the parameter 2.
Here's a step-by-step explanation of what the code does:
· The value of x is passed in the register %rdi and stored at %rbp-24.
· The code then checks if %rbp-24 is greater than 1. If it is, the code subtracts 1 from %rbp-24, passes it as a parameter to unknown, and stores the return value in %rbx.
· After the unknown function returns, the code subtracts 2 from %rbp-24, passes it as a parameter to unknown, and adds the return value from the previous call to %rbx.
· Finally, the code adds 24 to %rsp and restores the registers before returning.
(ii)
When x = 3, the code will make two iterations of the unknown function, including the very first one.
Here's a step-by-step explanation of what the code does:
· The value of x is passed in the register %rdi and stored at %rbp-24.
· The code then checks if %rbp-24 is greater than 1. Since it's not, the code jumps to .L3.
· At .L3, the code...