Clemson University -- CPSC 231 -- Fall 2009

example SPARC code for subroutines showing difference between
passing by value and passing by reference


by value

  C code                  equivalent assembly code
  ------                  ------------------------

  int a;                          .section ".bss"      ! .bss since a is not
                          a:      .skip 4              ! assigned an initial
                                                       ! value

                                  .section ".text"
  int main(void){         main:   save  %sp, -96, %sp

    a = 0;                        set   a, %l0         ! a = 0
                                  st    %g0, [%l0]     !

    a = sub( a );                 ld    [%l0], %o0     !\
                                  call  sub            ! | sub( a ) by value
  }                                nop                 !/

                                  st    %o0, [%l0]     ! a = return value

                                  ret
                                   restore

  int sub( int x ){       sub:    add   %o0, 1, %o0    ! return value = x + 1
    return( x + 1 );              
  }                               retl                 ! note that first parm
                                   nop                 ! and return value both
                                                       ! use reg %o0


by reference

  C code                  equivalent assembly code
  ------                  ------------------------

  int a;                          .section ".bss"      ! .bss since a is not
                          a:      .skip 4              ! assigned an initial
                                                       ! value

                                  .section ".text"
  int main(void){         main:   save  %sp, -96, %sp

    a = 0;                        set   a, %l0         ! a = 0
                                  st    %g0, [%l0]     !

    a = sub( &a );                mov   %l0, %o0       !\
                                  call  sub            ! | sub( &a ) by ref
  }                                nop                 !/

                                  st    %o0, [%l0]     ! a = return value

                                  ret
                                   restore

  int sub( int *x ){      sub:    ld    [%o0], %g1     ! deref first parm
    return( *x + 1 );             
  }                               add   %g1, 1, %o0    ! return value = *x + 1

                                  retl                 ! note that first parm
                                   nop                 ! and return value both
                                                       ! use reg %o0; also %g1
                                                       ! is available for use
                                                       ! in a leaf routine