LONGOPS.b 6.7 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295
  1. /*
  2. * Input file : test\longops.exe
  3. * File type : EXE
  4. */
  5. #include "dcc.h"
  6. long LXMUL@ (long arg0, long arg1)
  7. /* Uses register arguments:
  8. * arg0 = dx:ax.
  9. * arg1 = cx:bx.
  10. * Runtime support routine of the compiler.
  11. */
  12. {
  13. int loc1;
  14. int loc2; /* tmp */
  15. loc2 = LO(arg0);
  16. LO(arg0) = loc1;
  17. loc1 = loc2;
  18. loc2 = LO(arg0);
  19. LO(arg0) = HI(arg0);
  20. if ((LO(arg0) & LO(arg0)) != 0) {
  21. LO(arg0) = (LO(arg0) * LO(arg1));
  22. }
  23. loc2 = LO(arg0);
  24. LO(arg0) = HI(arg1);
  25. HI(arg1) = loc2;
  26. if ((LO(arg0) & LO(arg0)) != 0) {
  27. LO(arg0) = (LO(arg0) * loc1);
  28. HI(arg1) = (HI(arg1) + LO(arg0));
  29. }
  30. loc2 = LO(arg0);
  31. LO(arg0) = loc1;
  32. loc1 = loc2;
  33. arg0 = (LO(arg0) * LO(arg1));
  34. HI(arg0) = (HI(arg0) + HI(arg1));
  35. return (arg0);
  36. }
  37. long LDIV@ (long arg0, long arg2)
  38. /* Takes 8 bytes of parameters.
  39. * Runtime support routine of the compiler.
  40. * Untranslatable routine. Assembler provided.
  41. * Return value in registers dx:ax.
  42. * Pascal calling convention.
  43. */
  44. {
  45. XOR cx, 0
  46. PUSH bp
  47. PUSH si
  48. PUSH di
  49. MOV bp, sp
  50. MOV di, cx
  51. MOV ax, [bp+0Ah]
  52. MOV dx, [bp+0Ch]
  53. MOV bx, [bp+0Eh]
  54. MOV cx, [bp+10h]
  55. CMP cx, 0
  56. JNE L1
  57. OR dx, dx
  58. JE L2
  59. OR bx, bx
  60. JE L2
  61. L1: TEST di, 1
  62. JNE L3
  63. OR dx, dx
  64. JNS L4
  65. NEG dx
  66. NEG ax
  67. SBB dx, 0
  68. OR di, 0Ch
  69. L4: OR cx, cx
  70. JNS L3
  71. NEG cx
  72. NEG bx
  73. SBB cx, 0
  74. XOR di, 4
  75. L3: MOV bp, cx
  76. MOV cx, 20h
  77. PUSH di
  78. XOR di, 0
  79. XOR si, 0
  80. L5: SHL ax, 1
  81. RCL dx, 1
  82. RCL si, 1
  83. RCL di, 1
  84. CMP di, bp
  85. JB L6
  86. JA L7
  87. CMP si, bx
  88. JB L6
  89. L7: SUB si, bx
  90. SBB di, bp
  91. INC ax
  92. L6: LOOP L5
  93. POP bx
  94. TEST bx, 2
  95. JE L8
  96. MOV ax, si
  97. MOV dx, di
  98. SHR bx, 1
  99. L8: TEST bx, 4
  100. JE L9
  101. NEG dx
  102. NEG ax
  103. SBB dx, 0
  104. L9: POP di
  105. POP si
  106. POP bp
  107. RETF 8
  108. L2: MOV tmp, dx:ax ;Synthetic inst
  109. DIV bx
  110. MOD bx ;Synthetic inst
  111. TEST di, 2
  112. JE L10
  113. MOV ax, dx
  114. L10: XOR dx, dx
  115. JMP L9
  116. }
  117. long LMOD@ (long arg0, long arg2)
  118. /* Takes 8 bytes of parameters.
  119. * Runtime support routine of the compiler.
  120. * Untranslatable routine. Assembler provided.
  121. * Return value in registers dx:ax.
  122. * Pascal calling convention.
  123. */
  124. {
  125. MOV cx, 2
  126. PUSH bp
  127. PUSH si
  128. PUSH di
  129. MOV bp, sp
  130. MOV di, cx
  131. MOV ax, [bp+0Ah]
  132. MOV dx, [bp+0Ch]
  133. MOV bx, [bp+0Eh]
  134. MOV cx, [bp+10h]
  135. CMP cx, 0
  136. JNE L11
  137. OR dx, dx
  138. JE L12
  139. OR bx, bx
  140. JE L12
  141. L11: TEST di, 1
  142. JNE L13
  143. OR dx, dx
  144. JNS L14
  145. NEG dx
  146. NEG ax
  147. SBB dx, 0
  148. OR di, 0Ch
  149. L14: OR cx, cx
  150. JNS L13
  151. NEG cx
  152. NEG bx
  153. SBB cx, 0
  154. XOR di, 4
  155. L13: MOV bp, cx
  156. MOV cx, 20h
  157. PUSH di
  158. XOR di, 0
  159. XOR si, 0
  160. L15: SHL ax, 1
  161. RCL dx, 1
  162. RCL si, 1
  163. RCL di, 1
  164. CMP di, bp
  165. JB L16
  166. JA L17
  167. CMP si, bx
  168. JB L16
  169. L17: SUB si, bx
  170. SBB di, bp
  171. INC ax
  172. L16: LOOP L15
  173. POP bx
  174. TEST bx, 2
  175. JE L18
  176. MOV ax, si
  177. MOV dx, di
  178. SHR bx, 1
  179. L18: TEST bx, 4
  180. JE L19
  181. NEG dx
  182. NEG ax
  183. SBB dx, 0
  184. L19: POP di
  185. POP si
  186. POP bp
  187. RETF 8
  188. L12: MOV tmp, dx:ax ;Synthetic inst
  189. DIV bx
  190. MOD bx ;Synthetic inst
  191. TEST di, 2
  192. JE L20
  193. MOV ax, dx
  194. L20: XOR dx, dx
  195. JMP L19
  196. }
  197. long LXLSH@ (long arg0, char arg1)
  198. /* Uses register arguments:
  199. * arg0 = dx:ax.
  200. * arg1 = cl.
  201. * Runtime support routine of the compiler.
  202. */
  203. {
  204. int loc1; /* bx */
  205. if (arg1 < 16) {
  206. loc1 = LO(arg0);
  207. LO(arg0) = (LO(arg0) << arg1);
  208. HI(arg0) = (HI(arg0) << arg1);
  209. HI(arg0) = (HI(arg0) | (loc1 >> (!arg1 + 16)));
  210. return (arg0);
  211. }
  212. else {
  213. HI(arg0) = LO(arg0);
  214. LO(arg0) = 0;
  215. HI(arg0) = (HI(arg0) << (arg1 - 16));
  216. return (arg0);
  217. }
  218. }
  219. long LXRSH@ (long arg0, char arg1)
  220. /* Uses register arguments:
  221. * arg0 = dx:ax.
  222. * arg1 = cl.
  223. * Runtime support routine of the compiler.
  224. */
  225. {
  226. int loc1; /* bx */
  227. if (arg1 < 16) {
  228. loc1 = HI(arg0);
  229. LO(arg0) = (LO(arg0) >> arg1);
  230. HI(arg0) = (HI(arg0) >> arg1);
  231. LO(arg0) = (LO(arg0) | (loc1 << (!arg1 + 16)));
  232. return (arg0);
  233. }
  234. else {
  235. arg0 = HI(arg0);
  236. LO(arg0) = (LO(arg0) >> (arg1 - 16));
  237. return (arg0);
  238. }
  239. }
  240. void main ()
  241. /* Takes no parameters.
  242. * High-level language prologue code.
  243. */
  244. {
  245. long loc1;
  246. long loc2;
  247. loc2 = 255;
  248. loc1 = 143;
  249. loc1 = (loc2 + loc1);
  250. loc2 = (loc2 - loc1);
  251. loc2 = LXMUL@ (loc2, loc1);
  252. loc1 = LDIV@ (loc1, loc2);
  253. loc1 = LMOD@ (loc1, loc2);
  254. loc2 = LXLSH@ (loc2, 5);
  255. loc1 = LXRSH@ (loc1, loc1);
  256. printf ("a = %ld, b = %ld\n", loc2, loc1);
  257. }