home *** CD-ROM | disk | FTP | other *** search
/ Il CD di internet / CD.iso / SOURCE / D / CLISP / CLISPSRC.TAR / clisp-1995-01-01 / src / arivaxunix.d < prev    next >
Encoding:
Text File  |  1993-04-24  |  15.1 KB  |  569 lines
  1. # Externe Routinen zu ARILEV1.D
  2. # Prozessor: VAX
  3. # Compiler: GNU-C oder VAX C
  4. # Assembler: Unix "as"
  5. # Parameter-▄bergabe: auf dem Stack 4(ap),8(ap),...
  6. # Rⁿckgabewert: in Register r0
  7. # Register r0-r5 frei verwendbar, zu rettende Register ab r6 sind
  8. #   in der .word-Anweisung anzugeben (Bitmaske: Bit i fⁿr Register ri)
  9. # Einstellungen: intCsize=32, intDsize=32.
  10.  
  11. #ifdef INCLUDED_FROM_C
  12.  
  13.   #define COPY_LOOPS
  14.   #define FILL_LOOPS
  15.   #define CLEAR_LOOPS
  16.   #define LOG_LOOPS
  17.   #define TEST_LOOPS
  18.   #define ADDSUB_LOOPS
  19.  
  20. #else
  21.  
  22.            .globl _copy_loop_up
  23.            .globl _copy_loop_down
  24.            .globl _fill_loop_up
  25.            .globl _fill_loop_down
  26.            .globl _clear_loop_up
  27.            .globl _clear_loop_down
  28.            .globl _or_loop_up
  29.            .globl _xor_loop_up
  30.            .globl _and_loop_up
  31.            .globl _eqv_loop_up
  32.            .globl _nand_loop_up
  33.            .globl _nor_loop_up
  34.            .globl _andc2_loop_up
  35.            .globl _orc2_loop_up
  36.            .globl _not_loop_up
  37.            .globl _and_test_loop_up
  38.            .globl _test_loop_up
  39.            .globl _compare_loop_up
  40.            .globl _add_loop_down
  41.            .globl _addto_loop_down
  42.            .globl _inc_loop_down
  43.            .globl _sub_loop_down
  44.            .globl _subx_loop_down
  45.            .globl _subfrom_loop_down
  46.            .globl _dec_loop_down
  47.            .globl _neg_loop_down
  48.  
  49. #ifndef __GNUC__ /* mit GNU-C machen wir mulu32() als Macro, der inline multipliziert */
  50.            .globl _mulu32_
  51. #
  52. # Aus gcc-2.3.3/config/vax.md:
  53. # (define_insn ""
  54. #   [(set (match_operand:DI 0 "general_operand" "=g")
  55. #         (plus:DI
  56. #          (mult:DI (sign_extend:DI
  57. #                    (match_operand:SI 1 "nonimmediate_operand" "g"))
  58. #                   (sign_extend:DI
  59. #                    (match_operand:SI 2 "nonimmediate_operand" "g")))
  60. #          (sign_extend:DI (match_operand:SI 3 "nonimmediate_operand" "g"))))]
  61. #   ""
  62. #   "emul %1,%2,%3,%0")
  63. #
  64.            .align 1
  65. # extern struct { uint32 lo; uint32 hi; } mulu32_ (uint32 arg1, uint32 arg2);
  66. # 2^32*hi+lo := arg1*arg2.
  67. _mulu32_:  # Input in r2,r3, Output in r0,mulu32_high
  68.            .word 0
  69.            movl 4(ap),r2
  70.            movl 8(ap),r3
  71.            emul r2,r3,$0,r0 # 2^32*r1 + r0 := r2 * r3 (signed multiplication)
  72.            tstl r2
  73.            bgeq _m1
  74.            addl2 r3,r1
  75. _m1:       tstl r3
  76.            bgeq _m2
  77.            addl2 r2,r1
  78. _m2:       # 2^32*r1 + r0 = r2 * r3 (unsigned multiplication)
  79.            movl r1,_mulu32_high
  80.            ret
  81. #endif
  82.  
  83. #if 0
  84. #ifndef __GNUC__ /* mit GNU-C machen wir divu_6432_3232() als Macro, der inline dividiert */
  85.            .globl _divu_6432_3232_
  86. #
  87. # Aus gcc-2.3.3/config/vax.md:
  88. # ;This is left out because it is very slow;
  89. # ;we are better off programming around the "lack" of this insn.
  90. # ;(define_insn "divmoddisi4"
  91. # ;  [(set (match_operand:SI 0 "general_operand" "=g")
  92. # ;       (div:SI (match_operand:DI 1 "general_operand" "g")
  93. # ;               (match_operand:SI 2 "general_operand" "g")))
  94. # ;   (set (match_operand:SI 3 "general_operand" "=g")
  95. # ;       (mod:SI (match_operand:DI 1 "general_operand" "g")
  96. # ;               (match_operand:SI 2 "general_operand" "g")))]
  97. # ;  ""
  98. # ;  "ediv %2,%1,%0,%3")
  99. #
  100. # Aus gcc-2.3.3/config/vax.md:
  101. # (define_insn "divsi3"
  102. #   [(set (match_operand:SI 0 "general_operand" "=g,g")
  103. #         (div:SI (match_operand:SI 1 "general_operand" "0,g")
  104. #                 (match_operand:SI 2 "general_operand" "g,g")))]
  105. #   ""
  106. #   "@
  107. #    divl2 %2,%0
  108. #    divl3 %2,%1,%0")
  109. #
  110.            .align 1
  111. # extern struct { uint32 q; uint32 r; } divu_6432_3232_ (uint32 xhi, uint32 xlo, uint32 y);
  112. # x = 2^32*xhi+xlo = q*y+r schreiben. Sei bekannt, da▀ 0 <= x < 2^32*y .
  113. _divu_6432_3232_: # Input in d1,d0,d2, Output in d0,divu_32_rest
  114.            .word 0
  115.            ??
  116.            ret
  117. #endif
  118. #endif
  119.  
  120.            .align 1
  121. # extern uintD* copy_loop_up (uintD* sourceptr, uintD* destptr, uintC count);
  122. _copy_loop_up: # Input in r1,r0,r2, Output in r0
  123.            .word 0
  124.            movl 4(ap),r1
  125.            movl 8(ap),r0
  126.            movl 12(ap),r2
  127.            sobgeq r2,clu1
  128.            ret
  129. clu1:        movl (r1)+,(r0)+
  130.              sobgeq r2,clu1
  131.            ret
  132.  
  133.            .align 1
  134. # extern uintD* copy_loop_down (uintD* sourceptr, uintD* destptr, uintC count);
  135. _copy_loop_down: # Input in r1,r0,r2, Output in r0
  136.            .word 0
  137.            movl 4(ap),r1
  138.            movl 8(ap),r0
  139.            movl 12(ap),r2
  140.            sobgeq r2,cld1
  141.            ret
  142. cld1:        movl -(r1),-(r0)
  143.              sobgeq r2,cld1
  144.            ret
  145.  
  146.            .align 1
  147. # extern uintD* fill_loop_up (uintD* destptr, uintC count, uintD filler);
  148. _fill_loop_up: # Input in r0,r1,r2, Output in r0
  149.            .word 0
  150.            movl 4(ap),r0
  151.            movl 8(ap),r1
  152.            movl 12(ap),r2
  153.            sobgeq r1,flu1
  154.            ret
  155. flu1:        movl r2,(r0)+
  156.              sobgeq r1,flu1
  157.            ret
  158.  
  159.            .align 1
  160. # extern uintD* fill_loop_down (uintD* destptr, uintC count, uintD filler);
  161. _fill_loop_down: # Input in r0,r1,r2, Output in r0
  162.            .word 0
  163.            movl 4(ap),r0
  164.            movl 8(ap),r1
  165.            movl 12(ap),r2
  166.            sobgeq r1,fld1
  167.            ret
  168. fld1:        movl r2,-(r0)
  169.              sobgeq r1,fld1
  170.            ret
  171.  
  172.            .align 1
  173. # extern uintD* clear_loop_up (uintD* destptr, uintC count);
  174. _clear_loop_up: # Input in r0,r1, Output in r0
  175.            .word 0
  176.            movl 4(ap),r0
  177.            movl 8(ap),r1
  178.            sobgeq r1,clu2
  179.            ret
  180. clu2:        clrl (r0)+
  181.              sobgeq r1,clu2
  182.            ret
  183.  
  184.            .align 1
  185. # extern uintD* clear_loop_down (uintD* destptr, uintC count);
  186. _clear_loop_down: # Input in r0,r1, Output in r0
  187.            .word 0
  188.            movl 4(ap),r0
  189.            movl 8(ap),r1
  190.            sobgeq r1,clu3
  191.            ret
  192. clu3:        clrl -(r0)
  193.              sobgeq r1,clu3
  194.            ret
  195.  
  196.            .align 1
  197. # extern void or_loop_up (uintD* xptr, uintD* yptr, uintC count);
  198. _or_loop_up: # Input in r0,r1,r2
  199.            .word 0
  200.            movl 4(ap),r0
  201.            movl 8(ap),r1
  202.            movl 12(ap),r2
  203.            sobgeq r2,olu1
  204.            ret
  205. olu1:        bisl2 (r1)+,(r0)+
  206.              sobgeq r2,olu1
  207.            ret
  208.  
  209.            .align 1
  210. # extern void xor_loop_up (uintD* xptr, uintD* yptr, uintC count);
  211. _xor_loop_up: # Input in r0,r1,r2
  212.            .word 0
  213.            movl 4(ap),r0
  214.            movl 8(ap),r1
  215.            movl 12(ap),r2
  216.            sobgeq r2,xlu1
  217.            ret
  218. xlu1:        xorl2 (r1)+,(r0)+
  219.              sobgeq r2,xlu1
  220.            ret
  221.  
  222.            .align 1
  223. # extern void and_loop_up (uintD* xptr, uintD* yptr, uintC count);
  224. _and_loop_up: # Input in r0,r1,r2
  225.            .word 0
  226.            movl 4(ap),r0
  227.            movl 8(ap),r1
  228.            movl 12(ap),r2
  229.            sobgeq r2,alu1
  230.            ret
  231. alu1:        mcoml (r1)+,r3
  232.              bicl2 r3,(r0)+
  233.              sobgeq r2,alu1
  234.            ret
  235.  
  236.            .align 1
  237. # extern void eqv_loop_up (uintD* xptr, uintD* yptr, uintC count);
  238. _eqv_loop_up: # Input in r0,r1,r2
  239.            .word 0
  240.            movl 4(ap),r0
  241.            movl 8(ap),r1
  242.            movl 12(ap),r2
  243.            sobgeq r2,elu1
  244.            ret
  245. elu1:        xorl2 (r1)+,(r0)
  246.              mcoml (r0),(r0)+
  247.              sobgeq r2,elu1
  248.            ret
  249.  
  250.            .align 1
  251. # extern void nand_loop_up (uintD* xptr, uintD* yptr, uintC count);
  252. _nand_loop_up: # Input in r0,r1,r2
  253.            .word 0
  254.            movl 4(ap),r0
  255.            movl 8(ap),r1
  256.            movl 12(ap),r2
  257.            sobgeq r2,nalu1
  258.            ret
  259. nalu1:       mcoml (r0),r3
  260.              mcoml (r1)+,r4
  261.              bisl3 r3,r4,(r0)+
  262.              sobgeq r2,nalu1
  263.            ret
  264.  
  265.            .align 1
  266. # extern void nor_loop_up (uintD* xptr, uintD* yptr, uintC count);
  267. _nor_loop_up: # Input in r0,r1,r2
  268.            .word 0
  269.            movl 4(ap),r0
  270.            movl 8(ap),r1
  271.            movl 12(ap),r2
  272.            sobgeq r2,nolu1
  273.            ret
  274. nolu1:       bisl2 (r1)+,(r0)
  275.              mcoml (r0),(r0)+
  276.              sobgeq r2,nolu1
  277.            ret
  278.  
  279.            .align 1
  280. # extern void andc2_loop_up (uintD* xptr, uintD* yptr, uintC count);
  281. _andc2_loop_up: # Input in r0,r1,r2, verΣndert r3
  282.            .word 0
  283.            movl 4(ap),r0
  284.            movl 8(ap),r1
  285.            movl 12(ap),r2
  286.            sobgeq r2,alu2
  287.            ret
  288. alu2:        bicl2 (r1)+,(r0)+
  289.              sobgeq r2,alu2
  290.            ret
  291.  
  292.            .align 1
  293. # extern void orc2_loop_up (uintD* xptr, uintD* yptr, uintC count);
  294. _orc2_loop_up: # Input in r0,r1,r2, verΣndert r3
  295.            .word 0
  296.            movl 4(ap),r0
  297.            movl 8(ap),r1
  298.            movl 12(ap),r2
  299.            sobgeq r2,olu2
  300.            ret
  301. olu2:        mcoml (r1)+,r3
  302.              bisl2 r3,(r0)+
  303.              sobgeq r2,olu2
  304.            ret
  305.  
  306.            .align 1
  307. # extern void not_loop_up (uintD* xptr, uintC count);
  308. _not_loop_up: # Input in r0,r1
  309.            .word 0
  310.            movl 4(ap),r0
  311.            movl 8(ap),r1
  312.            sobgeq r1,nlu1
  313.            ret
  314. nlu1:        mcoml (r0),(r0)+
  315.              sobgeq r1,nlu1
  316.            ret
  317.  
  318.            .align 1
  319. # extern boolean and_test_loop_up (uintD* xptr, uintD* yptr, uintC count);
  320. _and_test_loop_up: # Input in r0,r1,r2, verΣndert r3, Output in r0
  321.            .word 0
  322.            movl 4(ap),r0
  323.            movl 8(ap),r1
  324.            movl 12(ap),r2
  325.            sobgeq r2,atlu1
  326.            clrl r0
  327.            ret
  328. atlu1:       mcoml (r0)+,r3
  329.              bicl3 r3,(r1)+,r3
  330.              bneq atlu2
  331.              sobgeq r2,atlu1
  332.            clrl r0
  333.            ret
  334. atlu2:     movl $1,r0
  335.            ret
  336.  
  337.            .align 1
  338. # extern boolean test_loop_up (uintD* ptr, uintC count);
  339. _test_loop_up: # Input in r0,r1, Output in r0
  340.            .word 0
  341.            movl 4(ap),r0
  342.            movl 8(ap),r1
  343.            sobgeq r1,tlu1
  344.            clrl r0
  345.            ret
  346. tlu1:        tstl (r0)+
  347.              bneq tlu2
  348.              sobgeq r1,tlu1
  349.            clrl r0
  350.            ret
  351. tlu2:      movl $1,r0
  352.            ret
  353.  
  354.            .align 1
  355. # extern signean compare_loop_up (uintD* xptr, uintD* yptr, uintC count);
  356. _compare_loop_up: # Input in r0,r1,r2, Output in r0
  357.            .word 0
  358.            movl 4(ap),r0
  359.            movl 8(ap),r1
  360.            movl 12(ap),r2
  361.            sobgeq r2,clu4
  362.            clrl r0
  363.            ret
  364. clu4:        cmpl (r0)+,(r1)+
  365.              bneq clu5
  366.              sobgeq r2,clu4
  367.            clrl r0
  368.            ret
  369. clu5:      blssu clu6
  370.            movl $1,r0
  371.            ret
  372. clu6:      movl $-1,r0
  373.            ret
  374.  
  375.            .align 1
  376. # extern uintD add_loop_down (uintD* sourceptr1, uintD* sourceptr2, uintD* destptr, uintC count);
  377. _add_loop_down: # Input in r0,r1,r2,r3, Output in r0
  378.            .word 0
  379.            movl 4(ap),r0
  380.            movl 8(ap),r1
  381.            movl 12(ap),r2
  382.            movl 16(ap),r3
  383.            sobgeq r3,ald1
  384.            clrl r0
  385.            ret
  386. ald1:        # Addition ohne Carry:
  387.              addl3 -(r0),-(r1),-(r2)
  388.              bcs ald4
  389. ald2:        sobgeq r3,ald1
  390.            clrl r0
  391.            ret
  392. ald3:        # Addition mit Carry:
  393.              addl3 -(r0),-(r1),-(r2)
  394.              bcs ald5
  395.              incl (r2)
  396.              bcc ald2
  397. ald4:        sobgeq r3,ald3
  398.            movl $1,r0
  399.            ret
  400. ald5:        incl (r2)
  401.              sobgeq r3,ald3
  402.            movl $1,r0
  403.            ret
  404.  
  405.            .align 1
  406. # extern uintD addto_loop_down (uintD* sourceptr, uintD* destptr, uintC count);
  407. _addto_loop_down: # Input in r0,r1,r2, Output in r0
  408.            .word 0
  409.            movl 4(ap),r0
  410.            movl 8(ap),r1
  411.            movl 12(ap),r2
  412.            sobgeq r2,atld1
  413.            clrl r0
  414.            ret
  415. atld1:       # Addition ohne Carry:
  416.              addl2 -(r0),-(r1)
  417.              bcs atld4
  418. atld2:       sobgeq r2,atld1
  419.            clrl r0
  420.            ret
  421. atld3:       # Addition mit Carry:
  422.              addl2 -(r0),-(r1)
  423.              bcs atld5
  424.              incl (r1)
  425.              bcc atld2
  426. atld4:       sobgeq r2,atld3
  427.            movl $1,r0
  428.            ret
  429. atld5:       incl (r1)
  430.              sobgeq r2,atld3
  431.            movl $1,r0
  432.            ret
  433.  
  434.            .align 1
  435. # extern uintD inc_loop_down (uintD* ptr, uintC count);
  436. _inc_loop_down: # Input in r0,r1, Output in r0
  437.            .word 0
  438.            movl 4(ap),r0
  439.            movl 8(ap),r1
  440.            sobgeq r1,ild1
  441.            movl $1,r0
  442.            ret
  443. ild1:        incl -(r0)
  444.              bcc ild2
  445.              sobgeq r1,ild1
  446.            movl $1,r0
  447.            ret
  448. ild2:      clrl r0
  449.            ret
  450.  
  451.            .align 1
  452. # extern uintD sub_loop_down (uintD* sourceptr1, uintD* sourceptr2, uintD* destptr, uintC count);
  453. _sub_loop_down: # Input in r0,r1,r2,r3, Output in r0
  454.            .word 0
  455.            movl 4(ap),r0
  456.            movl 8(ap),r1
  457.            movl 12(ap),r2
  458.            movl 16(ap),r3
  459.            sobgeq r3,sld1
  460.            clrl r0
  461.            ret
  462. sld1:        # Subtraktion ohne Carry:
  463.              subl3 -(r0),-(r1),-(r2) # oder subl3 -(r1),-(r0),-(r2) ??
  464.              bcs sld4
  465. sld2:        sobgeq r3,sld1
  466.            clrl r0
  467.            ret
  468. sld3:        # Subtraktion mit Carry:
  469.              subl3 -(r0),-(r1),-(r2) # dito??
  470.              bcs sld5
  471.              decl (r2)
  472.              bcc sld2
  473. sld4:        sobgeq r3,sld3
  474.            movl $-1,r0
  475.            ret
  476. sld5:        decl (r2)
  477.              sobgeq r3,sld3
  478.            movl $-1,r0
  479.            ret
  480.  
  481.            .align 1
  482. # extern uintD subx_loop_down (uintD* sourceptr1, uintD* sourceptr2, uintD* destptr, uintC count, uintD carry);
  483. _subx_loop_down: # Input in r0,r1,r2,r3, Output in r0
  484.            .word 0
  485.            movl 4(ap),r0
  486.            movl 8(ap),r1
  487.            movl 12(ap),r2
  488.            movl 16(ap),r3
  489.            tstl 20(ap)
  490.            beql sld2
  491.            brb sld4
  492.  
  493.            .align 1
  494. # extern uintD subfrom_loop_down (uintD* sourceptr, uintD* destptr, uintC count);
  495. _subfrom_loop_down: # Input in r0,r1,r2, Output in r0
  496.            .word 0
  497.            movl 4(ap),r0
  498.            movl 8(ap),r1
  499.            movl 12(ap),r2
  500.            sobgeq r2,sfld1
  501.            clrl r0
  502.            ret
  503. sfld1:       # Subtraktion ohne Carry:
  504.              subl2 -(r0),-(r1)
  505.              bcs sfld4
  506. sfld2:       sobgeq r2,sfld1
  507.            clrl r0
  508.            ret
  509. sfld3:       # Subtraktion mit Carry:
  510.              subl2 -(r0),-(r1)
  511.              bcs sfld5
  512.              decl (r1)
  513.              bcc sfld2
  514. sfld4:       sobgeq r2,sfld3
  515.            movl $-1,r0
  516.            ret
  517. sfld5:       decl (r1)
  518.              sobgeq r2,sfld3
  519.            movl $-1,r0
  520.            ret
  521.  
  522.            .align 1
  523. # extern uintD dec_loop_down (uintD* ptr, uintC count);
  524. _dec_loop_down: # Input in r0,r1, Output in r0
  525.            .word 0
  526.            movl 4(ap),r0
  527.            movl 8(ap),r1
  528.            sobgeq r1,dld1
  529.            movl $-1,r0
  530.            ret
  531. dld1:        decl -(r0)
  532.              bcc dld2
  533.              sobgeq r1,dld1
  534.            movl $-1,r0
  535.            ret
  536. dld2:      clrl r0
  537.            ret
  538.  
  539.            .align 1
  540. # extern uintD neg_loop_down (uintD* ptr, uintC count);
  541. _neg_loop_down: # Input in r0,r1, Output in r0
  542.            .word 0
  543.            movl 4(ap),r0
  544.            movl 8(ap),r1
  545.            # erstes Digit /=0 suchen:
  546.            sobgeq r1,nld1
  547.            clrl r0
  548.            ret
  549. nld1:        tstl -(r0)
  550.              bneq nld2
  551.              sobgeq r1,nld1
  552.            clrl r0
  553.            ret
  554. nld2:      # erstes Digit /=0 gefunden, ab jetzt gibt's Carrys
  555.            mnegl (r0),(r0)
  556.            # alle anderen Digits invertieren:
  557.            sobgeq r1,nld3
  558.            movl $-1,r1
  559.            ret
  560. nld3:        mcoml -(r0),(r0) # geht das??
  561.              sobgeq r1,nld3
  562.            movl $-1,r1
  563.            ret
  564.  
  565.            .end
  566.  
  567. #endif
  568.  
  569.