! .text

! .asciz ident "%Z%%M% %I% %E% SMI"

! .align 4

! .seg "text"

! Copyright 2005 Sun Microsystems, Inc. All rights reserved.

! Use is subject to license terms.

!

! CDDL HEADER START

!

! The contents of this file are subject to the terms of the

! Common Development and Distribution License, Version 1.0 only

! (the "License"). You may not use this file except in compliance

! with the License.

!

! You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE

! or http://www.opensolaris.org/os/licensing.

! See the License for the specific language governing permissions

! and limitations under the License.

!

! When distributing Covered Code, include this CDDL HEADER in each

! file and include the License file at usr/src/OPENSOLARIS.LICENSE.

! If applicable, add the following below this CDDL HEADER, with the

! fields enclosed by brackets "[]" replaced with your own identifying

! information: Portions Copyright [yyyy] [name of copyright owner]

!

! CDDL HEADER END

!

!

! C library routines for compiler support of misaligned memory

! references. These are called when an in-line test reveals a

! misaligned address.

!

.file "misalign.s"

#include <SYS.h>

!- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

!

! int ld_int(p)

! char *p;

! {

! /*

! }

!

RTENTRY(.ld_int)

andcc %o0,1,%g0 ! test 16-bit alignment

be,a 1f ! fast case: two loads;

lduh [%o0+2],%o1 ! do first one in delay slot

!

ldub [%o0+3],%o3 ! slow case: load 4 bytes in <o0,o1,o2,o3>

ldub [%o0+2],%o2

ldub [%o0+1],%o1

ldub [%o0],%o0 ! note this has to be done last.

sll %o2,8,%o2

sll %o1,16,%o1

sll %o0,24,%o0

or %o1,%o0,%o0 ! put the pieces together.

or %o2,%o0,%o0

retl

or %o3,%o0,%o0

1:

lduh [%o0],%o0 ! 2nd half of fast case

sll %o0,16,%o0 ! shift, concat, done.

retl

or %o0,%o1,%o0

SET_SIZE(.ld_int)

!- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

!

! float ld_float(p)

! char *p;

! {

! /* load 32-bit float (not double!) from misaligned address */

! }

!

RTENTRY(.ld_float)

save %sp,-SA(MINFRAME+8),%sp

andcc %i0,1,%g0 ! test for short alignment

be,a 1f

lduh [%i0],%o0 ! short aligned case: 2 loads, 2 stores

!

ldub [%i0],%o0 ! byte aligned case: 4 loads, 4 stores

ldub [%i0+1],%o1

ldub [%i0+2],%o2

ldub [%i0+3],%o3

stb %o0,[%fp-4]

stb %o1,[%fp-3]

stb %o2,[%fp-2]

b 2f

stb %o3,[%fp-1]

1:

lduh [%i0+2],%o1 ! rest of short aligned case

sth %o0,[%fp-4]

sth %o1,[%fp-2]

2:

ld [%fp-4],%f0 ! load FPU reg, done

ret

restore

SET_SIZE(.ld_float)

!- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

!

! double ld_double(p)

! char *p;

! {

! /* load 64-bit float from misaligned address */

! }

!

RTENTRY(.ld_double)

save %sp,-SA(MINFRAME+8),%sp

andcc %i0,3,%g0 ! test for long alignment

be,a 1f ! long aligned case: 2 loads, no stores

ld [%i0],%f0

!

andcc %i0,1,%g0 ! test for short alignment

be,a 2f ! short aligned case: 4 loads, 4 stores

lduh [%i0],%o0

!

ldub [%i0],%o0 ! worst case: byte alignment

ldub [%i0+1],%o1 ! 8 loads, 8 stores

ldub [%i0+2],%o2

ldub [%i0+3],%o3

stb %o0,[%fp-8]

stb %o1,[%fp-7]

stb %o2,[%fp-6]

stb %o3,[%fp-5]

ldub [%i0+4],%o0

ldub [%i0+5],%o1

ldub [%i0+6],%o2

ldub [%i0+7],%o3

stb %o0,[%fp-4]

stb %o1,[%fp-3]

stb %o2,[%fp-2]

stb %o3,[%fp-1]

ldd [%fp-8],%f0 ! load f0-f1, done

ret

restore

2:

lduh [%i0+2],%o1 ! rest of short aligned case

lduh [%i0+4],%o2

lduh [%i0+6],%o3

sth %o0,[%fp-8]

sth %o1,[%fp-6]

sth %o2,[%fp-4]

sth %o3,[%fp-2]

ldd [%fp-8],%f0 ! load f0-f1, done

ret

restore

1:

ld [%i0+4],%f1 ! rest of long aligned case

ret

restore

SET_SIZE(.ld_double)

!- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

!

! int st_int(x,p)

! int x;

! char *p;

! {

! /* store 32-bit int from misaligned address;

! }

!

RTENTRY(.st_int)

andcc %o1,1,%g0 ! test for short alignment

be,a 1f

srl %o0,16,%o4

!

srl %o0,24,%o5 ! byte aligned case

stb %o5,[%o1]

srl %o0,16,%o2

stb %o2,[%o1+1]

srl %o0,8,%o3

stb %o3,[%o1+2]

retl

stb %o0,[%o1+3]

1:

sth %o4,[%o1] ! rest of short aligned case

retl

sth %o0,[%o1+2]

SET_SIZE(.st_int)

!- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

!

! float st_float(x,p)

! float x;

! char *p;

! {

! /* store 32-bit float from misaligned address;

! }

!

RTENTRY(.st_float)

save %sp,-SA(MINFRAME+8),%sp

andcc %i1,1,%g0 ! test for short alignment

be,a 1f ! short aligned case

srl %i0,16,%o0

!

srl %i0,24,%o0 ! byte aligned case

srl %i0,16,%o1

srl %i0,8,%o2

stb %o0,[%i1]

stb %o1,[%i1+1]

stb %o2,[%i1+2]

stb %i0,[%i1+3]

st %i0,[%fp-4] ! store temp, load f0, done

ld [%fp-4],%f0

ret

restore

1:

sth %o0,[%i1] ! rest of short aligned case

sth %i0,[%i1+2]

st %i0,[%fp-4]

ld [%fp-4],%f0

ret

restore

SET_SIZE(.st_float)

!- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

!

! double st_double(x,p)

! double x;

! char *p;

! {

! /* store 64-bit float from misaligned address;

! }

!

RTENTRY(.st_double)

save %sp,-SA(MINFRAME+8),%sp

andcc %i2,3,%g0 ! test for long alignment

be,a 1f ! long aligned case: 2 stores, 2 loads

st %i0,[%i2]

!

andcc %i2,1,%g0 ! test for short alignment

be,a 2f ! short aligned case: 4 stores, 4 loads

srl %i0,16,%o0

! ! byte aligned case: the pits

srl %i0,24,%o0

srl %i0,16,%o1

srl %i0,8,%o2

stb %o0,[%i2] ! store first word, a byte at a time

stb %o1,[%i2+1]

stb %o2,[%i2+2]

stb %i0,[%i2+3]

srl %i1,24,%o0

srl %i1,16,%o1

srl %i1,8,%o2

stb %o0,[%i2+4] ! store second word, a byte at a time

stb %o1,[%i2+5]

stb %o2,[%i2+6]

stb %i1,[%i2+7]

std %i0,[%fp-8] ! since dest is misaligned, must use temp

ldd [%fp-8],%f0 ! load f0,f1 from double-aligned temp, done

ret

restore

2: ! rest of short aligned case

srl %i1,16,%o1

sth %o0,[%i2] ! store two words, a half word at a time

sth %i0,[%i2+2]

sth %o1,[%i2+4]

sth %i1,[%i2+6]

std %i0,[%fp-8] ! since dest is misaligned, must use temp

ldd [%fp-8],%f0 ! load f0,f1 from double-aligned temp, done

ret

restore

1: ! rest of long aligned case

st %i1,[%i2+4]

ld [%i2],%f0 ! load f0,f1 from long-aligned memory, done

ld [%i2+4],%f1

ret

restore

SET_SIZE(.st_double)

!- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

!

! void st_float_foreff(x,p)

! float x;

! char *p;

! {

! /* store 32-bit float from misaligned address */

! }

!

RTENTRY(.st_float_foreff)

andcc %o1,1,%g0 ! test for short alignment

be,a 1f

srl %o0,16,%o2

!

srl %o0,24,%o2 ! byte aligned case

srl %o0,16,%o3

srl %o0,8,%o4

stb %o2,[%o1]

stb %o3,[%o1+1]

stb %o4,[%o1+2]

retl

stb %o0,[%o1+3]

1: ! rest of short aligned case

sth %o2,[%o1]

retl

sth %o0,[%o1+2]

SET_SIZE(.st_float_foreff)

!- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

!

! void st_double_foreff(x,p)

! double x;

! char *p;

! {

! /* store 64-bit float from misaligned address;

! }

!

RTENTRY(.st_double_foreff)

andcc %o2,3,%g0 ! test for long alignment

be,a 1f ! long aligned case: 2 stores

st %o0,[%o2]

!

andcc %o2,1,%g0 ! test for short alignment

be,a 2f ! short aligned case: 4 stores

srl %o0,16,%o3

!

srl %o0,24,%o3 ! byte aligned case: 8 stores

srl %o0,16,%o4

srl %o0,8,%o5

stb %o3,[%o2]

stb %o4,[%o2+1]

stb %o5,[%o2+2]

stb %o0,[%o2+3]

srl %o1,24,%o3

srl %o1,16,%o4

srl %o1,8,%o5

stb %o3,[%o2+4]

stb %o4,[%o2+5]

stb %o5,[%o2+6]

retl

stb %o1,[%o2+7]

2: ! rest of short aligned case

srl %o1,16,%o4

sth %o3,[%o2]

sth %o0,[%o2+2]

sth %o4,[%o2+4]

retl

sth %o1,[%o2+6]

1: ! rest of long aligned case

retl

st %o1,[%o2+4]

SET_SIZE(.st_double_foreff)