btu32rotleftninplacerxn/src/btu32rotleftninplacerxn.s

;-------------------------------------------------------------------------------
;$Header: /home/dashley/cvsrep/uculib01/uculib01/src/stm8/cosmic/modx0/btu32rotleftninplacerxn/src/btu32rotleftninplacerxn.s,v 1.6 2010/05/14 18:18:50 dashley Exp $
;-------------------------------------------------------------------------------
;Copyright (c)2010 David T. Ashley
;
;Permission is hereby granted, free of charge, to any person obtaining a copy
;of this software source code and associated documentation files (the
;"Software"), to deal in the Software without restriction, including without
;limitation the rights to use, copy, modify, merge, publish, distribute,
;sublicense, and/or sell copies of the Software, and to permit persons to whom
;the Software is furnished to do so, subject to the following conditions:
;
;The above copyright notice and this permission notice shall be included in
;all copies or substantial portions of the Software.
;
;THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
;IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
;FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
;AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
;LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
;OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
;THE SOFTWARE.
;-------------------------------------------------------------------------------
;This function doesn't use any static storage, so it is OK for either mods0 or
;modsl0 memory models.  However, it does assume call/ret (rather than callf/retf)
;which affects both instructions used, stack offsets, and numerical values in
;the .dcall directive.  For this reason, must error out if being assembled
;for the wrong memory model.
#ifndef UCU_BD_MMBP
   #error "Program memory model define not provided on command line (UCU_BD_MMBP)."
#endif
#if (UCU_BD_MMBP != 1)
   #error "Attempt to assemble module for wrong program memory model (UCU_BD_MMBP != 1)."
#endif
;
            switch .text
            xdef   _UcuBtU32RotLeftNInPlaceRxn
;
;Per discussion with Cosmic, the first integer is the stack space used by the
;call instruction plus any automatic storage used by the function.  The second integer
;is the number of bytes stacked by the caller.  Haven't yet discussed the scenario
;of one assembly-language function called by another.  I've noticed that some
;assembly-language functions have a larger first integer than the stack they
;used, so there may be a special convention if C calls .S which then calls .S,
;as maybe the tools don't detect the .S calling the .S.  Will need to investigate
;further with Cosmic.
;
;2 bytes pushed on the stack by the call, 6 bytes stacked locally.  1 byte
;stacked by caller.
            .dcall  "8,1,_UcuBtU32RotLeftNInPlaceRxn"
;
_UcuBtU32RotLeftNInPlaceRxn:
        ;N (the number of bits to roll) has been pushed on the stack, and X
        ;contains the address of the UCU_UINT32 to roll.
        ;Stack frame now:
        ;  ( 1,SP)     :      Return address MSB.
        ;  ( 2,SP)     :      Return address LSB.
        ;  ( 3,SP)     :      N.
        ;----------
        pushw   x             ;Push X on the stack.  We will need to refer to this
                              ;address later.
        ;Stack frame now:
        ;  ( 1,SP)     :      TGT MSB
        ;  ( 2,SP)     :      TGT LSB
        ;  ( 3,SP)     :      Return address MSB.
        ;  ( 4,SP)     :      Return address LSB.
        ;  ( 5,SP)     :      N.
        ;----------
        subw   sp,#4          ;Reserve another 4 bytes on the stack for the item
                              ;to be rolled.
        ;----------
        ;Stack frame now:
        ;  ( 1,SP)     :      (*TGT) MSB
        ;  ( 2,SP)     :      (*TGT) Intermediate byte
        ;  ( 3,SP)     :      (*TGT) Intermediate byte
        ;  ( 4,SP)     :      (*TGT) LSB
        ;  ( 5,SP)     :      TGT MSB
        ;  ( 6,SP)     :      TGT LSB
        ;  ( 7,SP)     :      Return address MSB.
        ;  ( 8,SP)     :      Return address LSB.
        ;  ( 9,SP)     :      N.
        ;----------
        ;Load *TGT into the stack frame.
        ld    a,(x)
        ld    (1,sp),a
        ld    a,(1,x)
        ld    (2,sp),a
        ld    a,(2,x)
        ld    (3,sp),a
        ld    a,(3,x)
        ld    (4,sp),a
        ;----------
        ;Adjust N by AND'ing it with 31, which forms N mod 32.  The reason for this
        ;is that rolling a 32-bit quantity 32 places leaves it unchanged, so only
        ;N mod 32 matters.
        ld    a,(9,sp)
        and   a,#31
        ld    (9,sp),a
        ;----------
        ;Load X:Y with the 32-bit quantity to be rolled.  Manipulating it in these
        ;registers is probably faster than manipulating it in memory.
        ldw   x,(1,sp)
        ldw   y,(3,sp)
        ;----------
        ;If N >= 16, we can do the 16 counts of the left roll just by exchanging words.
        ld    a,(9,sp)
        cp    a,#16
        jrult n_less_than_16
        ;----------
        ;If we are here, N is 16 or larger.  Should subtract 16, as we will handle
        ;that part of the roll.
        sub   a,#16
        ld    (9,sp),a
        ;
        ;Exchange the words, which effectively rolls by 16.
        exgw  x,y
        ;----------
n_less_than_16:
        ;Check if N >= 8.  If so, can do the left roll by careful register exchanges.
        ld    a,(9,sp)
        cp    a,#8
        jrult n_less_than_8
        ;----------
        ;If we are here, N is 8 or larger.  Should subtract 8, as we will handle
        ;that part of the left roll.
        sub   a,#8
        ld    (9,sp),a
        ;
        ;Do the register exchanges to roll left by 8.
                              ;
                              ;  XH      XL      YH      YL       A
                              ;------------------------------------
                              ;  XH      XL      YH      YL       -
        ld    a,xh            ;  XH      XL      YH      YL      XH
        swapw x               ;  XL      XH      YH      YL      XH
        swapw y               ;  XL      XH      YL      YH      XH
        exg   a,yl            ;  XL      XH      YL      XH      YH
        exg   a,xl            ;  XL      YH      YL      XH      XH
        ;
        ;Fall through to final sequence, which handles 7 or fewer left roll operations.
        ;----------
n_less_than_8:
        ;----------
        ;Skip loop entry if count is 0.
        tnz   (9,sp)
        jreq  done
loop_top:
        ;Get the MSB of X into the carry bit.  This has to be done to prime the
        ;pump so that it makes it into the LSB of Y.
        ld    a,xh
        rlc   a
        ;Roll the 32-bit quantity.
        rlcw  y
        rlcw  x
        dec   (9,sp)
        jrne  loop_top
        ;----------
done:
        ;Restore X:Y to its place in the stack frame.
        ldw   (1,sp),x
        ldw   (3,sp),y
        ;
        ;Copy the result to the caller's *TGT location.  The LDW instruction isn't
        ;fully orthogonal, so it is easier to move things through the accumulator.
        ldw   x,(5,sp)        ;Get the TGT pointer.
        ld    a,(1,sp)
        ld    (x),a
        ld    a,(2,sp)
        ld    (1,x),a
        ld    a,(3,sp)
        ld    (2,x),a
        ld    a,(4,sp)
        ld    (3,x),a
        ;
        ;Restore the stack pointer.
        addw  sp,#6
        ;
        ;And return.
        ret
;
        end
;
;-------------------------------------------------------------------------------
;End of $Id: btu32rotleftninplacerxn.s,v 1.6 2010/05/14 18:18:50 dashley Exp $
;-------------------------------------------------------------------------------
;$Log: btu32rotleftninplacerxn.s,v $
;Revision 1.6  2010/05/14 18:18:50  dashley
;Minor comment enhancements.
;
;Revision 1.5  2010/05/14 17:14:25  dashley
;Defect corrected.
;
;Revision 1.4  2010/05/13 18:33:56  dashley
;Edits.
;
;Revision 1.3  2010/05/13 16:42:36  dashley
;Edits.
;
;Revision 1.2  2010/05/13 16:14:09  dashley
;Edits.
;
;Revision 1.1  2010/05/13 13:59:23  dashley
;Initial checkin.
;-------------------------------------------------------------------------------

1	dashley	30	;-------------------------------------------------------------------------------
2			;$Header: /home/dashley/cvsrep/uculib01/uculib01/src/stm8/cosmic/modx0/btu32rotleftninplacerxn/src/btu32rotleftninplacerxn.s,v 1.6 2010/05/14 18:18:50 dashley Exp $
3			;-------------------------------------------------------------------------------
4			;Copyright (c)2010 David T. Ashley
5			;
6			;Permission is hereby granted, free of charge, to any person obtaining a copy
7			;of this software source code and associated documentation files (the
8			;"Software"), to deal in the Software without restriction, including without
9			;limitation the rights to use, copy, modify, merge, publish, distribute,
10			;sublicense, and/or sell copies of the Software, and to permit persons to whom
11			;the Software is furnished to do so, subject to the following conditions:
12			;
13			;The above copyright notice and this permission notice shall be included in
14			;all copies or substantial portions of the Software.
15			;
16			;THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17			;IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18			;FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19			;AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20			;LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21			;OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22			;THE SOFTWARE.
23			;-------------------------------------------------------------------------------
24			;This function doesn't use any static storage, so it is OK for either mods0 or
25			;modsl0 memory models. However, it does assume call/ret (rather than callf/retf)
26			;which affects both instructions used, stack offsets, and numerical values in
27			;the .dcall directive. For this reason, must error out if being assembled
28			;for the wrong memory model.
29			#ifndef UCU_BD_MMBP
30			#error "Program memory model define not provided on command line (UCU_BD_MMBP)."
31			#endif
32			#if (UCU_BD_MMBP != 1)
33			#error "Attempt to assemble module for wrong program memory model (UCU_BD_MMBP != 1)."
34			#endif
35			;
36			switch .text
37			xdef _UcuBtU32RotLeftNInPlaceRxn
38			;
39			;Per discussion with Cosmic, the first integer is the stack space used by the
40			;call instruction plus any automatic storage used by the function. The second integer
41			;is the number of bytes stacked by the caller. Haven't yet discussed the scenario
42			;of one assembly-language function called by another. I've noticed that some
43			;assembly-language functions have a larger first integer than the stack they
44			;used, so there may be a special convention if C calls .S which then calls .S,
45			;as maybe the tools don't detect the .S calling the .S. Will need to investigate
46			;further with Cosmic.
47			;
48			;2 bytes pushed on the stack by the call, 6 bytes stacked locally. 1 byte
49			;stacked by caller.
50			.dcall "8,1,_UcuBtU32RotLeftNInPlaceRxn"
51			;
52			_UcuBtU32RotLeftNInPlaceRxn:
53			;N (the number of bits to roll) has been pushed on the stack, and X
54			;contains the address of the UCU_UINT32 to roll.
55			;Stack frame now:
56			; ( 1,SP) : Return address MSB.
57			; ( 2,SP) : Return address LSB.
58			; ( 3,SP) : N.
59			;----------
60			pushw x ;Push X on the stack. We will need to refer to this
61			;address later.
62			;Stack frame now:
63			; ( 1,SP) : TGT MSB
64			; ( 2,SP) : TGT LSB
65			; ( 3,SP) : Return address MSB.
66			; ( 4,SP) : Return address LSB.
67			; ( 5,SP) : N.
68			;----------
69			subw sp,#4 ;Reserve another 4 bytes on the stack for the item
70			;to be rolled.
71			;----------
72			;Stack frame now:
73			; ( 1,SP) : (*TGT) MSB
74			; ( 2,SP) : (*TGT) Intermediate byte
75			; ( 3,SP) : (*TGT) Intermediate byte
76			; ( 4,SP) : (*TGT) LSB
77			; ( 5,SP) : TGT MSB
78			; ( 6,SP) : TGT LSB
79			; ( 7,SP) : Return address MSB.
80			; ( 8,SP) : Return address LSB.
81			; ( 9,SP) : N.
82			;----------
83			;Load *TGT into the stack frame.
84			ld a,(x)
85			ld (1,sp),a
86			ld a,(1,x)
87			ld (2,sp),a
88			ld a,(2,x)
89			ld (3,sp),a
90			ld a,(3,x)
91			ld (4,sp),a
92			;----------
93			;Adjust N by AND'ing it with 31, which forms N mod 32. The reason for this
94			;is that rolling a 32-bit quantity 32 places leaves it unchanged, so only
95			;N mod 32 matters.
96			ld a,(9,sp)
97			and a,#31
98			ld (9,sp),a
99			;----------
100			;Load X:Y with the 32-bit quantity to be rolled. Manipulating it in these
101			;registers is probably faster than manipulating it in memory.
102			ldw x,(1,sp)
103			ldw y,(3,sp)
104			;----------
105			;If N >= 16, we can do the 16 counts of the left roll just by exchanging words.
106			ld a,(9,sp)
107			cp a,#16
108			jrult n_less_than_16
109			;----------
110			;If we are here, N is 16 or larger. Should subtract 16, as we will handle
111			;that part of the roll.
112			sub a,#16
113			ld (9,sp),a
114			;
115			;Exchange the words, which effectively rolls by 16.
116			exgw x,y
117			;----------
118			n_less_than_16:
119			;Check if N >= 8. If so, can do the left roll by careful register exchanges.
120			ld a,(9,sp)
121			cp a,#8
122			jrult n_less_than_8
123			;----------
124			;If we are here, N is 8 or larger. Should subtract 8, as we will handle
125			;that part of the left roll.
126			sub a,#8
127			ld (9,sp),a
128			;
129			;Do the register exchanges to roll left by 8.
130			;
131			; XH XL YH YL A
132			;------------------------------------
133			; XH XL YH YL -
134			ld a,xh ; XH XL YH YL XH
135			swapw x ; XL XH YH YL XH
136			swapw y ; XL XH YL YH XH
137			exg a,yl ; XL XH YL XH YH
138			exg a,xl ; XL YH YL XH XH
139			;
140			;Fall through to final sequence, which handles 7 or fewer left roll operations.
141			;----------
142			n_less_than_8:
143			;----------
144			;Skip loop entry if count is 0.
145			tnz (9,sp)
146			jreq done
147			loop_top:
148			;Get the MSB of X into the carry bit. This has to be done to prime the
149			;pump so that it makes it into the LSB of Y.
150			ld a,xh
151			rlc a
152			;Roll the 32-bit quantity.
153			rlcw y
154			rlcw x
155			dec (9,sp)
156			jrne loop_top
157			;----------
158			done:
159			;Restore X:Y to its place in the stack frame.
160			ldw (1,sp),x
161			ldw (3,sp),y
162			;
163			;Copy the result to the caller's *TGT location. The LDW instruction isn't
164			;fully orthogonal, so it is easier to move things through the accumulator.
165			ldw x,(5,sp) ;Get the TGT pointer.
166			ld a,(1,sp)
167			ld (x),a
168			ld a,(2,sp)
169			ld (1,x),a
170			ld a,(3,sp)
171			ld (2,x),a
172			ld a,(4,sp)
173			ld (3,x),a
174			;
175			;Restore the stack pointer.
176			addw sp,#6
177			;
178			;And return.
179			ret
180			;
181			end
182			;
183			;-------------------------------------------------------------------------------
184			;End of $Id: btu32rotleftninplacerxn.s,v 1.6 2010/05/14 18:18:50 dashley Exp $
185			;-------------------------------------------------------------------------------
186			;$Log: btu32rotleftninplacerxn.s,v $
187			;Revision 1.6 2010/05/14 18:18:50 dashley
188			;Minor comment enhancements.
189			;
190			;Revision 1.5 2010/05/14 17:14:25 dashley
191			;Defect corrected.
192			;
193			;Revision 1.4 2010/05/13 18:33:56 dashley
194			;Edits.
195			;
196			;Revision 1.3 2010/05/13 16:42:36 dashley
197			;Edits.
198			;
199			;Revision 1.2 2010/05/13 16:14:09 dashley
200			;Edits.
201			;
202			;Revision 1.1 2010/05/13 13:59:23 dashley
203			;Initial checkin.
204			;-------------------------------------------------------------------------------
205