SPARC Assembly Language
Mark Smotherman
Clemson University


Unix assembler is called "as" -- it has a two-pass structure but no macros
  (first pass builds symbol table, second pass translates into object code)
  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
	____________________________________
	%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 -g program.s -- generates executable file named "a.out" by calling the
			assembler and linker
                      ( -g flag tells compiler to keep symbol table for gdb)

  gcc -g 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
           |           |           |
           |           |           V
           |           |           gcc -c writes prog.o and stops
           |           V
           |           gcc -S (i.e., capital S) writes prog.s and stops
           V
           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

  or:

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


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


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


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


  example code from Paul text

	.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

  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)


gdb commands

  q -- quit
  r -- run
  b -- set breakpoint
  c -- continue from breakpoint
  x -- examine (needs /<format>)	x/i $pc
  p -- print register contents
  ni -- single step execution
  si -- single step execution, follows calls
  disassemble
  display  -- done at each prompt
  commands -- done at specific breakpoint
  .gdbinit -- file contains start-up commands


	.global main
main:	
	save %sp,-96,%sp
	mov  9, %l0
	sub  %l0, 1, %o0
	sub  %l0, 7, %o1
	call .mul
	nop 
	sub  %l0, 0xb, %o1
	call .div
	nop 
	mov  %o0, %l1
	mov  1, %g1
	ta   0

compile using gcc -g -static


% gdb a.out
GDB is free software and you are welcome to distribute copies of it
 under certain conditions; type "show copying" to see the conditions.
There is absolutely no warranty for GDB; type "show warranty" for details.
GDB 4.16 (sparc-sun-solaris2.6), 
Copyright 1996 Free Software Foundation, Inc...
(gdb) display $o1
(gdb) display $o0
(gdb) display $l1
(gdb) display $l0
(gdb) display/i $pc-4
(gdb) b main
Breakpoint 1 at 0x101b8
(gdb) r
Starting program: /home/mark/231/lectures.99/a.out 

Breakpoint 1, 0x101b8 in main ()
5: x/i $pc - 4  0x101b4 <main>: save  %sp, -96, %sp
4: $l0 = 0
3: $l1 = 0
2: $o0 = 0
1: $o1 = 160964
(gdb) disassemble
Dump of assembler code for function main:
0x101b4 <main>: save  %sp, -96, %sp
0x101b8 <main+4>:       mov  9, %l0
0x101bc <main+8>:       sub  %l0, 1, %o0
0x101c0 <main+12>:      sub  %l0, 7, %o1
0x101c4 <main+16>:      call  0x10d90 <.mul>
0x101c8 <main+20>:      nop 
0x101cc <main+24>:      sub  %l0, 0xb, %o1
0x101d0 <main+28>:      call  0x156d0 <.div>
0x101d4 <main+32>:      nop 
0x101d8 <main+36>:      mov  %o0, %l1
0x101dc <main+40>:      mov  1, %g1
0x101e0 <main+44>:      ta  0
End of assembler dump.
(gdb) ni
0x101bc in main ()
5: x/i $pc - 4  0x101b8 <main+4>:       mov  9, %l0
4: $l0 = 9
3: $l1 = 0
2: $o0 = 0
1: $o1 = 160964
(gdb) ni
0x101c0 in main ()
5: x/i $pc - 4  0x101bc <main+8>:       sub  %l0, 1, %o0
4: $l0 = 9
3: $l1 = 0
2: $o0 = 8
1: $o1 = 160964
(gdb) ni
0x101c4 in main ()
5: x/i $pc - 4  0x101c0 <main+12>:      sub  %l0, 7, %o1
4: $l0 = 9
3: $l1 = 0
2: $o0 = 8
1: $o1 = 2
(gdb) ni
0x101c8 in main ()
5: x/i $pc - 4  0x101c4 <main+16>:      call  0x10d90 <.mul>
4: $l0 = 9
3: $l1 = 0
2: $o0 = 8
1: $o1 = 2
(gdb) ni
0x101cc in main ()
5: x/i $pc - 4  0x101c8 <main+20>:      nop 
4: $l0 = 9
3: $l1 = 0
2: $o0 = 16
1: $o1 = 0
(gdb) ni
0x101d0 in main ()
5: x/i $pc - 4  0x101cc <main+24>:      sub  %l0, 0xb, %o1
4: $l0 = 9
3: $l1 = 0
2: $o0 = 16
1: $o1 = -2
(gdb) ni
0x101d4 in main ()
5: x/i $pc - 4  0x101d0 <main+28>:      call  0x156d0 <.div>
4: $l0 = 9
3: $l1 = 0
2: $o0 = 16
1: $o1 = -2
(gdb) ni
0x101d8 in main ()
5: x/i $pc - 4  0x101d4 <main+32>:      nop 
4: $l0 = 9
3: $l1 = 0
2: $o0 = -8
1: $o1 = 2
(gdb) ni
0x101dc in main ()
5: x/i $pc - 4  0x101d8 <main+36>:      mov  %o0, %l1
4: $l0 = 9
3: $l1 = -8
2: $o0 = -8
1: $o1 = 2
(gdb) ni
0x101e0 in main ()
5: x/i $pc - 4  0x101dc <main+40>:      mov  1, %g1
4: $l0 = 9
3: $l1 = -8
2: $o0 = -8
1: $o1 = 2
(gdb) ni

Program exited with code 0370.
(gdb) quit



second example program

	
		.global main
	main:	
		save	%sp,-96,%sp
		clr	%l0		!initialize x to zero
	
		.global	loop
	loop:				!the do loop
		sub	%l0, 1, %o0	!(x - 1) into %o0
		sub	%l0, 7, %o1	!(x - 7) into %o1
		call	.mul		!.mul does %o0 = %o0 * %o1
		nop
		sub	%l0, 11, %o1	!(x - 11) into %o1, the divisor
		call	.div		!.div does %o0 = %o0 / %o1
		nop
		mov	%o0, %l1	!store it in y,
				
		add	%l0, 1, %l0	!x++
	
		subcc	%l0, 11, %g0	!set condition codes
		bl	loop
		nop
	
		mov	1, %g1		!trap dispatch
		ta	0		!trap to system


examine memory contents using gdb

  "x/16x main"

	0x10a98 <main>:     0x9de3bfa0  0xa0100000  0x90242001  0x92242007
	0x10aa8 <loop+8>:   0x40004302  0x01000000  0x9224200b  0x40004302
	0x10ab8 <loop+24>:  0x01000000  0xa2100008  0xa0042001  0x80a4200b
	0x10ac8 <loop+40>:  0x06bffff6  0x01000000  0x82102001  0x91d02000

  "x/16i main"

	0x10a98 <main>:         save  %sp, -96, %sp
	0x10a9c <main+4>:       mov  %g0, %l0
	0x10aa0 <loop>:         sub  %l0, 1, %o0
	0x10aa4 <loop+4>:       sub  %l0, 7, %o1
	0x10aa8 <loop+8>:       call  0x216b0 <.mul>
	0x10aac <loop+12>:      nop 
	0x10ab0 <loop+16>:      sub  %l0, 0xb, %o1
	0x10ab4 <loop+20>:      call  0x216bc <.div>
	0x10ab8 <loop+24>:      nop 
	0x10abc <loop+28>:      mov  %o0, %l1
	0x10ac0 <loop+32>:      inc  %l0
	0x10ac4 <loop+36>:      cmp  %l0, 0xb
	0x10ac8 <loop+40>:      bl  0x10aa0 <loop>
	0x10acc <loop+44>:      nop 
	0x10ad0 <loop+48>:      mov  1, %g1
	0x10ad4 <loop+52>:      ta  0


Instruction formats

  formats are basically rules on how bit patterns are interpreted/decoded

  a format specifies the positions of fields such as opcodes, register
      identifiers, and constants

  format 1: call      +--+----------------------------------+
      bit encoding is |01|.......30-bit displacement........|
                      +--+----------------------------------+

  format 2:           +--+-----+---+------------------------+
      sethi is        |00|rdest|100|..22-bit displacement...|
                      +--+-+---+---+------------------------+
      branch is       |00|a|cnd|op2|..22-bit displacement...|
                      +--+-+---+---+------------------------+

			"a" is the annul bit, if set then the instruction in the
			delay slot of the branch is executed only if the branch
			is taken (thus you can move the first instruction from
			the branch target into the delay slot without causing
			incorrect values when the branch is untaken)

  format 3:           +--+-----+------+-----+-+--------+-----+
      3-register is   |1x|rdest|.op3..|rsrc1|0|asi/fpop|rsrc2|
                      +--+-----+------+-----+-+--------+-----+
      immediate is    |1x|rdest|.op3..|rsrc1|1|signed 13-bit |
                      +--+-----+------+-----+-+--------------+

  note that calls and branches are pc-relative, this makes it easier to
      link and load programs