do_comp.c 5.4 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271
  1. /*
  2. * Sources of the "COMPARE" group instructions
  3. */
  4. /* $Header$ */
  5. #include <em_abs.h>
  6. #include "logging.h"
  7. #include "nofloat.h"
  8. #include "global.h"
  9. #include "log.h"
  10. #include "warn.h"
  11. #include "mem.h"
  12. #include "shadow.h"
  13. #include "trap.h"
  14. #include "text.h"
  15. #include "fra.h"
  16. #ifndef NOFLOAT
  17. extern double fpop();
  18. #endif NOFLOAT
  19. PRIVATE compare_obj();
  20. DoCMIl2(arg)
  21. size arg;
  22. {
  23. /* CMI w: Compare w byte integers, Push negative, zero, positive for <, = or > */
  24. register size l = (L_arg_2() * arg);
  25. register long t = spop(arg_wi(l));
  26. register long s = spop(l);
  27. LOG(("@T6 DoCMIl2(%ld)", l));
  28. spoilFRA();
  29. npush((long)(t < s ? 1 : t > s ? -1 : 0), wsize);
  30. }
  31. DoCMIm(arg)
  32. size arg;
  33. {
  34. /* CMI w: Compare w byte integers, Push negative, zero, positive for <, = or > */
  35. register size l = arg_wi(arg);
  36. register long t = spop(l);
  37. register long s = spop(l);
  38. LOG(("@T6 DoCMIm(%ld)", l));
  39. spoilFRA();
  40. npush((long)(t < s ? 1 : t > s ? -1 : 0), wsize);
  41. }
  42. DoCMIz()
  43. {
  44. /* CMI w: Compare w byte integers, Push negative, zero, positive for <, = or > */
  45. register size l = upop(wsize);
  46. register long t = spop(arg_wi(l));
  47. register long s = spop(l);
  48. LOG(("@T6 DoCMIz(%ld)", l));
  49. spoilFRA();
  50. npush((long)(t < s ? 1 : t > s ? -1 : 0), wsize);
  51. }
  52. DoCMFl2(arg)
  53. size arg;
  54. {
  55. /* CMF w: Compare w byte reals */
  56. #ifndef NOFLOAT
  57. register size l = (L_arg_2() * arg);
  58. double t = fpop(arg_wf(l));
  59. double s = fpop(l);
  60. LOG(("@T6 DoCMFl2(%ld)", l));
  61. spoilFRA();
  62. npush((long)(t < s ? 1 : t > s ? -1 : 0), wsize);
  63. #else NOFLOAT
  64. arg = arg;
  65. nofloat();
  66. #endif NOFLOAT
  67. }
  68. DoCMFs(hob, wfac)
  69. long hob;
  70. size wfac;
  71. {
  72. /* CMF w: Compare w byte reals */
  73. #ifndef NOFLOAT
  74. register size l = (S_arg(hob) * wfac);
  75. double t = fpop(arg_wf(l));
  76. double s = fpop(l);
  77. LOG(("@T6 DoCMFs(%ld)", l));
  78. spoilFRA();
  79. npush((long)(t < s ? 1 : t > s ? -1 : 0), wsize);
  80. #else NOFLOAT
  81. hob = hob;
  82. wfac = wfac;
  83. nofloat();
  84. #endif NOFLOAT
  85. }
  86. DoCMFz()
  87. {
  88. /* CMF w: Compare w byte reals */
  89. #ifndef NOFLOAT
  90. register size l = upop(wsize);
  91. double t = fpop(arg_wf(l));
  92. double s = fpop(l);
  93. LOG(("@T6 DoCMFz(%ld)", l));
  94. spoilFRA();
  95. npush((long)(t < s ? 1 : t > s ? -1 : 0), wsize);
  96. #else NOFLOAT
  97. nofloat();
  98. #endif NOFLOAT
  99. }
  100. DoCMUl2(arg)
  101. size arg;
  102. {
  103. /* CMU w: Compare w byte unsigneds */
  104. register size l = (L_arg_2() * arg);
  105. register unsigned long t = upop(arg_wi(l));
  106. register unsigned long s = upop(l);
  107. LOG(("@T6 DoCMUl2(%ld)", l));
  108. spoilFRA();
  109. npush((long)(t < s ? 1 : t > s ? -1 : 0), wsize);
  110. }
  111. DoCMUz()
  112. {
  113. /* CMU w: Compare w byte unsigneds */
  114. register size l = upop(wsize);
  115. register unsigned long t = upop(arg_wi(l));
  116. register unsigned long s = upop(l);
  117. LOG(("@T6 DoCMUz(%ld)", l));
  118. spoilFRA();
  119. npush((long)(t < s ? 1 : t > s ? -1 : 0), wsize);
  120. }
  121. DoCMSl2(arg)
  122. size arg;
  123. {
  124. /* CMS w: Compare w byte values, can only be used for bit for bit equality test */
  125. register size l = (L_arg_2() * arg);
  126. LOG(("@T6 DoCMSl2(%ld)", l));
  127. spoilFRA();
  128. compare_obj(arg_w(l));
  129. }
  130. DoCMSs(hob, wfac)
  131. long hob;
  132. size wfac;
  133. {
  134. /* CMS w: Compare w byte values, can only be used for bit for bit equality test */
  135. register size l = (S_arg(hob) * wfac);
  136. LOG(("@T6 DoCMSs(%ld)", l));
  137. spoilFRA();
  138. compare_obj(arg_w(l));
  139. }
  140. DoCMSz()
  141. {
  142. /* CMS w: Compare w byte values, can only be used for bit for bit equality test */
  143. register size l = upop(wsize);
  144. LOG(("@T6 DoCMSz(%ld)", l));
  145. spoilFRA();
  146. compare_obj(arg_w(l));
  147. }
  148. DoCMPz()
  149. {
  150. /* CMP -: Compare pointers */
  151. register ptr t, s;
  152. LOG(("@T6 DoCMPz()"));
  153. spoilFRA();
  154. t = dppop();
  155. s = dppop();
  156. npush((long)(t < s ? 1 : t > s ? -1 : 0), wsize);
  157. }
  158. DoTLTz()
  159. {
  160. /* TLT -: True if less, i.e. iff top of stack < 0 */
  161. LOG(("@T6 DoTLTz()"));
  162. spoilFRA();
  163. npush((long)(wpop() < 0 ? 1 : 0), wsize);
  164. }
  165. DoTLEz()
  166. {
  167. /* TLE -: True if less or equal, i.e. iff top of stack <= 0 */
  168. LOG(("@T6 DoTLEz()"));
  169. spoilFRA();
  170. npush((long)(wpop() <= 0 ? 1 : 0), wsize);
  171. }
  172. DoTEQz()
  173. {
  174. /* TEQ -: True if equal, i.e. iff top of stack = 0 */
  175. LOG(("@T6 DoTEQz()"));
  176. spoilFRA();
  177. npush((long)(wpop() == 0 ? 1 : 0), wsize);
  178. }
  179. DoTNEz()
  180. {
  181. /* TNE -: True if not equal, i.e. iff top of stack non zero */
  182. LOG(("@T6 DoTNEz()"));
  183. spoilFRA();
  184. npush((long)(wpop() != 0 ? 1 : 0), wsize);
  185. }
  186. DoTGEz()
  187. {
  188. /* TGE -: True if greater or equal, i.e. iff top of stack >= 0 */
  189. LOG(("@T6 DoTGEz()"));
  190. spoilFRA();
  191. npush((long)(wpop() >= 0 ? 1 : 0), wsize);
  192. }
  193. DoTGTz()
  194. {
  195. /* TGT -: True if greater, i.e. iff top of stack > 0 */
  196. LOG(("@T6 DoTGTz()"));
  197. spoilFRA();
  198. npush((long)(wpop() > 0 ? 1 : 0), wsize);
  199. }
  200. /********************************************************
  201. * Compare objects *
  202. * *
  203. * Two 'obj_size' sized objects are bytewise *
  204. * compared; as soon as one byte is different *
  205. * 1 is returned, otherwise 0. No type checking *
  206. * is performed. Checking for undefined bytes *
  207. * is done when LOGGING is defined. *
  208. ********************************************************/
  209. PRIVATE compare_obj(obj_size)
  210. size obj_size;
  211. {
  212. register ptr addr1; /* ADDRess in object highest on st. */
  213. register ptr addr2; /* ADDRess in object deeper in st. */
  214. register int comp_res = 0; /* COMPare RESult */
  215. for ( addr1 = SP, addr2 = SP + obj_size;
  216. addr1 < SP + obj_size;
  217. addr1++, addr2++
  218. ) {
  219. #ifdef LOGGING
  220. if (!st_sh(addr1) || !st_sh(addr2)) {
  221. warning(WUNCMP);
  222. /* Let's say undefined's are not equal: */
  223. comp_res = 1;
  224. break;
  225. }
  226. #endif LOGGING
  227. if (stack_loc(addr1) != stack_loc(addr2)) {
  228. comp_res = 1;
  229. break;
  230. }
  231. }
  232. st_dec(2 * obj_size);
  233. npush((long) comp_res, wsize);
  234. }