cs_partit.c 10 KB

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