4 new(int t, Node *l, Node *r)
13 n->lineno = l->lineno;
15 n->lineno = r->lineno;
23 new1(int o, Node *l, Node *r)
33 prtree(Node *n, char *s)
36 print(" == %s ==\n", s);
42 prtree1(Node *n, int d, int f)
54 prtree1(n->left, d, 0);
55 prtree1(n->right, d, 1);
65 print(" %ld", n->xoffset);
70 print(" %ld(R%d)", n->xoffset, n->reg);
76 print(" %ld+R%d", n->xoffset, n->reg);
78 print(" R%d", n->reg);
83 print(" \"%s\"", n->cstring);
88 print(" \"%S\"", n->rstring);
98 if(typefd[n->type->etype])
99 print(" \"%.8e\"", n->fconst);
101 print(" \"%lld\"", n->vconst);
106 print(" <%d>", n->addable);
108 print(" %T", n->type);
110 print(" (%d)", n->complex);
111 print(" %L\n", n->lineno);
113 prtree1(n->left, d, 1);
115 prtree1(n->right, d, 1);
123 t = alloc(sizeof(*t));
128 t->width = ewidth[et];
147 garbt(Type *t, long b)
153 t1->garb = simpleg(b);
169 case BVOLATILE|BCONSTNT:
170 return GCONSTNT|GVOLATILE;
185 case BAUTO|BREGISTER:
189 case BEXTERN|BREGISTER:
198 diag(Z, "illegal combination of classes %Q", b);
206 b &= ~BCLASS & ~BGARB;
212 case BCHAR|BUNSIGNED:
213 return types[TUCHAR];
218 case BSHORT|BINT|BSIGNED:
219 return types[TSHORT];
221 case BUNSIGNED|BSHORT:
222 case BUNSIGNED|BSHORT|BINT:
223 return types[TUSHORT];
238 case BLONG|BINT|BSIGNED:
241 case BUNSIGNED|BLONG:
242 case BUNSIGNED|BLONG|BINT:
243 return types[TULONG];
246 case BVLONG|BLONG|BINT:
247 case BVLONG|BLONG|BSIGNED:
248 case BVLONG|BLONG|BINT|BSIGNED:
249 return types[TVLONG];
251 case BVLONG|BLONG|BUNSIGNED:
252 case BVLONG|BLONG|BINT|BUNSIGNED:
253 return types[TUVLONG];
256 return types[TFLOAT];
261 return types[TDOUBLE];
267 diag(Z, "illegal combination of types %Q", b);
272 stcompat(Node *n, Type *t1, Type *t2, long ttab[])
286 if(b == BSTRUCT || b == BUNION)
287 if(!sametype(t1, t2))
290 if(b == BIND && i == TIND)
291 if(!sametype(t1, t2))
299 tcompat(Node *n, Type *t1, Type *t2, long ttab[])
302 if(stcompat(n, t1, t2, ttab)) {
304 diag(n, "incompatible type: \"%T\" for op \"%O\"",
307 diag(n, "incompatible types: \"%T\" and \"%T\" for op \"%O\"",
315 makedot(Node *n, Type *t, long o)
320 n1 = new(OXXX, Z, Z);
326 n->addable = n1->left->addable;
329 n->addable = n->left->addable;
330 if(n->addable == 0) {
331 n1 = new1(OCONST, Z, Z);
333 n1->type = types[TLONG];
344 n1 = new1(OCONST, Z, Z);
347 t->width = types[TIND]->width;
350 n2 = new1(OADDR, n->left, Z);
353 n1 = new1(OADD, n1, n2);
362 dotsearch(Sym *s, Type *t, Node *n, long *off)
371 for(t1 = t; t1 != T; t1 = t1->down)
381 if(s->class == CTYPEDEF || s->class == CTYPESTR)
382 for(t1 = t; t1 != T; t1 = t1->down)
383 if(t1->sym == S && typesu[t1->etype])
384 if(sametype(s->type, t1)) {
395 * look it up in unnamed substructures
397 for(t1 = t; t1 != T; t1 = t1->down)
398 if(t1->sym == S && typesu[t1->etype]){
399 rt = dotsearch(s, t1->link, n, off);
410 diag(n, "ambiguous structure element: %s", s->name);
415 dotoffset(Type *st, Type *lt, Node *n)
423 * first try matching at the top level
424 * for matching tag names
428 for(t=lt->link; t!=T; t=t->down)
439 * second try matching at the top level
442 for(t=lt->link; t!=T; t=t->down)
444 if(sametype(st, t)) {
453 * last try matching sub-levels
455 for(t=lt->link; t!=T; t=t->down)
457 if(typesu[t->etype]) {
458 o1 = dotoffset(st, t, n);
468 diag(n, "ambiguous unnamed structure element");
473 * look into tree for floating point constant expressions
476 allfloat(Node *n, int flag)
480 if(n->type->etype != TDOUBLE)
485 n->type = types[TFLOAT];
487 case OADD: /* no need to get more exotic than this */
491 if(!allfloat(n->right, flag))
494 if(!allfloat(n->left, flag))
497 n->type = types[TFLOAT];
505 constas(Node *n, Type *il, Type *ir)
514 if(l->garb & GCONSTNT) {
515 warn(n, "assignment to a constant type (%T)", il);
521 if(l->etype != TIND || r->etype != TIND)
527 if(r->garb & GCONSTNT)
528 if(!(l->garb & GCONSTNT)) {
529 warn(n, "assignment of a constant pointer type (%T)", ir);
536 typeext1(Type *st, Node *l)
538 if(st->etype == TFLOAT && allfloat(l, 0))
543 typeext(Type *st, Node *l)
552 if(st->etype == TIND && vconst(l) == 0) {
561 * if assign of struct containing unnamed sub-struct
562 * to type of sub-struct, insert the DOT.
563 * if assign of *struct containing unnamed substruct
564 * to type of *sub-struct, insert the add-offset
566 if(typesu[st->etype] && typesu[lt->etype]) {
567 o = dotoffset(st, lt, l);
569 n1 = new1(OXXX, Z, Z);
578 if(st->etype == TIND && typesu[st->link->etype])
579 if(lt->etype == TIND && typesu[lt->link->etype]) {
580 o = dotoffset(st->link, lt->link, l);
585 n1 = new1(OXXX, Z, Z);
587 n2 = new1(OCONST, Z, Z);
599 * a cast that generates no code
603 nocast(Type *t1, Type *t2)
622 * a cast that has a noop semantic
623 * (small to large, convert)
626 nilcast(Type *t1, Type *t2)
640 if(typefd[et1] && typefd[et2]) {
641 if(ewidth[et1] < ewidth[et2])
645 if(typechlp[et1] && typechlp[et2]) {
646 if(ewidth[et1] < ewidth[et2])
654 * "the usual arithmetic conversions are performed"
657 arith(Node *n, int f)
683 /* convert up to at least int */
690 if(i == TIND && j == TIND) {
691 w = n->right->type->link->width;
692 if(w < 1 || n->left->type->link == T || n->left->type->link->width < 1)
694 n->type = types[ewidth[TIND] <= ewidth[TLONG]? TLONG: TVLONG];
695 if(1 && ewidth[TIND] > ewidth[TLONG]){
696 n1 = new1(OXXX, Z, Z);
701 n->type = types[TLONG];
704 n1 = new1(OXXX, Z, Z);
708 n1 = new1(OCONST, Z, Z);
720 if(!sametype(n->type, n->left->type)) {
721 n->left = new1(OCAST, n->left, Z);
722 n->left->type = n->type;
723 if(n->type->etype == TIND) {
724 w = n->type->link->width;
727 w = n->type->link->width;
732 n1 = new1(OCONST, Z, Z);
735 n->left = new1(OMUL, n->left, n1);
736 n->left->type = n->type;
741 if(!sametype(n->type, n->right->type)) {
742 n->right = new1(OCAST, n->right, Z);
743 n->right->type = n->type;
744 if(n->type->etype == TIND) {
745 w = n->type->link->width;
748 w = n->type->link->width;
753 n1 = new1(OCONST, Z, Z);
756 n->right = new1(OMUL, n->right, n1);
757 n->right->type = n->type;
763 diag(n, "pointer addition not fully declared: %T", n->type->link);
767 * try to rewrite shift & mask
770 simplifyshift(Node *n)
773 int o, s1, s2, c1, c2;
775 if(!typechlp[n->type->etype])
790 if(n->right->op != OCONST)
792 if(n->left->op != OAND)
794 if(n->left->right->op != OCONST)
796 switch(n->left->left->op) {
809 if(n->left->left->right->op != OCONST)
812 c1 = n->right->vconst;
813 c2 = n->left->left->right->vconst;
814 c3 = n->left->right->vconst;
818 print("%.3o %ld %ld %d #%.lux\n",
819 (s1<<3)|s2, c1, c2, topbit(c3), c3);
824 case 000: /* (((e <<u c2) & c3) <<u c1) */
831 case 002: /* (((e >>s c2) & c3) <<u c1) */
832 if(topbit(c3) >= (32-c2))
834 case 001: /* (((e >>u c2) & c3) <<u c1) */
848 case 022: /* (((e >>s c2) & c3) >>s c1) */
851 case 012: /* (((e >>s c2) & c3) >>u c1) */
852 if(topbit(c3) >= (32-c2))
855 case 021: /* (((e >>u c2) & c3) >>s c1) */
856 if(topbit(c3) >= 31 && c2 <= 0)
859 case 011: /* (((e >>u c2) & c3) >>u c1) */
868 case 020: /* (((e <<u c2) & c3) >>s c1) */
871 case 010: /* (((e <<u c2) & c3) >>u c1) */
885 rewrite0: /* get rid of both shifts */
886 if(debug['<'])prtree(n, "rewrite0");
888 n->left = n->left->left;
889 n->right->vconst = c3;
891 rewrite1: /* get rid of lower shift */
892 if(debug['<'])prtree(n, "rewrite1");
893 n->left->left = n->left->left->left;
894 n->left->right->vconst = c3;
895 n->right->vconst = c1;
898 rewrite2: /* get rid of upper shift */
899 if(debug['<'])prtree(n, "rewrite2");
901 n->right->vconst = c3;
902 n->left->right->vconst = c1;
976 switch(n->type->etype)
981 if(n->fconst > i || n->fconst < -i)
1010 return -159; /* first uninteresting constant */
1014 * return log(n) if n is a power of 2 constant
1023 m = MASK(8*sizeof(uvlong));
1024 for(i=32; i; i>>=1) {
1041 if(typefd[n->type->etype])
1044 return log2(n->vconst);
1061 * try to cast a constant down
1062 * rather than cast a variable up
1067 relcon(Node *l, Node *r)
1075 if(!nilcast(r->left->type, r->type))
1077 switch(r->type->etype) {
1084 v = convvtox(l->vconst, r->type->etype);
1089 l->type = r->left->type;
1099 diag(Z, "bad in relindex: %O", o);
1118 if(n == Z || n->op != OLIST)
1121 for(n = n->left; n != Z; n = n->left) {
1140 diag(Z, "bad in bitno");
1145 typebitor(long a, long b)
1151 if((a & b) == BLONG)
1152 c |= BVLONG; /* long long => vlong */
1154 warn(Z, "once is enough: %Q", a & b);
1159 diag(Node *n, char *fmt, ...)
1165 vseprint(buf, buf+sizeof(buf), fmt, arg);
1167 Bprint(&diagbuf, "%L %s\n", (n==Z)? nearln: n->lineno, buf);
1175 prtree(n, "diagnostic");
1179 Bprint(&diagbuf, "too many errors\n");
1185 warn(Node *n, char *fmt, ...)
1191 Bprint(&diagbuf, "warning: ");
1193 vseprint(buf, buf+sizeof(buf), fmt, arg);
1195 Bprint(&diagbuf, "%L %s\n", (n==Z)? nearln: n->lineno, buf);
1199 prtree(n, "warning");
1204 yyerror(char *fmt, ...)
1210 * hack to intercept message from yaccpar
1212 if(strcmp(fmt, "syntax error") == 0) {
1213 yyerror("syntax error, last name: %s", symb);
1217 vseprint(buf, buf+sizeof(buf), fmt, arg);
1219 Bprint(&diagbuf, "%L %s\n", lineno, buf);
1222 Bprint(&diagbuf, "too many errors\n");
1228 fatal(Node *n, char *fmt, ...)
1234 vseprint(buf, buf+sizeof(buf), fmt, arg);
1236 Bprint(&diagbuf, "%L %s\n", (n==Z)? nearln: n->lineno, buf);
1244 prtree(n, "diagnostic");
1250 ulong thash1 = 0x2edab8c9;
1251 ulong thash2 = 0x1dc74fb8;
1252 ulong thash3 = 0x1f241331;
1253 ulong thash[NALLTYPES];
1256 TXXX, 0x17527bbd, 0,
1257 TCHAR, 0x5cedd32b, 0,
1258 TUCHAR, 0x552c4454, 0,
1259 TSHORT, 0x63040b4b, 0,
1260 TUSHORT, 0x32a45878, 0,
1261 TINT, 0x4151d5bd, 0,
1262 TUINT, 0x5ae707d6, 0,
1263 TLONG, 0x5ef20f47, 0,
1264 TULONG, 0x36d8eb8f, 0,
1265 TVLONG, 0x6e5e9590, 0,
1266 TUVLONG, 0x75910105, 0,
1267 TFLOAT, 0x25fd7af1, 0,
1268 TDOUBLE, 0x7c40a1b2, 0,
1269 TIND, 0x1b832357, 0,
1270 TFUNC, 0x6babc9cb, 0,
1271 TARRAY, 0x7c50986d, 0,
1272 TVOID, 0x44112eff, 0,
1273 TSTRUCT, 0x7c2da3bf, 0,
1274 TUNION, 0x3eb25e98, 0,
1275 TENUM, 0x44b54f61, 0,
1276 TFILE, 0x19242ac3, 0,
1277 TOLD, 0x22b15988, 0,
1278 TDOT, 0x0204f6b3, 0,
1282 char* bnames[NALIGN];
1296 char* tnames[NALLTYPES];
1303 TUSHORT, 0, "USHORT",
1309 TUVLONG, 0, "UVLONG",
1311 TDOUBLE, 0, "DOUBLE",
1316 TSTRUCT, 0, "STRUCT",
1325 char* gnames[NGTYPES];
1329 GCONSTNT, 0, "CONST",
1330 GVOLATILE, 0, "VOLATILE",
1331 GVOLATILE|GCONSTNT, 0, "CONST-VOLATILE",
1335 char* qnames[NALLTYPES];
1342 TUSHORT, 0, "USHORT",
1348 TUVLONG, 0, "UVLONG",
1350 TDOUBLE, 0, "DOUBLE",
1355 TSTRUCT, 0, "STRUCT",
1360 TEXTERN, 0, "EXTERN",
1361 TSTATIC, 0, "STATIC",
1362 TTYPEDEF, 0, "TYPEDEF",
1363 TTYPESTR, 0, "TYPESTR",
1364 TREGISTER, 0, "REGISTER",
1365 TCONSTNT, 0, "CONSTNT",
1366 TVOLATILE, 0, "VOLATILE",
1367 TUNSIGNED, 0, "UNSIGNED",
1368 TSIGNED, 0, "SIGNED",
1374 char* cnames[NCTYPES];
1379 CEXTERN, 0, "EXTERN",
1381 CSTATIC, 0, "STATIC",
1383 CTYPEDEF, 0, "TYPEDEF",
1384 CTYPESTR, 0, "TYPESTR",
1392 char* onames[OEND+1];
1399 OANDAND, 0, "ANDAND",
1405 OASASHL, 0, "ASASHL",
1406 OASASHR, 0, "ASASHR",
1410 OASLDIV, 0, "ASLDIV",
1411 OASLMOD, 0, "ASLMOD",
1412 OASLMUL, 0, "ASLMUL",
1413 OASLSHR, 0, "ASLSHR",
1426 OCONTINUE, 0, "CONTINUE",
1429 ODOTDOT, 0, "DOTDOT",
1430 ODWHILE, 0, "DWHILE",
1442 OINDREG, 0, "INDREG",
1461 OPOSTDEC, 0, "POSTDEC",
1462 OPOSTINC, 0, "POSTINC",
1463 OPREDEC, 0, "PREDEC",
1464 OPREINC, 0, "PREINC",
1466 OREGISTER, 0, "REGISTER",
1467 ORETURN, 0, "RETURN",
1471 OSTRING, 0, "STRING",
1472 OLSTRING, 0, "LSTRING",
1473 OSTRUCT, 0, "STRUCT",
1475 OSWITCH, 0, "SWITCH",
1487 OREGPAIR, 0, "REGPAIR",
1493 /* OEQ, ONE, OLE, OLS, OLT, OLO, OGE, OHS, OGT, OHI */
1496 ONE, OEQ, OGT, OHI, OGE, OHS, OLT, OLO, OLE, OLS,
1500 OEQ, ONE, OGE, OHS, OGT, OHI, OLE, OLS, OLT, OLO,
1504 OEQ, ONE, OLS, OLS, OLO, OLO, OHS, OHS, OHI, OHI,
1510 TCHAR, TUCHAR, TSHORT, TUSHORT, TINT, TUINT, TLONG, TULONG, TVLONG, TUVLONG, -1,
1515 TUCHAR, TUSHORT, TUINT, TULONG, TUVLONG, TIND, -1,
1518 char typesuv[NTYPE];
1521 TVLONG, TUVLONG, TSTRUCT, TUNION, -1,
1524 char typeilp[NTYPE];
1527 TINT, TUINT, TLONG, TULONG, TIND, -1
1530 char typechl[NTYPE];
1531 char typechlv[NTYPE];
1532 char typechlvp[NTYPE];
1535 TCHAR, TUCHAR, TSHORT, TUSHORT, TINT, TUINT, TLONG, TULONG, -1,
1538 char typechlp[NTYPE];
1539 int typechlpinit[] =
1541 TCHAR, TUCHAR, TSHORT, TUSHORT, TINT, TUINT, TLONG, TULONG, TIND, -1,
1544 char typechlpfd[NTYPE];
1545 int typechlpfdinit[] =
1547 TCHAR, TUCHAR, TSHORT, TUSHORT, TINT, TUINT, TLONG, TULONG, TFLOAT, TDOUBLE, TIND, -1,
1559 TSHORT, TUSHORT, -1,
1565 TINT, TUINT, TLONG, TULONG, -1,
1571 TVLONG, TUVLONG, -1,
1577 TFLOAT, TDOUBLE, -1,
1589 TSTRUCT, TUNION, -1,
1598 TUSHORT, BNUMBER, 0,
1604 TUVLONG, BNUMBER, 0,
1606 TDOUBLE, BNUMBER, 0,
1608 TSTRUCT, BSTRUCT, 0,
1619 TUSHORT, BNUMBER, 0,
1625 TUVLONG, BNUMBER, 0,
1627 TDOUBLE, BNUMBER, 0,
1635 TCHAR, BNUMBER|BIND|BVOID, 0,
1636 TUCHAR, BNUMBER|BIND|BVOID, 0,
1637 TSHORT, BNUMBER|BIND|BVOID, 0,
1638 TUSHORT, BNUMBER|BIND|BVOID, 0,
1639 TINT, BNUMBER|BIND|BVOID, 0,
1640 TUINT, BNUMBER|BIND|BVOID, 0,
1641 TLONG, BNUMBER|BIND|BVOID, 0,
1642 TULONG, BNUMBER|BIND|BVOID, 0,
1643 TVLONG, BNUMBER|BIND|BVOID, 0,
1644 TUVLONG, BNUMBER|BIND|BVOID, 0,
1645 TFLOAT, BNUMBER|BVOID, 0,
1646 TDOUBLE, BNUMBER|BVOID, 0,
1647 TIND, BINTEGER|BIND|BVOID, 0,
1649 TSTRUCT, BSTRUCT|BVOID, 0,
1650 TUNION, BUNION|BVOID, 0,
1657 TCHAR, BNUMBER|BIND, 0,
1658 TUCHAR, BNUMBER|BIND, 0,
1659 TSHORT, BNUMBER|BIND, 0,
1660 TUSHORT, BNUMBER|BIND, 0,
1661 TINT, BNUMBER|BIND, 0,
1662 TUINT, BNUMBER|BIND, 0,
1663 TLONG, BNUMBER|BIND, 0,
1664 TULONG, BNUMBER|BIND, 0,
1665 TVLONG, BNUMBER|BIND, 0,
1666 TUVLONG, BNUMBER|BIND, 0,
1668 TDOUBLE, BNUMBER, 0,
1679 TUSHORT, BNUMBER, 0,
1685 TUVLONG, BNUMBER, 0,
1687 TDOUBLE, BNUMBER, 0,
1688 TIND, BINTEGER|BIND, 0,
1698 TUSHORT, BNUMBER, 0,
1704 TUVLONG, BNUMBER, 0,
1706 TDOUBLE, BNUMBER, 0,
1714 TUCHAR, BINTEGER, 0,
1715 TSHORT, BINTEGER, 0,
1716 TUSHORT, BINTEGER, 0,
1720 TULONG, BINTEGER, 0,
1721 TVLONG, BINTEGER, 0,
1722 TUVLONG, BINTEGER, 0,
1732 TUSHORT, BNUMBER, 0,
1738 TUVLONG, BNUMBER, 0,
1740 TDOUBLE, BNUMBER, 0,
1767 BNUMBER|BIND|BSTRUCT|BUNION,
1770 char tab[NTYPE][NTYPE] =
1775 /*TCHAR*/ { 0, TCHAR, TUCHAR, TSHORT, TUSHORT, TINT, TUINT, TLONG,
1776 TULONG, TVLONG, TUVLONG, TFLOAT, TDOUBLE, TIND,
1778 /*TUCHAR*/ { 0, TUCHAR, TUCHAR, TUSHORT, TUSHORT, TUINT, TUINT, TULONG,
1779 TULONG, TUVLONG, TUVLONG, TFLOAT, TDOUBLE, TIND,
1781 /*TSHORT*/ { 0, TSHORT, TUSHORT, TSHORT, TUSHORT, TINT, TUINT, TLONG,
1782 TULONG, TVLONG, TUVLONG, TFLOAT, TDOUBLE, TIND,
1784 /*TUSHORT*/ { 0, TUSHORT, TUSHORT, TUSHORT, TUSHORT, TUINT, TUINT, TULONG,
1785 TULONG, TUVLONG, TUVLONG, TFLOAT, TDOUBLE, TIND,
1787 /*TINT*/ { 0, TINT, TUINT, TINT, TUINT, TINT, TUINT, TLONG,
1788 TULONG, TVLONG, TUVLONG, TFLOAT, TDOUBLE, TIND,
1790 /*TUINT*/ { 0, TUINT, TUINT, TUINT, TUINT, TUINT, TUINT, TULONG,
1791 TULONG, TUVLONG, TUVLONG, TFLOAT, TDOUBLE, TIND,
1793 /*TLONG*/ { 0, TLONG, TULONG, TLONG, TULONG, TLONG, TULONG, TLONG,
1794 TULONG, TVLONG, TUVLONG, TFLOAT, TDOUBLE, TIND,
1796 /*TULONG*/ { 0, TULONG, TULONG, TULONG, TULONG, TULONG, TULONG, TULONG,
1797 TULONG, TUVLONG, TUVLONG, TFLOAT, TDOUBLE, TIND,
1799 /*TVLONG*/ { 0, TVLONG, TUVLONG, TVLONG, TUVLONG, TVLONG, TUVLONG, TVLONG,
1800 TUVLONG, TVLONG, TUVLONG, TFLOAT, TDOUBLE, TIND,
1802 /*TUVLONG*/ { 0, TUVLONG, TUVLONG, TUVLONG, TUVLONG, TUVLONG, TUVLONG, TUVLONG,
1803 TUVLONG, TUVLONG, TUVLONG, TFLOAT, TDOUBLE, TIND,
1805 /*TFLOAT*/ { 0, TFLOAT, TFLOAT, TFLOAT, TFLOAT, TFLOAT, TFLOAT, TFLOAT,
1806 TFLOAT, TFLOAT, TFLOAT, TFLOAT, TDOUBLE, TIND,
1808 /*TDOUBLE*/ { 0, TDOUBLE, TDOUBLE, TDOUBLE, TDOUBLE, TDOUBLE, TDOUBLE, TDOUBLE,
1809 TDOUBLE, TDOUBLE, TDOUBLE, TFLOAT, TDOUBLE, TIND,
1811 /*TIND*/ { 0, TIND, TIND, TIND, TIND, TIND, TIND, TIND,
1812 TIND, TIND, TIND, TIND, TIND, TIND,
1817 urk(char *name, int max, int i)
1820 fprint(2, "bad tinit: %s %d>=%d\n", name, i, max);
1831 for(p=thashinit; p->code >= 0; p++) {
1832 urk("thash", nelem(thash), p->code);
1833 thash[p->code] = p->value;
1835 for(p=bnamesinit; p->code >= 0; p++) {
1836 urk("bnames", nelem(bnames), p->code);
1837 bnames[p->code] = p->s;
1839 for(p=tnamesinit; p->code >= 0; p++) {
1840 urk("tnames", nelem(tnames), p->code);
1841 tnames[p->code] = p->s;
1843 for(p=gnamesinit; p->code >= 0; p++) {
1844 urk("gnames", nelem(gnames), p->code);
1845 gnames[p->code] = p->s;
1847 for(p=qnamesinit; p->code >= 0; p++) {
1848 urk("qnames", nelem(qnames), p->code);
1849 qnames[p->code] = p->s;
1851 for(p=cnamesinit; p->code >= 0; p++) {
1852 urk("cnames", nelem(cnames), p->code);
1853 cnames[p->code] = p->s;
1855 for(p=onamesinit; p->code >= 0; p++) {
1856 urk("onames", nelem(onames), p->code);
1857 onames[p->code] = p->s;
1859 for(ip=typeiinit; *ip>=0; ip++) {
1860 urk("typei", nelem(typei), *ip);
1863 for(ip=typeuinit; *ip>=0; ip++) {
1864 urk("typeu", nelem(typeu), *ip);
1867 for(ip=typesuvinit; *ip>=0; ip++) {
1868 urk("typesuv", nelem(typesuv), *ip);
1871 for(ip=typeilpinit; *ip>=0; ip++) {
1872 urk("typeilp", nelem(typeilp), *ip);
1875 for(ip=typechlinit; *ip>=0; ip++) {
1876 urk("typechl", nelem(typechl), *ip);
1881 for(ip=typechlpinit; *ip>=0; ip++) {
1882 urk("typechlp", nelem(typechlp), *ip);
1886 for(ip=typechlpfdinit; *ip>=0; ip++) {
1887 urk("typechlpfd", nelem(typechlpfd), *ip);
1888 typechlpfd[*ip] = 1;
1890 for(ip=typecinit; *ip>=0; ip++) {
1891 urk("typec", nelem(typec), *ip);
1894 for(ip=typehinit; *ip>=0; ip++) {
1895 urk("typeh", nelem(typeh), *ip);
1898 for(ip=typeilinit; *ip>=0; ip++) {
1899 urk("typeil", nelem(typeil), *ip);
1902 for(ip=typevinit; *ip>=0; ip++) {
1903 urk("typev", nelem(typev), *ip);
1908 for(ip=typefdinit; *ip>=0; ip++) {
1909 urk("typefd", nelem(typefd), *ip);
1912 for(ip=typeafinit; *ip>=0; ip++) {
1913 urk("typeaf", nelem(typeaf), *ip);
1916 for(ip=typesuinit; *ip >= 0; ip++) {
1917 urk("typesu", nelem(typesu), *ip);
1920 for(p=tasigninit; p->code >= 0; p++) {
1921 urk("tasign", nelem(tasign), p->code);
1922 tasign[p->code] = p->value;
1924 for(p=tasaddinit; p->code >= 0; p++) {
1925 urk("tasadd", nelem(tasadd), p->code);
1926 tasadd[p->code] = p->value;
1928 for(p=tcastinit; p->code >= 0; p++) {
1929 urk("tcast", nelem(tcast), p->code);
1930 tcast[p->code] = p->value;
1932 for(p=taddinit; p->code >= 0; p++) {
1933 urk("tadd", nelem(tadd), p->code);
1934 tadd[p->code] = p->value;
1936 for(p=tsubinit; p->code >= 0; p++) {
1937 urk("tsub", nelem(tsub), p->code);
1938 tsub[p->code] = p->value;
1940 for(p=tmulinit; p->code >= 0; p++) {
1941 urk("tmul", nelem(tmul), p->code);
1942 tmul[p->code] = p->value;
1944 for(p=tandinit; p->code >= 0; p++) {
1945 urk("tand", nelem(tand), p->code);
1946 tand[p->code] = p->value;
1948 for(p=trelinit; p->code >= 0; p++) {
1949 urk("trel", nelem(trel), p->code);
1950 trel[p->code] = p->value;
1953 /* 32-bit defaults */
1954 typeword = typechlp;
1955 typeswitch = typechl;
1956 typecmplx = typesuv;
1960 * return 1 if it is impossible to jump into the middle of n.
1963 deadhead(Node *n, int caseok)
1970 if(!deadhead(n->left, caseok))
1991 return deadhead(n->right, 1);
2007 return deadhead(n->right->left, caseok) && deadhead(n->right->right, caseok);
2019 return deadhead(c->left, 0) && deadhead(c->right, 0);
2023 mixedasop(Type *l, Type *r)
2025 return !typefd[l->etype] && typefd[r->etype];