expr.c 7.0 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331
  1. /*
  2. * (c) copyright 1987 by the Vrije Universiteit, Amsterdam, The Netherlands.
  3. * See the copyright notice in the ACK home directory, in the file "Copyright".
  4. */
  5. #include <string.h>
  6. #include <stdlib.h>
  7. #include <stdio.h>
  8. #include "assert.h"
  9. #include "param.h"
  10. #include "set.h"
  11. #include "reg.h"
  12. #include "lookup.h"
  13. #include "token.h"
  14. #include "property.h"
  15. #include "expr.h"
  16. #include "regvar.h"
  17. #include "error.h"
  18. #include <cgg_cg.h>
  19. #include "extern.h"
  20. extern set_t l_sets[];
  21. void subregset(short *sp, int subreg, short *regset);
  22. int i_expr(expr_t e)
  23. {
  24. if (e.ex_typ != TYPINT)
  25. error("Expression should be integer");
  26. return(e.ex_index);
  27. }
  28. int b_expr(expr_t e)
  29. {
  30. if (e.ex_typ != TYPBOOL)
  31. error("Expression should be boolean");
  32. return(e.ex_index);
  33. }
  34. expr_t make_expr(int type, int operator, int op1, int op2)
  35. {
  36. expr_t result;
  37. result.ex_typ=type;
  38. result.ex_index=ex_lookup(operator,op1,op2);
  39. return(result);
  40. }
  41. expr_t regno_expr(int regno)
  42. {
  43. expr_t result;
  44. int i;
  45. result.ex_typ = TYPREG;
  46. result.ex_index = ex_lookup(EX_REG,regno,0);
  47. for (i=0;i<SZOFSET(MAXREGS);i++)
  48. result.ex_regset[i] = 0;
  49. BIS(result.ex_regset,regno);
  50. return(result);
  51. }
  52. expr_t ident_expr(char *name)
  53. {
  54. symbol *sy_p;
  55. sy_p = lookup(name,symany,mustexist);
  56. if (sy_p->sy_type==symconst)
  57. return(make_expr(TYPINT,EX_CON,
  58. (int) (sy_p->sy_value.syv_cstval&0xFFFF),
  59. (int) (sy_p->sy_value.syv_cstval>>16)));
  60. else if (sy_p->sy_type==symsconst)
  61. return(make_expr(TYPADDR,EX_STRING,sy_p->sy_value.syv_stringno,0));
  62. else if (sy_p->sy_type!=symreg)
  63. error("Wrong type of identifier %s",name);
  64. return(regno_expr(sy_p->sy_value.syv_regno));
  65. }
  66. expr_t subreg_expr(int tokarg, int subreg)
  67. {
  68. expr_t result;
  69. result.ex_typ = TYPREG;
  70. subregset(l_sets[tokpatset[tokarg > 0 ? tokarg-1 : tokarg]].set_val,
  71. subreg,result.ex_regset);
  72. result.ex_index = ex_lookup(EX_SUBREG,tokarg,subreg);
  73. return(result);
  74. }
  75. void subregset(short *sp, int subreg, short *regset)
  76. {
  77. int i;
  78. reginfo *rp;
  79. for (i=0;i<SZOFSET(MAXREGS);i++)
  80. regset[i]=0;
  81. for (i=1;i<nregs;i++) if (BIT(sp,i)) {
  82. if(subreg) {
  83. rp = &l_regs[i];
  84. if (rp->ri_memb[subreg-1]==0)
  85. error("Register %s in set has no member %d",
  86. rp->ri_name,subreg);
  87. BIS(regset,rp->ri_memb[subreg-1]);
  88. } else
  89. BIS(regset,i);
  90. }
  91. for(;i<nregs+MAXTOKENS;i++) if(BIT(sp,i))
  92. error("Set contains %s, which is not a register",
  93. l_tokens[i-nregs]->tk_name);
  94. }
  95. int membset(int setno, char *name, short *regset, char *appearance, int restyp, int *typp)
  96. {
  97. register short *sp;
  98. register token_p tp;
  99. register i,j,k;
  100. int thistyp;
  101. int typesdiffer=0;
  102. int res_j= -1;
  103. if (setno < 0) return 0;
  104. sp = l_sets[setno].set_val;
  105. for (i=1;i<nregs;i++) if (BIT(sp,i)) {
  106. error("Set in %s contains %s, which is not a token",
  107. appearance,l_regs[i].ri_name);
  108. break;
  109. }
  110. for (i=0;i<SZOFSET(MAXREGS);i++)
  111. regset[i] = 0;
  112. for (i=nregs;i<nregs+MAXTOKENS;i++) if (BIT(sp,i)) {
  113. tp = l_tokens[i-nregs];
  114. for(j=0;j<MAXATT &&
  115. (tp->tk_att[j].ta_type == -3 ||
  116. strcmp(tp->tk_att[j].ta_name,name));j++)
  117. ;
  118. if (j==MAXATT)
  119. error("Token %s does not contain %s",tp->tk_name,name);
  120. else if (j!=res_j && res_j != -1)
  121. typesdiffer=1;
  122. else {
  123. res_j = j;
  124. thistyp = tp->tk_att[j].ta_type;
  125. if (thistyp== -2) {
  126. if (restyp!=TYPADDR && restyp!=0)
  127. typesdiffer=1;
  128. else
  129. restyp=TYPADDR;
  130. } else if (thistyp== -1) {
  131. if (restyp!=TYPINT && restyp!=0)
  132. typesdiffer=1;
  133. else
  134. restyp=TYPINT;
  135. } else {
  136. if (restyp!=TYPREG && restyp!=0)
  137. typesdiffer=1;
  138. else {
  139. restyp=TYPREG;
  140. for(k=0;k<SZOFSET(MAXREGS);k++)
  141. regset[k] |=
  142. l_props[tp->tk_att[j].ta_type].pr_regset[k];
  143. }
  144. }
  145. }
  146. }
  147. if (typesdiffer)
  148. error("%s is not a valid expression; types differ in the set",
  149. appearance);
  150. *typp = restyp==0 ? TYPINT : restyp;
  151. return(res_j == -1 ? 0 : res_j);
  152. }
  153. expr_t memb_expr(int setno, char *name, char *appearance, int tokarg)
  154. {
  155. expr_t result;
  156. int res_j;
  157. res_j = membset(setno,name,result.ex_regset,appearance,0,&result.ex_typ);
  158. result.ex_index = ex_lookup(EX_TOKFIELD,tokarg,res_j+1);
  159. return(result);
  160. }
  161. expr_t tokm_expr(int tokarg, char *name)
  162. {
  163. char app[100];
  164. int tokarg1 = tokarg > 0 ? tokarg : 1;
  165. sprintf(app,"%%%d.%s",tokarg1,name);
  166. return(memb_expr(tokpatset[tokarg1-1],name,app,tokarg));
  167. }
  168. expr_t perc_ident_expr(char *name)
  169. {
  170. char app[100];
  171. sprintf(app,"%%%s",name);
  172. return(memb_expr(cursetno,name,app,0));
  173. }
  174. expr_t all_expr(int all_no, int subreg)
  175. {
  176. set_t localset;
  177. int i;
  178. short *sp;
  179. expr_t result;
  180. sp = l_props[allreg[all_no]].pr_regset;
  181. for (i=0;i<SETSIZE;i++)
  182. localset.set_val[i] = i<SZOFSET(MAXREGS) ? sp[i] : 0;
  183. subregset(localset.set_val,subreg,result.ex_regset);
  184. result.ex_typ = TYPREG;
  185. result.ex_index = ex_lookup(EX_ALLREG,all_no+1,subreg);
  186. return(result);
  187. }
  188. int eq2expr(expr_t e1, expr_t e2)
  189. {
  190. if (e1.ex_typ != e2.ex_typ)
  191. error("Expressions around == should have equal type");
  192. switch (e1.ex_typ) {
  193. default: assert(0);
  194. case TYPBOOL:
  195. error("== on booleans not implemented");
  196. case TYPINT:
  197. return(EX_NCPEQ);
  198. case TYPADDR:
  199. return(EX_SCPEQ);
  200. case TYPREG:
  201. return(EX_RCPEQ);
  202. }
  203. }
  204. int ne2expr(expr_t e1, expr_t e2)
  205. {
  206. if (e1.ex_typ != e2.ex_typ)
  207. error("Expressions around != should have equal type");
  208. switch (e1.ex_typ) {
  209. default: assert(0);
  210. case TYPBOOL:
  211. error("!= on booleans not implemented");
  212. case TYPINT:
  213. return(EX_NCPNE);
  214. case TYPADDR:
  215. return(EX_SCPNE);
  216. case TYPREG:
  217. return(EX_RCPNE);
  218. }
  219. }
  220. expr_t sum_expr(expr_t e1, expr_t e2)
  221. {
  222. int operator,op1,op2;
  223. expr_t result;
  224. operator = EX_CAT; op1 = e1.ex_index; op2 = e2.ex_index;
  225. if (e1.ex_typ==e2.ex_typ) {
  226. result.ex_typ = e1.ex_typ;
  227. if (e1.ex_typ == TYPINT)
  228. operator = EX_PLUS;
  229. else if (e1.ex_typ != TYPADDR)
  230. error("+ is not implemented on this type");
  231. } else {
  232. result.ex_typ = TYPADDR;
  233. if (e1.ex_typ != TYPADDR) {
  234. if (e1.ex_typ!=TYPINT)
  235. error("Wrong left operand of +");
  236. op1 = ex_lookup(EX_TOSTRING,op1,0);
  237. }
  238. if (e2.ex_typ != TYPADDR) {
  239. if (e2.ex_typ!=TYPINT)
  240. error("Wrong right operand of +");
  241. op2 = ex_lookup(EX_TOSTRING,op2,0);
  242. }
  243. }
  244. result.ex_index=ex_lookup(operator,op1,op2);
  245. return(result);
  246. }
  247. expr_t iextoaddr(expr_t e)
  248. {
  249. expr_t result;
  250. result.ex_typ = TYPADDR;
  251. result.ex_index = ex_lookup(EX_TOSTRING,e.ex_index,0);
  252. return(result);
  253. }
  254. expr_t regvar_expr(expr_t e, int regtyp)
  255. {
  256. expr_t result;
  257. int i;
  258. result = make_expr(TYPREG,EX_REGVAR,i_expr(e),0);
  259. for(i=0;i<SZOFSET(MAXREGS);i++)
  260. result.ex_regset[i]=0;
  261. for(i=0;i<nregvar[regtyp];i++)
  262. BIS(result.ex_regset,rvnumbers[regtyp][i]);
  263. return(result);
  264. }
  265. /*
  266. * Node table lookup part
  267. */
  268. node_t nodes[MAXNODES];
  269. int nnodes=0;
  270. void initnodes()
  271. {
  272. nodes[0].ex_operator = EX_CON;
  273. nodes[0].ex_lnode = 0;
  274. nodes[0].ex_rnode = 0;
  275. nnodes++;
  276. }
  277. int ex_lookup(int operator, int lnode, int rnode)
  278. {
  279. register node_p p;
  280. for(p=nodes+1;p< &nodes[nnodes];p++) {
  281. if (p->ex_operator != operator)
  282. continue;
  283. if (p->ex_lnode != lnode)
  284. continue;
  285. if (p->ex_rnode != rnode)
  286. continue;
  287. return(p-nodes);
  288. }
  289. NEXT(nnodes,MAXNODES,"Node");
  290. p->ex_operator = operator;
  291. p->ex_lnode = lnode;
  292. p->ex_rnode = rnode;
  293. return(p-nodes);
  294. }