CMSC216 Lab05: Basic Assembly Coding

                           _________________

                            LAB05 QUESTIONS
                           _________________


Exercise Instructions
=====================

  Follow the instructions below to experiment with topics related to
  this exercise.
  - For sections marked QUIZ, fill in an (X) for the appropriate
    response in this file. Use the command `make test-quiz' to see if
    all of your answers are correct.
  - For sections marked CODE, complete the code indicated. Use the
    command `make test-code' to check if your code is complete.
  - DO NOT CHANGE any parts of this file except the QUIZ sections as it
    may interfere with the tests otherwise.
  - If your `QUESTIONS.txt' file seems corrupted, restore it by copying
    over the `QUESTIONS.txt.bk' backup file.
  - When you complete the exercises, check your answers with `make test'
    and if all is well. Create a zip file and submit it to Gradescope
    with `make submit'. Ensure that the Autograder there reflects your
    local results.
  - IF YOU WORK IN A GROUP only one member needs to submit and then add
    the names of their group on Gradescope.


PROBLEM 1 Background on asmbasics
=================================

  The `asmbasics_*' files allow for the construction of two executables
  which can be built via `make'.

  ,----
  | >> make
  | ...
  | >> ./asmbasics_c_only             # C only version, asmbasics_main.c and asmbasics_funcs.c
  | Let's explore Euclid's formula!
  | ...
  | 
  | >> ./asmbasics_mixed              # Mixed C/Assmebly version: asmbasics_main.c and asmbasics_funcs_asm.s
  | Let's explore Euclid's formula!
  | ...
  `----

  Both executables will do the same thing.
  - Accept to integer on the command line
  - Demonstrate a simple numerical relationship that Euclid worked out
    in the BC era.

  The intent of studying them is to get acquainted with how x86-64
  assembly instructions work by observing C code and equivalent assembly
  code then writing some assembly code that is equivalent to existing C
  code.

  Demoers will tour the slightly odd looking C code in
  `asmbasics_funcs.c' which are very short, arithmetically oriented
  functions. The code is written in an unusual style but one which
  matches the basic arithmetic operations that x86-64 Assembly
  instructions carry out making it easier to see the connection between
  C code and the provided assembly code. These appear in
  `asmbasics_funcs_asm.s' which is an x86-64 assembly source file.

  To pass automated tests, coders will need get a basic understanding of
  how assembly looks and works and then complete the TODO function in
  `asmbasics_funcs_asm.s'.


PROBLEM 1 QUIZ on asmbasics
===========================

  The function code in `asmbasics_funcs.c' looks a little odd because
  - ( ) It uses only operators like +=, *=, -= and so forth
  - ( ) It sets up an `ans' variable in each function to return a value
    rather than just returning something like a+b
  - ( ) Only two variables are used in any arithmetic expression;
    statements like `a = b+c;' do not appear
  - ( ) Actually all of these things are done and while readable, it
    seems inelegant

  On inspecting three provided assembly functions `difference, squared,
  squared_sum' in `asmbasics_funcs_asm.s', these show how many arguments
  and give them names by
  - ( ) Similar to C, they have a prototype like `difference(edi,esi)'
    which shows the registers storing the arguments but not their types
  - ( ) The parameter names are listed below the functions which looks a
    bit strange
  - ( ) They don't list how many and where parameters come in; it's the
    same for all functions and listed in documentation at the top of the
    file without anything in the function code giving clues about it
  - ( ) Trick question: it's actually not possible to pass parameters
    directly in assembly functions

  The equivalent of the `ans' variable used as the return variable in
  the C functions is this thing in x86-64 assembly:
  - ( ) The %eax register
  - ( ) The ret instruction
  - ( ) The %edi register
  - ( ) The addl instruction

  Which of the following is a valid sequence of instructions that will
  complete the `squared_diff' assembly function?
  ,----
  | squared_diff:
  |         movl  %eax, %edi              # (A)
  |         imull %edi, %edi
  |         imull %esi, %esi
  |         subl  %esi, %edi
  |         ret   %edi
  | 
  | squared_diff:
  |         movl  %edi, %eax              # (B)
  |         imull %eax, %eax
  |         imull %esi, %esi
  |         subl  %esi, %eax
  |         ret
  | 
  | squared_diff:
  |         movl  %eax, %edi              # (C)
  |         imull %eax, %eax 
  |         imull %esi, %esi 
  |         subl  %eax, %esi 
  |         ret
  | 
  | squared_diff:
  |         movl  %edi, %eax              # (B)
  |         imull %eax, %eax
  |         imull %esi, %esi
  |         subl  %esi, %eax
  |         ret   %eax
  `----
  - ( ) A
  - ( ) B
  - ( ) C
  - ( ) D


PROBLEM 1 CODE Complete asmbasics_funcs_asm.s
=============================================

  Complete the TODO portions of the code in `asmbasics_funcs_asm.s' and
  run the provided tests. The output should be identical to the behavior
  given when the C versions are run. Experiment with these two
  executables and compare their behavior if in doubt:
  - `asmbasics_c_only' : compiled with C code for main and functions
  - `asmbasics_mixed' : compiled with C code for main and assembly code
    for functions

  Test that the code behaves correctly via the command
  ,----
  | make test-prob1
  `----


PROBLEM 2 QUIZ: Assembly Functions
==================================

  Answer the following questions on basic techniques for assembly
  function coding.

  How are the first 6 arguments to an assembly functions made available
  within the function?
  - ( ) Arguments are passed in registers; the first two are in the
    `%rax' and `%rbx' registers
  - ( ) Arguments are passed in registers; the first two are in the
    `%rdi' and `%rsi' registers
  - ( ) Arguments are in the stack; the first two are available using
    the stack pointer as `0(%rsp)' and `8(%rsp)'
  - ( ) Arguments are in the stack; the first two are available using
    the stack pointer as `8(%rsp)' and `12(%rsp)'

  Which of the following best describes how the kind of arguments passed
  to the FIRST function `set_coins()' function in assembly?
  - ( ) An integer in `%edi' and a pointer to a struct in `%rsi'; to
    get/set fields of the struct syntax like `2(%rsi)' is used
  - ( ) An integer in `%edi' and a packed struct in `%rsi'; to get/set
    fields of the struct bitwise shifts and AND operations are used
  - ( ) An integer in `%esi' and a pointer to a struct in `%rdi'; to
    get/set fields of the struct syntax like `2(%rsi)' is used
  - ( ) An integer in `%esi' and a packed struct in `%rdi'; to get/set
    fields of the struct bitwise shifts and AND operations are used

  Which of the following best describes how the kind of arguments passed
  to the SECOND function `total_coins()' function in assembly?
  - ( ) A pointer to a struct in `%rsi'; to get/set fields of the struct
    syntax like `2(%rsi)' is used
  - ( ) A packed struct in `%rsi'; to get/set fields of the struct
    bitwise shifts and AND operations are used
  - ( ) A pointer to a struct in `%rdi'; to get/set fields of the struct
    syntax like `2(%rsi)' is used
  - ( ) A packed struct in `%rdi'; to get/set fields of the struct
    bitwise shifts and AND operations are used


PROBLEM 2 CODE: Complete coins_funcs_asm.s
==========================================

  Complete the two assembly functions in `coins_funcs_asm.s'. Note that
  until both functions are complete, the tests will likely fail. Correct
  output will appear something like the following:
  ,----
  | >> make
  | ...
  | 
  | >> ./coins_main 88
  | set_coins():
  | 88 cents is...
  | 3 quarters
  | 1 dimes
  | 0 nickels
  | 3 pennies
  | total_coins():
  | which is 88 cents
  `----

  Make sure to complete both assembly functions and test them via
  ,----
  | make test-prob2
  `----