Clemson University -- CPSC 231 -- Fall 2009

Example of a four-module program where separate assembly is managed by the
  Unix make utility


                    m4               as                 ld
                                  (gcc -c)             (gcc)

        main.m --------> main.s --------> main.o ------.
                                                        \
        memzero.m -----> memzero.s -----> memzero.o ----.\
                                                         >--> popf
        popcount.m ----> popcount.s ----> popcount.o ---'//
                                                        //
        prttable.m ----> prttable.s ----> prttable.o --'/
                                                       /
                                          printf stub '

----

% cat makefile
OBJS = main.o memzero.o popcount.o prttable.o
ASMS = main.s memzero.s popcount.s prttable.s

popf:   $(OBJS)
        gcc -gstabs $(OBJS) -o popf

main.o: main.m
        m4 main.m >main.s
        gcc -gstabs -c main.s

memzero.o: memzero.m
        m4 memzero.m >memzero.s
        gcc -gstabs -c memzero.s

popcount.o: popcount.m
        m4 popcount.m >popcount.s
        gcc -gstabs -c popcount.s

prttable.o: prttable.m
        m4 prttable.m >prttable.s
        gcc -gstabs -c prttable.s

cleanup:
        /usr/bin/rm $(OBJS) $(ASMS)

----

"make" is name of the command; it expects a file named "makefile" to be
  present in the current directory

a makefile is composed of a set of "rules"

        <dependency line>                (must start in column 1)
                <action line>                (must start with a tab)
        ...
        <dependency line                (rules may have multiple actions)
                <action line>
                <action line>
        ...

a rule begins with a dependency line, which lists file dependencies
        <label>: <required files>
where label is (usually) the name of a file that depends on other files

if the timestamp on the dependent file is older than any of the timestamps
  of the files in the required list, make will reconstruct the dependent
  file using the action lines (i.e., it will apply the rule)

the assignments at the top of the makefile are macro definitions; the macro
  names used below will be replaced with the definitions; by convention
  macro names are capitalized; macro defs can cross lines by using \

by default, make will apply the first dependency rule in the file; however,
  you can enter a label on the command line and that dependency rule will
  be applied

empty dependencies can be defined, such as "cleanup" above, where the label
  is not a file name but a mnemonic for some commands to be run (i.e., the
  action lines are executed when the user types in make with that label)
empty dependencies are always considered out-of-date

comments start with # and run to the end of the line




cat % main.m
/* Clemson University -- CPSC 231 -- Fall 2000
 * example program for 231
 * mark smotherman, april 1999
 *
 *  process a (static) block of instructions and determine the frequencies
 *  of number of bits equal to one for the instruction words in that block.
 *  (i.e., perform population counts on the instruction words and determine
 *  the popcount frequencies.)  print the frequency table of entries from 0
 *  (= no bits equal to one) to 32 (= all bits equal to one).
 *
 *  input (from main to end of this program)
 *  -- note these addresses are assembler and OS dependent --
 *  -- you may get slightly varied addresses and bit patterns --
 *
 *    assembly statement      bit pattern in memory             pop count
 *    ("x/30i main" in gdb)   ("x/30tw main" in gdb)
 *    ----------------------  --------------------------------    --
 *    save  %sp,-96,%sp       10011101111000111011111110100000    19
 *    sethi %hi(0x21800),%o0  00010001000000000000000010000110     5
 *    or    %o0,0x2d0,%o0     10010000000100100010001011010000     9
 *    mov   0x84,%o1          10010010000100000010000010000100     7
 *    call  memzero           01000000000000000000000000011010     4
 *    nop                     00000001000000000000000000000000     1
 *    sethi %hi(0x10800),%l0  00100001000000000000000001000010     4
 *    or    %l0,0x33c,%l0     10100000000101000010001100111100    11
 *    sethi %hi(0x21800),%l1  00100011000000000000000010000110     6
 *    or    %l1,0x2d0,%l1     10100010000101000110001011010000    11
 *    sethi %hi(0x10800),%l3  00100111000000000000000001000010     6
 *    or    %l3,0x3b4,%l3     10100110000101001110001110110100    15
 *    ld    [%l0],%o0         11010000000001000000000000000000     4
 *    call  popcount          01000000000000000000000000011110     5
 *    nop                     00000001000000000000000000000000     1
 *    sll   %o0,2,%o0         10010001001010100010000000000010     8
 *    ld    [%l1+%o0],%l2     11100100000001000100000000001000     7
 *    inc   %l2               10100100000001001010000000000001     7
 *    st    %l2,[%l1+%o0]     11100100001001000100000000001000     8
 *    add   %l0,4,%l0         10100000000001000010000000000100     5
 *    cmp   %l0,%l3           10000000101001000000000000010011     7
 *    bne   loop              00010010101111111111111111110111    24
 *    nop                     00000001000000000000000000000000     1
 *    sethi %hi(0x21800),%o0  00010001000000000000000010000110     5
 *    or    %o0,0x2d0,%o0     10010000000100100010001011010000     9
 *    mov   0x21,%o1          10010010000100000010000000100001     7
 *    call  prttable          01000000000000000000000000011011     5
 *    nop                     00000001000000000000000000000000     1
 *    ret                     10000001110001111110000000001000    11
 *    restore                 10000001111010000000000000000000     6
 *
 *  output
 *    0: 0
 *    1: 4
 *    2: 0
 *    3: 0
 *    4: 3
 *    5: 5
 *    6: 3
 *    7: 5
 *    8: 2
 *    9: 2
 *    10: 0
 *    11: 3
 *    12: 0
 *    13: 0
 *    14: 0
 *    15: 1
 *    16: 0
 *    17: 0
 *    18: 0
 *    19: 1
 *    20: 0
 *    21: 0
 *    22: 0
 *    23: 0
 *    24: 1
 *    25: 0
 *    26: 0
 *    27: 0
 *    28: 0
 *    29: 0
 *    30: 0
 *    31: 0
 *    32: 0
 *
 *  Rather than performing an important function, this program is more of a
 *  teaching tool for assembly language programming:
 *
 *  1) illustrates separate assembly and use of makefile
 *       main.m     - main program
 *       memzero.m  - pass address and byte count of block to be zeroed
 *       popcount.m - population count
 *       prttable.m - pass address and word count of table to print
 *       makefile   - describes dependencies among program modules and
 *                    gives compiling steps and linking step
 *     note that each module uses the local label "loop" without confusion
 *     and that each of the three subroutines use the label "done"
 *
 *  2) illustrates four different types of loops
 *       main.m     - pointer incremented until limit value reached
 *                    ptr = &main; repeat{ ...; ptr++; }until( ptr == end );
 *       memzero.m  - pointer incremented and loop count decremented until
 *                    loop count reaches zero
 *                    ptr = addr; i = count; while(i>0){ ...; ptr++; i--; }
 *       popcount.m - value left shifted until zero
 *                    repeat{ value = value << 1; ...; }until( value == 0 );
 *       prttable.m - pointer incremented and loop index incremented until
 *                    loop index reaches loop count
 *                    ptr = addr; for(i=0;i<count;i++){ ...; ptr++; }
 *
 *  3) illustrates storage of instructions in memory as bit patterns and
 *     access of those same memory locations as both instructions and data
 *       main.m - fetches and executes instructions from main to end
 *       main.m - reads memory words from main to end as data and passes to
 *                popcount subroutine
 *
 *  4) illustrates access of same memory locations as both bytes and words
 *       memzero.m  - clears (i.e., sets to zero) table, byte-by-byte
 *       prttable.m - prints table, word-by-word
 */

        .global        main
        .global memzero,popcount,prttable

main:
        save        %sp,-96,%sp

/*  initialize the bit count table by calling memzero
 *    pass: %o0 address of table "bctab"
 *          %o1 byte count of table = 33*4 = 132
 *    no return values
 */

        set        bctab, %o0
        mov        132,   %o1
        call        memzero
         nop

/*  perform popcount on each instruction between "main" and ""end"
 *  and increment appropriate entry in bit count table
 *    reg. usage: %ptr_r   - %l0 instruction pointer, initialized to main
 *                %base_r  - %l1 base address of bit count table
 *                %ent_r   - %l2 copy of entry in bit count table
 *                %limit_r - %l3 limit address, set to end
 */

define(`ptr_r',   l0)
define(`base_r',  l1)
define(`ent_r',   l2)
define(`limit_r', l3)

        set  main,  %ptr_r
        set  bctab, %base_r
        set  end,   %limit_r
loop:
        ld   [%ptr_r], %o0            ! load instruction bit pattern into %o0
        call popcount                 ! call popcount with inst. word %o0,
         nop                          !   count returned in %o0

        sll  %o0, 2, %o0              ! prepare index into word-oriented table
                                      !   by multiplying by 4 (or sll by 2)

        ld   [%base_r + %o0], %ent_r  ! load table entry
        add  %ent_r, 1, %ent_r        ! increment count
        st   %ent_r, [%base_r + %o0]  ! store entry back into table

        add  %ptr_r, 4, %ptr_r        ! move inst. ptr. to next inst.

        cmp  %ptr_r, %limit_r         ! test against addr. limit
        bne  loop
         nop

/*  print the bit count table by calling prttable
 *    pass: %o0 address of table "bctab"
 *          %o1 word count of table = 33
 *    no return values
 */

        set  bctab, %o0
        mov  33,    %o1
        call prttable
         nop

        ret
         restore
end:


/* bit count table
 *   since there can be 0 - 32 bits turned on in a word, there must
 *   be 33 entries in the table.  if each entry is allocated as a word,
 *   then 33*4 = 132 bytes must be allocated.
 */

       .section ".bss"
bctab: .skip 132

% cat memzero.m
/* example 231 module                                mark smotherman, april 1999
 *
 *   memory cleared (set to zero) - zero a given number of bytes
 *
 *   input parameters:
 *     %i0 (%o0 in caller) - starting address of block to be cleared
 *     %i1 (%o1 in caller) - byte count of block
 *
 *   return value and other output parameters:
 *     none
 *
 *   effect/output:
 *     area of memory set to zeros
 *
 *   typical calling sequence:
 *     set  addr,  %o0
 *     mov  count, %o1          (or use  set count,%o1  if count > 4095)
 *     call memzero
 *     nop
 *
 *   local register usage:
 *     %ptr_r - %l0 - byte pointer, initialized to starting address of block
 *     %cnt_r - %l1 - byte count, initialized to input value
 */     

define(`ptr_r',l0)
define(`cnt_r',l1)

        .global memzero
memzero:
        save %sp,-96,%sp

        mov  %i0, %ptr_r        ! copy starting address
        mov  %i1, %cnt_r        ! copy count

loop:
        cmp  %cnt_r, 0          ! quit when count down to zero
        ble  done
         nop

        stb  %g0, [%ptr_r]      ! set byte to zero
        add  %ptr_r, 1, %ptr_r  ! increment byte pointer

        sub  %cnt_r, 1, %cnt_r  ! decrement byte count
        ba   loop
         nop
done:
        ret
         restore

% cat popcount.m
/* example 231 module                                mark smotherman, april 1999
 *
 *   population count - count the number of one bits in a word
 *
 *   input parameter:
 *     %i0 (%o0 in caller) - word for which pop count desired
 *
 *   return value:
 *     %i0 (%o0 in caller) - pop count
 *
 *   other output parameters:
 *     none
 *
 *   effect/output:
 *     none apart from return value
 *
 *   typical calling sequence:
 *     mov  value, %o0          (or use  set value,%o0  if value > 4095)
 *     call popcount
 *     nop
 *
 *   local register usage:
 *     %work_r - %l0 - working copy of input
 *     %popc_r - %l1 - pop count, initialized to zero
 */     

define(`work_r',l0)
define(`popc_r',l1)

        .global popcount
popcount:
        save  %sp,-96,%sp

        clr   %popc_r                 ! initialize counter
        mov   %i0, %work_r            ! copy input

/* main loop - executes at least one time and up to 32 times if there is
 * a one in the least significant bit, that is the loop count is
 *   min( 1 , 32-(# trailing zeros) )
 */

loop:
        addcc %work_r, %work_r, %work_r   ! add and set condition codes;
                                          ! equiv. to a sll with shifting
                                          ! leftmost bit into the carry
                                          ! condition code

        addx  %popc_r, %g0, %popc_r   ! add with carry into count
                                      ! (for a tight loop, this inst.
                                      ! could go in the delay slot)

        bne   loop                    ! exit loop when only zeros are left
         nop
done:
        mov   %popc_r, %i0            ! copy count to provide as output parm.
        ret
         restore

% cat prttable.m
/* example 231 module                                mark smotherman, april 1999
 *
 *   print table - print index values and entries of a word-oriented table
 *
 *   input parameters:
 *     %i0 (%o0 in caller) - starting address of table
 *     %i1 (%o1 in caller) - word count of table
 *
 *   return value and other output parameters:
 *     none
 *
 *   effect/output:
 *     table is printed
 *
 *   typical calling sequence:
 *     set  addr,  %o0
 *     mov  count, %o1          (or use  set count,%o1  if count > 4095)
 *     call prttable
 *     nop
 *
 *   local register usage:
 *     %ptr_r - %l0 - word pointer, initialized to starting address of table
 *     %ndx_r - %l1 - index, initialized to zero
 *     %cnt_r - %l2 - word count, set to input value
 */     

define(`ptr_r',l0)
define(`cnt_r',l1)
define(`ndx_r',l2)

        .global prttable

prttable:
        save %sp,-96,%sp

        mov  %i0, %ptr_r         ! copy starting address
        mov  %i1, %cnt_r         ! copy count

        clr  %ndx_r              ! clear index

loop:
        cmp  %ndx_r, %cnt_r      ! quit when index reaches count
        bge  done
         nop

        set  ptfmt,    %o0       ! call printf with format address
        mov  %ndx_r,   %o1       !   in %o0, index value in %o1, and
        ld   [%ptr_r], %o2       !   table entry in %o2
        call printf
         nop

        add  %ptr_r, 4, %ptr_r   ! increment word pointer

        add  %ndx_r, 1, %ndx_r   ! increment index
        ba   loop
         nop
done:
        ret
         restore

        .section ".data"
ptfmt:  .asciz "%d: %d\n"