Rev 7696 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed
| Rev | Author | Line No. | Line |
|---|---|---|---|
| 7983 | leency | 1 | (* |
| 2 | BSD 2-Clause License |
||
| 3 | |||
| 4 | Copyright (c) 2019-2020, Anton Krotov |
||
| 5 | All rights reserved. |
||
| 6 | *) |
||
| 7 | |||
| 8 | MODULE MSP430RTL; |
||
| 9 | |||
| 10 | |||
| 11 | CONST |
||
| 12 | |||
| 13 | _mul* = 0; |
||
| 14 | _divmod* = 1; |
||
| 15 | _lsl* = 2; |
||
| 16 | _asr* = 3; |
||
| 17 | _ror* = 4; |
||
| 18 | _lsr* = 5; |
||
| 19 | _in* = 6; |
||
| 20 | _in2* = 7; |
||
| 21 | _set1* = 8; |
||
| 22 | _incl* = 9; |
||
| 23 | _excl* = 10; |
||
| 24 | _move* = 11; |
||
| 25 | _set* = 12; |
||
| 26 | _arrcpy* = 13; |
||
| 27 | _rot* = 14; |
||
| 28 | _strcmp* = 15; |
||
| 29 | _error* = 16; |
||
| 30 | _is* = 17; |
||
| 31 | _guard* = 18; |
||
| 32 | _guardrec* = 19; |
||
| 33 | _length* = 20; |
||
| 34 | _new* = 21; |
||
| 35 | |||
| 36 | |||
| 37 | HP = 14; |
||
| 38 | |||
| 39 | LenIV* = 32; |
||
| 40 | |||
| 41 | iv = 10000H - LenIV * 2; |
||
| 42 | bsl = iv - 2; |
||
| 43 | sp = bsl - 2; |
||
| 44 | empty_proc* = sp - 2; |
||
| 45 | free_size = empty_proc - 2; |
||
| 46 | free_adr = free_size - 2; |
||
| 47 | bits = free_adr - 272; |
||
| 48 | bits_offs = bits - 32; |
||
| 49 | DataSize* = iv - bits_offs; |
||
| 50 | types = bits_offs - 2; |
||
| 51 | |||
| 52 | IntVectorSize* = LenIV * 2 + DataSize; |
||
| 53 | |||
| 54 | VarSize* = 4; |
||
| 55 | |||
| 56 | |||
| 57 | TYPE |
||
| 58 | |||
| 59 | EMITPROC = PROCEDURE (n: INTEGER); |
||
| 60 | |||
| 61 | |||
| 62 | VAR |
||
| 63 | |||
| 64 | ram*, trap*, int*: INTEGER; |
||
| 65 | |||
| 66 | rtl*: ARRAY 22 OF |
||
| 67 | RECORD |
||
| 68 | label*: INTEGER; |
||
| 69 | used: BOOLEAN |
||
| 70 | END; |
||
| 71 | |||
| 72 | Label, Word, Call: EMITPROC; |
||
| 73 | |||
| 74 | |||
| 75 | PROCEDURE Gen*; |
||
| 76 | |||
| 77 | |||
| 78 | PROCEDURE Word1 (word: INTEGER); |
||
| 79 | BEGIN |
||
| 80 | Word(word) |
||
| 81 | END Word1; |
||
| 82 | |||
| 83 | |||
| 84 | PROCEDURE Word2 (word1, word2: INTEGER); |
||
| 85 | BEGIN |
||
| 86 | Word1(word1); |
||
| 87 | Word1(word2) |
||
| 88 | END Word2; |
||
| 89 | |||
| 90 | |||
| 91 | PROCEDURE Word3 (word1, word2, word3: INTEGER); |
||
| 92 | BEGIN |
||
| 93 | Word1(word1); |
||
| 94 | Word1(word2); |
||
| 95 | Word1(word3) |
||
| 96 | END Word3; |
||
| 97 | |||
| 98 | |||
| 99 | BEGIN |
||
| 100 | (* _lsl (n, x: INTEGER): INTEGER *) |
||
| 101 | IF rtl[_lsl].used THEN |
||
| 102 | Label(rtl[_lsl].label); |
||
| 103 | Word2(4115H, 2); (* MOV 2(SP), R5; R5 <- n *) |
||
| 104 | Word2(4114H, 4); (* MOV 4(SP), R4; R4 <- x *) |
||
| 105 | Word2(0F035H, 15); (* AND #15, R5 *) |
||
| 106 | Word1(2400H + 3); (* JZ L1 *) |
||
| 107 | (* L2: *) |
||
| 108 | Word1(5404H); (* ADD R4, R4 *) |
||
| 109 | Word1(8315H); (* SUB #1, R5 *) |
||
| 110 | Word1(2000H + 400H - 3); (* JNZ L2 *) |
||
| 111 | (* L1: *) |
||
| 112 | Word1(4130H) (* RET *) |
||
| 113 | END; |
||
| 114 | |||
| 115 | (* _asr (n, x: INTEGER): INTEGER *) |
||
| 116 | IF rtl[_asr].used THEN |
||
| 117 | Label(rtl[_asr].label); |
||
| 118 | Word2(4115H, 2); (* MOV 2(SP), R5; R5 <- n *) |
||
| 119 | Word2(4114H, 4); (* MOV 4(SP), R4; R4 <- x *) |
||
| 120 | Word2(0F035H, 15); (* AND #15, R5 *) |
||
| 121 | Word1(2400H + 3); (* JZ L1 *) |
||
| 122 | (* L2: *) |
||
| 123 | Word1(1104H); (* RRA R4 *) |
||
| 124 | Word1(8315H); (* SUB #1, R5 *) |
||
| 125 | Word1(2000H + 400H - 3); (* JNZ L2 *) |
||
| 126 | (* L1: *) |
||
| 127 | Word1(4130H) (* RET *) |
||
| 128 | END; |
||
| 129 | |||
| 130 | (* _ror (n, x: INTEGER): INTEGER *) |
||
| 131 | IF rtl[_ror].used THEN |
||
| 132 | Label(rtl[_ror].label); |
||
| 133 | Word2(4115H, 2); (* MOV 2(SP), R5; R5 <- n *) |
||
| 134 | Word2(4114H, 4); (* MOV 4(SP), R4; R4 <- x *) |
||
| 135 | Word2(0F035H, 15); (* AND #15, R5 *) |
||
| 136 | Word1(2400H + 5); (* JZ L1 *) |
||
| 137 | Word1(4406H); (* MOV R4, R6 *) |
||
| 138 | (* L2: *) |
||
| 139 | Word1(1006H); (* RRC R6 *) |
||
| 140 | Word1(1004H); (* RRC R4 *) |
||
| 141 | Word1(8315H); (* SUB #1, R5 *) |
||
| 142 | Word1(2000H + 400H - 4); (* JNZ L2 *) |
||
| 143 | (* L1: *) |
||
| 144 | Word1(4130H) (* RET *) |
||
| 145 | END; |
||
| 146 | |||
| 147 | (* _lsr (n, x: INTEGER): INTEGER *) |
||
| 148 | IF rtl[_lsr].used THEN |
||
| 149 | Label(rtl[_lsr].label); |
||
| 150 | Word2(4115H, 2); (* MOV 2(SP), R5; R5 <- n *) |
||
| 151 | Word2(4114H, 4); (* MOV 4(SP), R4; R4 <- x *) |
||
| 152 | Word2(0F035H, 15); (* AND #15, R5 *) |
||
| 153 | Word1(2400H + 4); (* JZ L1 *) |
||
| 154 | (* L2: *) |
||
| 155 | Word1(0C312H); (* BIC #1, SR *) |
||
| 156 | Word1(1004H); (* RRC R4 *) |
||
| 157 | Word1(8315H); (* SUB #1, R5 *) |
||
| 158 | Word1(2000H + 400H - 4); (* JNZ L2 *) |
||
| 159 | (* L1: *) |
||
| 160 | Word1(4130H) (* RET *) |
||
| 161 | END; |
||
| 162 | |||
| 163 | (* _set (b, a: INTEGER): SET *) |
||
| 164 | IF rtl[_set].used THEN |
||
| 165 | Label(rtl[_set].label); |
||
| 166 | Word2(4114H, 2); (* MOV 2(SP), R4; R4 <- b *) |
||
| 167 | Word2(4115H, 4); (* MOV 4(SP), R5; R5 <- a *) |
||
| 168 | Word1(9504H); (* CMP R5, R4 *) |
||
| 169 | Word1(3800H + 24); (* JL L1 *) |
||
| 170 | Word2(9035H, 16); (* CMP #16, R5 *) |
||
| 171 | Word1(3400H + 21); (* JGE L1 *) |
||
| 172 | Word1(9304H); (* CMP #0, R4 *) |
||
| 173 | Word1(3800H + 19); (* JL L1 *) |
||
| 174 | Word2(9034H, 16); (* CMP #16, R4 *) |
||
| 175 | Word1(3800H + 2); (* JL L2 *) |
||
| 176 | Word2(4034H, 15); (* MOV #15, R4 *) |
||
| 177 | (* L2: *) |
||
| 178 | Word1(9305H); (* CMP #0, R5 *) |
||
| 179 | Word1(3400H + 1); (* JGE L3 *) |
||
| 180 | Word1(4305H); (* MOV #0, R5 *) |
||
| 181 | (* L3: *) |
||
| 182 | Word1(8504H); (* SUB R5, R4 *) |
||
| 183 | Word1(5404H); (* ADD R4, R4 *) |
||
| 184 | Word2(5034H, bits_offs); (* ADD bits_offs, R4 *) |
||
| 185 | Word1(4424H); (* MOV @R4, R4 *) |
||
| 186 | Word1(5505H); (* ADD R5, R5 *) |
||
| 187 | Word1(5405H); (* ADD R4, R5 *) |
||
| 188 | Word2(5035H, bits); (* ADD bits, R5 *) |
||
| 189 | Word1(4524H); (* MOV @R5, R4 *) |
||
| 190 | Word1(4130H); (* MOV @SP+, PC *) |
||
| 191 | (* L1: *) |
||
| 192 | Word1(4304H); (* MOV #0, R4 *) |
||
| 193 | Word1(4130H) (* RET *) |
||
| 194 | END; |
||
| 195 | |||
| 196 | (* _set1 (a: INTEGER): SET *) |
||
| 197 | IF rtl[_set1].used THEN |
||
| 198 | Label(rtl[_set1].label); |
||
| 199 | Word2(4114H, 2); (* MOV 2(SP), R4; R4 <- a *) |
||
| 200 | Word2(0B034H, 0FFF0H); (* BIT #0FFF0H, R4 *) |
||
| 201 | Word1(2000H + 5); (* JNZ L1 *) |
||
| 202 | Word1(5404H); (* ADD R4, R4 *) |
||
| 203 | Word2(5034H, bits); (* ADD bits, R4 *) |
||
| 204 | Word1(4424H); (* MOV @R4, R4 *) |
||
| 205 | Word1(4130H); (* MOV @SP+, PC *) |
||
| 206 | (* L1: *) |
||
| 207 | Word1(4304H); (* MOV #0, R4 *) |
||
| 208 | Word1(4130H) (* RET *) |
||
| 209 | END; |
||
| 210 | |||
| 211 | (* _in2 (i, s: INTEGER): BOOLEAN *) |
||
| 212 | IF rtl[_in2].used THEN |
||
| 213 | Label(rtl[_in2].label); |
||
| 214 | Word2(4114H, 2); (* MOV 2(SP), R4; R4 <- i *) |
||
| 215 | Word1(5404H); (* ADD R4, R4 *) |
||
| 216 | Word2(5034H, bits); (* ADD bits, R4 *) |
||
| 217 | Word1(4424H); (* MOV @R4, R4 *) |
||
| 218 | Word2(0F114H, 4); (* AND 4(SP), R4 *) |
||
| 219 | Word1(2400H + 1); (* JZ L1 *) |
||
| 220 | Word1(4314H); (* MOV #1, R4 *) |
||
| 221 | (* L1: *) |
||
| 222 | Word1(4130H) (* RET *) |
||
| 223 | END; |
||
| 224 | |||
| 225 | (* _in (s, i: INTEGER): BOOLEAN *) |
||
| 226 | IF rtl[_in].used THEN |
||
| 227 | Label(rtl[_in].label); |
||
| 228 | Word2(4114H, 4); (* MOV 4(SP), R4; R4 <- i *) |
||
| 229 | Word2(0B034H, 0FFF0H); (* BIT #0FFF0H, R4 *) |
||
| 230 | Word1(2000H + 9); (* JNZ L2 *) |
||
| 231 | Word1(5404H); (* ADD R4, R4 *) |
||
| 232 | Word2(5034H, bits); (* ADD bits, R4 *) |
||
| 233 | Word1(4424H); (* MOV @R4, R4 *) |
||
| 234 | Word2(0F114H, 2); (* AND 2(SP), R4 *) |
||
| 235 | Word1(2400H + 3); (* JZ L1 *) |
||
| 236 | Word1(4314H); (* MOV #1, R4 *) |
||
| 237 | Word1(4130H); (* MOV @SP+, PC *) |
||
| 238 | (* L2: *) |
||
| 239 | Word1(4304H); (* MOV #0, R4 *) |
||
| 240 | (* L1: *) |
||
| 241 | Word1(4130H) (* RET *) |
||
| 242 | END; |
||
| 243 | |||
| 244 | (* _incl (VAR s: SET; i: INTEGER) *) |
||
| 245 | IF rtl[_incl].used THEN |
||
| 246 | Label(rtl[_incl].label); |
||
| 247 | Word2(4114H, 4); (* MOV 4(SP), R4; R4 <- i *) |
||
| 248 | Word2(0B034H, 0FFF0H); (* BIT #0FFF0H, R4 *) |
||
| 249 | Word1(2000H + 8); (* JNZ L1 *) |
||
| 250 | Word1(5404H); (* ADD R4, R4 *) |
||
| 251 | Word2(5034H, bits); (* ADD bits, R4 *) |
||
| 252 | Word1(4424H); (* MOV @R4, R4 *) |
||
| 253 | Word2(4115H, 2); (* MOV 2(SP), R5; R5 <- @s *) |
||
| 254 | Word2(0D485H, 0); (* BIS R4, 0(R5) *) |
||
| 255 | (* L1: *) |
||
| 256 | Word1(4130H) (* RET *) |
||
| 257 | END; |
||
| 258 | |||
| 259 | (* _excl (VAR s: SET; i: INTEGER) *) |
||
| 260 | IF rtl[_excl].used THEN |
||
| 261 | Label(rtl[_excl].label); |
||
| 262 | Word2(4114H, 4); (* MOV 4(SP), R4; R4 <- i *) |
||
| 263 | Word2(0B034H, 0FFF0H); (* BIT #0FFF0H, R4 *) |
||
| 264 | Word1(2000H + 8); (* JNZ L1 *) |
||
| 265 | Word1(5404H); (* ADD R4, R4 *) |
||
| 266 | Word2(5034H, bits); (* ADD bits, R4 *) |
||
| 267 | Word1(4424H); (* MOV @R4, R4 *) |
||
| 268 | Word2(4115H, 2); (* MOV 2(SP), R5; R5 <- @s *) |
||
| 269 | Word2(0C485H, 0); (* BIC R4, 0(R5) *) |
||
| 270 | (* L1: *) |
||
| 271 | Word1(4130H) (* RET *) |
||
| 272 | END; |
||
| 273 | |||
| 274 | (* _rot (len, adr: INTEGER) *) |
||
| 275 | IF rtl[_rot].used THEN |
||
| 276 | Label(rtl[_rot].label); |
||
| 277 | Word2(4114H, 2); (* MOV 2(SP), R4; R4 <- len *) |
||
| 278 | Word2(4115H, 4); (* MOV 4(SP), R5; R5 <- adr *) |
||
| 279 | Word1(8314H); (* SUB #1, R4 *) |
||
| 280 | Word1(5404H); (* ADD R4, R4 *) |
||
| 281 | Word1(1225H); (* PUSH @R5 *) |
||
| 282 | Word1(4406H); (* MOV R4, R6 *) |
||
| 283 | (* L1: *) |
||
| 284 | Word3(4595H, 2, 0); (* MOV 2(R5), 0(R5) *) |
||
| 285 | Word1(5325H); (* ADD #2, R5 *) |
||
| 286 | Word1(8326H); (* SUB #2, R6 *) |
||
| 287 | Word1(2000H + 400H - 6); (* JNZ L1 *) |
||
| 288 | Word2(41B5H, 0); (* MOV @SP+, 0(R5) *) |
||
| 289 | Word1(4130H) (* RET *) |
||
| 290 | END; |
||
| 291 | |||
| 292 | (* _divmod (b, a: INTEGER): INTEGER (* res -> R4, mod -> R5 *) *) |
||
| 293 | IF rtl[_divmod].used THEN |
||
| 294 | Label(rtl[_divmod].label); |
||
| 295 | Word2(4115H, 4); (* MOV 4(SP), R5; R5 <- a *) |
||
| 296 | Word1(4304H); (* MOV #0, R4 *) |
||
| 297 | (* L1: *) |
||
| 298 | Word2(4116H, 2); (* MOV 2(SP), R6; R6 <- b *) |
||
| 299 | Word1(9605H); (* CMP R6, R5 *) |
||
| 300 | Word1(3800H + 17); (* JL L3 *) |
||
| 301 | Word1(4327H); (* MOV #2, R7 *) |
||
| 302 | Word1(5606H); (* ADD R6, R6 *) |
||
| 303 | (* L4: *) |
||
| 304 | Word1(9306H); (* CMP #0, R6 *) |
||
| 305 | Word1(2400H + 6); (* JZ L2 *) |
||
| 306 | Word1(3800H + 5); (* JL L2 *) |
||
| 307 | Word1(9605H); (* CMP R6, R5 *) |
||
| 308 | Word1(3800H + 3); (* JL L2 *) |
||
| 309 | Word1(5606H); (* ADD R6, R6 *) |
||
| 310 | Word1(5707H); (* ADD R7, R7 *) |
||
| 311 | Word1(3C00H + 400H - 8); (* JMP L4 *) |
||
| 312 | (* L2: *) |
||
| 313 | Word1(0C312H); (* BIC #1, SR *) |
||
| 314 | Word1(1006H); (* RRC R6 *) |
||
| 315 | Word1(0C312H); (* BIC #1, SR *) |
||
| 316 | Word1(1007H); (* RRC R7 *) |
||
| 317 | Word1(8605H); (* SUB R6, R5 *) |
||
| 318 | Word1(5704H); (* ADD R7, R4 *) |
||
| 319 | Word1(3C00H + 400H - 21); (* JMP L1 *) |
||
| 320 | (* L3: *) |
||
| 321 | (*----------- (a < 0) --------------*) |
||
| 322 | (* L1: *) |
||
| 323 | Word1(9305H); (* CMP #0, R5 *) |
||
| 324 | Word1(3400H + 23); (* JGE L3 *) |
||
| 325 | Word2(4116H, 2); (* MOV 2(SP), R6; R6 <- b *) |
||
| 326 | Word1(4327H); (* MOV #2, R7 *) |
||
| 327 | Word1(5606H); (* ADD R6, R6 *) |
||
| 328 | Word1(0E335H); (* XOR #-1, R5 *) |
||
| 329 | Word1(5315H); (* ADD #1, R5 *) |
||
| 330 | (* L4: *) |
||
| 331 | Word1(9306H); (* CMP #0, R6 *) |
||
| 332 | Word1(2400H + 6); (* JZ L2 *) |
||
| 333 | Word1(3800H + 5); (* JL L2 *) |
||
| 334 | Word1(9605H); (* CMP R6, R5 *) |
||
| 335 | Word1(3800H + 3); (* JL L2 *) |
||
| 336 | Word1(5606H); (* ADD R6, R6 *) |
||
| 337 | Word1(5707H); (* ADD R7, R7 *) |
||
| 338 | Word1(3C00H + 400H - 8); (* JMP L4 *) |
||
| 339 | (* L2: *) |
||
| 340 | Word1(0E335H); (* XOR #-1, R5 *) |
||
| 341 | Word1(5315H); (* ADD #1, R5 *) |
||
| 342 | Word1(0C312H); (* BIC #1, SR *) |
||
| 343 | Word1(1006H); (* RRC R6 *) |
||
| 344 | Word1(0C312H); (* BIC #1, SR *) |
||
| 345 | Word1(1007H); (* RRC R7 *) |
||
| 346 | Word1(5605H); (* ADD R6, R5 *) |
||
| 347 | Word1(8704H); (* SUB R7, R4 *) |
||
| 348 | Word1(3C00H + 400H - 25); (* JMP L1 *) |
||
| 349 | (* L3: *) |
||
| 350 | Word1(4130H) (* RET *) |
||
| 351 | END; |
||
| 352 | |||
| 353 | (* _mul (a, b: INTEGER): INTEGER *) |
||
| 354 | IF rtl[_mul].used THEN |
||
| 355 | Label(rtl[_mul].label); |
||
| 356 | Word2(4115H, 2); (* MOV 2(SP), R5; R5 <- a *) |
||
| 357 | Word2(4116H, 4); (* MOV 4(SP), R6; R6 <- b *) |
||
| 358 | Word1(4304H); (* MOV #0, R4; res := 0 *) |
||
| 359 | Word1(9306H); (* CMP #0, R6 *) |
||
| 360 | Word1(2400H + 7); (* JZ L1 *) |
||
| 361 | (* L2: *) |
||
| 362 | Word1(0B316H); (* BIT #1, R6 *) |
||
| 363 | Word1(2400H + 1); (* JZ L3 *) |
||
| 364 | Word1(5504H); (* ADD R5, R4 *) |
||
| 365 | (* L3: *) |
||
| 366 | Word1(5505H); (* ADD R5, R5 *) |
||
| 367 | Word1(0C312H); (* BIC #1, SR *) |
||
| 368 | Word1(1006H); (* RRC R6 *) |
||
| 369 | Word1(2000H + 400H - 7); (* JNZ L2 *) |
||
| 370 | (* L1: *) |
||
| 371 | Word1(4130H) (* RET *) |
||
| 372 | END; |
||
| 373 | |||
| 374 | (* _error (modNum, modName, err, line: INTEGER) *) |
||
| 375 | IF rtl[_error].used THEN |
||
| 376 | Label(rtl[_error].label); |
||
| 377 | Word1(0C232H); (* BIC #8, SR; DINT *) |
||
| 378 | Word1(4303H); (* MOV R3, R3; NOP *) |
||
| 379 | Word2(4114H, 2); (* MOV 2(SP), R4; R4 <- modNum *) |
||
| 380 | Word2(4115H, 4); (* MOV 4(SP), R5; R5 <- modName *) |
||
| 381 | Word2(4116H, 6); (* MOV 6(SP), R6; R6 <- err *) |
||
| 382 | Word2(4117H, 8); (* MOV 8(SP), R7; R7 <- line *) |
||
| 383 | Word2(4211H, sp); (* MOV sp(SR), SP *) |
||
| 384 | Word1(1207H); (* PUSH R7 *) |
||
| 385 | Word1(1206H); (* PUSH R6 *) |
||
| 386 | Word1(1205H); (* PUSH R5 *) |
||
| 387 | Word1(1204H); (* PUSH R4 *) |
||
| 388 | Word2(4214H, trap); (* MOV trap(SR), R4 *) |
||
| 389 | Word1(9304H); (* TST R4 *) |
||
| 390 | Word1(2400H + 1); (* JZ L *) |
||
| 391 | Word1(1284H); (* CALL R4 *) |
||
| 392 | (* L: *) |
||
| 393 | Word2(04032H, 0F0H) (* MOV CPUOFF+OSCOFF+SCG0+SCG1, SR *) |
||
| 394 | END; |
||
| 395 | |||
| 396 | (* _new (t, size: INTEGER; VAR ptr: INTEGER) *) |
||
| 397 | IF rtl[_new].used THEN |
||
| 398 | Label(rtl[_new].label); |
||
| 399 | Word1(1202H); (* PUSH SR *) |
||
| 400 | Word1(4302H); (* MOV #0, SR *) |
||
| 401 | Word1(4303H); (* NOP *) |
||
| 402 | Word1(4104H); (* MOV SP, R4 *) |
||
| 403 | Word2(8034H, 16); (* SUB #16, R4 *) |
||
| 404 | Word1(4005H + 100H * HP); (* MOV HP, R5 *) |
||
| 405 | Word2(5115H, 6); (* ADD 6(SP), R5 *) |
||
| 406 | Word1(9504H); (* CMP R5, R4 *) |
||
| 407 | Word2(4114H, 8); (* MOV 8(SP), R4 *) |
||
| 408 | Word1(3800H + 12); (* JL L1 *) |
||
| 409 | Word3(4190H + HP, 4, 0); (* MOV 4(SP), 0(HP) *) |
||
| 410 | Word1(5320H + HP); (* ADD #2, HP *) |
||
| 411 | Word2(4084H + 100H * HP, 0); (* MOV HP, 0(R4) *) |
||
| 412 | (* L3 *) |
||
| 413 | Word2(4380H + HP, 0); (* MOV #0, 0(HP) *) |
||
| 414 | Word1(5320H + HP); (* ADD #2, HP *) |
||
| 415 | Word1(9500H + HP); (* CMP R5, HP *) |
||
| 416 | Word1(3800H + 400H - 5); (* JL L3 *) |
||
| 417 | Word1(3C00H + 2); (* JMP L2 *) |
||
| 418 | (* L1 *) |
||
| 419 | Word2(4384H, 0); (* MOV #0, 0(R4) *) |
||
| 420 | (* L2 *) |
||
| 421 | Word1(1300H) (* RETI *) |
||
| 422 | END; |
||
| 423 | |||
| 424 | (* _guardrec (t0, t1: INTEGER): INTEGER *) |
||
| 425 | IF rtl[_guardrec].used THEN |
||
| 426 | Label(rtl[_guardrec].label); |
||
| 427 | Word2(4114H, 2); (* MOV 2(SP), R4; R4 <- t0 *) |
||
| 428 | Word2(4115H, 4); (* MOV 4(SP), R5; R5 <- t1 *) |
||
| 429 | Word2(4036H, types); (* MOV #types, R6 *) |
||
| 430 | (* L3: *) |
||
| 431 | Word1(9305H); (* CMP #0, R5 *) |
||
| 432 | Word1(2400H + 8); (* JZ L1 *) |
||
| 433 | Word1(9405H); (* CMP R4, R5 *) |
||
| 434 | Word1(2400H + 10); (* JZ L2 *) |
||
| 435 | Word1(5505H); (* ADD R5, R5 *) |
||
| 436 | Word1(0E335H); (* XOR #-1, R5 *) |
||
| 437 | Word1(5315H); (* ADD #1, R5 *) |
||
| 438 | Word1(5605H); (* ADD R6, R5 *) |
||
| 439 | Word1(4525H); (* MOV @R5, R5 *) |
||
| 440 | Word1(3C00H + 400H - 10); (* JMP L3 *) |
||
| 441 | (* L1: *) |
||
| 442 | Word1(9405H); (* CMP R4, R5 *) |
||
| 443 | Word1(2400H + 2); (* JZ L2 *) |
||
| 444 | Word1(4304H); (* MOV #0, R4 *) |
||
| 445 | Word1(4130H); (* MOV @SP+, PC *) |
||
| 446 | (* L2: *) |
||
| 447 | Word1(4314H); (* MOV #1, R4 *) |
||
| 448 | Word1(4130H) (* RET *) |
||
| 449 | END; |
||
| 450 | |||
| 451 | (* _is (t, p: INTEGER): INTEGER *) |
||
| 452 | IF rtl[_is].used THEN |
||
| 453 | Label(rtl[_is].label); |
||
| 454 | Word2(4114H, 4); (* MOV 4(SP), R4; R4 <- p *) |
||
| 455 | Word2(4115H, 2); (* MOV 2(SP), R5; R5 <- t *) |
||
| 456 | Word1(9304H); (* TST R4 *) |
||
| 457 | Word1(2400H + 2); (* JZ L *) |
||
| 458 | Word2(4414H, -2); (* MOV -2(R4), R4 *) |
||
| 459 | (* L: *) |
||
| 460 | Word1(1204H); (* PUSH R4 *) |
||
| 461 | Word1(1205H); (* PUSH R5 *) |
||
| 462 | Call(rtl[_guardrec].label); (* CALL _guardrec *) |
||
| 463 | Word1(5221H); (* ADD #4, SP *) |
||
| 464 | Word1(4130H) (* RET *) |
||
| 465 | END; |
||
| 466 | |||
| 467 | (* _guard (t, p: INTEGER): INTEGER *) |
||
| 468 | IF rtl[_guard].used THEN |
||
| 469 | Label(rtl[_guard].label); |
||
| 470 | Word2(4115H, 4); (* MOV 4(SP), R5; R5 <- p *) |
||
| 471 | Word1(4314H); (* MOV #1, R4 *) |
||
| 472 | Word1(4525H); (* MOV @R5, R5 *) |
||
| 473 | Word1(9305H); (* TST R5 *) |
||
| 474 | Word1(2400H + 9); (* JZ L *) |
||
| 475 | Word2(4515H, -2); (* MOV -2(R5), R5 *) |
||
| 476 | Word2(4114H, 2); (* MOV 2(SP), R4; R4 <- t *) |
||
| 477 | Word1(1205H); (* PUSH R5 *) |
||
| 478 | Word1(1204H); (* PUSH R4 *) |
||
| 479 | Call(rtl[_guardrec].label); (* CALL _guardrec *) |
||
| 480 | Word1(5221H); (* ADD #4, SP *) |
||
| 481 | (* L: *) |
||
| 482 | Word1(4130H) (* RET *) |
||
| 483 | END; |
||
| 484 | |||
| 485 | (* _move (bytes, dest, source: INTEGER) *) |
||
| 486 | IF rtl[_move].used THEN |
||
| 487 | Label(rtl[_move].label); |
||
| 488 | Word2(4116H, 2); (* MOV 2(SP), R6; R6 <- bytes *) |
||
| 489 | Word2(4117H, 4); (* MOV 4(SP), R7; R7 <- dest *) |
||
| 490 | Word2(4115H, 6); (* MOV 6(SP), R5; R5 <- source *) |
||
| 491 | Word1(9306H); (* CMP #0, R6 *) |
||
| 492 | Word1(3800H + 6); (* JL L1 *) |
||
| 493 | Word1(2400H + 5); (* JZ L1 *) |
||
| 494 | (* L2: *) |
||
| 495 | Word2(45F7H, 0); (* MOV.B @R5+, 0(R7) *) |
||
| 496 | Word1(5317H); (* ADD #1, R7 *) |
||
| 497 | Word1(8316H); (* SUB #1, R6 *) |
||
| 498 | Word1(2000H + 400H - 5); (* JNZ L2 *) |
||
| 499 | (* L1: *) |
||
| 500 | Word1(4130H) (* RET *) |
||
| 501 | END; |
||
| 502 | |||
| 503 | (* _arrcpy (base_size, len_dst, dst, len_src, src: INTEGER) *) |
||
| 504 | IF rtl[_arrcpy].used THEN |
||
| 505 | Label(rtl[_arrcpy].label); |
||
| 506 | Word3(9191H, 8, 4); (* CMP 8(SP), 4(SP) *) |
||
| 507 | Word1(3800H + 18); (* JL L1 *) |
||
| 508 | Word2(1211H, 12); (* PUSH 12(SP) *) |
||
| 509 | Word2(1211H, 10); (* PUSH 10(SP) *) |
||
| 510 | Word2(1211H, 14); (* PUSH 14(SP) *) |
||
| 511 | Word2(1211H, 10); (* PUSH 10(SP) *) |
||
| 512 | Call(rtl[_mul].label); (* CALL _mul *) |
||
| 513 | Word1(5221H); (* ADD #4, SP *) |
||
| 514 | Word1(1204H); (* PUSH R4 *) |
||
| 515 | Call(rtl[_move].label); (* CALL _move *) |
||
| 516 | Word2(5031H, 6); (* ADD #6, SP *) |
||
| 517 | Word1(4314H); (* MOV #1, R4 *) |
||
| 518 | Word1(4130H); (* RET *) |
||
| 519 | (* L1 *) |
||
| 520 | Word1(4304H); (* MOV #0, R4 *) |
||
| 521 | Word1(4130H) (* RET *) |
||
| 522 | END; |
||
| 523 | |||
| 524 | (* _length (len, str: INTEGER): INTEGER *) |
||
| 525 | IF rtl[_length].used THEN |
||
| 526 | Label(rtl[_length].label); |
||
| 527 | Word2(4116H, 2); (* MOV 2(SP), R6; R6 <- len *) |
||
| 528 | Word2(4117H, 4); (* MOV 4(SP), R7; R7 <- str *) |
||
| 529 | Word1(4304H); (* MOV #0, R4; res := 0 *) |
||
| 530 | (* L2: *) |
||
| 531 | Word1(4775H); (* MOV.B @R7+, R5 *) |
||
| 532 | Word1(9305H); (* CMP #0, R5 *) |
||
| 533 | Word1(2400H + 3); (* JZ L1 *) |
||
| 534 | Word1(5314H); (* ADD #1, R4 *) |
||
| 535 | Word1(8316H); (* SUB #1, R6 *) |
||
| 536 | Word1(2000H + 400H - 6); (* JNZ L2 *) |
||
| 537 | (* L1: *) |
||
| 538 | Word1(4130H) (* RET *) |
||
| 539 | END; |
||
| 540 | |||
| 541 | (* _strcmp (op, len2, str2, len1, str1: INTEGER): BOOLEAN *) |
||
| 542 | IF rtl[_strcmp].used THEN |
||
| 543 | Label(rtl[_strcmp].label); |
||
| 544 | Word2(4116H, 4); (* MOV 4(SP), R6; R6 <- len2 *) |
||
| 545 | Word2(4117H, 8); (* MOV 8(SP), R7; R7 <- len1 *) |
||
| 546 | Word1(9607H); (* CMP R6, R7 *) |
||
| 547 | Word1(3400H + 1); (* JGE L5 *) |
||
| 548 | Word1(4706H); (* MOV R7, R6 *) |
||
| 549 | (* L5: *) |
||
| 550 | Word1(1206H); (* PUSH R6 *) |
||
| 551 | Word2(4116H, 12); (* MOV 12(SP), R6; R6 <- str1 *) |
||
| 552 | Word2(4117H, 8); (* MOV 8(SP), R7; R7 <- str2 *) |
||
| 553 | (* L3: *) |
||
| 554 | Word2(9381H, 0); (* CMP #0, 0(SP) *) |
||
| 555 | Word1(2400H + 11); (* JZ L1 *) |
||
| 556 | Word1(4674H); (* MOV.B @R6+, R4 *) |
||
| 557 | Word1(4775H); (* MOV.B @R7+, R5 *) |
||
| 558 | Word2(8391H, 0); (* SUB #1, 0(SP) *) |
||
| 559 | Word1(9405H); (* CMP R4, R5 *) |
||
| 560 | Word1(2400H + 2); (* JZ L2 *) |
||
| 561 | Word1(8504H); (* SUB R5, R4 *) |
||
| 562 | Word1(3C00H + 5); (* JMP L4 *) |
||
| 563 | (* L2: *) |
||
| 564 | Word1(9304H); (* CMP #0, R4 *) |
||
| 565 | Word1(2000H + 400H - 13); (* JNZ L3 *) |
||
| 566 | Word1(3C00H + 2); (* JMP L4 *) |
||
| 567 | (* L1: *) |
||
| 568 | Word2(4034H, 8000H); (* MOV #8000H, R4 *) |
||
| 569 | (* L4: *) |
||
| 570 | Word1(5321H); (* ADD #2, SP *) |
||
| 571 | |||
| 572 | Word2(9034H, 8000H); (* CMP #8000H, R4 *) |
||
| 573 | Word1(2000H + 18); (* JNZ L6 *) |
||
| 574 | Word2(4116H, 4); (* MOV 4(SP), R6; R6 <- len2 *) |
||
| 575 | Word2(4117H, 8); (* MOV 8(SP), R7; R7 <- len1 *) |
||
| 576 | Word1(9607H); (* CMP R6, R7 *) |
||
| 577 | Word1(2400H + 11); (* JZ L7 *) |
||
| 578 | Word1(3800H + 4); (* JL L8 *) |
||
| 579 | Word2(5116H, 10); (* ADD 10(SP), R6 *) |
||
| 580 | Word1(4664H); (* MOV.B @R6, R4 *) |
||
| 581 | Word1(3C00H + 7); (* JMP L6 *) |
||
| 582 | (* L8: *) |
||
| 583 | Word2(5117H, 6); (* ADD 6(SP), R7 *) |
||
| 584 | Word1(4764H); (* MOV.B @R7, R4 *) |
||
| 585 | Word1(0E334H); (* XOR #-1, R4 *) |
||
| 586 | Word1(5314H); (* ADD #1, R4 *) |
||
| 587 | Word1(3C00H + 1); (* JMP L6 *) |
||
| 588 | (* L7: *) |
||
| 589 | Word1(4304H); (* MOV #0, R4 *) |
||
| 590 | (* L6: *) |
||
| 591 | |||
| 592 | Word2(5110H, 2); (* ADD 2(SP), PC; PC <- PC + op *) |
||
| 593 | |||
| 594 | Word1(9304H); (* CMP #0, R4 *) |
||
| 595 | Word1(4314H); (* MOV #1, R4 *) |
||
| 596 | Word1(2400H + 1); (* JZ L *) |
||
| 597 | Word1(4304H); (* MOV #0, R4 *) |
||
| 598 | (* L *) |
||
| 599 | Word1(4130H); (* RET *) |
||
| 600 | Word1(4303H); (* NOP *) |
||
| 601 | |||
| 602 | Word1(9304H); (* CMP #0, R4 *) |
||
| 603 | Word1(4314H); (* MOV #1, R4 *) |
||
| 604 | Word1(2000H + 1); (* JNZ L *) |
||
| 605 | Word1(4304H); (* MOV #0, R4 *) |
||
| 606 | (* L *) |
||
| 607 | Word1(4130H); (* RET *) |
||
| 608 | Word1(4303H); (* NOP *) |
||
| 609 | |||
| 610 | Word1(9304H); (* CMP #0, R4 *) |
||
| 611 | Word1(4314H); (* MOV #1, R4 *) |
||
| 612 | Word1(3800H + 1); (* JL L *) |
||
| 613 | Word1(4304H); (* MOV #0, R4 *) |
||
| 614 | (* L *) |
||
| 615 | Word1(4130H); (* RET *) |
||
| 616 | Word1(4303H); (* NOP *) |
||
| 617 | |||
| 618 | Word1(9304H); (* CMP #0, R4 *) |
||
| 619 | Word1(4314H); (* MOV #1, R4 *) |
||
| 620 | Word1(3800H + 2); (* JL L *) |
||
| 621 | Word1(2400H + 1); (* JZ L *) |
||
| 622 | Word1(4304H); (* MOV #0, R4 *) |
||
| 623 | (* L *) |
||
| 624 | Word1(4130H); (* RET *) |
||
| 625 | |||
| 626 | Word1(9304H); (* CMP #0, R4 *) |
||
| 627 | Word1(4304H); (* MOV #0, R4 *) |
||
| 628 | Word1(3800H + 2); (* JL L *) |
||
| 629 | Word1(2400H + 1); (* JZ L *) |
||
| 630 | Word1(4314H); (* MOV #1, R4 *) |
||
| 631 | (* L *) |
||
| 632 | Word1(4130H); (* RET *) |
||
| 633 | |||
| 634 | Word1(9304H); (* CMP #0, R4 *) |
||
| 635 | Word1(4314H); (* MOV #1, R4 *) |
||
| 636 | Word1(3400H + 1); (* JGE L *) |
||
| 637 | Word1(4304H); (* MOV #0, R4 *) |
||
| 638 | (* L *) |
||
| 639 | Word1(4130H) (* RET *) |
||
| 640 | END |
||
| 641 | |||
| 642 | END Gen; |
||
| 643 | |||
| 644 | |||
| 645 | PROCEDURE Set* (idx, label: INTEGER); |
||
| 646 | BEGIN |
||
| 647 | rtl[idx].label := label; |
||
| 648 | rtl[idx].used := FALSE |
||
| 649 | END Set; |
||
| 650 | |||
| 651 | |||
| 652 | PROCEDURE Used* (idx: INTEGER); |
||
| 653 | BEGIN |
||
| 654 | rtl[idx].used := TRUE; |
||
| 655 | IF (idx = _guard) OR (idx = _is) THEN |
||
| 656 | rtl[_guardrec].used := TRUE |
||
| 657 | ELSIF idx = _arrcpy THEN |
||
| 658 | rtl[_move].used := TRUE; |
||
| 659 | rtl[_mul].used := TRUE |
||
| 660 | END |
||
| 661 | END Used; |
||
| 662 | |||
| 663 | |||
| 664 | PROCEDURE Init* (pLabel, pWord, pCall: EMITPROC; ramSize: INTEGER); |
||
| 665 | BEGIN |
||
| 666 | Label := pLabel; |
||
| 667 | Word := pWord; |
||
| 668 | Call := pCall; |
||
| 669 | ram := 200H; |
||
| 670 | trap := ram; |
||
| 671 | int := trap + 2 |
||
| 672 | END Init; |
||
| 673 | |||
| 674 | |||
| 675 | END MSP430RTL. |