Subversion Repositories Kolibri OS

Rev

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

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