Subversion Repositories Kolibri OS

Rev

Rev 8859 | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

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