/* libgcc routines for M68HC11 & M68HC12.
Copyright (C) 1999, 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
This file is part of GCC.
GCC is free software; you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by the
Free Software Foundation; either version 2, or (at your option) any
later version.
In addition to the permissions in the GNU General Public License, the
Free Software Foundation gives you unlimited permission to link the
compiled version of this file with other programs, and to distribute
those programs without any restriction coming from the use of this
file. (The General Public License restrictions do apply in other
respects; for example, they cover modification of the file, and
distribution when not linked into another program.)
This file is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; see the file COPYING. If not, write to
the Free Software Foundation, 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
/* As a special exception, if you link this library with other files,
some of which are compiled with GCC, to produce an executable,
this library does not by itself cause the resulting executable
to be covered by the GNU General Public License.
This exception does not however invalidate any other reasons why
the executable file might be covered by the GNU General Public License. */
.file "larith.asm"
#ifdef __HAVE_SHORT_INT__
.mode mshort
#else
.mode mlong
#endif
.macro declare_near name
.globl \name
.type \name,@function
.size \name,.Lend-\name
\name:
.endm
#if defined(__USE_RTC__)
# define ARG(N) N+1
.macro ret
#if defined(mc68hc12)
rtc
#else
jmp __return_32
#endif
.endm
.macro declare name
.globl \name
.type \name,@function
.size \name,.Lend-\name
.far \name
\name:
.endm
.macro farsym name
.far NAME
.endm
#else
# define ARG(N) N
.macro ret
rts
.endm
.macro farsym name
.endm
.macro declare name
.globl \name
.type \name,@function
.size \name,.Lend-\name
\name:
.endm
#endif
.sect .text
#define REG(NAME) \
NAME: .dc.w 1; \
.type NAME,@object ; \
.size NAME,2
#ifdef L_regs_min
/* Pseudo hard registers used by gcc.
They should be located in page0. */
.sect .softregs
.globl _.tmp
.globl _.z,_.xy
REG(_.tmp)
REG(_.z)
REG(_.xy)
#endif
#ifdef L_regs_frame
.sect .softregs
.globl _.frame
REG(_.frame)
#endif
#ifdef L_regs_d1_2
.sect .softregs
.globl _.d1,_.d2
REG(_.d1)
REG(_.d2)
#endif
#ifdef L_regs_d3_4
.sect .softregs
.globl _.d3,_.d4
REG(_.d3)
REG(_.d4)
#endif
#ifdef L_regs_d5_6
.sect .softregs
.globl _.d5,_.d6
REG(_.d5)
REG(_.d6)
#endif
#ifdef L_regs_d7_8
.sect .softregs
.globl _.d7,_.d8
REG(_.d7)
REG(_.d8)
#endif
#ifdef L_regs_d9_16
/* Pseudo hard registers used by gcc.
They should be located in page0. */
.sect .softregs
.globl _.d9,_.d10,_.d11,_.d12,_.d13,_.d14
.globl _.d15,_.d16
REG(_.d9)
REG(_.d10)
REG(_.d11)
REG(_.d12)
REG(_.d13)
REG(_.d14)
REG(_.d15)
REG(_.d16)
#endif
#ifdef L_regs_d17_32
/* Pseudo hard registers used by gcc.
They should be located in page0. */
.sect .softregs
.globl _.d17,_.d18,_.d19,_.d20,_.d21,_.d22
.globl _.d23,_.d24,_.d25,_.d26,_.d27,_.d28
.globl _.d29,_.d30,_.d31,_.d32
REG(_.d17)
REG(_.d18)
REG(_.d19)
REG(_.d20)
REG(_.d21)
REG(_.d22)
REG(_.d23)
REG(_.d24)
REG(_.d25)
REG(_.d26)
REG(_.d27)
REG(_.d28)
REG(_.d29)
REG(_.d30)
REG(_.d31)
REG(_.d32)
#endif
#ifdef L_premain
;;
;; Specific initialization for 68hc11 before the main.
;; Nothing special for a generic routine; Just enable interrupts.
;;
declare_near __premain
clra
tap ; Clear both I and X.
rts
#endif
#ifdef L__exit
;;
;; Exit operation. Just loop forever and wait for interrupts.
;; (no other place to go)
;; This operation is split in several pieces collected together by
;; the linker script. This allows to support destructors at the
;; exit stage while not impacting program sizes when there is no
;; destructors.
;;
;; _exit:
;; *(.fini0) /* Beginning of finish code (_exit symbol). */
;; *(.fini1) /* Place holder for applications. */
;; *(.fini2) /* C++ destructors. */
;; *(.fini3) /* Place holder for applications. */
;; *(.fini4) /* Runtime exit. */
;;
.sect .fini0,"ax",@progbits
.globl _exit
.globl exit
.weak exit
farsym exit
farsym _exit
exit:
_exit:
.sect .fini4,"ax",@progbits
fatal:
cli
wai
bra fatal
#endif
#ifdef L_abort
;;
;; Abort operation. This is defined for the GCC testsuite.
;;
declare abort
ldd #255 ;
#ifdef mc68hc12
trap #0x30
#else
.byte 0xCD ; Generate an illegal instruction trap
.byte 0x03 ; The simulator catches this and stops.
#endif
jmp _exit
#endif
#ifdef L_cleanup
;;
;; Cleanup operation used by exit().
;;
declare _cleanup
ret
#endif
;-----------------------------------------
; required gcclib code
;-----------------------------------------
#ifdef L_memcpy
declare memcpy
declare __memcpy
.weak memcpy
;;;
;;; void* memcpy(void*, const void*, size_t)
;;;
;;; D = dst Pmode
;;; 2,sp = src Pmode
;;; 4,sp = size HImode (size_t)
;;;
#ifdef mc68hc12
ldx ARG(2),sp
ldy ARG(4),sp
pshd
xgdy
lsrd
bcc Start
movb 1,x+,1,y+
Start:
beq Done
Loop:
movw 2,x+,2,y+
dbne d,Loop
Done:
puld
ret
#else
xgdy
tsx
ldd ARG(4),x
ldx ARG(2),x ; SRC = X, DST = Y
cpd #0
beq End
pshy
inca ; Correction for the deca below
L0:
psha ; Save high-counter part
L1:
ldaa 0,x ; Copy up to 256 bytes
staa 0,y
inx
iny
decb
bne L1
pula
deca
bne L0
puly ; Restore Y to return the DST
End:
xgdy
ret
#endif
#endif
#ifdef L_memset
declare memset
declare __memset
;;;
;;; void* memset(void*, int value, size_t)
;;;
#ifndef __HAVE_SHORT_INT__
;;; D = dst Pmode
;;; 2,sp = src SImode
;;; 6,sp = size HImode (size_t)
val = ARG(5)
size = ARG(6)
#else
;;; D = dst Pmode
;;; 2,sp = src SImode
;;; 6,sp = size HImode (size_t)
val = ARG(3)
size = ARG(4)
#endif
#ifdef mc68hc12
xgdx
ldab val,sp
ldy size,sp
pshx
beq End
Loop:
stab 1,x+
dbne y,Loop
End:
puld
ret
#else
xgdx
tsy
ldab val,y
ldy size,y ; DST = X, CNT = Y
beq End
pshx
L0:
stab 0,x ; Fill up to 256 bytes
inx
dey
bne L0
pulx ; Restore X to return the DST
End:
xgdx
ret
#endif
#endif
#ifdef L_adddi3
declare ___adddi3
tsx
xgdy
ldd ARG(8),x ; Add LSB
addd ARG(16),x
std 6,y ; Save (carry preserved)
ldd ARG(6),x
adcb ARG(15),x
adca ARG(14),x
std 4,y
ldd ARG(4),x
adcb ARG(13),x
adca ARG(12),x
std 2,y
ldd ARG(2),x
adcb ARG(11),x ; Add MSB
adca ARG(10),x
std 0,y
xgdy
ret
#endif
#ifdef L_subdi3
declare ___subdi3
tsx
xgdy
ldd ARG(8),x ; Subtract LSB
subd ARG(16),x
std 6,y ; Save, borrow preserved
ldd ARG(6),x
sbcb ARG(15),x
sbca ARG(14),x
std 4,y
ldd ARG(4),x
sbcb ARG(13),x
sbca ARG(12),x
std 2,y
ldd ARG(2),x ; Subtract MSB
sbcb ARG(11),x
sbca ARG(10),x
std 0,y
xgdy ;
ret
#endif
#ifdef L_notdi2
declare ___notdi2
tsy
xgdx
ldd ARG(8),y
coma
comb
std 6,x
ldd ARG(6),y
coma
comb
std 4,x
ldd ARG(4),y
coma
comb
std 2,x
ldd ARG(2),y
coma
comb
std 0,x
xgdx
ret
#endif
#ifdef L_negsi2
declare_near ___negsi2
comb
coma
xgdx
comb
coma
inx
xgdx
bne done
inx
done:
rts
#endif
#ifdef L_one_cmplsi2
declare_near ___one_cmplsi2
comb
coma
xgdx
comb
coma
xgdx
rts
#endif
#ifdef L_ashlsi3
declare_near ___ashlsi3
xgdy
clra
andb #0x1f
xgdy
beq Return
Loop:
lsld
xgdx
rolb
rola
xgdx
dey
bne Loop
Return:
rts
#endif
#ifdef L_ashrsi3
declare_near ___ashrsi3
xgdy
clra
andb #0x1f
xgdy
beq Return
Loop:
xgdx
asra
rorb
xgdx
rora
rorb
dey
bne Loop
Return:
rts
#endif
#ifdef L_lshrsi3
declare_near ___lshrsi3
xgdy
clra
andb #0x1f
xgdy
beq Return
Loop:
xgdx
lsrd
xgdx
rora
rorb
dey
bne Loop
Return:
rts
#endif
#ifdef L_lshrhi3
declare_near ___lshrhi3
cpx #16
bge Return_zero
cpx #0
beq Return
Loop:
lsrd
dex
bne Loop
Return:
rts
Return_zero:
clra
clrb
rts
#endif
#ifdef L_lshlhi3
declare_near ___lshlhi3
cpx #16
bge Return_zero
cpx #0
beq Return
Loop:
lsld
dex
bne Loop
Return:
rts
Return_zero:
clra
clrb
rts
#endif
#ifdef L_rotrhi3
declare_near ___rotrhi3
___rotrhi3:
xgdx
clra
andb #0x0f
xgdx
beq Return
Loop:
tap
rorb
rora
dex
bne Loop
Return:
rts
#endif
#ifdef L_rotlhi3
declare_near ___rotlhi3
___rotlhi3:
xgdx
clra
andb #0x0f
xgdx
beq Return
Loop:
asrb
rolb
rola
rolb
dex
bne Loop
Return:
rts
#endif
#ifdef L_ashrhi3
declare_near ___ashrhi3
cpx #16
bge Return_minus_1_or_zero
cpx #0
beq Return
Loop:
asra
rorb
dex
bne Loop
Return:
rts
Return_minus_1_or_zero:
clrb
tsta
bpl Return_zero
comb
Return_zero:
tba
rts
#endif
#ifdef L_ashrqi3
declare_near ___ashrqi3
cmpa #8
bge Return_minus_1_or_zero
tsta
beq Return
Loop:
asrb
deca
bne Loop
Return:
rts
Return_minus_1_or_zero:
clrb
tstb
bpl Return_zero
coma
Return_zero:
tab
rts
#endif
#ifdef L_lshlqi3
declare_near ___lshlqi3
cmpa #8
bge Return_zero
tsta
beq Return
Loop:
lslb
deca
bne Loop
Return:
rts
Return_zero:
clrb
rts
#endif
#ifdef L_divmodhi4
#ifndef mc68hc12
/* 68HC12 signed divisions are generated inline (idivs). */
declare_near __divmodhi4
;
;; D = numerator
;; X = denominator
;;
;; Result: D = D / X
;; X = D % X
;;
tsta
bpl Numerator_pos
comb ; D = -D <=> D = (~D) + 1
coma
xgdx
inx
tsta
bpl Numerator_neg_denominator_pos
Numerator_neg_denominator_neg:
comb ; X = -X
coma
addd #1
xgdx
idiv
coma
comb
xgdx ; Remainder <= 0 and result >= 0
inx
rts
Numerator_pos_denominator_pos:
xgdx
idiv
xgdx ; Both values are >= 0
rts
Numerator_pos:
xgdx
tsta
bpl Numerator_pos_denominator_pos
Numerator_pos_denominator_neg:
coma ; X = -X
comb
xgdx
inx
idiv
xgdx ; Remainder >= 0 but result <= 0
coma
comb
addd #1
rts
Numerator_neg_denominator_pos:
xgdx
idiv
coma ; One value is > 0 and the other < 0
comb ; Change the sign of result and remainder
xgdx
inx
coma
comb
addd #1
rts
#endif /* !mc68hc12 */
#endif
#ifdef L_mulqi3
declare_near ___mulqi3
;
; short __mulqi3(signed char a, signed char b);
;
; signed char a -> register A
; signed char b -> register B
;
; returns the signed result of A * B in register D.
;
tsta
bmi A_neg
tstb
bmi B_neg
mul
rts
B_neg:
negb
bra A_or_B_neg
A_neg:
nega
tstb
bmi AB_neg
A_or_B_neg:
mul
coma
comb
addd #1
rts
AB_neg:
negb
mul
rts
#endif
#ifdef L_mulhi3
declare_near ___mulhi3
;
;
; unsigned short ___mulhi3(unsigned short a, unsigned short b)
;
; a = register D
; b = register X
;
#ifdef mc68hc12
pshx ; Preserve X
exg x,y
emul
exg x,y
pulx
rts
#else
#ifdef NO_TMP
;
; 16 bit multiplication without temp memory location.
; (smaller but slower)
;
pshx ; (4)
ins ; (3)
pshb ; (3)
psha ; (3)
pshx ; (4)
pula ; (4)
pulx ; (5)
mul ; (10) B.high * A.low
xgdx ; (3)
mul ; (10) B.low * A.high
abx ; (3)
pula ; (4)
pulb ; (4)
mul ; (10) B.low * A.low
pshx ; (4)
tsx ; (3)
adda 1,x ; (4)
pulx ; (5)
rts ; (5) 20 bytes
; ---
; 91 cycles
#else
stx *_.tmp ; (4)
pshb ; (3)
ldab *_.tmp+1 ; (3)
mul ; (10) A.high * B.low
ldaa *_.tmp ; (3)
stab *_.tmp ; (3)
pulb ; (4)
pshb ; (4)
mul ; (10) A.low * B.high
addb *_.tmp ; (4)
stab *_.tmp ; (3)
ldaa *_.tmp+1 ; (3)
pulb ; (4)
mul ; (10) A.low * B.low
adda *_.tmp ; (4)
rts ; (5) 24/32 bytes
; 77/85 cycles
#endif
#endif
#endif
#ifdef L_mulhi32
;
;
; unsigned long __mulhi32(unsigned short a, unsigned short b)
;
; a = register D
; b = value on stack
;
; +---------------+
; | B low | <- 7,x
; +---------------+
; | B high | <- 6,x
; +---------------+
; | PC low |
; +---------------+
; | PC high |
; +---------------+
; | Tmp low |
; +---------------+
; | Tmp high |
; +---------------+
; | A low |
; +---------------+
; | A high |
; +---------------+ <- 0,x
;
;
; <B-low> 5,x
; <B-high> 4,x
; <ret> 2,x
; <A-low> 1,x
; <A-high> 0,x
;
declare_near __mulhi32
#ifdef mc68hc12
ldy 2,sp
emul
exg x,y
rts
#else
pshx ; Room for temp value
pshb
psha
tsx
ldab 6,x
mul
xgdy ; A.high * B.high
ldab 7,x
pula
mul ; A.high * B.low
std 2,x
ldaa 1,x
ldab 6,x
mul ; A.low * B.high
addd 2,x
stab 2,x
tab
aby
bcc N
ldab #0xff
aby
iny
N:
ldab 7,x
pula
mul ; A.low * B.low
adda 2,x
pulx ; Drop temp location
pshy ; Put high part in X
pulx
bcc Ret
inx
Ret:
rts
#endif
#endif
#ifdef L_mulsi3
;
; <B-low> 8,y
; <B-high> 6,y
; <ret> 4,y
; <tmp> 2,y
; <A-low> 0,y
;
; D,X -> A
; Stack -> B
;
; The result is:
;
; (((A.low * B.high) + (A.high * B.low)) << 16) + (A.low * B.low)
;
;
;
declare __mulsi3
#ifdef mc68hc12
pshd ; Save A.low
ldy ARG(4),sp
emul ; A.low * B.high
ldy ARG(6),sp
exg x,d
emul ; A.high * B.low
leax d,x
ldy ARG(6),sp
puld
emul ; A.low * B.low
exg d,y
leax d,x
exg d,y
ret
#else
B_low = ARG(8)
B_high = ARG(6)
A_low = 0
A_high = 2
pshx
pshb
psha
tsy
;
; If B.low is 0, optimize into: (A.low * B.high) << 16
;
ldd B_low,y
beq B_low_zero
;
; If A.high is 0, optimize into: (A.low * B.high) << 16 + (A.low * B.low)
;
cpx #0
beq A_high_zero
bsr ___mulhi3 ; A.high * B.low
;
; If A.low is 0, optimize into: (A.high * B.low) << 16
;
ldx A_low,y
beq A_low_zero ; X = 0, D = A.high * B.low
std 2,y
;
; If B.high is 0, we can avoid the (A.low * B.high) << 16 term.
;
ldd B_high,y
beq B_high_zero
bsr ___mulhi3 ; A.low * B.high
addd 2,y
std 2,y
;
; Here, we know that A.low and B.low are not 0.
;
B_high_zero:
ldd B_low,y ; A.low is on the stack
bsr __mulhi32 ; A.low * B.low
xgdx
tsy ; Y was clobbered, get it back
addd 2,y
A_low_zero: ; See A_low_zero_non_optimized below
xgdx
Return:
ins
ins
ins
ins
ret
;
;
; A_low_zero_non_optimized:
;
; At this step, X = 0 and D = (A.high * B.low)
; Optimize into: (A.high * B.low) << 16
;
; xgdx
; clra ; Since X was 0, clearing D is superfuous.
; clrb
; bra Return
; ----------------
; B.low == 0, the result is: (A.low * B.high) << 16
;
; At this step:
; D = B.low = 0
; X = A.high ?
; A.low is at A_low,y ?
; B.low is at B_low,y ?
;
B_low_zero:
ldd A_low,y
beq Zero1
ldx B_high,y
beq Zero2
bsr ___mulhi3
Zero1:
xgdx
Zero2:
clra
clrb
bra Return
; ----------------
; A.high is 0, optimize into: (A.low * B.high) << 16 + (A.low * B.low)
;
; At this step:
; D = B.low != 0
; X = A.high = 0
; A.low is at A_low,y ?
; B.low is at B_low,y ?
;
A_high_zero:
ldd A_low,y ; A.low
beq Zero1
ldx B_high,y ; B.high
beq A_low_B_low
bsr ___mulhi3
std 2,y
bra B_high_zero ; Do the (A.low * B.low) and the add.
; ----------------
; A.high and B.high are 0 optimize into: (A.low * B.low)
;
; At this step:
; D = B.high = 0
; X = A.low != 0
; A.low is at A_low,y != 0
; B.high is at B_high,y = 0
;
A_low_B_low:
ldd B_low,y ; A.low is on the stack
bsr __mulhi32
bra Return
#endif
#endif
#ifdef L_map_data
.sect .install2,"ax",@progbits
.globl __map_data_section
.globl __data_image
#ifdef mc68hc12
.globl __data_section_size
#endif
__map_data_section:
#ifdef mc68hc12
ldx #__data_image
ldy #__data_section_start
ldd #__data_section_size
beq Done
Loop:
movb 1,x+,1,y+
dbne d,Loop
#else
ldx #__data_image
ldy #__data_section_start
bra Start_map
Loop:
ldaa 0,x
staa 0,y
inx
iny
Start_map:
cpx #__data_image_end
blo Loop
#endif
Done:
#endif
#ifdef L_init_bss
.sect .install2,"ax",@progbits
.globl __init_bss_section
__init_bss_section:
ldd #__bss_size
beq Done
ldx #__bss_start
Loop:
#ifdef mc68hc12
clr 1,x+
dbne d,Loop
#else
clr 0,x
inx
subd #1
bne Loop
#endif
Done:
#endif
#ifdef L_ctor
; End of constructor table
.sect .install3,"ax",@progbits
.globl __do_global_ctors
__do_global_ctors:
; Start from the end - sizeof(void*)
ldx #__CTOR_END__-2
ctors_loop:
cpx #__CTOR_LIST__
blo ctors_done
pshx
ldx 0,x
jsr 0,x
pulx
dex
dex
bra ctors_loop
ctors_done:
#endif
#ifdef L_dtor
.sect .fini3,"ax",@progbits
.globl __do_global_dtors
;;
;; This piece of code is inserted in the _exit() code by the linker.
;;
__do_global_dtors:
pshb ; Save exit code
psha
ldx #__DTOR_LIST__
dtors_loop:
cpx #__DTOR_END__
bhs dtors_done
pshx
ldx 0,x
jsr 0,x
pulx
inx
inx
bra dtors_loop
dtors_done:
pula ; Restore exit code
pulb
#endif
#ifdef L_far_tramp
#ifdef mc68hc12
.sect .tramp,"ax",@progbits
.globl __far_trampoline
;; This is a trampoline used by the linker to invoke a function
;; using rtc to return and being called with jsr/bsr.
;; The trampoline generated is:
;;
;; foo_tramp:
;; ldy #foo
;; call __far_trampoline,page(foo)
;;
;; The linker transforms:
;;
;; jsr foo
;;
;; into
;; jsr foo_tramp
;;
;; The linker generated trampoline and _far_trampoline must be in
;; non-banked memory.
;;
__far_trampoline:
movb 0,sp, 2,sp ; Copy page register below the caller's return
leas 2,sp ; address.
jmp 0,y ; We have a 'call/rtc' stack layout now
; and can jump to the far handler
; (whose memory bank is mapped due to the
; call to the trampoline).
#endif
#ifdef mc68hc11
.sect .tramp,"ax",@progbits
.globl __far_trampoline
;; Trampoline generated by gcc for 68HC11:
;;
;; pshb
;; ldab #%page(func)
;; ldy #%addr(func)
;; jmp __far_trampoline
;;
__far_trampoline:
psha ; (2) Save function parameter (high)
;; <Read current page in A>
psha ; (2)
;; <Set currenge page from B>
pshx ; (4)
tsx ; (3)
ldab 4,x ; (4) Restore function parameter (low)
ldaa 2,x ; (4) Get saved page number
staa 4,x ; (4) Save it below return PC
pulx ; (5)
pula ; (3)
pula ; (3) Restore function parameter (high)
jmp 0,y ; (4)
#endif
#endif
#ifdef L_call_far
#ifdef mc68hc11
.sect .tramp,"ax",@progbits
.globl __call_a16
.globl __call_a32
;;
;; The call methods are used for 68HC11 to support memory bank switching.
;; Every far call is redirected to these call methods. Its purpose is to:
;;
;; 1/ Save the current page on the stack (1 byte to follow 68HC12 call frame)
;; 2/ Install the new page
;; 3/ Jump to the real function
;;
;; The page switching (get/save) is board dependent. The default provided
;; here does nothing (just create the appropriate call frame).
;;
;; Call sequence (10 bytes, 13 cycles):
;;
;; ldx #page ; (3)
;; ldy #func ; (4)
;; jsr __call_a16 ; (6)
;;
;; Call trampoline (11 bytes, 19 cycles):
;;
__call_a16:
;; xgdx ; (3)
;; <Read current page in A> ; (3) ldaa _current_page
psha ; (2)
;; <Set current page from B> ; (4) staa _current_page
;; xgdx ; (3)
jmp 0,y ; (4)
;;
;; Call sequence (10 bytes, 14 cycles):
;;
;; pshb ; (2)
;; ldab #page ; (2)
;; ldy #func ; (4)
;; jsr __call_a32 ; (6)
;;
;; Call trampoline (87 bytes, 57 cycles):
;;
__call_a32:
pshx ; (4)
psha ; (2)
;; <Read current page in A> ; (3) ldaa _current_page
psha ; (2)
;; <Set current page from B> ; (4) staa _current_page
tsx ; (3)
ldab 6,x ; (4) Restore function parameter
ldaa 5,x ; (4) Move PC return at good place
staa 6,x ; (4)
ldaa 4,x ; (4)
staa 5,x ; (4)
pula ; (3)
staa 4,x ; (4)
pula ; (3)
pulx ; (5)
jmp 0,y ; (4)
#endif
#endif
#ifdef L_return_far
#ifdef mc68hc11
.sect .tramp,"ax",@progbits
.globl __return_void
.globl __return_16
.globl __return_32
__return_void:
;; pulb
;; <Set current page from B> (Board specific)
;; rts
__return_16:
;; xgdx
;; pulb
;; <Set current page from B> (Board specific)
;; xgdx
;; rts
__return_32:
;; xgdy
;; pulb
;; <Set current page from B> (Board specific)
;; xgdy
;; rts
ins
rts
#endif
#endif
.Lend:
;-----------------------------------------
; end required gcclib code
;-----------------------------------------