| /* 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, 51 Franklin Street, Fifth Floor, |
| Boston, MA 02110-1301, 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 |
| ;----------------------------------------- |
