OpenSolaris_b135/lib/libbc/libc/crt/sparc/misalign.s
! .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;
! {
! /*
! * load 32-bit int from misaligned address
! * cost(16-bit aligned case): 9 cycles
! * cost(8-bit aligned case): 18 cycles
! */
! }
!
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;
! return stored value */
! }
!
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;
! return stored value */
! }
!
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;
! return stored value */
! }
!
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;
! return stored value */
! }
!
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)