Subversion Repositories Kolibri OS

Rev

Rev 7696 | Go to most recent revision | Blame | Last modification | View Log | Download | RSS feed

  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.