3 static int resvreg[nelem(reg)];
5 static void gopcode64(int, Node*, Node*, Node*);
6 static void gori64(int, Node*, Node*, Node*);
7 static void gandi64(int, Node*, Node*, Node*);
17 exfregoffset = FREGEXT;
29 tfield = types[TLONG];
31 typeswitch = typechlv;
36 zprog.from.type = D_NONE;
37 zprog.from.name = D_NONE;
38 zprog.from.reg = NREG;
39 zprog.from3 = zprog.from;
40 zprog.to = zprog.from;
42 regnode.op = OREGISTER;
43 regnode.class = CEXREG;
47 regnode.type = types[TLONG];
49 constnode.op = OCONST;
50 constnode.class = CXXX;
51 constnode.complex = 0;
52 constnode.addable = 20;
53 constnode.type = types[TLONG];
55 fconstnode.op = OCONST;
56 fconstnode.class = CXXX;
57 fconstnode.complex = 0;
58 fconstnode.addable = 20;
59 fconstnode.type = types[TDOUBLE];
61 nodsafe = new(ONAME, Z, Z);
62 nodsafe->sym = slookup(".safe");
63 nodsafe->type = types[TINT];
64 nodsafe->etype = types[TINT]->etype;
65 nodsafe->class = CAUTO;
68 t = typ(TARRAY, types[TCHAR]);
69 symrathole = slookup(".rathole");
70 symrathole->class = CGLOBL;
73 nodrat = new(ONAME, Z, Z);
74 nodrat->sym = symrathole;
75 nodrat->type = types[TIND];
76 nodrat->etype = TVOID;
77 nodrat->class = CGLOBL;
83 memset(reg, 0, sizeof(reg));
84 reg[REGZERO] = 1; /* don't use */
86 reg[FREGCVI+NREG] = 1;
87 reg[FREGZERO+NREG] = 1;
88 reg[FREGHALF+NREG] = 1;
89 reg[FREGONE+NREG] = 1;
90 reg[FREGTWO+NREG] = 1;
91 memmove(resvreg, reg, sizeof(reg));
100 for(i=0; i<NREG; i++)
101 if(reg[i] && !resvreg[i])
102 diag(Z, "reg %d left allocated", i);
103 for(i=NREG; i<NREG+NREG; i++)
104 if(reg[i] && !resvreg[i])
105 diag(Z, "freg %d left allocated", i-NREG);
108 symstring->type->width = nstring;
109 symrathole->type->width = nrathole;
110 for(i=0; i<NHASH; i++)
111 for(s = hash[i]; s != S; s = s->link) {
114 if(s->type->width == 0)
116 if(s->class != CGLOBL && s->class != CSTATIC)
118 if(s->type == types[TENUM])
120 gpseudo(AGLOBL, s, nodconst(s->type->width));
131 p = alloc(sizeof(*p));
145 gargs(Node *n, Node *tn1, Node *tn2)
148 Node fnxargs[20], *fnxp;
153 garg1(n, tn1, tn2, 0, &fnxp); /* compile fns to temps */
157 garg1(n, tn1, tn2, 1, &fnxp); /* compile normal args and temps */
163 garg1(Node *n, Node *tn1, Node *tn2, int f, Node **fnxp)
170 garg1(n->left, tn1, tn2, f, fnxp);
171 garg1(n->right, tn1, tn2, f, fnxp);
175 if(n->complex >= FNX) {
187 if(typesuv[n->type->etype]) {
189 if(n->complex >= FNX) {
196 if(REGARG && curarg == 0 && typechlp[n->type->etype]) {
198 if(n->complex >= FNX) {
207 gopcode(OAS, n, Z, tn2);
211 if(n->complex >= FNX) {
217 gopcode(OAS, tn1, Z, tn2);
224 constnode.vconst = v & MASK(32);
231 constnode.vconst = v;
238 fconstnode.fconst = d;
243 nodreg(Node *n, Node *nn, int reg)
248 n->lineno = nn->lineno;
252 regret(Node *n, Node *nn)
257 if(typefd[nn->type->etype])
264 regalloc(Node *n, Node *tn, Node *o)
269 switch(tn->type->etype) {
279 if(o != Z && o->op == OREGISTER) {
281 if(i > 0 && i < NREG)
284 j = lasti + REGRET+1;
285 for(i=REGRET+1; i<NREG; i++) {
294 diag(tn, "out of fixed registers");
299 if(o != Z && o->op == OREGISTER) {
301 if(i >= NREG && i < NREG+NREG)
305 for(i=NREG; i<NREG+NREG; i++) {
314 diag(tn, "out of float registers");
320 n->complex = 0; /* already in registers */
324 n->left = alloc(sizeof(Node));
325 n->right = alloc(sizeof(Node));
326 if(o != Z && o->op == OREGPAIR) {
327 regalloc(n->left, ®node, o->left);
328 regalloc(n->right, ®node, o->right);
330 regalloc(n->left, ®node, Z);
331 regalloc(n->right, ®node, Z);
333 n->right->type = types[TULONG];
334 if(tn->type->etype == TUVLONG)
335 n->left->type = types[TULONG]; /* TO DO: is this a bad idea? */
338 diag(tn, "unknown type in regalloc: %T", tn->type);
351 regialloc(Node *n, Node *tn, Node *o)
356 nod.type = types[TIND];
357 regalloc(n, &nod, o);
365 if(n->op == OREGPAIR) {
371 if(n->op != OREGISTER && n->op != OINDREG)
374 if(i < 0 || i >= sizeof(reg))
381 diag(n, "error in regfree: %d [%d]", i, reg[i]);
382 prtree(n, "regfree");
386 regsalloc(Node *n, Node *nn)
388 cursafe = align(cursafe+stkoff, nn->type, Aaut3)-stkoff;
389 maxargsafe = maxround(maxargsafe, cursafe+curarg);
390 // if(nn->type->etype == TDOUBLE || nn->type->etype == TVLONG){
391 // extern int hasdoubled;
392 // fprint(2, "stkoff=%ld cursafe=%ld curarg=%ld %d\n", stkoff, cursafe, curarg, hasdoubled);
395 n->xoffset = -(stkoff + cursafe);
397 n->etype = nn->type->etype;
398 n->lineno = nn->lineno;
402 regaalloc1(Node *n, Node *nn)
404 nodreg(n, nn, REGARG);
406 curarg = align(curarg, nn->type, Aarg1);
407 curarg = align(curarg, nn->type, Aarg2);
408 maxargsafe = maxround(maxargsafe, cursafe+curarg);
412 regaalloc(Node *n, Node *nn)
414 curarg = align(curarg, nn->type, Aarg1);
418 n->xoffset = curarg + SZ_LONG;
421 curarg = align(curarg, nn->type, Aarg2);
422 maxargsafe = maxround(maxargsafe, cursafe+curarg);
426 regind(Node *n, Node *nn)
429 if(n->op != OREGISTER) {
430 diag(n, "regind not OREGISTER");
438 raddr(Node *n, Prog *p)
443 if(R0ISZERO && a.type == D_CONST && a.offset == 0) {
447 if(a.type != D_REG && a.type != D_FREG) {
449 diag(n, "bad in raddr: %O", n->op);
451 diag(n, "bad in raddr: <null>");
458 naddr(Node *n, Adr *a)
468 diag(n, "bad in naddr: %O", n->op);
483 a->offset += n->xoffset; /* little hack for reglcgenv */
484 if(a->type == D_REG) {
488 if(a->type == D_CONST) {
497 a->offset = n->xoffset;
506 a->offset = n->xoffset;
507 if(n->class == CSTATIC)
509 if(n->class == CEXTERN || n->class == CGLOBL) {
513 if(n->class == CAUTO) {
517 if(n->class == CPARAM) {
526 if(typefd[n->type->etype]) {
531 a->offset = n->vconst;
537 if(a->type == D_OREG) {
544 if(n->left->op == OCONST) {
560 gloadhi(Node *f, Node *t, int c)
565 f = nodconst((long)(f->vconst>>32));
566 if(c==1 && sconst(f) || c==2 && uconst(f)){
567 if(t->op == OREGISTER)
573 if(f->op == OREGPAIR) {
578 f->type = types[TLONG];
584 gloadlo(Node *f, Node *t, int c)
589 f = nodconst((long)f->vconst);
591 if(t->op == OREGISTER)
597 if(f->op == OREGPAIR) {
602 f->type = types[TLONG];
603 f->xoffset += SZ_LONG;
605 prtree(f, "gloadlo f"); prtree(t, "gloadlo t");
608 f->xoffset -= SZ_LONG;
613 fop(int as, int f1, int f2, Node *t)
615 Node nod1, nod2, nod3;
617 nodreg(&nod1, t, NREG+f1);
618 nodreg(&nod2, t, NREG+f2);
619 regalloc(&nod3, t, t);
620 gopcode(as, &nod1, &nod2, &nod3);
626 floattofix(Node *f, Node *t)
630 regalloc(&nod, f, Z);
631 regsalloc(&fxrat, &fconstnode);
632 gins(AFCTIWZ, f, &nod);
633 gins(AFMOVD, &nod, &fxrat);
635 fxrat.type = nodrat->type;
636 fxrat.etype = nodrat->etype;
638 gins(AMOVW, &fxrat, t);
643 fixtofloat(Node *f, Node *t)
647 Node nod, fxc0, fxc1, fxc2, fxrat;
653 * rat[0] = 0x43300000; rat[1] = f^0x80000000;
654 * t = *(double*)rat - FREGCVI;
655 * is-unsigned(t) => if(t<0) t += 2^32;
656 * could be streamlined for int-to-float
658 regalloc(&fxc0, f, Z);
659 regalloc(&fxc2, f, Z);
660 regsalloc(&fxrat, &fconstnode); /* should be type float */
661 gins(AMOVW, nodconst(0x43300000L), &fxc0);
662 gins(AMOVW, f, &fxc2);
663 gins(AMOVW, &fxc0, &fxrat);
664 gins(AXOR, nodconst(0x80000000L), &fxc2);
666 fxc1.type = nodrat->type;
667 fxc1.etype = nodrat->etype;
668 fxc1.xoffset += SZ_LONG;
669 gins(AMOVW, &fxc2, &fxc1);
672 regalloc(&nod, t, t); /* should be type float */
673 gins(AFMOVD, &fxrat, &nod);
674 nodreg(&fxc1, t, NREG+FREGCVI);
675 gins(AFSUB, &fxc1, &nod);
682 regalloc(&nod, t, Z);
685 p->to.reg = FREGZERO;
689 gins(AFMOVS, nodfconst(4294967296.), &nod);
690 gins(AFADDS, &nod, t);
692 gins(AFMOVD, nodfconst(4294967296.), &nod);
693 gins(AFADD, &nod, t);
701 gmove(Node *f, Node *t)
710 if(ft == TDOUBLE && f->op == OCONST) {
729 fop(OSUB, FREGHALF, FREGZERO, t);
733 fop(OSUB, FREGONE, FREGZERO, t);
737 fop(OSUB, FREGTWO, FREGZERO, t);
741 fop(OADD, FREGONE, FREGHALF, t);
745 fop(OADD, FREGTWO, FREGHALF, t);
749 fop(OADD, FREGTWO, FREGONE, t);
753 if(ft == TFLOAT && f->op == OCONST) {
758 nodreg(&nod, f, NREG+a);
763 if((ft == TVLONG || ft == TUVLONG) && f->op == OCONST && t->op == OREGPAIR) {
764 if(align(0, types[TCHAR], Aarg1)) /* isbigendian */
765 gmove(nod32const(f->vconst>>32), t->left);
767 gmove(nod32const(f->vconst), t->left);
768 if(align(0, types[TCHAR], Aarg1)) /* isbigendian */
769 gmove(nod32const(f->vconst), t->right);
771 gmove(nod32const(f->vconst>>32), t->right);
776 * put it into a register then
777 * worry what to do with it.
779 if(f->op == ONAME || f->op == OINDREG || f->op == OIND) {
804 if(typev[tt] || typefd[tt]) {
805 regalloc(&nod, f, t);
806 /* low order first, because its value will be used first */
807 f->xoffset += SZ_LONG;
808 gins(AMOVW, f, nod.right);
809 f->xoffset -= SZ_LONG;
810 gins(AMOVW, f, nod.left);
812 /* assumed not float or double */
813 regalloc(&nod, ®node, t);
814 f->xoffset += SZ_LONG;
815 gins(AMOVW, f, &nod);
816 f->xoffset -= SZ_LONG;
819 regalloc(&nod, f, t);
829 * put it into a register then
832 if(t->op == ONAME || t->op == OINDREG || t->op == OIND) {
856 if(R0ISZERO && !typefd[ft] && vconst(f) == 0) {
859 t->xoffset += SZ_LONG;
861 t->xoffset -= SZ_LONG;
866 regalloc(&nod, t, f);
868 regalloc(&nod, t, Z);
871 t->xoffset += SZ_LONG;
872 gins(a, nod.right, t);
873 t->xoffset -= SZ_LONG;
874 gins(a, nod.left, t);
882 * type x type cross table
892 a = AFMOVS; /* AFMOVSD */
908 /* BUG: not right for unsigned long */
913 diag(f, "unimplemented double->vlong");
1035 diag(Z, "bad opcode in gmove %T -> %T", f->type, t->type);
1036 if(a == AMOVW || a == AFMOVS || a == AFMOVD)
1040 if(f->op != OREGPAIR || t->op != OREGPAIR)
1041 diag(Z, "bad vlong in gmove (%O->%O)", f->op, t->op);
1042 gins(a, f->left, t->left);
1043 gins(a, f->right, t->right);
1049 gins(int a, Node *f, Node *t)
1063 gins3(int a, Node *f1, Node *f2, Node *t)
1070 naddr(f1, &p->from);
1071 if(f2 != Z && (f2->op != OREGISTER || !samaddr(f2, t))) {
1072 ta = zprog.from; /* TO DO */
1075 if(ta.type == D_CONST && ta.offset == 0) {
1079 diag(Z, "REGZERO in gins3 %A", a);
1080 }else if(ta.type == D_CONST)
1090 gins4(int a, Node *f1, Node *f2, Node *f3, Node *t)
1096 naddr(f1, &p->from);
1097 if(f2->op != OREGISTER && (f2->op != OCONST || vconst(f2) != 0))
1098 diag(f2, "invalid gins4");
1101 if(ta.type == D_CONST && ta.offset == 0)
1103 naddr(f3, &p->from3);
1110 gopcode(int o, Node *f1, Node *f2, Node *t)
1119 if(f1 != Z && f1->type != T) {
1120 if(f1->op == OCONST && t != Z && t->type != T)
1121 et = t->type->etype;
1123 et = f1->type->etype;
1125 if((typev[et] || t->type != T && typev[t->type->etype]) && o != OFUNC) {
1126 gopcode64(o, f1, f2, t);
1161 if(f1->op == OCONST)
1238 if(et == TFLOAT || et == TDOUBLE)
1244 if(t->op == OCONST && t->vconst >= (1<<15))
1250 if(t->op == OCONST && t->vconst >= (1<<15))
1290 p->as = uns? ACMPU: ACMP;
1297 naddr(f1, &p->from);
1300 if(f1 == Z || t == Z || f2 != Z)
1301 diag(Z, "bad cmp in gopcode %O", o);
1310 diag(Z, "bad in gopcode %O", o);
1311 gins3(a, f1, f2, t);
1315 gopcode64(int o, Node *f1, Node *f2, Node *t)
1318 Node nod, nod1, nod2, sh;
1322 if(t->op != OREGPAIR || f2 != Z && f2->op != OREGPAIR) {
1323 diag(Z, "bad f2/dest in gopcode64 %O", o);
1326 if(f1->op != OCONST &&
1327 (typev[f1->type->etype] && f1->op != OREGPAIR || !typev[f1->type->etype] && f1->op != OREGISTER)) {
1328 diag(Z, "bad f1[%O] in gopcode64 %O", f1->op, o);
1331 /* a1 for low-order, a2 for high-order */
1337 if(f1->op == OCONST && sconst(f1)) {
1340 gins3(AADDC, f1, f2->right, t->right);
1341 if((f1->vconst>>32) == 0)
1342 gins(AADDZE, f2->left, t->left);
1343 else if((f1->vconst>>32) == -1)
1344 gins(AADDME, f2->left, t->left);
1346 diag(t, "odd vlong ADD: %lld", f1->vconst);
1361 if(f1->op == OCONST) {
1362 gori64(AOR, f1, f2, t);
1370 if(f1->op == OCONST) {
1371 gandi64(AANDCC, f1, f2, t);
1379 if(f1->op == OCONST) {
1380 gori64(AXOR, f1, f2, t);
1390 if(f1->op == OCONST) {
1391 if(f1->vconst >= 32) {
1392 if(f1->vconst == 32)
1393 gmove(f2->left, t->right);
1394 else if(f1->vconst < 64)
1395 gins3(ASRW, nodconst(f1->vconst-32), f2->left, t->right);
1397 gmove(nodconst(0), t->right);
1398 gmove(nodconst(0), t->left);
1401 if(f1->vconst <= 0) {
1406 sh = *nodconst(32 - f1->vconst);
1407 m = 0xFFFFFFFFUL >> f1->vconst;
1408 gins4(ARLWNM, &sh, f2->right, nodconst(m), t->right);
1409 gins4(ARLWMI, &sh, f2->left, nodconst(~m), t->right);
1410 gins4(ARLWNM, &sh, f2->left, nodconst(m), t->left);
1413 regalloc(&nod, ®node, Z);
1414 gins3(ASUBC, f1, nodconst(32), &nod);
1415 gins3(ASRW, f1, f2->right, t->right);
1416 regalloc(&nod1, ®node, Z);
1417 gins3(ASLW, &nod, f2->left, &nod1);
1418 gins(AOR, &nod1, t->right);
1419 gins3(AADD, nodconst(-32), f1, &nod);
1420 gins3(ASRW, &nod, f2->left, &nod1);
1421 gins(AOR, &nod1, t->right);
1422 gins3(ASRW, f1, f2->left, t->left);
1431 if(f1->op == OCONST) {
1432 if(f1->vconst >= 32) {
1433 if(f1->vconst == 32)
1434 gmove(f2->left, t->right);
1435 else if(f1->vconst < 64)
1436 gins3(ASRAW, nodconst(f1->vconst-32), f2->left, t->right);
1437 gins3(ASRAW, nodconst(31), f2->left, t->left);
1438 if(f1->vconst >= 64) {
1439 gmove(t->left, t->right);
1444 if(f1->vconst <= 0) {
1449 sh = *nodconst(32 - f1->vconst);
1450 m = 0xFFFFFFFFUL >> f1->vconst;
1451 gins4(ARLWNM, &sh, f2->right, nodconst(m), t->right);
1452 gins4(ARLWMI, &sh, f2->left, nodconst(~m), t->right);
1453 gins3(ASRAW, &sh, f2->left, t->left);
1456 regalloc(&nod, ®node, Z);
1457 gins3(ASUBC, f1, nodconst(32), &nod);
1458 gins3(ASRW, f1, f2->right, t->right);
1459 regalloc(&nod1, ®node, Z);
1460 gins3(ASLW, &nod, f2->left, &nod1);
1461 gins(AOR, &nod1, t->right);
1462 gins3(AADDCCC, nodconst(-32), f1, &nod);
1463 gins3(ASRAW, &nod, f2->left, &nod1);
1466 gins(AMOVW, &nod1, t->right);
1468 gins3(ASRAW, f1, f2->left, t->left);
1477 if(f1->op == OCONST) {
1478 if(f1->vconst >= 32) {
1479 if(f1->vconst == 32)
1480 gmove(f2->right, t->left);
1481 else if(f1->vconst >= 64)
1482 gmove(nodconst(0), t->left);
1484 gins3(ASLW, nodconst(f1->vconst-32), f2->right, t->left);
1485 gmove(nodconst(0), t->right);
1488 if(f1->vconst <= 0) {
1493 m = 0xFFFFFFFFUL << f1->vconst;
1494 gins4(ARLWNM, f1, f2->left, nodconst(m), t->left);
1495 gins4(ARLWMI, f1, f2->right, nodconst(~m), t->left);
1496 gins4(ARLWNM, f1, f2->right, nodconst(m), t->right);
1499 regalloc(&nod, ®node, Z);
1500 gins3(ASUBC, f1, nodconst(32), &nod);
1501 gins3(ASLW, f1, f2->left, t->left);
1502 regalloc(&nod1, ®node, Z);
1503 gins3(ASRW, &nod, f2->right, &nod1);
1504 gins(AOR, &nod1, t->left);
1505 gins3(AADD, nodconst(-32), f1, &nod);
1506 gins3(ASLW, &nod, f2->right, &nod1);
1507 gins(AOR, &nod1, t->left);
1508 gins3(ASLW, f1, f2->right, t->right);
1519 regalloc(&nod, ®node, Z);
1520 gins3(AMULLW, f1->right, f2->right, &nod); /* lo(f2.low*f1.low) */
1521 regalloc(&nod1, ®node, Z);
1522 gins3(AMULHWU, f1->right, f2->right, &nod1); /* hi(f2.low*f1.low) */
1523 regalloc(&nod2, ®node, Z);
1524 gins3(AMULLW, f2->right, f1->left, &nod2); /* lo(f2.low*f1.high) */
1525 gins(AADD, &nod2, &nod1);
1526 gins3(AMULLW, f1->right, f2->left, &nod2); /* lo(f2.high*f1.low) */
1527 gins(AADD, &nod2, &nod1);
1529 gmove(&nod, t->right);
1530 gmove(&nod1, t->left);
1540 gins3(ASUBC, t->right, nodconst(0), t->right);
1541 gins(ASUBZE, t->left, t->left);
1544 if(a1 == AGOK || a2 == AGOK)
1545 diag(Z, "bad in gopcode64 %O", o);
1546 if(f1->op == OCONST) {
1547 if(f2 != Z & f2 != t)
1548 diag(Z, "bad const in gopcode64 %O", o);
1549 gins(a1, nod32const(f1->vconst), t->right);
1550 gins(a2, nod32const(f1->vconst>>32), t->left);
1552 if(f2 != Z && f2 != t) {
1553 gins3(a1, f1->right, f2->right, t->right);
1554 gins3(a2, f1->left, f2->left, t->left);
1556 gins(a1, f1->right, t->right);
1557 gins(a2, f1->left, t->left);
1562 samaddr(Node *f, Node *t)
1570 if(f->reg != t->reg)
1575 return samaddr(f->left, t->left) && samaddr(f->right, t->right);
1581 gori64(int a, Node *f1, Node *f2, Node *t)
1587 lo = f1->vconst & MASK(32);
1588 hi = (f1->vconst >> 32) & MASK(32);
1590 gins3(a, nodconst(lo & 0xFFFF), f2->right, t->right);
1592 gins3(a, nodconst(lo & 0xFFFF0000UL), f2->right, t->right);
1594 gins3(a, nodconst(hi & 0xFFFF), f2->left, t->left);
1596 gins3(a, nodconst(hi & 0xFFFF0000UL), f2->left, t->left);
1600 gandi64(int a, Node *f1, Node *f2, Node *t)
1606 lo = f1->vconst & MASK(32);
1607 hi = (f1->vconst >> 32) & MASK(32);
1609 gins(AMOVW, nodconst(0), t->right);
1611 gins3(a, nodconst(lo), f2->right, t->right);
1613 gins(AMOVW, nodconst(0), t->left);
1615 gins3(a, nodconst(hi), f2->left, t->left);
1634 diag(Z, "bad in gbranch %O", o);
1641 patch(Prog *op, long pc)
1645 op->to.type = D_BRANCH;
1649 gpseudo(int a, Sym *s, Node *n)
1654 p->from.type = D_OREG;
1657 p->reg = (profileflg ? 0 : NOPROF);
1658 p->from.name = D_EXTERN;
1659 if(s->class == CSTATIC)
1660 p->from.name = D_STATIC;
1662 if(a == ADATA || a == AGLOBL)
1670 if(v >= -(1<<15) && v < (1<<15))
1680 if(n->op == OCONST) {
1681 if(!typefd[n->type->etype]) {
1683 if(vv >= -(((vlong)1)<<15) && vv < (((vlong)1)<<15))
1695 if(n->op == OCONST) {
1696 if(!typefd[n->type->etype]) {
1698 if(vv >= 0 && vv < (((vlong)1)<<16))
1710 if(typechlp[t->etype]) {
1711 if(exregoffset <= 3)
1717 if(typefd[t->etype]) {
1718 if(exfregoffset <= 16)
1720 o = exfregoffset + NREG;
1727 schar ewidth[NTYPE] =
1730 SZ_CHAR, /* [TCHAR] */
1731 SZ_CHAR, /* [TUCHAR] */
1732 SZ_SHORT, /* [TSHORT] */
1733 SZ_SHORT, /* [TUSHORT] */
1734 SZ_INT, /* [TINT] */
1735 SZ_INT, /* [TUINT] */
1736 SZ_LONG, /* [TLONG] */
1737 SZ_LONG, /* [TULONG] */
1738 SZ_VLONG, /* [TVLONG] */
1739 SZ_VLONG, /* [TUVLONG] */
1740 SZ_FLOAT, /* [TFLOAT] */
1741 SZ_DOUBLE, /* [TDOUBLE] */
1742 SZ_IND, /* [TIND] */
1748 SZ_INT, /* [TENUM] */
1753 BCHAR|BUCHAR, /* [TCHAR] */
1754 BCHAR|BUCHAR, /* [TUCHAR] */
1755 BSHORT|BUSHORT, /* [TSHORT] */
1756 BSHORT|BUSHORT, /* [TUSHORT] */
1757 BINT|BUINT|BLONG|BULONG|BIND, /* [TINT] */
1758 BINT|BUINT|BLONG|BULONG|BIND, /* [TUINT] */
1759 BINT|BUINT|BLONG|BULONG|BIND, /* [TLONG] */
1760 BINT|BUINT|BLONG|BULONG|BIND, /* [TULONG] */
1761 BVLONG|BUVLONG, /* [TVLONG] */
1762 BVLONG|BUVLONG, /* [TUVLONG] */
1763 BFLOAT, /* [TFLOAT] */
1764 BDOUBLE, /* [TDOUBLE] */
1765 BLONG|BULONG|BIND, /* [TIND] */
1769 BSTRUCT, /* [TSTRUCT] */
1770 BUNION, /* [TUNION] */