do_intar.c 4.2 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264
  1. /*
  2. * Sources of the "INTEGER ARITHMETIC" group instructions
  3. */
  4. /* $Id$ */
  5. #include <em_abs.h>
  6. #include "logging.h"
  7. #include "global.h"
  8. #include "log.h"
  9. #include "mem.h"
  10. #include "trap.h"
  11. #include "warn.h"
  12. #include "text.h"
  13. #include "fra.h"
  14. PRIVATE long adi(), sbi(), dvi(), mli(), rmi(), ngi(), sli(), sri();
  15. DoADI(l)
  16. register size l;
  17. {
  18. /* ADI w: Addition (*) */
  19. register long t = spop(arg_wi(l));
  20. LOG(("@I6 DoADI(%ld)", l));
  21. spoilFRA();
  22. npush(adi(spop(l), t, l), l);
  23. }
  24. DoSBI(l)
  25. register size l;
  26. {
  27. /* SBI w: Subtraction (*) */
  28. register long t = spop(arg_wi(l));
  29. LOG(("@I6 DoSBI(%ld)", l));
  30. spoilFRA();
  31. npush(sbi(spop(l), t, l), l);
  32. }
  33. DoMLI(l)
  34. register size l;
  35. {
  36. /* MLI w: Multiplication (*) */
  37. register long t = spop(arg_wi(l));
  38. LOG(("@I6 DoMLI(%ld)", l));
  39. spoilFRA();
  40. npush(mli(spop(l), t, l), l);
  41. }
  42. DoDVI(l)
  43. register size l;
  44. {
  45. /* DVI w: Division (*) */
  46. register long t = spop(arg_wi(l));
  47. LOG(("@I6 DoDVI(%ld)", l));
  48. spoilFRA();
  49. npush(dvi(spop(l), t), l);
  50. }
  51. DoRMI(l)
  52. register size l;
  53. {
  54. /* RMI w: Remainder (*) */
  55. register long t = spop(arg_wi(l));
  56. LOG(("@I6 DoRMI(%ld)", l));
  57. spoilFRA();
  58. npush(rmi(spop(l), t), l);
  59. }
  60. DoNGI(l)
  61. register size l;
  62. {
  63. /* NGI w: Negate (two's complement) (*) */
  64. LOG(("@I6 DoNGI(%ld)", l));
  65. spoilFRA();
  66. l = arg_wi(l);
  67. npush(ngi(spop(l), l), l);
  68. }
  69. DoSLI(l)
  70. register size l;
  71. {
  72. /* SLI w: Shift left (*) */
  73. register long t = swpop();
  74. LOG(("@I6 DoSLI(%ld)", l));
  75. spoilFRA();
  76. l = arg_wi(l);
  77. npush(sli(spop(l), t, l), l);
  78. }
  79. DoSRI(l)
  80. register size l;
  81. {
  82. /* SRI w: Shift right (*) */
  83. register long t = swpop();
  84. LOG(("@I6 DoSRI(%ld)", l));
  85. spoilFRA();
  86. l = arg_wi(l);
  87. npush(sri(spop(l), t, l), l);
  88. }
  89. #define i_maxs(n) ((n == 2) ? I_MAXS2 : I_MAXS4)
  90. #define i_mins(n) ((n == 2) ? I_MINS2 : I_MINS4)
  91. PRIVATE long adi(w1, w2, nbytes) /* returns w1 + w2 */
  92. long w1, w2;
  93. size nbytes;
  94. {
  95. if (must_test && !(IgnMask&BIT(EIOVFL))) {
  96. if (w1 > 0 && w2 > 0) {
  97. if (i_maxs(nbytes) - w1 < w2)
  98. trap(EIOVFL);
  99. }
  100. else if (w1 < 0 && w2 < 0) {
  101. if (i_mins(nbytes) - w1 > w2)
  102. trap(EIOVFL);
  103. }
  104. }
  105. return (w1 + w2);
  106. }
  107. PRIVATE long sbi(w1, w2, nbytes) /* returns w1 - w2 */
  108. long w1, w2;
  109. size nbytes;
  110. {
  111. if (must_test && !(IgnMask&BIT(EIOVFL))) {
  112. if (w2 < 0 && w1 > 0) {
  113. if (i_maxs(nbytes) + w2 < w1)
  114. trap(EIOVFL);
  115. }
  116. else if (w2 > 0 && w1 < 0) {
  117. if (i_mins(nbytes) + w2 > w1) {
  118. trap(EIOVFL);
  119. }
  120. }
  121. }
  122. return (w1 - w2);
  123. }
  124. #define labs(w) ((w < 0) ? (-w) : w)
  125. PRIVATE long mli(w1, w2, nbytes) /* returns w1 * w2 */
  126. long w1, w2;
  127. size nbytes;
  128. {
  129. if (w1 == 0 || w2 == 0)
  130. return (0L);
  131. if (must_test && !(IgnMask&BIT(EIOVFL))) {
  132. if ((w1 > 0 && w2 > 0) || (w2 < 0 && w1 < 0)) {
  133. if ( w1 == i_mins(nbytes) || w2 == i_mins(nbytes)
  134. || (i_maxs(nbytes) / labs(w1)) < labs(w2)
  135. ) {
  136. trap(EIOVFL);
  137. }
  138. }
  139. else if (w1 > 0) {
  140. if (i_mins(nbytes) / w1 > w2)
  141. trap(EIOVFL);
  142. }
  143. else if (i_mins(nbytes) / w2 > w1) {
  144. trap(EIOVFL);
  145. }
  146. }
  147. return (w1 * w2);
  148. }
  149. PRIVATE long dvi(w1, w2)
  150. long w1, w2;
  151. {
  152. if (w2 == 0) {
  153. if (!(IgnMask&BIT(EIDIVZ))) {
  154. trap(EIDIVZ);
  155. }
  156. else return (0L);
  157. }
  158. return (w1 / w2);
  159. }
  160. PRIVATE long rmi(w1, w2)
  161. long w1, w2;
  162. {
  163. if (w2 == 0) {
  164. if (!(IgnMask&BIT(EIDIVZ))) {
  165. trap(EIDIVZ);
  166. }
  167. else return (0L);
  168. }
  169. return (w1 % w2);
  170. }
  171. PRIVATE long ngi(w1, nbytes)
  172. long w1;
  173. size nbytes;
  174. {
  175. if (must_test && !(IgnMask&BIT(EIOVFL))) {
  176. if (w1 == i_mins(nbytes)) {
  177. trap(EIOVFL);
  178. }
  179. }
  180. return (-w1);
  181. }
  182. PRIVATE long sli(w1, w2, nbytes) /* w1 << w2 */
  183. long w1, w2;
  184. size nbytes;
  185. {
  186. if (must_test) {
  187. #ifdef LOGGING
  188. /* check shift distance */
  189. if (w2 < 0) {
  190. warning(WSHNEG);
  191. w2 = 0;
  192. }
  193. if (w2 >= nbytes*8) {
  194. warning(WSHLARGE);
  195. w2 = nbytes*8 - 1;
  196. }
  197. #endif /* LOGGING */
  198. if (!(IgnMask&BIT(EIOVFL))) {
  199. /* check overflow */
  200. if ( (w1 >= 0 && (w1 >> (nbytes*8 - w2)) != 0)
  201. || (w1 < 0 && (w1 >> (nbytes*8 - w2)) != -1)
  202. ) {
  203. trap(EIOVFL);
  204. }
  205. }
  206. }
  207. /* calculate result */
  208. return (w1 << w2);
  209. }
  210. /*ARGSUSED*/
  211. PRIVATE long sri(w1, w2, nbytes) /* w1 >> w2 */
  212. long w1, w2;
  213. size nbytes;
  214. {
  215. #ifdef LOGGING
  216. if (must_test) {
  217. /* check shift distance */
  218. if (w2 < 0) {
  219. warning(WSHNEG);
  220. w2 = 0;
  221. }
  222. if (w2 >= nbytes*8) {
  223. warning(WSHLARGE);
  224. w2 = nbytes*8 - 1;
  225. }
  226. }
  227. #endif /* LOGGING */
  228. /* calculate result */
  229. return (w1 >> w2);
  230. }