home *** CD-ROM | disk | FTP | other *** search
/ PC Media 3 / PC MEDIA CD03.iso / share / prog / qmath10 / quad3_32.asm < prev    next >
Encoding:
Assembly Source File  |  1993-07-12  |  5.5 KB  |  328 lines
  1. .386
  2. .model small,pascal
  3.  
  4. quad    struc
  5. q0    dd    ?
  6. q1    dd    ?
  7. quad    ends
  8.  
  9. .code
  10.  
  11. ;-----------------------------------------------------------------------------
  12. ;void pascal quadinc(quad* z, quad x)
  13. ;compute z=z+x
  14.  
  15. public    QUADINC
  16. QUADINC    proc    z:ptr, x:qword
  17.  
  18.     mov    eax,(x).q0
  19.     mov    edx,(x).q1
  20.     mov    ebx,z
  21.     add    [ebx].q0,eax
  22.     adc    [ebx].q1,edx
  23.     ret
  24.  
  25. QUADINC    endp
  26.  
  27. ;-----------------------------------------------------------------------------
  28. ;void pascal quadinca(quad* z, quad* x)
  29. ;compute z=z+x
  30.  
  31. public    QUADINCA
  32. QUADINCA    proc    z:ptr, x:ptr
  33.  
  34.     mov    ebx,x
  35.     mov    eax,[ebx].q0
  36.     mov    edx,[ebx].q1
  37.     mov    ebx,z
  38.     add    [ebx].q0,eax
  39.     adc    [ebx].q1,edx
  40.     ret
  41.  
  42. QUADINCA    endp
  43.  
  44. ;-----------------------------------------------------------------------------
  45. ;void pascal quaddec(quad* z, quad x)
  46. ;compute z=z-x
  47.  
  48. public    QUADDEC
  49. QUADDEC    proc    z:ptr, x:qword
  50.  
  51.     mov    eax,(x).q0
  52.     mov    edx,(x).q1
  53.     mov    ebx,z
  54.     sub    [ebx].q0,eax
  55.     sbb    [ebx].q1,edx
  56.     ret
  57.  
  58. QUADDEC    endp
  59.  
  60. ;-----------------------------------------------------------------------------
  61. ;void pascal quaddeca(quad* z, quad* x)
  62. ;compute z=z-x
  63.  
  64. public    QUADDECA
  65. QUADDECA    proc    z:ptr, x:ptr
  66.  
  67.     mov    ebx,x
  68.     mov    eax,[ebx].q0
  69.     mov    edx,[ebx].q1
  70.     mov    ebx,z
  71.     sub    [ebx].q0,eax
  72.     sbb    [ebx].q1,edx
  73.     ret
  74.  
  75. QUADDECA    endp
  76.  
  77. ;-----------------------------------------------------------------------------
  78. ;void pascal quadadd(quad* z, quad x, quad y)
  79. ;compute z=x+y
  80.  
  81. public    QUADADD
  82. QUADADD    proc    z:ptr, x:qword, y:qword
  83.  
  84.     mov    eax,(x).q0
  85.     mov    edx,(x).q1
  86.     add    eax,(y).q0
  87.     adc    edx,(y).q1
  88.     mov    ebx,z
  89.     mov    [ebx].q0,eax
  90.     mov    [ebx].q1,edx
  91.     ret
  92.  
  93. QUADADD    endp
  94.  
  95. ;-----------------------------------------------------------------------------
  96. ;void pascal quadadda(quad* z, quad* x, quad* y)
  97. ;compute z=x+y
  98.  
  99. public    QUADADDA
  100. QUADADDA    proc    z:ptr, x:ptr, y:ptr
  101.  
  102.     mov    ebx,x
  103.     mov    eax,[ebx].q0
  104.     mov    edx,[ebx].q1
  105.     mov    ebx,y
  106.     add    eax,[ebx].q0
  107.     adc    edx,[ebx].q1
  108.     mov    ebx,z
  109.     mov    [ebx].q0,eax
  110.     mov    [ebx].q1,edx
  111.     ret
  112.  
  113. QUADADDA    endp
  114.  
  115. ;-----------------------------------------------------------------------------
  116. ;void pascal quadsub(quad* z, quad x, quad y)
  117. ;compute z=x-y
  118.  
  119. public    QUADSUB
  120. QUADSUB    proc    z:ptr, x:qword, y:qword
  121.  
  122.     mov    eax,(x).q0
  123.     mov    edx,(x).q1
  124.     sub    eax,(y).q0
  125.     sbb    edx,(y).q1
  126.     mov    ebx,z
  127.     mov    [ebx].q0,eax
  128.     mov    [ebx].q1,edx
  129.     ret
  130.  
  131. QUADSUB    endp
  132.  
  133. ;-----------------------------------------------------------------------------
  134. ;void pascal quadsuba(quad* z, quad* x, quad* y)
  135. ;compute z=x-y
  136.  
  137. public    QUADSUBA
  138. QUADSUBA    proc    z:ptr, x:ptr, y:ptr
  139.  
  140.     mov    ebx,x
  141.     mov    eax,[ebx].q0
  142.     mov    edx,[ebx].q1
  143.     mov    ebx,y
  144.     sub    eax,[ebx].q0
  145.     sbb    edx,[ebx].q1
  146.     mov    ebx,z
  147.     mov    [ebx].q0,eax
  148.     mov    [ebx].q1,edx
  149.     ret
  150.  
  151. QUADSUBA    endp
  152.  
  153. ;-----------------------------------------------------------------------------
  154. ;void pascal quadmult(quad* z, quad x, quad y)
  155. ;compute z=x*y
  156.  
  157. public    QUADMULT
  158. QUADMULT    proc    z:ptr, x:qword, y:qword
  159.  
  160.     mov    eax,(x).q0
  161.     mov    ebx,eax
  162.     mul    (y).q1
  163.     xchg    eax,ebx
  164.     mov    ecx,(y).q0
  165.     mul    ecx
  166.     add    ebx,edx
  167.     xchg    eax,ecx
  168.     mul    (x).q1
  169.     add    eax,ebx
  170.     mov    ebx,z
  171.     mov    [ebx].q0,ecx
  172.     mov    [ebx].q1,eax
  173.     ret
  174.  
  175. QUADMULT    endp
  176.  
  177. ;-----------------------------------------------------------------------------
  178. ;void pascal quadmulta(quad* z, quad* x, quad* y)
  179. ;compute z=x*y
  180.  
  181. public    QUADMULTA
  182. QUADMULTA    proc    uses esi, z:ptr, x:ptr, y:ptr
  183.  
  184.     mov    ebx,x
  185.     mov    esi,[ebx].q0
  186.     mov    ecx,[ebx].q1
  187.     mov    ebx,y
  188.     mov    eax,[ebx].q1
  189.     mov    ebx,[ebx].q0
  190.     mul    esi
  191.     xchg    eax,ecx
  192.     mul    ebx
  193.     add    ecx,eax
  194.     mov    eax,ebx
  195.     mul    esi
  196.     add    edx,ecx
  197.     mov    ebx,z
  198.     mov    [ebx].q0,eax
  199.     mov    [ebx].q1,edx
  200.     ret
  201.  
  202. QUADMULTA    endp
  203.  
  204. ;-----------------------------------------------------------------------------
  205. ;void pascal quaddiv(quad* z, quad x, quad y)
  206. ;compute z=x/y
  207.  
  208. public    QUADDIV
  209. QUADDIV    proc    uses esi edi, z:ptr, x:qword, y:qword
  210.  
  211.     xor    edi,edi        ;sign
  212.  
  213.     mov    eax,(x).q0
  214.     mov    edx,(x).q1
  215.     or    edx,edx
  216.     jns    quaddiv1
  217.  
  218.     inc    edi
  219.     neg    eax
  220.     adc    edx,0
  221.     neg    edx
  222.     mov    (x).q1,edx
  223.     mov    (x).q0,eax
  224. quaddiv1:
  225.     mov    ebx,(y).q0
  226.     mov    esi,(y).q1
  227.     or    esi,esi
  228.     jns    quaddiv2
  229.  
  230.     inc    edi
  231.     neg    ebx
  232.     adc    esi,0
  233.     neg    esi
  234. quaddiv2:
  235.     jnz    quaddiv3    ;y >= 2^16?
  236.  
  237. ;---------------------------------------
  238. ;y < 2^16:
  239.  
  240.     or    ebx,ebx
  241.     jz    quaddiv9    ;divide by zero?
  242.  
  243.     mov    ecx,eax
  244.     mov    eax,edx
  245.     xor    edx,edx
  246.     div    ebx
  247.     xchg    eax,ecx
  248.     div    ebx
  249.     jmp    quaddiv6
  250.  
  251. ;---------------------------------------
  252. ;y >= 2^16:
  253.  
  254. quaddiv3:
  255.     bsr    ecx,esi        ;shift right x and y so that y<2^16
  256.     inc    cl
  257.     push    ebx
  258.     shrd    ebx,esi,cl
  259.     shrd    eax,edx,cl
  260.     shr    edx,cl
  261.  
  262.     div    ebx        ;estimate z
  263.  
  264.     mov    ebx,eax        ;multiply z with y
  265.     mul    esi
  266.     mov    ecx,eax
  267.     pop    eax
  268.     mul    ebx
  269.     add    edx,ecx
  270.  
  271.     jc    quaddiv4    ;compare z*y with x
  272.     cmp    edx,(x).q1
  273.     ja    quaddiv4
  274.     jb    quaddiv5
  275.     cmp    eax,(x).q0
  276.     jbe    quaddiv5
  277. quaddiv4:
  278.     dec    ebx        ;decrement z if z*y > x
  279. quaddiv5:
  280.     xor    ecx,ecx
  281.     mov    eax,ebx
  282.  
  283. ;---------------------------------------
  284. quaddiv6:
  285.     dec    edi
  286.     jnz    quaddiv7
  287.  
  288.     neg    eax        ;change sign of result
  289.     adc    ecx,0
  290.     neg    ecx
  291.  
  292. quaddiv7:
  293.     mov    ebx,z
  294.     mov    [ebx].q0,eax
  295.     mov    [ebx].q1,ecx
  296.     ret
  297.  
  298. quaddiv9:            ;divide error
  299.     xor    eax,eax
  300.     dec    eax
  301.     mov    ecx,7fffffffh
  302.     jmp    quaddiv6    ;return 7fffffffffffffffh
  303.  
  304. QUADDIV    endp
  305.  
  306. ;-----------------------------------------------------------------------------
  307. ;void pascal quaddiva(quad* z, quad* x, quad* y)
  308. ;compute z=x*y
  309.  
  310. public    QUADDIVA
  311. QUADDIVA    proc    z:ptr, x:ptr, y:ptr
  312.  
  313.     push    z
  314.     mov    ebx,x
  315.     push    [ebx].q1
  316.     push    [ebx].q0
  317.     mov    ebx,y
  318.     push    [ebx].q1
  319.     push    [ebx].q0
  320.     call    QUADDIV
  321.  
  322.     ret
  323.  
  324. QUADDIVA    endp
  325.  
  326. ;-----------------------------------------------------------------------------
  327. end
  328.