cs_vnm.c 6.4 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332
  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. /* V A L U E N U M B E R I N G M E T H O D */
  7. #include <em_mnem.h>
  8. #include "../share/types.h"
  9. #include "../share/global.h"
  10. #include "../share/debug.h"
  11. #include "../share/aux.h"
  12. #include "cs.h"
  13. #include "cs_alloc.h"
  14. #include "cs_aux.h"
  15. #include "cs_entity.h"
  16. #include "cs_avail.h"
  17. #include "cs_stack.h"
  18. #include "cs_kill.h"
  19. #include "cs_partit.h"
  20. #include "cs_getent.h"
  21. static void push_entity(entity_p enp, line_p lfirst)
  22. {
  23. /* Build token and Push it. */
  24. struct token tk;
  25. tk.tk_vn = enp->en_vn;
  26. tk.tk_size = enp->en_size;
  27. tk.tk_lfirst = lfirst;
  28. Push(&tk);
  29. }
  30. static void put_expensive_load(bblock_p bp, line_p lnp, line_p lfirst, entity_p enp)
  31. {
  32. struct avail av;
  33. occur_p ocp;
  34. av.av_instr = INSTR(lnp);
  35. av.av_size = enp->en_size;
  36. av.av_operand = enp->en_vn;
  37. ocp = newoccur(lfirst, lnp, bp);
  38. av_enter(&av, ocp, EXPENSIVE_LOAD);
  39. }
  40. static void put_aar(bblock_p bp, line_p lnp, line_p lfirst, entity_p enp)
  41. {
  42. /* Enp points to an ENARRELEM. We do as if its address was computed. */
  43. struct avail av;
  44. occur_p ocp;
  45. assert(enp->en_kind == ENARRELEM);
  46. av.av_instr = op_aar;
  47. av.av_size = ps;
  48. av.av_ofirst = enp->en_arbase;
  49. av.av_osecond = enp->en_index;
  50. av.av_othird = enp->en_adesc;
  51. ocp = newoccur(lfirst, lnp, bp);
  52. av_enter(&av, ocp, TERNAIR_OP);
  53. }
  54. static void push_avail(avail_p avp, line_p lfirst)
  55. {
  56. struct token tk;
  57. tk.tk_vn = avp->av_result;
  58. tk.tk_size = avp->av_size;
  59. tk.tk_lfirst = lfirst;
  60. Push(&tk);
  61. }
  62. static void push_unair_op(bblock_p bp, line_p lnp, token_p tkp1)
  63. {
  64. struct avail av;
  65. occur_p ocp;
  66. av.av_instr = INSTR(lnp);
  67. av.av_size = avsize(lnp);
  68. av.av_operand = tkp1->tk_vn;
  69. ocp = newoccur(tkp1->tk_lfirst, lnp, bp);
  70. push_avail(av_enter(&av, ocp, UNAIR_OP), tkp1->tk_lfirst);
  71. }
  72. static void push_binair_op(bblock_p bp, line_p lnp, token_p tkp1, token_p tkp2)
  73. {
  74. struct avail av;
  75. occur_p ocp;
  76. av.av_instr = INSTR(lnp);
  77. av.av_size = avsize(lnp);
  78. av.av_oleft = tkp1->tk_vn;
  79. av.av_oright = tkp2->tk_vn;
  80. ocp = newoccur(tkp1->tk_lfirst, lnp, bp);
  81. push_avail(av_enter(&av, ocp, BINAIR_OP), tkp1->tk_lfirst);
  82. }
  83. static void push_ternair_op(bblock_p bp, line_p lnp, token_p tkp1, token_p tkp2, token_p tkp3)
  84. {
  85. struct avail av;
  86. occur_p ocp;
  87. av.av_instr = INSTR(lnp);
  88. av.av_size = avsize(lnp);
  89. av.av_ofirst = tkp1->tk_vn;
  90. av.av_osecond = tkp2->tk_vn;
  91. av.av_othird = tkp3->tk_vn;
  92. ocp = newoccur(tkp1->tk_lfirst, lnp, bp);
  93. push_avail(av_enter(&av, ocp, TERNAIR_OP), tkp1->tk_lfirst);
  94. }
  95. static void fiddle_stack(line_p lnp)
  96. {
  97. /* The instruction in lnp does something to the valuenumber-stack. */
  98. struct token dummy;
  99. offset size;
  100. /* Partly initialize dummy. */
  101. dummy.tk_lfirst = lnp;
  102. switch (INSTR(lnp)) {
  103. default:
  104. assert(FALSE);
  105. break;
  106. case op_lor:
  107. dummy.tk_vn = newvalnum(); dummy.tk_size = ps;
  108. Push(&dummy);
  109. break;
  110. case op_asp:
  111. if ((size = off_set(lnp)) > 0) {
  112. Pop(&dummy, size);
  113. } else {
  114. dummy.tk_vn = newvalnum();
  115. dummy.tk_size = size;
  116. Push(&dummy);
  117. }
  118. break;
  119. case op_dup:
  120. Dup(lnp);
  121. break;
  122. case op_ass:
  123. case op_dus:
  124. case op_exg:
  125. case op_los:
  126. /* Don't waste effort. */
  127. clr_stack();
  128. break;
  129. case op_sig:
  130. Pop(&dummy, (offset) ps);
  131. break;
  132. case op_lfr:
  133. dummy.tk_vn = newvalnum();
  134. dummy.tk_size = off_set(lnp);
  135. Push(&dummy);
  136. break;
  137. case op_beq:
  138. case op_bge:
  139. case op_bgt:
  140. case op_bne:
  141. case op_ble:
  142. case op_blt:
  143. Pop(&dummy, (offset) ws);
  144. Pop(&dummy, (offset) ws);
  145. break;
  146. case op_bra:
  147. case op_csa:/* ??? */
  148. case op_csb:/* ??? */
  149. case op_gto:/* ??? */
  150. case op_ret:/* ??? */
  151. case op_rtt:/* ??? */
  152. break;
  153. case op_zeq:
  154. case op_zge:
  155. case op_zgt:
  156. case op_zne:
  157. case op_zle:
  158. case op_zlt:
  159. case op_trp:
  160. Pop(&dummy, (offset) ws);
  161. break;
  162. case op_rck:
  163. Pop(&dummy, (offset) ps);
  164. break;
  165. }
  166. }
  167. static proc_p find_proc(valnum vn)
  168. {
  169. /* Find the procedure-identifier with valuenumber vn. */
  170. entity_p enp;
  171. enp = find_entity(vn);
  172. if (enp != (entity_p) 0 && enp->en_kind == ENPROC)
  173. return enp->en_pro;
  174. return (proc_p) 0;
  175. }
  176. static void side_effects(line_p lnp)
  177. {
  178. /* Lnp contains a cai or cal instruction. We try to find the callee
  179. * and see what side-effects it has.
  180. */
  181. struct token tk;
  182. proc_p pp;
  183. if (INSTR(lnp) == op_cai) {
  184. Pop(&tk, (offset) ps);
  185. pp = find_proc(tk.tk_vn);
  186. } else {
  187. assert(INSTR(lnp) == op_cal);
  188. pp = PROC(lnp);
  189. }
  190. if (pp != (proc_p) 0) {
  191. kill_call(pp);
  192. } else {
  193. kill_much();
  194. }
  195. }
  196. void hopeless(int instr)
  197. {
  198. /* The effect of `instr' is too difficult to
  199. * compute. We assume worst case behaviour.
  200. */
  201. switch (instr) {
  202. default:
  203. assert(FALSE);
  204. break;
  205. case op_mon:
  206. case op_str:
  207. case op_nop: /* for volatiles */
  208. /* We can't even trust "static" entities. */
  209. kill_all();
  210. clr_stack();
  211. break;
  212. case op_blm:
  213. case op_bls:
  214. case op_sts:
  215. kill_much();
  216. clr_stack();
  217. break;
  218. }
  219. }
  220. void vnm(bblock_p bp)
  221. {
  222. line_p lnp;
  223. entity_p rep;
  224. line_p lfirst;
  225. struct token tk, tk1, tk2, tk3;
  226. for (lnp = bp->b_start; lnp != (line_p) 0; lnp = lnp->l_next) {
  227. rep = getentity(lnp, &lfirst);
  228. switch (instrgroup(lnp)) {
  229. case SIMPLE_LOAD:
  230. push_entity(rep, lfirst);
  231. break;
  232. case LOAD_ARRAY:
  233. put_aar(bp, lnp, lfirst, rep);
  234. /* Fall through ... */
  235. case EXPENSIVE_LOAD:
  236. push_entity(rep, lfirst);
  237. put_expensive_load(bp, lnp, lfirst, rep);
  238. break;
  239. case STORE_DIRECT:
  240. kill_direct(rep);
  241. Pop(&tk, rep->en_size);
  242. rep->en_vn = tk.tk_vn;
  243. break;
  244. case STORE_ARRAY:
  245. put_aar(bp, lnp, lfirst, rep);
  246. /* Fall through ... */
  247. case STORE_INDIR:
  248. kill_indir(rep);
  249. Pop(&tk, rep->en_size);
  250. rep->en_vn = tk.tk_vn;
  251. break;
  252. case UNAIR_OP:
  253. Pop(&tk1, op11size(lnp));
  254. push_unair_op(bp, lnp, &tk1);
  255. break;
  256. case BINAIR_OP:
  257. Pop(&tk2, op22size(lnp));
  258. Pop(&tk1, op12size(lnp));
  259. push_binair_op(bp, lnp, &tk1, &tk2);
  260. break;
  261. case TERNAIR_OP:
  262. Pop(&tk3, op33size(lnp));
  263. Pop(&tk2, op23size(lnp));
  264. Pop(&tk1, op13size(lnp));
  265. push_ternair_op(bp, lnp, &tk1, &tk2, &tk3);
  266. break;
  267. case KILL_ENTITY:
  268. kill_direct(rep);
  269. break;
  270. case SIDE_EFFECTS:
  271. side_effects(lnp);
  272. break;
  273. case FIDDLE_STACK:
  274. fiddle_stack(lnp);
  275. break;
  276. case IGNORE:
  277. break;
  278. case HOPELESS:
  279. hopeless(INSTR(lnp));
  280. break;
  281. case BBLOCK_END:
  282. fiddle_stack(lnp);
  283. break;
  284. default:
  285. assert(FALSE);
  286. break;
  287. }
  288. }
  289. }