cs_partit.c 10 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376
  1. /* $Id$ */
  2. /*
  3. * (c) copyright 1987 by the Vrije Universiteit, Amsterdam, The Netherlands.
  4. * See the copyright notice in the ACK home directory, in the file "Copyright".
  5. */
  6. /* Functions to partition the huge set of EM-instructions. */
  7. #include <em_mnem.h>
  8. #include <em_pseu.h>
  9. #include <em_reg.h>
  10. #include <em_spec.h>
  11. #include "../share/types.h"
  12. #include "../share/aux.h"
  13. #include "../share/debug.h"
  14. #include "../share/global.h"
  15. #include "cs.h"
  16. #include "cs_stack.h"
  17. #define XXX (-1)
  18. #define ARGW 0
  19. #define WS 1
  20. #define PS 2
  21. #define FEF 3
  22. #define FIF 4
  23. #define CVT 5
  24. #define ANY 0
  25. #define PTR 1
  26. #define FLT 2
  27. STATIC struct {
  28. byte i_group; /* Group of instruction. */
  29. byte i_op1; /* Indication of size of operand of unary operator. */
  30. /* Idem for 1st operand of binary operator. */
  31. byte i_op2; /* Idem for 2nd operand of binary operator. */
  32. byte i_av; /* Idem for result of operators. */
  33. byte i_regtype; /* ANY, PTR, FLT. */
  34. } info[] = {
  35. XXX, XXX, XXX, XXX, XXX,
  36. /* aar */ TERNAIR_OP, XXX, XXX, PS, PTR,
  37. /* adf */ BINAIR_OP, ARGW, ARGW, ARGW, FLT,
  38. /* adi */ BINAIR_OP, ARGW, ARGW, ARGW, ANY,
  39. /* adp */ EXPENSIVE_LOAD, XXX, XXX, XXX, PTR,
  40. /* ads */ BINAIR_OP, PS, ARGW, PS, PTR,
  41. /* adu */ BINAIR_OP, ARGW, ARGW, ARGW, ANY,
  42. /* and */ BINAIR_OP, ARGW, ARGW, ARGW, ANY,
  43. /* asp */ FIDDLE_STACK, XXX, XXX, XXX, XXX,
  44. /* ass */ FIDDLE_STACK, XXX, XXX, XXX, XXX,
  45. /* beq */ BBLOCK_END, XXX, XXX, XXX, XXX,
  46. /* bge */ BBLOCK_END, XXX, XXX, XXX, XXX,
  47. /* bgt */ BBLOCK_END, XXX, XXX, XXX, XXX,
  48. /* ble */ BBLOCK_END, XXX, XXX, XXX, XXX,
  49. /* blm */ HOPELESS, XXX, XXX, XXX, XXX,
  50. /* bls */ HOPELESS, XXX, XXX, XXX, XXX,
  51. /* blt */ BBLOCK_END, XXX, XXX, XXX, XXX,
  52. /* bne */ BBLOCK_END, XXX, XXX, XXX, XXX,
  53. /* bra */ BBLOCK_END, XXX, XXX, XXX, XXX,
  54. /* cai */ SIDE_EFFECTS, XXX, XXX, XXX, XXX,
  55. /* cal */ SIDE_EFFECTS, XXX, XXX, XXX, XXX,
  56. /* cff */ TERNAIR_OP, XXX, XXX, CVT, FLT,
  57. /* cfi */ TERNAIR_OP, XXX, XXX, CVT, ANY,
  58. /* cfu */ TERNAIR_OP, XXX, XXX, CVT, ANY,
  59. /* cif */ TERNAIR_OP, XXX, XXX, CVT, FLT,
  60. /* cii */ TERNAIR_OP, XXX, XXX, CVT, ANY,
  61. /* ciu */ TERNAIR_OP, XXX, XXX, CVT, ANY,
  62. /* cmf */ BINAIR_OP, ARGW, ARGW, WS, ANY,
  63. /* cmi */ BINAIR_OP, ARGW, ARGW, WS, ANY,
  64. /* cmp */ BINAIR_OP, PS, PS, WS, ANY,
  65. /* cms */ BINAIR_OP, ARGW, ARGW, WS, ANY,
  66. /* cmu */ BINAIR_OP, ARGW, ARGW, WS, ANY,
  67. /* com */ UNAIR_OP, ARGW, XXX, ARGW, ANY,
  68. /* csa */ BBLOCK_END, XXX, XXX, XXX, XXX,
  69. /* csb */ BBLOCK_END, XXX, XXX, XXX, XXX,
  70. /* cuf */ TERNAIR_OP, XXX, XXX, CVT, FLT,
  71. /* cui */ TERNAIR_OP, XXX, XXX, CVT, ANY,
  72. /* cuu */ TERNAIR_OP, XXX, XXX, CVT, ANY,
  73. /* dch */ UNAIR_OP, PS, XXX, PS, PTR,
  74. /* dec */ UNAIR_OP, WS, XXX, WS, ANY,
  75. /* dee */ KILL_ENTITY, XXX, XXX, XXX, XXX,
  76. /* del */ KILL_ENTITY, XXX, XXX, XXX, XXX,
  77. /* dup */ FIDDLE_STACK, XXX, XXX, XXX, XXX,
  78. /* dus */ FIDDLE_STACK, XXX, XXX, XXX, XXX,
  79. /* dvf */ BINAIR_OP, ARGW, ARGW, ARGW, FLT,
  80. /* dvi */ BINAIR_OP, ARGW, ARGW, ARGW, ANY,
  81. /* dvu */ BINAIR_OP, ARGW, ARGW, ARGW, ANY,
  82. /* exg */ FIDDLE_STACK, XXX, XXX, XXX, XXX,
  83. /* fef */ UNAIR_OP, ARGW, XXX, FEF, XXX,
  84. /* fif */ BINAIR_OP, ARGW, ARGW, FIF, XXX,
  85. /* fil */ IGNORE, XXX, XXX, XXX, XXX,
  86. /* gto */ BBLOCK_END, XXX, XXX, XXX, XXX,
  87. /* inc */ UNAIR_OP, WS, XXX, WS, ANY,
  88. /* ine */ KILL_ENTITY, XXX, XXX, XXX, XXX,
  89. /* inl */ KILL_ENTITY, XXX, XXX, XXX, XXX,
  90. /* inn */ BINAIR_OP, ARGW, WS, WS, ANY,
  91. /* ior */ BINAIR_OP, ARGW, ARGW, ARGW, ANY,
  92. /* lae */ SIMPLE_LOAD, XXX, XXX, XXX, XXX,
  93. /* lal */ SIMPLE_LOAD, XXX, XXX, XXX, XXX,
  94. /* lar */ LOAD_ARRAY, XXX, XXX, XXX, ANY,
  95. /* ldc */ SIMPLE_LOAD, XXX, XXX, XXX, XXX,
  96. /* lde */ SIMPLE_LOAD, XXX, XXX, XXX, XXX,
  97. /* ldf */ EXPENSIVE_LOAD, XXX, XXX, XXX, ANY,
  98. /* ldl */ SIMPLE_LOAD, XXX, XXX, XXX, XXX,
  99. /* lfr */ FIDDLE_STACK, XXX, XXX, XXX, XXX,
  100. /* lil */ SIMPLE_LOAD, XXX, XXX, XXX, XXX,
  101. /* lim */ SIMPLE_LOAD, XXX, XXX, XXX, XXX,
  102. /* lin */ IGNORE, XXX, XXX, XXX, XXX,
  103. /* lni */ IGNORE, XXX, XXX, XXX, XXX,
  104. /* loc */ SIMPLE_LOAD, XXX, XXX, XXX, XXX,
  105. /* loe */ SIMPLE_LOAD, XXX, XXX, XXX, XXX,
  106. /* lof */ EXPENSIVE_LOAD, XXX, XXX, XXX, ANY,
  107. /* loi */ EXPENSIVE_LOAD, XXX, XXX, XXX, ANY,
  108. /* lol */ SIMPLE_LOAD, XXX, XXX, XXX, XXX,
  109. /* lor */ SIMPLE_LOAD, XXX, XXX, XXX, XXX,
  110. /* los */ FIDDLE_STACK, XXX, XXX, XXX, XXX,
  111. /* lpb */ UNAIR_OP, PS, XXX, PS, PTR,
  112. /* lpi */ SIMPLE_LOAD, XXX, XXX, XXX, XXX,
  113. /* lxa */ EXPENSIVE_LOAD, XXX, XXX, XXX, PTR,
  114. /* lxl */ EXPENSIVE_LOAD, XXX, XXX, XXX, PTR,
  115. /* mlf */ BINAIR_OP, ARGW, ARGW, ARGW, FLT,
  116. /* mli */ BINAIR_OP, ARGW, ARGW, ARGW, ANY,
  117. /* mlu */ BINAIR_OP, ARGW, ARGW, ARGW, ANY,
  118. /* mon */ HOPELESS, XXX, XXX, XXX, XXX,
  119. /* ngf */ UNAIR_OP, ARGW, XXX, ARGW, FLT,
  120. /* ngi */ UNAIR_OP, ARGW, XXX, ARGW, ANY,
  121. /* nop */ HOPELESS, XXX, XXX, XXX, XXX,
  122. /* rck */ BBLOCK_END, XXX, XXX, XXX, XXX,
  123. /* ret */ BBLOCK_END, XXX, XXX, XXX, XXX,
  124. /* rmi */ BINAIR_OP, ARGW, ARGW, ARGW, ANY,
  125. /* rmu */ BINAIR_OP, ARGW, ARGW, ARGW, ANY,
  126. /* rol */ BINAIR_OP, ARGW, WS, ARGW, ANY,
  127. /* ror */ BINAIR_OP, ARGW, WS, ARGW, ANY,
  128. /* rtt */ BBLOCK_END, XXX, XXX, XXX, XXX,
  129. /* sar */ STORE_ARRAY, XXX, XXX, XXX, XXX,
  130. /* sbf */ BINAIR_OP, ARGW, ARGW, ARGW, FLT,
  131. /* sbi */ BINAIR_OP, ARGW, ARGW, ARGW, ANY,
  132. /* sbs */ BINAIR_OP, PS, PS, ARGW, ANY,
  133. /* sbu */ BINAIR_OP, ARGW, ARGW, ARGW, ANY,
  134. /* sde */ STORE_DIRECT, XXX, XXX, XXX, XXX,
  135. /* sdf */ STORE_INDIR, XXX, XXX, XXX, XXX,
  136. /* sdl */ STORE_DIRECT, XXX, XXX, XXX, XXX,
  137. /* set */ UNAIR_OP, WS, XXX, ARGW, ANY,
  138. /* sig */ FIDDLE_STACK, XXX, XXX, XXX, XXX,
  139. /* sil */ STORE_INDIR, XXX, XXX, XXX, XXX,
  140. /* sim */ STORE_DIRECT, XXX, XXX, XXX, XXX,
  141. /* sli */ BINAIR_OP, ARGW, WS, ARGW, ANY,
  142. /* slu */ BINAIR_OP, ARGW, WS, ARGW, ANY,
  143. /* sri */ BINAIR_OP, ARGW, WS, ARGW, ANY,
  144. /* sru */ BINAIR_OP, ARGW, WS, ARGW, ANY,
  145. /* ste */ STORE_DIRECT, XXX, XXX, XXX, XXX,
  146. /* stf */ STORE_INDIR, XXX, XXX, XXX, XXX,
  147. /* sti */ STORE_INDIR, XXX, XXX, XXX, XXX,
  148. /* stl */ STORE_DIRECT, XXX, XXX, XXX, XXX,
  149. /* str */ HOPELESS, XXX, XXX, XXX, XXX,
  150. /* sts */ HOPELESS, XXX, XXX, XXX, XXX,
  151. /* teq */ UNAIR_OP, WS, XXX, WS, ANY,
  152. /* tge */ UNAIR_OP, WS, XXX, WS, ANY,
  153. /* tgt */ UNAIR_OP, WS, XXX, WS, ANY,
  154. /* tle */ UNAIR_OP, WS, XXX, WS, ANY,
  155. /* tlt */ UNAIR_OP, WS, XXX, WS, ANY,
  156. /* tne */ UNAIR_OP, WS, XXX, WS, ANY,
  157. /* trp */ BBLOCK_END, XXX, XXX, XXX, XXX,
  158. /* xor */ BINAIR_OP, ARGW, ARGW, ARGW, ANY,
  159. /* zeq */ BBLOCK_END, XXX, XXX, XXX, XXX,
  160. /* zer */ SIMPLE_LOAD, XXX, XXX, XXX, XXX,
  161. /* zge */ BBLOCK_END, XXX, XXX, XXX, XXX,
  162. /* zgt */ BBLOCK_END, XXX, XXX, XXX, XXX,
  163. /* zle */ BBLOCK_END, XXX, XXX, XXX, XXX,
  164. /* zlt */ BBLOCK_END, XXX, XXX, XXX, XXX,
  165. /* zne */ BBLOCK_END, XXX, XXX, XXX, XXX,
  166. /* zre */ KILL_ENTITY, XXX, XXX, XXX, XXX,
  167. /* zrf */ SIMPLE_LOAD, XXX, XXX, XXX, XXX,
  168. /* zrl */ KILL_ENTITY, XXX, XXX, XXX, XXX
  169. };
  170. #define GROUP(n) (info[n].i_group)
  171. #define OP1SIZE(l) (info[INSTR(l)].i_op1)
  172. #define OP2SIZE(l) (info[INSTR(l)].i_op2)
  173. #define AVSIZE(l) (info[INSTR(l)].i_av)
  174. #define REGTYPE(n) (info[n].i_regtype)
  175. int instrgroup(lnp)
  176. line_p lnp;
  177. {
  178. if (INSTR(lnp) == op_lor && SHORT(lnp) == 1) {
  179. /* We can't do anything with the stackpointer. */
  180. return FIDDLE_STACK;
  181. }
  182. if (INSTR(lnp) < sp_fmnem || INSTR(lnp) > sp_lmnem) {
  183. VI((short) INSTR(lnp));
  184. return IGNORE;
  185. }
  186. return GROUP(INSTR(lnp));
  187. }
  188. bool stack_group(instr)
  189. int instr;
  190. {
  191. /* Is this an instruction that only does something to the top of
  192. * the stack?
  193. */
  194. switch (GROUP(instr)) {
  195. case SIMPLE_LOAD:
  196. case EXPENSIVE_LOAD:
  197. case LOAD_ARRAY:
  198. case UNAIR_OP:
  199. case BINAIR_OP:
  200. case TERNAIR_OP:
  201. return TRUE;
  202. default:
  203. return FALSE;
  204. }
  205. }
  206. STATIC offset argw(lnp)
  207. line_p lnp;
  208. {
  209. /* Some EM-instructions have their argument either on the same line,
  210. * or on top of the stack. We give up when the argument is on top of
  211. * the stack.
  212. */
  213. struct token dummy;
  214. if (TYPE(lnp) != OPNO) {
  215. return off_set(lnp);
  216. } else {
  217. Pop(&dummy, (offset) ws);
  218. return UNKNOWN_SIZE;
  219. }
  220. }
  221. offset op11size(lnp)
  222. line_p lnp;
  223. {
  224. /* Returns the size of the first argument of
  225. * the unary operator in lnp.
  226. */
  227. switch (OP1SIZE(lnp)) {
  228. case ARGW:
  229. return argw(lnp);
  230. case WS:
  231. return ws;
  232. case PS:
  233. return ps;
  234. default:
  235. assert(FALSE);
  236. }
  237. /* NOTREACHED */
  238. }
  239. offset op12size(lnp)
  240. line_p lnp;
  241. {
  242. /* Same for first of binary. */
  243. switch (OP1SIZE(lnp)) {
  244. case ARGW:
  245. return argw(lnp);
  246. case PS:
  247. return ps;
  248. default:
  249. assert(FALSE);
  250. }
  251. /* NOTREACHED */
  252. }
  253. offset op22size(lnp)
  254. line_p lnp;
  255. {
  256. switch (OP2SIZE(lnp)) {
  257. case ARGW:
  258. return argw(lnp);
  259. case WS:
  260. return ws;
  261. case PS:
  262. return ps;
  263. default:
  264. assert(FALSE);
  265. }
  266. /* NOTREACHED */
  267. }
  268. /* Ternary operators are op_aar and conversions between types and/or sizes. */
  269. offset op13size(lnp)
  270. line_p lnp;
  271. {
  272. /* When the instruction is a conversion, the size of the first
  273. * operand is the value of the second operand.
  274. * We only handle the most likely case, namely that the second operand
  275. * was pushed by a loc-instruction.
  276. */
  277. if (INSTR(lnp) == op_aar) return ps;
  278. if (lnp->l_prev != (line_p) 0 &&
  279. lnp->l_prev->l_prev != (line_p) 0 &&
  280. INSTR(lnp->l_prev->l_prev) == op_loc
  281. )
  282. return off_set(lnp->l_prev->l_prev);
  283. else
  284. return UNKNOWN_SIZE;
  285. }
  286. offset op23size(lnp)
  287. line_p lnp;
  288. {
  289. if (INSTR(lnp) == op_aar)
  290. return argw(lnp);
  291. else
  292. return ws;
  293. }
  294. offset op33size(lnp)
  295. line_p lnp;
  296. {
  297. if (INSTR(lnp) == op_aar)
  298. return ps;
  299. else
  300. return ws;
  301. }
  302. offset avsize(lnp)
  303. line_p lnp;
  304. {
  305. /* Returns the size of the result of the instruction in lnp.
  306. * If the instruction is a conversion this size is given on the stack.
  307. * We only handle the case that this value was pushed by a loc.
  308. */
  309. offset size;
  310. switch (AVSIZE(lnp)) {
  311. case ARGW:
  312. return argw(lnp);
  313. case WS:
  314. return ws;
  315. case PS:
  316. return ps;
  317. case FEF:
  318. if ((size = argw(lnp)) != UNKNOWN_SIZE)
  319. return size + ws;
  320. else
  321. return UNKNOWN_SIZE;
  322. case FIF:
  323. if ((size = argw(lnp)) != UNKNOWN_SIZE)
  324. return size + size;
  325. else
  326. return UNKNOWN_SIZE;
  327. case CVT:
  328. if (lnp->l_prev != (line_p) 0 &&
  329. INSTR(lnp->l_prev) == op_loc
  330. )
  331. return off_set(lnp->l_prev);
  332. else
  333. return UNKNOWN_SIZE;
  334. default:
  335. assert(FALSE);
  336. break;
  337. }
  338. /* NOTREACHED */
  339. }
  340. int regtype(instr)
  341. byte instr;
  342. {
  343. switch (REGTYPE(instr & BMASK)) {
  344. case ANY:
  345. return reg_any;
  346. case PTR:
  347. return reg_pointer;
  348. case FLT:
  349. return reg_float;
  350. default:
  351. assert(FALSE);
  352. }
  353. /* NOTREACHED */
  354. }