LONGOPS.b 10 KB

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