git.sur5r.net Git - cc65/blob - libsrc/runtime/runtime.s

   1 ;
   2 ; Runtime code for cc65.
   3 ;
   4
   5
   6         .import         ldai, ldaxi, pushax
   7         .importzp       sp, tmp1, tmp2, tmp3, ptr1, ptr4
   8
   9
  10 ; Pop a from stack
  11         .export         popa
  12
  13 popa:   ldy     #0
  14         lda     (sp),y          ; Read byte
  15         inc     sp
  16         bne     *+4
  17         inc     sp+1
  18         rts
  19
  20 ;
  21 ; pop a from stack and load x with zero
  22 ;
  23
  24         .export         popa0
  25
  26 popa0:  ldy     #0
  27         lda     (sp),y          ; load low byte
  28         ldx     #0
  29         beq     incsp2
  30
  31 ;
  32 ; pop a/x from stack. This function will run directly into incsp2
  33 ;
  34
  35         .export         popax           ; pop stack into AX
  36
  37 popax:  ldy     #1
  38         lda     (sp),y          ; get hi byte
  39         tax                     ; into x
  40         dey
  41         lda     (sp),y          ; get lo byte
  42
  43 ;
  44 ; routines for inc/dec'ing sp
  45 ;
  46
  47         .export         addysp, addysp1
  48         .export         incsp1, incsp2, incsp3, incsp4
  49         .export         incsp5, incsp6, incsp7, incsp8
  50
  51 ; do this by hand, cause it gets used a lot
  52
  53 incsp2: ldy     sp              ; 3
  54         iny                     ; 2
  55         beq     @L1             ; 2
  56         iny                     ; 2
  57         beq     @L2             ; 2
  58         sty     sp              ; 3
  59         rts
  60
  61 @L1:    iny                     ; 2
  62 @L2:    sty     sp              ; 3
  63         inc     sp+1            ; 5
  64         rts
  65
  66 ; Hand optimize this one also...
  67
  68 incsp1: inc     sp
  69         bne     *+4
  70         inc     sp+1
  71         rts
  72
  73 incsp3: ldy     #3
  74         bne     addysp
  75
  76 incsp4: ldy     #4
  77         bne     addysp
  78
  79 incsp5: ldy     #5
  80         bne     addysp
  81
  82 incsp6: ldy     #6
  83         bne     addysp
  84
  85 incsp7: ldy     #7
  86         bne     addysp
  87
  88 incsp8: ldy     #8
  89         bne     addysp
  90
  91 addysp1:
  92         iny
  93 addysp: pha                     ; save A
  94         clc
  95         tya                     ; get the value
  96         adc     sp              ; add lo byte
  97         sta     sp              ; put it back
  98         bcc     addysp_1        ; if no carry, we're done
  99         inc     sp+1            ; inc hi byte
 100 addysp_1:
 101         pla                     ; get A back
 102         rts
 103
 104
 105 ;
 106 ;
 107         .export         subysp          ; sub Y from SP
 108         .export         decsp1, decsp2, decsp3, decsp4
 109         .export         decsp5, decsp6, decsp7, decsp8
 110
 111 ; Do this one by hand, cause it gets used a lot
 112
 113 decsp2: ldy     sp
 114         beq     @L1
 115         dey
 116         beq     @L2
 117         dey
 118         sty     sp
 119         rts
 120
 121 @L1:    dey
 122 @L2:    dey
 123         sty     sp
 124         dec     sp+1
 125         rts
 126
 127 ; Decrement by 1 also done as fast as possible
 128
 129 decsp1: ldy     sp
 130         bne     *+4
 131         dec     sp+1
 132         dec     sp
 133         rts
 134
 135 decsp3: ldy     #3
 136         bne     subysp
 137
 138 decsp4: ldy     #4
 139         bne     subysp
 140
 141 decsp5: ldy     #5
 142         bne     subysp
 143
 144 decsp6: ldy     #6
 145         bne     subysp
 146
 147 decsp7: ldy     #7
 148         bne     subysp
 149
 150 decsp8: ldy     #8
 151 ;       bne     subysp
 152
 153 subysp: pha                     ; save A
 154         sty     tmp1            ; save the value
 155         lda     sp              ; get lo byte
 156         sec
 157         sbc     tmp1            ; sub y val
 158         sta     sp              ; put it back
 159         bcs     *+4
 160         dec     sp+1
 161         pla                     ; get A back
 162         rts                     ; done
 163
 164 ;
 165 ; Various kinds of store operators
 166 ;
 167 ; store AX at SP@@(Y)
 168
 169         .export         staxspidx, staspidx, staspic
 170 staxspidx:
 171         jsr     staspic         ; use common part
 172         pha
 173         iny
 174         lda     tmp2
 175         sta     (ptr4),y
 176         tax
 177         pla
 178         rts
 179 staspidx:
 180         jsr     staspic         ; use common part
 181         ldx     tmp2
 182         rts
 183
 184 staspic:
 185         sta     tmp1
 186         stx     tmp2
 187         sty     tmp3
 188         jsr     popax           ; get the pointer
 189         sta     ptr4
 190         stx     ptr4+1
 191         ldy     tmp3
 192         lda     tmp1
 193         sta     (ptr4),y
 194         rts
 195
 196 ; ax --> (sp),y
 197
 198
 199         .export         staxspp         ; store AX thru (sp), and pop
 200 staxspp:
 201         ldy     #0
 202         pha
 203         lda     (sp),y
 204         sta     ptr1
 205         iny
 206         lda     (sp),y
 207         sta     ptr1+1
 208         txa
 209         sta     (ptr1),y
 210         pla
 211         dey
 212         sta     (ptr1),y
 213         jmp     incsp2          ; Drop address
 214
 215
 216         .export         staspp          ; store A thru (sp), and pop
 217 staspp:
 218         ldy     #1
 219         pha
 220         lda     (sp),y
 221         sta     ptr1+1
 222         dey
 223         lda     (sp),y
 224         sta     ptr1
 225         pla
 226         sta     (ptr1),y
 227         jmp     incsp2          ; Drop address
 228
 229
 230 ;
 231 ; Boolean function return entries.
 232 ;
 233
 234         .export         return0, return1
 235
 236 return1:
 237         ldx     #0
 238         lda     #1
 239         rts
 240
 241 return0:
 242         lda     #0
 243         tax
 244         rts
 245
 246 ;
 247 ; random stuff
 248 ;
 249
 250 ; (a/x) 16--> (--sp)
 251
 252         .export         pushwaxi
 253 pushwaxi:                       ; push word at (ax)
 254         jsr     ldaxi
 255         jmp     pushax
 256
 257 ; (a/x) 8--> (--sp)
 258
 259         .export         pushbaxi        ; push byte at (ax)
 260 pushbaxi:
 261         jsr     ldai
 262         jmp     pushax
 263
 264
 265