Clemson University -- CPSC 231 -- Fall 2009


Verifying that you are on a SPARC - use "uname -p" or "mach"


Unix assembler is called "as" -- it has a two-pass structure but no macros
  (can use m4 or cpp for macros); Gnu assembler is called "gas"


  statement syntax

        <label:>        mnemonic_opcode         operands        ! comments

  also C-style comments (i.e., /* */) are acceptable


  other statements, called "pseudo-ops", are available to control the
    assembler's actions or to specify data

                        .section ".data"
                        .global        <label>
        <label:>        .word        <argument(s)>    ! could be several


  registers are indicated by a percent sign ("%")

  register usage (p. 52)
        ____________________________________
        %g0 == %r0  (always zero)           \
        %g1 == %r1                          | g stands for global
        ...                                 |
        %g7 == %r7                          |
        ____________________________________/
        %o0 == %r8                          \
        ...                                 | o stands for output (note: not 0)
        %o6 == %r14 == %sp (stack ptr)      |
        %o7 == %r15 == for return address   |
        ____________________________________/
        %l0 == %r16                         \
        ...                                 | l stands for local (note: not 1)
        %l7 == %r23                         |
        ____________________________________/
        %i0 == %r24                         \
        ...                                 | i stands for input
        %i6 == %r30 == %fp (frame ptr)      |
        %i7 == %r31 == for return address   |
        ____________________________________/


  assembly code must be translated into binary machine code, called object
    code, which must then be linked and loaded to run

               assembler        linker       loader

        file.s---------->file.o------->a.out------->memory image

                        (object)     (executable)    (program loaded
                                                      and running)


  gcc -S program.c -- generates assembly language from "program.c" and places
                        assembly code in file named "program.s"

  gcc -gstabs program.s -- generates executable file named "a.out" by calling
                        the assembler and linker
                      ( -gstabs tells compiler to keep symbol table for gdb)

  gcc -gstabs program.s -o program -- generates executable named "program"
                      ( -o flag give name of executable instead of a.out)


           -------gcc calls these in order--------
          /                                       \

          cpp         ccom         as        linker     loader

   prog.c ===> prog.i ===> prog.s ===> prog.o ===> a.out ===> memory image
           |           |           |
   source  |intermediate  assembly |   object    executable
    file   |   source  |   source  |    file       file
           |           |           |
           |           |           gcc -c writes prog.o and stops
           |           |
           |           gcc -S (i.e., capital S) writes prog.s and stops
           |
           gcc -E sends result of preprocessor to stdout



  skeleton for SPARC assembly language programs
  * execution always starts at the label "main" (just like C programs)
  * an initial save instruction provides a new register window
  * end by either trapping back to the operating system, or by a normal
      procedure exit of return and restore instructions

                .global main
        main:   save    %sp, -96, %sp
                ... other code ...
                mov     1, %g1
                ta      0

        (finish by trapping back to OS)

  or:

                .global main
        main:   save    %sp, -96, %sp
                ... other code ...
                ret
                 restore

        (since your program will linked to a startup routine that calls
        various initialization routines, then main, then exit - so main
        is actually a subroutine, and you can finish by returning to its
        caller)


  compile and execute steps:
        m4 file.m > file.s
        gcc -gstabs file.s -o file
        gdb file


               m4         ---- gcc ----       gdb
                         /             \
        file.m---->file.s---->file.o---->file---->in-memory


  notes:
  * if we use the C preprocessor macro language instead of m4, we can
    save source files as file.S - note the capital S - and gcc file.S
    would run cpp before running the assembler.  however, cpp does not
    provide for multi-line macro expansions; that is, even if the macro
    body has newlines (and continuation markers of \), cpp places the
    expanded body on a single line.  (there is an mlm patch for gcc
    2.7.2, but it is not installed locally.)
  * gcc file.m doesn't work since for gcc the .m suffix normally means
    an Objective C source file
  * the as assembler - but not gas - has -m and -P options to run either
    the m4 or cpp preprocessor before assembly


some details of SPARC assembly language

  standard formats

        <op>  src_reg, src_reg, dest_reg
        <op>  src_reg, immediate, dest_reg    ! -4096 <= immediate < 4096


  synthetic instructions (see appendix D)

        clr  reg                     =>  or  %g0, %g0, reg
        mov  immediate, dest_reg     =>  or  %g0, immediate, dest_reg
        mov  src_reg, dest_reg       =>  or  %g0, src_reg, dest_reg


  multiply and divide must be called as procedures on early SPARCs (p. 56)


  code from p. 62

        .global main
main:   save    %sp, -96, %sp
        mov     9, %l0          !initialize x
        sub     %l0, 1, %o0     !(x - 1) into %o0
        sub     %l0, 7, %o1     !(x - 7) into %o1
        call    .mul
         nop                    !result in %o0
        sub     %l0, 11, %o1    !(x - 11) into %o1, the divisor
        call    .div
         nop                    !result in %o0
        mov     %o0, %l1        !store it in y

        mov     1, %g1          !trap dispatch
        ta      0               !trap to system

partial execution trace of above

execution starts at 2290
2290 @ 0> 2668 @ 12> 
 address:instruction   cycle> 0  |1  |2  |3  |4  |5  |6  |7  |8  |9  |10 |11 |
    2290: save r14, 1fa0,r14  F   D   E   W   
    2294: or r0 ,    9,r16    .   F   D   E   W   
    2298: sub r16,    1,r8    .   .   F   D   E   W   
    229c: sub r16,    7,r9    .   .   .   F   D   E   W   
    22a0: call 2d8            .   .   .   .   F   D   E   W   
    22a4: sethi r0 , 0        .   .   .   .   .   F   D   E   W   
    2578: wry r8 ,r0 ,r0      .   .   .   .   .   .   F   D   E   W   
    257c: andncc r8 ,    f,r12.   .   .   .   .   .   .   F   D   E   W   
    2580: be e0               .   .   .   .   .   .   .   .   F   D   E   W   
    2584: sethi r13, 3fffc0   .   .   .   .   .   .   .   .   .   F   D   E   
    2660: mulscc r12,r9 ,r12  .   .   .   .   .   .   .   .   .   .   F   D   
    2664: mulscc r12,r9 ,r12  .   .   .   .   .   .   .   .   .   .   .   F   

  notes:
    2290: -96 in save inst. is encoded as signed 13-bit hex constant, 0x1fa0;
          %sp is shown as register r14
    2294: mov is synthetic assembly language inst. and is executed as an "or"
    22a0: call uses offset of 0x2d8 rather than absolute address of 0x2578
    22a4: nop is synthetic assembly language inst. and is executed as "sethi"
    2578: wry is first inst. in .mul subroutine, write to special Y register
    257c: -cc means set the condition codes for subsequent branch
    2580: be (branch on equal) uses offset of 0xe0 rather than absolute
          address of 0x2660


delayed branches (p. 59)

  pipelined implementation (F - fetch, D - decode, E - execute, W - write-back)
    with overlapped activity in the stages (visible in cycles 3-11 above)

  on branches, the target address isn't known until the end of the D stage

  pipelining led instruction set designers to choose to define a delay slot
    after each control transfer (call, branch) since the following instruction
    had already been fetched:

        1. execute instruction corresponding to %pc
        2. fetch next instruction corresponding to %npc
        3. then normally %pc = %npc, %npc += 4

    for branches corresponding to %pc go ahead and execute instruction
      corresponding to %npc

  two examples of delayed branches are in the trace above:

        >> watch changes in the inst. address <<
                                ----
        call .mul               22a0: call 2d8
         nop                    22a4: sethi r0,0 (synthetic inst. for nop)
        <now in .mul>           2578: wry r8,r0,r0

        ** you can and should fill delay slots with nop (unlike book's advice)

     inst addr
        ----
        2580: be e0                (a branch within the .mul routine)
        2584: sethi r13,3fffc0     (a filled delay slot)
        2660: mulscc r12,r9,r12    (at target of branch)


coding convention - indent one extra space for each delay slot instruction