LONGOPS.b 10 KB

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