1IntroductionThis project will feel somewhat familiar in that it is nearly identical to the preceding project: there is a coding problem and a puzzle-solving problem. The major change is that...

The files to be submitted for this problem include

• 
  
  
  clock_update.c: C version of the functions




• 
  
  
  clock_update_asm.s: Assembly version of the functions

Graders may examine these for a correspondence between to the algorithm used in the C version to the Assembly version. Compiler generated assembly often does significant re-arrangements of assembly code with many intermediate labels that hand-written code will not have.

If you were not able to complete the C functions for the Project 2 or were not confident in your solutions,


see a course staff member who will help you get them up and running quickly.

Comment your assembly code A LOT. While good C code can be quite self-explanatory with descriptive variable names and clear control structures, assembly is rarely so easy to understand. Include clear commentary on your assembly. This should include

• Subdividing functions into smaller blocks with comments describing what the blocks accomplish.




• Descriptions of which "variables" from the C side are held in which registers.




• Descriptions of most assembly lines and their effect on the variables held in the registers.




• Descriptions of any data such as bitmasks stored in the assembly code.




• Use informative label names like.ROUNDING_UPto convey further meaning about what goals certain positions in code are accomplishing.

While it is a slow instruction that is cumbersome to set up, usingidivXdivision instruction is the most human-readable means to compute several results needed in the required functions. Compiler generated code uses many tricks to avoid integer division so a lack ofidivXinstructions along this line will be a clear sign little effort has been put into the assembly code.

.text                           # IMPORTANT: subsequent stuff is executable .global  set_tod_from_ports          ## ENTRY POINT FOR REQUIRED FUNCTION set_tod_from_ports:         ## assembly instructions here          ## a useful technique for this problem         movX    SOME_GLOBAL_VAR(%rip), %reg  # load global variable into register                                              # use movl / movq / movw / movb                                              # and appropriately sized destination register  ### Data area associated with the next function .data                           # IMPORTANT: use .data directive for data section  my_int:                         # declare location an single int         .int 1234               # value 1234  other_int:                      # declare another accessible via name 'other_int'         .int 0b0101             # binary value as per C '0b' convention  my_array:                       # declare multiple ints in a row          .int 10                 # for an array. Each are spaced         .int 20                 # 4 bytes from each other         .int 30   .text                           # IMPORTANT: switch back to executable code after .data section .global  set_display_from_tod  ## ENTRY POINT FOR REQUIRED FUNCTION set_display_from_tod:         ## assembly instructions here  ## two useful techniques for this problem         movl    my_int(%rip),%eax    # load my_int into register eax         leaq    my_array(%rip),%rdx  # load pointer to beginning of my_array into rdx   .text .global clock_update          ## ENTRY POINT FOR REQUIRED FUNCTION clock_update: ## assembly instructions here

int set_tod_from_ports(tod_t *tod); // Reads the time of day from the TIME_OF_DAY_PORT global variable. If // the port's value is invalid (negative or larger than 16 times the // number of seconds in a day) does nothing to tod and returns 1 to // indicate an error. Otherwise, this function uses the port value to // calculate the number of seconds from start of day (port value is // 16*number of seconds from midnight). Rounds seconds up if there at // least 8/16 have passed. Uses shifts and masks for this calculation // to be efficient. Then uses division on the seconds since the // begining of the day to calculate the time of day broken into hours, // minutes, seconds, and sets the AM/PM designation with 1 for AM and // 2 for PM. By the end, all fields of the `tod` struct are filled in // and 0 is returned for success.  //  // CONSTRAINT: Uses only integer operations. No floating point // operations are used as the target machine does not have a FPU.

// Breaks time down into 12-hour format typedef struct{   int   day_secs;    // seconds from start of day   short time_secs;   // seconds in current hour   short time_mins;   // minutes in current hour   short time_hours;  // current hour of day   char  ampm;        // 1 for am, 2 for pm } tod_t;

1. The function one argument: a pointer to a struct which will be in registerrdi.




2. Return values or functions are to be placedeaxfor 32 bit quantities as is the case here (int).




3. 
   
   
   

   To access a global variable and copy it into a register, use the following assembly syntax

   
   
   
   
   
   
   
   

   
   
   
   movl  TIME_OF_DAY_PORT(%rip), %ecx    # copy global var to reg ecx
   
   

   
   
   
   
   
   
   
   

   The function should not changeTIME_OF_DAY_PORTso copying it to a register is among the first steps to perform.

   
   
   
   




4. Use comparisons and jump to a separate section of code that is clearly marked as "error" if you detect a bad arguments.




5. Make use of shift / mask operations to convert the port value to the number of seconds from the beginning of the day. Use the remainder value to determine if seconds should round up or not.




6. Make use of division to "break down" the argumenttime_secs. Keep in mind that theidivlinstruction must haveeaxas the dividend,edxzeroed out via acqtoinstruction. Any 32-bit register can contain thedivisor. After the instruction,eaxwill hold thequotientandedxthe remainder. With cleverness, you'll only need to do a couple divisions.




7. 
   
   
   

   A pointer to atod_tstruct can access its fields using the following offset table which assume that%regholds a pointer to the struct (substitute an actual register name).

   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   

   		Destination	Assembly
   C Field Access	Offset	Size	Assign 5 to field
   tod->day_secs	0 bytes	4 bytes	movl $5, 0(%reg)
   tod->time_secs	4 bytes	2 bytes	movw $5, 4(%reg)
   tod->time_mins	6 bytes	2 bytes	movw $5, 6(%reg)
   tod->time_hours	8 bytes	2 bytes	movw $5, 8(%reg)
   tod->ampm	10 bytes	1 byte	movb $5,10(%reg)

   
   
   
   

   You will need to use these offsets to set the fields of the struct near the end of the routine.

   
   
   
   

int set_display_from_tod(tod_t tod, int *display); // Accepts a tod and alters the bits in the int pointed at by display // to reflect how the LCD clock should appear. If any time_** fields // of tod are negative or too large (e.g. bigger than 12 for hours, // bigger than 59 for min/sec) or if the AM/PM is not 1 or 2, no // change is made to display and 1 is returned to indicate an // error. The display pattern is constructed via shifting bit patterns // representing digits and using logical operations to combine them. // May make use of an array of bit masks corresponding to the pattern // for each digit of the clock to make the task easier.  Returns 0 to // indicate success. This function DOES NOT modify any global // variables

1. Arguments will be
   
   
   
   
   • a packedtod_tstruct in%rdiand%rsi
     
     
     
   
   
   
   
   • an integer pointer in%rdx
     
     
     
   
   
   
   
   
   
   
   




2. 
   
   
   

   The packedtod_tstruct is spread across two registers,%rdiand%rsiso will have the following layout.

   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   

   		Bits	Shift
   C Field Access	Register	in reg	Required	Size
   tod.day_secs	%rdi	0-31	None	4 bytes
   tod.time_secs	%rdi	32-47	Right by 32	2 bytes
   tod.time_mins	%rdi	48-63	Right by 48	2 bytes
   tod.time_hours	%rsi	0-15	None	2 bytes
   tod.ampm	%rsi	16-23	Right by 16	1 bytes

   
   
   
   

   To access individual fields of the struct, you will need to do shifting and masking to extract the values from the%rdi / %rsiregisters.

   
   
   
   




3. Use comparisons and jump to a separate section of code that is clearly marked as "error" if you detect bad fields in thetodstruct argument.




4. 
   
   
   

   As was the case in the C version of the problem, it is useful to create a table of bit masks corresponding to the bits that should be set for each clock digit (e.g. digit "1" has bit patter0b0000110). In assembly this is easiest to do by using a data section with successive integers. An example of how this can be done is below.

   
   
   
   
   
   
   
   

   
   
   
   .section .data    array:                          # an array of 3 ints            .int 200                # array[0] = 200            .int 300                # array[1] = 300            .int 400                # array[3] = 400    const:            .int 17                 # special constant         .section .text    .globl func    func:            leaq array(%rip),%r8    # r8 points to array, rip used to enable relocation            movq $2,%r9             # r9 = 2, index into array            movl (%r8,%r9,4),%r10d  # r10d = array[2], note 32-bit movl and dest reg            movl const(%rip),%r11d  # r11d = 17 (const), rip used to enable relocation
   
   

   
   
   
   
   
   
   
   

   Adapt this example to create a table of useful bit masks for digits. The GCC assembler understands binary constants specified with the0b0011011style syntax.

   
   
   
   




5. Make use of division again to compute "digits" for the ones and tens place of the hours and minutes for the clock. Use these digits to reference into the table of digit bit masks you create to progressively build up the correct bit pattern for the clock display.




6. Use shifts and ORs to combine the digit bit patterns to create the final clock display bit pattern.

int clock_update(); // Examines the TIME_OF_DAY_PORT global variable to determine hour, // minute, and am/pm.  Sets the global variable CLOCK_DISPLAY_PORT bits // to show the proper time.  If TIME_OF_DAY_PORT appears to be in error // (to large/small) makes no change to CLOCK_DISPLAY_PORT and returns 1 // to indicate an error. Otherwise returns 0 to indicate success. // // Makes use of the previous two functions: set_tod_from_ports() and // set_display_from_tod(). //  // CONSTRAINT: Does not allocate any heap memory as malloc() is NOT // available on the target microcontroller.  Uses stack and global // memory only.

1. No arguments come into the function.




2. 
   
   
   

   Call the two previous functions to create the struct and manipulate the bits of an the display. Calling a function requires that the stack be aligned to 16-bytes; there is always an 8-byte quantity on the stack (previous value of therspstack pointer). This means the stack must be extended with apushqinstruction before any calls. A typical sequence is

   
   
   
   
   
   
   
   

   
   
   
   subq    $8,%rsp      # extend the stack by 8 bytes    call    some_func    # stack aligned, call function    ## return val from func in rax or eax    addq    $8,Rsp       # restore the stack    ## NOTE: the above provides 8 bytes on the stack for local    ## variables; in the likely event that more space in stack is    ## needed, a bigger stack extension should be done but the stack    ## should always be grown by 16*N+8 bytes if calling another    ## function as this ensures proper alignment.
   
   

   
   
   
   
   
   
   
   




3. 
   
   
   

   If several function calls will be made, a single stack extension is all that is needed. needed as in the below

   
   
   
   
   
   
   
   

   
   
   
   subq    $8,%rsp     # extend once    call    some_func1  # stack aligned, call function    ## return val from func in rax or eax     ## do some more stuff     call    some_func2  # stack aligned, call function    ## return val from func in rax or eax     addq     $8,%rsp    # restore the stack
   
   

   
   
   
   
   
   
   
   




4. In order to call theset_tod_from_ports()function, this function will need to allocate space on the stack for atod_t. This struct is 12 bytes big so at least that amount of memory will need be available in the stack for use. Since there are also function calls required, grow the stack by16*N+8bytes for a non-negative value ofN.




5. Similarly, to call theset_display_from_tod()function, one will need a packedtod_tin a register. If the precedingset_tod_from_ports()call succeeded, this packed struct can be read from memory into registers with severalmovqinstructions. That stack space can re-used if needed.




6. Keep in mind that you will need to do error checking of the return values from the two functions: if they return non-zero values jump to a clearly marked "error" section and return a 1. If an error occurs,don't forget to pop restore registers and the stack pointer before returning.
   
   
   

> ./bomb Initialization error: illegal host 'ck-laptop'. Legal hosts are as follows:   csel-apollo   csel-atlas   csel-vole-01   csel-vole-02   ...

• Ensure that the score listed on theScoreboard sitereflects your progress.




• Ensure yourinput.txtalong with yourbombNN/directory are in your project directory with the rest of your code.