History

move parser/generator to tccgen.c

grischka committed 17 years ago

Commit 0d1ed741 parent 805990b2 files · +5103 −5102Browse files

Unified · Split

2 files
  1. tcc.c +1 −5102
  2. tccgen.c +5102 −0
tcc.c+1−5102
@@ -1107,5108 +1107,7 @@ void tcc_close(BufferedFile *bf) · 1106 unmodified lines
11071107 }
11081108
11091109 #include "tccpp.c"
1110−
1111−void swap(int *p, int *q)
1112−{
1113− int t;
1114− t = *p;
1115− *p = *q;
1116− *q = t;
1117−}
1118−
1119−void vsetc(CType *type, int r, CValue *vc)
1120−{
1121− int v;
1122−
1123− if (vtop >= vstack + (VSTACK_SIZE - 1))
1124− error("memory full");
1125− /* cannot let cpu flags if other instruction are generated. Also
1126− avoid leaving VT_JMP anywhere except on the top of the stack
1127− because it would complicate the code generator. */
1128− if (vtop >= vstack) {
1129− v = vtop->r & VT_VALMASK;
1130− if (v == VT_CMP || (v & ~1) == VT_JMP)
1131− gv(RC_INT);
1132− }
1133− vtop++;
1134− vtop->type = *type;
1135− vtop->r = r;
1136− vtop->r2 = VT_CONST;
1137− vtop->c = *vc;
1138−}
1139−
1140−/* push integer constant */
1141−void vpushi(int v)
1142−{
1143− CValue cval;
1144− cval.i = v;
1145− vsetc(&int_type, VT_CONST, &cval);
1146−}
1147−
1148−/* push long long constant */
1149−void vpushll(long long v)
1150−{
1151− CValue cval;
1152− CType ctype;
1153− ctype.t = VT_LLONG;
1154− cval.ull = v;
1155− vsetc(&ctype, VT_CONST, &cval);
1156−}
1157−
1158−/* Return a static symbol pointing to a section */
1159−static Sym *get_sym_ref(CType *type, Section *sec,
1160− unsigned long offset, unsigned long size)
1161−{
1162− int v;
1163− Sym *sym;
1164−
1165− v = anon_sym++;
1166− sym = global_identifier_push(v, type->t | VT_STATIC, 0);
1167− sym->type.ref = type->ref;
1168− sym->r = VT_CONST | VT_SYM;
1169− put_extern_sym(sym, sec, offset, size);
1170− return sym;
1171−}
1172−
1173−/* push a reference to a section offset by adding a dummy symbol */
1174−static void vpush_ref(CType *type, Section *sec, unsigned long offset, unsigned long size)
1175−{
1176− CValue cval;
1177−
1178− cval.ul = 0;
1179− vsetc(type, VT_CONST | VT_SYM, &cval);
1180− vtop->sym = get_sym_ref(type, sec, offset, size);
1181−}
1182−
1183−/* define a new external reference to a symbol 'v' of type 'u' */
1184−static Sym *external_global_sym(int v, CType *type, int r)
1185−{
1186− Sym *s;
1187−
1188− s = sym_find(v);
1189− if (!s) {
1190− /* push forward reference */
1191− s = global_identifier_push(v, type->t | VT_EXTERN, 0);
1192− s->type.ref = type->ref;
1193− s->r = r | VT_CONST | VT_SYM;
1194− }
1195− return s;
1196−}
1197−
1198−/* define a new external reference to a symbol 'v' of type 'u' */
1199−static Sym *external_sym(int v, CType *type, int r)
1200−{
1201− Sym *s;
1202−
1203− s = sym_find(v);
1204− if (!s) {
1205− /* push forward reference */
1206− s = sym_push(v, type, r | VT_CONST | VT_SYM, 0);
1207− s->type.t |= VT_EXTERN;
1208− } else {
1209− if (!is_compatible_types(&s->type, type))
1210− error("incompatible types for redefinition of '%s'",
1211− get_tok_str(v, NULL));
1212− }
1213− return s;
1214−}
1215−
1216−/* push a reference to global symbol v */
1217−static void vpush_global_sym(CType *type, int v)
1218−{
1219− Sym *sym;
1220− CValue cval;
1221−
1222− sym = external_global_sym(v, type, 0);
1223− cval.ul = 0;
1224− vsetc(type, VT_CONST | VT_SYM, &cval);
1225− vtop->sym = sym;
1226−}
1227−
1228−void vset(CType *type, int r, int v)
1229−{
1230− CValue cval;
1231−
1232− cval.i = v;
1233− vsetc(type, r, &cval);
1234−}
1235−
1236−void vseti(int r, int v)
1237−{
1238− CType type;
1239− type.t = VT_INT;
1240− vset(&type, r, v);
1241−}
1242−
1243−void vswap(void)
1244−{
1245− SValue tmp;
1246−
1247− tmp = vtop[0];
1248− vtop[0] = vtop[-1];
1249− vtop[-1] = tmp;
1250−}
1251−
1252−void vpushv(SValue *v)
1253−{
1254− if (vtop >= vstack + (VSTACK_SIZE - 1))
1255− error("memory full");
1256− vtop++;
1257− *vtop = *v;
1258−}
1259−
1260−void vdup(void)
1261−{
1262− vpushv(vtop);
1263−}
1264−
1265−/* save r to the memory stack, and mark it as being free */
1266−void save_reg(int r)
1267−{
1268− int l, saved, size, align;
1269− SValue *p, sv;
1270− CType *type;
1271−
1272− /* modify all stack values */
1273− saved = 0;
1274− l = 0;
1275− for(p=vstack;p<=vtop;p++) {
1276− if ((p->r & VT_VALMASK) == r ||
1277− ((p->type.t & VT_BTYPE) == VT_LLONG && (p->r2 & VT_VALMASK) == r)) {
1278− /* must save value on stack if not already done */
1279− if (!saved) {
1280− /* NOTE: must reload 'r' because r might be equal to r2 */
1281− r = p->r & VT_VALMASK;
1282− /* store register in the stack */
1283− type = &p->type;
1284− if ((p->r & VT_LVAL) ||
1285− (!is_float(type->t) && (type->t & VT_BTYPE) != VT_LLONG))
1286−#ifdef TCC_TARGET_X86_64
1287− type = &char_pointer_type;
1288−#else
1289− type = &int_type;
1290−#endif
1291− size = type_size(type, &align);
1292− loc = (loc - size) & -align;
1293− sv.type.t = type->t;
1294− sv.r = VT_LOCAL | VT_LVAL;
1295− sv.c.ul = loc;
1296− store(r, &sv);
1297−#if defined(TCC_TARGET_I386) || defined(TCC_TARGET_X86_64)
1298− /* x86 specific: need to pop fp register ST0 if saved */
1299− if (r == TREG_ST0) {
1300− o(0xd9dd); /* fstp %st(1) */
1301− }
1302−#endif
1303−#ifndef TCC_TARGET_X86_64
1304− /* special long long case */
1305− if ((type->t & VT_BTYPE) == VT_LLONG) {
1306− sv.c.ul += 4;
1307− store(p->r2, &sv);
1308− }
1309−#endif
1310− l = loc;
1311− saved = 1;
1312− }
1313− /* mark that stack entry as being saved on the stack */
1314− if (p->r & VT_LVAL) {
1315− /* also clear the bounded flag because the
1316− relocation address of the function was stored in
1317− p->c.ul */
1318− p->r = (p->r & ~(VT_VALMASK | VT_BOUNDED)) | VT_LLOCAL;
1319− } else {
1320− p->r = lvalue_type(p->type.t) | VT_LOCAL;
1321− }
1322− p->r2 = VT_CONST;
1323− p->c.ul = l;
1324− }
1325− }
1326−}
1327−
1328−/* find a register of class 'rc2' with at most one reference on stack.
1329− * If none, call get_reg(rc) */
1330−int get_reg_ex(int rc, int rc2)
1331−{
1332− int r;
1333− SValue *p;
1334−
1335− for(r=0;r<NB_REGS;r++) {
1336− if (reg_classes[r] & rc2) {
1337− int n;
1338− n=0;
1339− for(p = vstack; p <= vtop; p++) {
1340− if ((p->r & VT_VALMASK) == r ||
1341− (p->r2 & VT_VALMASK) == r)
1342− n++;
1343− }
1344− if (n <= 1)
1345− return r;
1346− }
1347− }
1348− return get_reg(rc);
1349−}
1350−
1351−/* find a free register of class 'rc'. If none, save one register */
1352−int get_reg(int rc)
1353−{
1354− int r;
1355− SValue *p;
1356−
1357− /* find a free register */
1358− for(r=0;r<NB_REGS;r++) {
1359− if (reg_classes[r] & rc) {
1360− for(p=vstack;p<=vtop;p++) {
1361− if ((p->r & VT_VALMASK) == r ||
1362− (p->r2 & VT_VALMASK) == r)
1363− goto notfound;
1364− }
1365− return r;
1366− }
1367− notfound: ;
1368− }
1369−
1370− /* no register left : free the first one on the stack (VERY
1371− IMPORTANT to start from the bottom to ensure that we don't
1372− spill registers used in gen_opi()) */
1373− for(p=vstack;p<=vtop;p++) {
1374− r = p->r & VT_VALMASK;
1375− if (r < VT_CONST && (reg_classes[r] & rc))
1376− goto save_found;
1377− /* also look at second register (if long long) */
1378− r = p->r2 & VT_VALMASK;
1379− if (r < VT_CONST && (reg_classes[r] & rc)) {
1380− save_found:
1381− save_reg(r);
1382− return r;
1383− }
1384− }
1385− /* Should never comes here */
1386− return -1;
1387−}
1388−
1389−/* save registers up to (vtop - n) stack entry */
1390−void save_regs(int n)
1391−{
1392− int r;
1393− SValue *p, *p1;
1394− p1 = vtop - n;
1395− for(p = vstack;p <= p1; p++) {
1396− r = p->r & VT_VALMASK;
1397− if (r < VT_CONST) {
1398− save_reg(r);
1399− }
1400− }
1401−}
1402−
1403−/* move register 's' to 'r', and flush previous value of r to memory
1404− if needed */
1405−void move_reg(int r, int s)
1406−{
1407− SValue sv;
1408−
1409− if (r != s) {
1410− save_reg(r);
1411− sv.type.t = VT_INT;
1412− sv.r = s;
1413− sv.c.ul = 0;
1414− load(r, &sv);
1415− }
1416−}
1417−
1418−/* get address of vtop (vtop MUST BE an lvalue) */
1419−void gaddrof(void)
1420−{
1421− vtop->r &= ~VT_LVAL;
1422− /* tricky: if saved lvalue, then we can go back to lvalue */
1423− if ((vtop->r & VT_VALMASK) == VT_LLOCAL)
1424− vtop->r = (vtop->r & ~(VT_VALMASK | VT_LVAL_TYPE)) | VT_LOCAL | VT_LVAL;
1425−}
1426−
1427−#ifdef CONFIG_TCC_BCHECK
1428−/* generate lvalue bound code */
1429−void gbound(void)
1430−{
1431− int lval_type;
1432− CType type1;
1433−
1434− vtop->r &= ~VT_MUSTBOUND;
1435− /* if lvalue, then use checking code before dereferencing */
1436− if (vtop->r & VT_LVAL) {
1437− /* if not VT_BOUNDED value, then make one */
1438− if (!(vtop->r & VT_BOUNDED)) {
1439− lval_type = vtop->r & (VT_LVAL_TYPE | VT_LVAL);
1440− /* must save type because we must set it to int to get pointer */
1441− type1 = vtop->type;
1442− vtop->type.t = VT_INT;
1443− gaddrof();
1444− vpushi(0);
1445− gen_bounded_ptr_add();
1446− vtop->r |= lval_type;
1447− vtop->type = type1;
1448− }
1449− /* then check for dereferencing */
1450− gen_bounded_ptr_deref();
1451− }
1452−}
1453−#endif
1454−
1455−/* store vtop a register belonging to class 'rc'. lvalues are
1456− converted to values. Cannot be used if cannot be converted to
1457− register value (such as structures). */
1458−int gv(int rc)
1459−{
1460− int r, rc2, bit_pos, bit_size, size, align, i;
1461−
1462− /* NOTE: get_reg can modify vstack[] */
1463− if (vtop->type.t & VT_BITFIELD) {
1464− CType type;
1465− int bits = 32;
1466− bit_pos = (vtop->type.t >> VT_STRUCT_SHIFT) & 0x3f;
1467− bit_size = (vtop->type.t >> (VT_STRUCT_SHIFT + 6)) & 0x3f;
1468− /* remove bit field info to avoid loops */
1469− vtop->type.t &= ~(VT_BITFIELD | (-1 << VT_STRUCT_SHIFT));
1470− /* cast to int to propagate signedness in following ops */
1471− if ((vtop->type.t & VT_BTYPE) == VT_LLONG) {
1472− type.t = VT_LLONG;
1473− bits = 64;
1474− } else
1475− type.t = VT_INT;
1476− if((vtop->type.t & VT_UNSIGNED) ||
1477− (vtop->type.t & VT_BTYPE) == VT_BOOL)
1478− type.t |= VT_UNSIGNED;
1479− gen_cast(&type);
1480− /* generate shifts */
1481− vpushi(bits - (bit_pos + bit_size));
1482− gen_op(TOK_SHL);
1483− vpushi(bits - bit_size);
1484− /* NOTE: transformed to SHR if unsigned */
1485− gen_op(TOK_SAR);
1486− r = gv(rc);
1487− } else {
1488− if (is_float(vtop->type.t) &&
1489− (vtop->r & (VT_VALMASK | VT_LVAL)) == VT_CONST) {
1490− Sym *sym;
1491− int *ptr;
1492− unsigned long offset;
1493−#if defined(TCC_TARGET_ARM) && !defined(TCC_ARM_VFP)
1494− CValue check;
1495−#endif
1496−
1497− /* XXX: unify with initializers handling ? */
1498− /* CPUs usually cannot use float constants, so we store them
1499− generically in data segment */
1500− size = type_size(&vtop->type, &align);
1501− offset = (data_section->data_offset + align - 1) & -align;
1502− data_section->data_offset = offset;
1503− /* XXX: not portable yet */
1504−#if defined(__i386__) || defined(__x86_64__)
1505− /* Zero pad x87 tenbyte long doubles */
1506− if (size == LDOUBLE_SIZE)
1507− vtop->c.tab[2] &= 0xffff;
1508−#endif
1509− ptr = section_ptr_add(data_section, size);
1510− size = size >> 2;
1511−#if defined(TCC_TARGET_ARM) && !defined(TCC_ARM_VFP)
1512− check.d = 1;
1513− if(check.tab[0])
1514− for(i=0;i<size;i++)
1515− ptr[i] = vtop->c.tab[size-1-i];
1516− else
1517−#endif
1518− for(i=0;i<size;i++)
1519− ptr[i] = vtop->c.tab[i];
1520− sym = get_sym_ref(&vtop->type, data_section, offset, size << 2);
1521− vtop->r |= VT_LVAL | VT_SYM;
1522− vtop->sym = sym;
1523− vtop->c.ul = 0;
1524− }
1525−#ifdef CONFIG_TCC_BCHECK
1526− if (vtop->r & VT_MUSTBOUND)
1527− gbound();
1528−#endif
1529−
1530− r = vtop->r & VT_VALMASK;
1531− rc2 = RC_INT;
1532− if (rc == RC_IRET)
1533− rc2 = RC_LRET;
1534− /* need to reload if:
1535− - constant
1536− - lvalue (need to dereference pointer)
1537− - already a register, but not in the right class */
1538− if (r >= VT_CONST ||
1539− (vtop->r & VT_LVAL) ||
1540− !(reg_classes[r] & rc) ||
1541− ((vtop->type.t & VT_BTYPE) == VT_LLONG &&
1542− !(reg_classes[vtop->r2] & rc2))) {
1543− r = get_reg(rc);
1544−#ifndef TCC_TARGET_X86_64
1545− if ((vtop->type.t & VT_BTYPE) == VT_LLONG) {
1546− int r2;
1547− unsigned long long ll;
1548− /* two register type load : expand to two words
1549− temporarily */
1550− if ((vtop->r & (VT_VALMASK | VT_LVAL)) == VT_CONST) {
1551− /* load constant */
1552− ll = vtop->c.ull;
1553− vtop->c.ui = ll; /* first word */
1554− load(r, vtop);
1555− vtop->r = r; /* save register value */
1556− vpushi(ll >> 32); /* second word */
1557− } else if (r >= VT_CONST || /* XXX: test to VT_CONST incorrect ? */
1558− (vtop->r & VT_LVAL)) {
1559− /* We do not want to modifier the long long
1560− pointer here, so the safest (and less
1561− efficient) is to save all the other registers
1562− in the stack. XXX: totally inefficient. */
1563− save_regs(1);
1564− /* load from memory */
1565− load(r, vtop);
1566− vdup();
1567− vtop[-1].r = r; /* save register value */
1568− /* increment pointer to get second word */
1569− vtop->type.t = VT_INT;
1570− gaddrof();
1571− vpushi(4);
1572− gen_op('+');
1573− vtop->r |= VT_LVAL;
1574− } else {
1575− /* move registers */
1576− load(r, vtop);
1577− vdup();
1578− vtop[-1].r = r; /* save register value */
1579− vtop->r = vtop[-1].r2;
1580− }
1581− /* allocate second register */
1582− r2 = get_reg(rc2);
1583− load(r2, vtop);
1584− vpop();
1585− /* write second register */
1586− vtop->r2 = r2;
1587− } else
1588−#endif
1589− if ((vtop->r & VT_LVAL) && !is_float(vtop->type.t)) {
1590− int t1, t;
1591− /* lvalue of scalar type : need to use lvalue type
1592− because of possible cast */
1593− t = vtop->type.t;
1594− t1 = t;
1595− /* compute memory access type */
1596− if (vtop->r & VT_LVAL_BYTE)
1597− t = VT_BYTE;
1598− else if (vtop->r & VT_LVAL_SHORT)
1599− t = VT_SHORT;
1600− if (vtop->r & VT_LVAL_UNSIGNED)
1601− t |= VT_UNSIGNED;
1602− vtop->type.t = t;
1603− load(r, vtop);
1604− /* restore wanted type */
1605− vtop->type.t = t1;
1606− } else {
1607− /* one register type load */
1608− load(r, vtop);
1609− }
1610− }
1611− vtop->r = r;
1612−#ifdef TCC_TARGET_C67
1613− /* uses register pairs for doubles */
1614− if ((vtop->type.t & VT_BTYPE) == VT_DOUBLE)
1615− vtop->r2 = r+1;
1616−#endif
1617− }
1618− return r;
1619−}
1620−
1621−/* generate vtop[-1] and vtop[0] in resp. classes rc1 and rc2 */
1622−void gv2(int rc1, int rc2)
1623−{
1624− int v;
1625−
1626− /* generate more generic register first. But VT_JMP or VT_CMP
1627− values must be generated first in all cases to avoid possible
1628− reload errors */
1629− v = vtop[0].r & VT_VALMASK;
1630− if (v != VT_CMP && (v & ~1) != VT_JMP && rc1 <= rc2) {
1631− vswap();
1632− gv(rc1);
1633− vswap();
1634− gv(rc2);
1635− /* test if reload is needed for first register */
1636− if ((vtop[-1].r & VT_VALMASK) >= VT_CONST) {
1637− vswap();
1638− gv(rc1);
1639− vswap();
1640− }
1641− } else {
1642− gv(rc2);
1643− vswap();
1644− gv(rc1);
1645− vswap();
1646− /* test if reload is needed for first register */
1647− if ((vtop[0].r & VT_VALMASK) >= VT_CONST) {
1648− gv(rc2);
1649− }
1650− }
1651−}
1652−
1653−/* wrapper around RC_FRET to return a register by type */
1654−int rc_fret(int t)
1655−{
1656−#ifdef TCC_TARGET_X86_64
1657− if (t == VT_LDOUBLE) {
1658− return RC_ST0;
1659− }
1660−#endif
1661− return RC_FRET;
1662−}
1663−
1664−/* wrapper around REG_FRET to return a register by type */
1665−int reg_fret(int t)
1666−{
1667−#ifdef TCC_TARGET_X86_64
1668− if (t == VT_LDOUBLE) {
1669− return TREG_ST0;
1670− }
1671−#endif
1672− return REG_FRET;
1673−}
1674−
1675−/* expand long long on stack in two int registers */
1676−void lexpand(void)
1677−{
1678− int u;
1679−
1680− u = vtop->type.t & VT_UNSIGNED;
1681− gv(RC_INT);
1682− vdup();
1683− vtop[0].r = vtop[-1].r2;
1684− vtop[0].r2 = VT_CONST;
1685− vtop[-1].r2 = VT_CONST;
1686− vtop[0].type.t = VT_INT | u;
1687− vtop[-1].type.t = VT_INT | u;
1688−}
1689−
1690−#ifdef TCC_TARGET_ARM
1691−/* expand long long on stack */
1692−void lexpand_nr(void)
1693−{
1694− int u,v;
1695−
1696− u = vtop->type.t & VT_UNSIGNED;
1697− vdup();
1698− vtop->r2 = VT_CONST;
1699− vtop->type.t = VT_INT | u;
1700− v=vtop[-1].r & (VT_VALMASK | VT_LVAL);
1701− if (v == VT_CONST) {
1702− vtop[-1].c.ui = vtop->c.ull;
1703− vtop->c.ui = vtop->c.ull >> 32;
1704− vtop->r = VT_CONST;
1705− } else if (v == (VT_LVAL|VT_CONST) || v == (VT_LVAL|VT_LOCAL)) {
1706− vtop->c.ui += 4;
1707− vtop->r = vtop[-1].r;
1708− } else if (v > VT_CONST) {
1709− vtop--;
1710− lexpand();
1711− } else
1712− vtop->r = vtop[-1].r2;
1713− vtop[-1].r2 = VT_CONST;
1714− vtop[-1].type.t = VT_INT | u;
1715−}
1716−#endif
1717−
1718−/* build a long long from two ints */
1719−void lbuild(int t)
1720−{
1721− gv2(RC_INT, RC_INT);
1722− vtop[-1].r2 = vtop[0].r;
1723− vtop[-1].type.t = t;
1724− vpop();
1725−}
1726−
1727−/* rotate n first stack elements to the bottom
1728− I1 ... In -> I2 ... In I1 [top is right]
1729−*/
1730−void vrotb(int n)
1731−{
1732− int i;
1733− SValue tmp;
1734−
1735− tmp = vtop[-n + 1];
1736− for(i=-n+1;i!=0;i++)
1737− vtop[i] = vtop[i+1];
1738− vtop[0] = tmp;
1739−}
1740−
1741−/* rotate n first stack elements to the top
1742− I1 ... In -> In I1 ... I(n-1) [top is right]
1743− */
1744−void vrott(int n)
1745−{
1746− int i;
1747− SValue tmp;
1748−
1749− tmp = vtop[0];
1750− for(i = 0;i < n - 1; i++)
1751− vtop[-i] = vtop[-i - 1];
1752− vtop[-n + 1] = tmp;
1753−}
1754−
1755−#ifdef TCC_TARGET_ARM
1756−/* like vrott but in other direction
1757− In ... I1 -> I(n-1) ... I1 In [top is right]
1758− */
1759−void vnrott(int n)
1760−{
1761− int i;
1762− SValue tmp;
1763−
1764− tmp = vtop[-n + 1];
1765− for(i = n - 1; i > 0; i--)
1766− vtop[-i] = vtop[-i + 1];
1767− vtop[0] = tmp;
1768−}
1769−#endif
1770−
1771−/* pop stack value */
1772−void vpop(void)
1773−{
1774− int v;
1775− v = vtop->r & VT_VALMASK;
1776−#if defined(TCC_TARGET_I386) || defined(TCC_TARGET_X86_64)
1777− /* for x86, we need to pop the FP stack */
1778− if (v == TREG_ST0 && !nocode_wanted) {
1779− o(0xd9dd); /* fstp %st(1) */
1780− } else
1781−#endif
1782− if (v == VT_JMP || v == VT_JMPI) {
1783− /* need to put correct jump if && or || without test */
1784− gsym(vtop->c.ul);
1785− }
1786− vtop--;
1787−}
1788−
1789−/* convert stack entry to register and duplicate its value in another
1790− register */
1791−void gv_dup(void)
1792−{
1793− int rc, t, r, r1;
1794− SValue sv;
1795−
1796− t = vtop->type.t;
1797− if ((t & VT_BTYPE) == VT_LLONG) {
1798− lexpand();
1799− gv_dup();
1800− vswap();
1801− vrotb(3);
1802− gv_dup();
1803− vrotb(4);
1804− /* stack: H L L1 H1 */
1805− lbuild(t);
1806− vrotb(3);
1807− vrotb(3);
1808− vswap();
1809− lbuild(t);
1810− vswap();
1811− } else {
1812− /* duplicate value */
1813− rc = RC_INT;
1814− sv.type.t = VT_INT;
1815− if (is_float(t)) {
1816− rc = RC_FLOAT;
1817−#ifdef TCC_TARGET_X86_64
1818− if ((t & VT_BTYPE) == VT_LDOUBLE) {
1819− rc = RC_ST0;
1820− }
1821−#endif
1822− sv.type.t = t;
1823− }
1824− r = gv(rc);
1825− r1 = get_reg(rc);
1826− sv.r = r;
1827− sv.c.ul = 0;
1828− load(r1, &sv); /* move r to r1 */
1829− vdup();
1830− /* duplicates value */
1831− vtop->r = r1;
1832− }
1833−}
1834−
1835−#ifndef TCC_TARGET_X86_64
1836−/* generate CPU independent (unsigned) long long operations */
1837−void gen_opl(int op)
1838−{
1839− int t, a, b, op1, c, i;
1840− int func;
1841− unsigned short reg_iret = REG_IRET;
1842− unsigned short reg_lret = REG_LRET;
1843− SValue tmp;
1844−
1845− switch(op) {
1846− case '/':
1847− case TOK_PDIV:
1848− func = TOK___divdi3;
1849− goto gen_func;
1850− case TOK_UDIV:
1851− func = TOK___udivdi3;
1852− goto gen_func;
1853− case '%':
1854− func = TOK___moddi3;
1855− goto gen_mod_func;
1856− case TOK_UMOD:
1857− func = TOK___umoddi3;
1858− gen_mod_func:
1859−#ifdef TCC_ARM_EABI
1860− reg_iret = TREG_R2;
1861− reg_lret = TREG_R3;
1862−#endif
1863− gen_func:
1864− /* call generic long long function */
1865− vpush_global_sym(&func_old_type, func);
1866− vrott(3);
1867− gfunc_call(2);
1868− vpushi(0);
1869− vtop->r = reg_iret;
1870− vtop->r2 = reg_lret;
1871− break;
1872− case '^':
1873− case '&':
1874− case '|':
1875− case '*':
1876− case '+':
1877− case '-':
1878− t = vtop->type.t;
1879− vswap();
1880− lexpand();
1881− vrotb(3);
1882− lexpand();
1883− /* stack: L1 H1 L2 H2 */
1884− tmp = vtop[0];
1885− vtop[0] = vtop[-3];
1886− vtop[-3] = tmp;
1887− tmp = vtop[-2];
1888− vtop[-2] = vtop[-3];
1889− vtop[-3] = tmp;
1890− vswap();
1891− /* stack: H1 H2 L1 L2 */
1892− if (op == '*') {
1893− vpushv(vtop - 1);
1894− vpushv(vtop - 1);
1895− gen_op(TOK_UMULL);
1896− lexpand();
1897− /* stack: H1 H2 L1 L2 ML MH */
1898− for(i=0;i<4;i++)
1899− vrotb(6);
1900− /* stack: ML MH H1 H2 L1 L2 */
1901− tmp = vtop[0];
1902− vtop[0] = vtop[-2];
1903− vtop[-2] = tmp;
1904− /* stack: ML MH H1 L2 H2 L1 */
1905− gen_op('*');
1906− vrotb(3);
1907− vrotb(3);
1908− gen_op('*');
1909− /* stack: ML MH M1 M2 */
1910− gen_op('+');
1911− gen_op('+');
1912− } else if (op == '+' || op == '-') {
1913− /* XXX: add non carry method too (for MIPS or alpha) */
1914− if (op == '+')
1915− op1 = TOK_ADDC1;
1916− else
1917− op1 = TOK_SUBC1;
1918− gen_op(op1);
1919− /* stack: H1 H2 (L1 op L2) */
1920− vrotb(3);
1921− vrotb(3);
1922− gen_op(op1 + 1); /* TOK_xxxC2 */
1923− } else {
1924− gen_op(op);
1925− /* stack: H1 H2 (L1 op L2) */
1926− vrotb(3);
1927− vrotb(3);
1928− /* stack: (L1 op L2) H1 H2 */
1929− gen_op(op);
1930− /* stack: (L1 op L2) (H1 op H2) */
1931− }
1932− /* stack: L H */
1933− lbuild(t);
1934− break;
1935− case TOK_SAR:
1936− case TOK_SHR:
1937− case TOK_SHL:
1938− if ((vtop->r & (VT_VALMASK | VT_LVAL | VT_SYM)) == VT_CONST) {
1939− t = vtop[-1].type.t;
1940− vswap();
1941− lexpand();
1942− vrotb(3);
1943− /* stack: L H shift */
1944− c = (int)vtop->c.i;
1945− /* constant: simpler */
1946− /* NOTE: all comments are for SHL. the other cases are
1947− done by swaping words */
1948− vpop();
1949− if (op != TOK_SHL)
1950− vswap();
1951− if (c >= 32) {
1952− /* stack: L H */
1953− vpop();
1954− if (c > 32) {
1955− vpushi(c - 32);
1956− gen_op(op);
1957− }
1958− if (op != TOK_SAR) {
1959− vpushi(0);
1960− } else {
1961− gv_dup();
1962− vpushi(31);
1963− gen_op(TOK_SAR);
1964− }
1965− vswap();
1966− } else {
1967− vswap();
1968− gv_dup();
1969− /* stack: H L L */
1970− vpushi(c);
1971− gen_op(op);
1972− vswap();
1973− vpushi(32 - c);
1974− if (op == TOK_SHL)
1975− gen_op(TOK_SHR);
1976− else
1977− gen_op(TOK_SHL);
1978− vrotb(3);
1979− /* stack: L L H */
1980− vpushi(c);
1981− if (op == TOK_SHL)
1982− gen_op(TOK_SHL);
1983− else
1984− gen_op(TOK_SHR);
1985− gen_op('|');
1986− }
1987− if (op != TOK_SHL)
1988− vswap();
1989− lbuild(t);
1990− } else {
1991− /* XXX: should provide a faster fallback on x86 ? */
1992− switch(op) {
1993− case TOK_SAR:
1994− func = TOK___ashrdi3;
1995− goto gen_func;
1996− case TOK_SHR:
1997− func = TOK___lshrdi3;
1998− goto gen_func;
1999− case TOK_SHL:
2000− func = TOK___ashldi3;
2001− goto gen_func;
2002− }
2003− }
2004− break;
2005− default:
2006− /* compare operations */
2007− t = vtop->type.t;
2008− vswap();
2009− lexpand();
2010− vrotb(3);
2011− lexpand();
2012− /* stack: L1 H1 L2 H2 */
2013− tmp = vtop[-1];
2014− vtop[-1] = vtop[-2];
2015− vtop[-2] = tmp;
2016− /* stack: L1 L2 H1 H2 */
2017− /* compare high */
2018− op1 = op;
2019− /* when values are equal, we need to compare low words. since
2020− the jump is inverted, we invert the test too. */
2021− if (op1 == TOK_LT)
2022− op1 = TOK_LE;
2023− else if (op1 == TOK_GT)
2024− op1 = TOK_GE;
2025− else if (op1 == TOK_ULT)
2026− op1 = TOK_ULE;
2027− else if (op1 == TOK_UGT)
2028− op1 = TOK_UGE;
2029− a = 0;
2030− b = 0;
2031− gen_op(op1);
2032− if (op1 != TOK_NE) {
2033− a = gtst(1, 0);
2034− }
2035− if (op != TOK_EQ) {
2036− /* generate non equal test */
2037− /* XXX: NOT PORTABLE yet */
2038− if (a == 0) {
2039− b = gtst(0, 0);
2040− } else {
2041−#if defined(TCC_TARGET_I386)
2042− b = psym(0x850f, 0);
2043−#elif defined(TCC_TARGET_ARM)
2044− b = ind;
2045− o(0x1A000000 | encbranch(ind, 0, 1));
2046−#elif defined(TCC_TARGET_C67)
2047− error("not implemented");
2048−#else
2049−#error not supported
2050−#endif
2051− }
2052− }
2053− /* compare low. Always unsigned */
2054− op1 = op;
2055− if (op1 == TOK_LT)
2056− op1 = TOK_ULT;
2057− else if (op1 == TOK_LE)
2058− op1 = TOK_ULE;
2059− else if (op1 == TOK_GT)
2060− op1 = TOK_UGT;
2061− else if (op1 == TOK_GE)
2062− op1 = TOK_UGE;
2063− gen_op(op1);
2064− a = gtst(1, a);
2065− gsym(b);
2066− vseti(VT_JMPI, a);
2067− break;
2068− }
2069−}
2070−#endif
2071−
2072−/* handle integer constant optimizations and various machine
2073− independent opt */
2074−void gen_opic(int op)
2075−{
2076− int c1, c2, t1, t2, n;
2077− SValue *v1, *v2;
2078− long long l1, l2;
2079− typedef unsigned long long U;
2080−
2081− v1 = vtop - 1;
2082− v2 = vtop;
2083− t1 = v1->type.t & VT_BTYPE;
2084− t2 = v2->type.t & VT_BTYPE;
2085−
2086− if (t1 == VT_LLONG)
2087− l1 = v1->c.ll;
2088− else if (v1->type.t & VT_UNSIGNED)
2089− l1 = v1->c.ui;
2090− else
2091− l1 = v1->c.i;
2092−
2093− if (t2 == VT_LLONG)
2094− l2 = v2->c.ll;
2095− else if (v2->type.t & VT_UNSIGNED)
2096− l2 = v2->c.ui;
2097− else
2098− l2 = v2->c.i;
2099−
2100− /* currently, we cannot do computations with forward symbols */
2101− c1 = (v1->r & (VT_VALMASK | VT_LVAL | VT_SYM)) == VT_CONST;
2102− c2 = (v2->r & (VT_VALMASK | VT_LVAL | VT_SYM)) == VT_CONST;
2103− if (c1 && c2) {
2104− switch(op) {
2105− case '+': l1 += l2; break;
2106− case '-': l1 -= l2; break;
2107− case '&': l1 &= l2; break;
2108− case '^': l1 ^= l2; break;
2109− case '|': l1 |= l2; break;
2110− case '*': l1 *= l2; break;
2111−
2112− case TOK_PDIV:
2113− case '/':
2114− case '%':
2115− case TOK_UDIV:
2116− case TOK_UMOD:
2117− /* if division by zero, generate explicit division */
2118− if (l2 == 0) {
2119− if (const_wanted)
2120− error("division by zero in constant");
2121− goto general_case;
2122− }
2123− switch(op) {
2124− default: l1 /= l2; break;
2125− case '%': l1 %= l2; break;
2126− case TOK_UDIV: l1 = (U)l1 / l2; break;
2127− case TOK_UMOD: l1 = (U)l1 % l2; break;
2128− }
2129− break;
2130− case TOK_SHL: l1 <<= l2; break;
2131− case TOK_SHR: l1 = (U)l1 >> l2; break;
2132− case TOK_SAR: l1 >>= l2; break;
2133− /* tests */
2134− case TOK_ULT: l1 = (U)l1 < (U)l2; break;
2135− case TOK_UGE: l1 = (U)l1 >= (U)l2; break;
2136− case TOK_EQ: l1 = l1 == l2; break;
2137− case TOK_NE: l1 = l1 != l2; break;
2138− case TOK_ULE: l1 = (U)l1 <= (U)l2; break;
2139− case TOK_UGT: l1 = (U)l1 > (U)l2; break;
2140− case TOK_LT: l1 = l1 < l2; break;
2141− case TOK_GE: l1 = l1 >= l2; break;
2142− case TOK_LE: l1 = l1 <= l2; break;
2143− case TOK_GT: l1 = l1 > l2; break;
2144− /* logical */
2145− case TOK_LAND: l1 = l1 && l2; break;
2146− case TOK_LOR: l1 = l1 || l2; break;
2147− default:
2148− goto general_case;
2149− }
2150− v1->c.ll = l1;
2151− vtop--;
2152− } else {
2153− /* if commutative ops, put c2 as constant */
2154− if (c1 && (op == '+' || op == '&' || op == '^' ||
2155− op == '|' || op == '*')) {
2156− vswap();
2157− c2 = c1; //c = c1, c1 = c2, c2 = c;
2158− l2 = l1; //l = l1, l1 = l2, l2 = l;
2159− }
2160− /* Filter out NOP operations like x*1, x-0, x&-1... */
2161− if (c2 && (((op == '*' || op == '/' || op == TOK_UDIV ||
2162− op == TOK_PDIV) &&
2163− l2 == 1) ||
2164− ((op == '+' || op == '-' || op == '|' || op == '^' ||
2165− op == TOK_SHL || op == TOK_SHR || op == TOK_SAR) &&
2166− l2 == 0) ||
2167− (op == '&' &&
2168− l2 == -1))) {
2169− /* nothing to do */
2170− vtop--;
2171− } else if (c2 && (op == '*' || op == TOK_PDIV || op == TOK_UDIV)) {
2172− /* try to use shifts instead of muls or divs */
2173− if (l2 > 0 && (l2 & (l2 - 1)) == 0) {
2174− n = -1;
2175− while (l2) {
2176− l2 >>= 1;
2177− n++;
2178− }
2179− vtop->c.ll = n;
2180− if (op == '*')
2181− op = TOK_SHL;
2182− else if (op == TOK_PDIV)
2183− op = TOK_SAR;
2184− else
2185− op = TOK_SHR;
2186− }
2187− goto general_case;
2188− } else if (c2 && (op == '+' || op == '-') &&
2189− ((vtop[-1].r & (VT_VALMASK | VT_LVAL | VT_SYM)) ==
2190− (VT_CONST | VT_SYM) ||
2191− (vtop[-1].r & (VT_VALMASK | VT_LVAL)) == VT_LOCAL)) {
2192− /* symbol + constant case */
2193− if (op == '-')
2194− l2 = -l2;
2195− vtop--;
2196− vtop->c.ll += l2;
2197− } else {
2198− general_case:
2199− if (!nocode_wanted) {
2200− /* call low level op generator */
2201− if (t1 == VT_LLONG || t2 == VT_LLONG)
2202− gen_opl(op);
2203− else
2204− gen_opi(op);
2205− } else {
2206− vtop--;
2207− }
2208− }
2209− }
2210−}
2211−
2212−/* generate a floating point operation with constant propagation */
2213−void gen_opif(int op)
2214−{
2215− int c1, c2;
2216− SValue *v1, *v2;
2217− long double f1, f2;
2218−
2219− v1 = vtop - 1;
2220− v2 = vtop;
2221− /* currently, we cannot do computations with forward symbols */
2222− c1 = (v1->r & (VT_VALMASK | VT_LVAL | VT_SYM)) == VT_CONST;
2223− c2 = (v2->r & (VT_VALMASK | VT_LVAL | VT_SYM)) == VT_CONST;
2224− if (c1 && c2) {
2225− if (v1->type.t == VT_FLOAT) {
2226− f1 = v1->c.f;
2227− f2 = v2->c.f;
2228− } else if (v1->type.t == VT_DOUBLE) {
2229− f1 = v1->c.d;
2230− f2 = v2->c.d;
2231− } else {
2232− f1 = v1->c.ld;
2233− f2 = v2->c.ld;
2234− }
2235−
2236− /* NOTE: we only do constant propagation if finite number (not
2237− NaN or infinity) (ANSI spec) */
2238− if (!ieee_finite(f1) || !ieee_finite(f2))
2239− goto general_case;
2240−
2241− switch(op) {
2242− case '+': f1 += f2; break;
2243− case '-': f1 -= f2; break;
2244− case '*': f1 *= f2; break;
2245− case '/':
2246− if (f2 == 0.0) {
2247− if (const_wanted)
2248− error("division by zero in constant");
2249− goto general_case;
2250− }
2251− f1 /= f2;
2252− break;
2253− /* XXX: also handles tests ? */
2254− default:
2255− goto general_case;
2256− }
2257− /* XXX: overflow test ? */
2258− if (v1->type.t == VT_FLOAT) {
2259− v1->c.f = f1;
2260− } else if (v1->type.t == VT_DOUBLE) {
2261− v1->c.d = f1;
2262− } else {
2263− v1->c.ld = f1;
2264− }
2265− vtop--;
2266− } else {
2267− general_case:
2268− if (!nocode_wanted) {
2269− gen_opf(op);
2270− } else {
2271− vtop--;
2272− }
2273− }
2274−}
2275−
2276−static int pointed_size(CType *type)
2277−{
2278− int align;
2279− return type_size(pointed_type(type), &align);
2280−}
2281−
2282−static inline int is_null_pointer(SValue *p)
2283−{
2284− if ((p->r & (VT_VALMASK | VT_LVAL | VT_SYM)) != VT_CONST)
2285− return 0;
2286− return ((p->type.t & VT_BTYPE) == VT_INT && p->c.i == 0) ||
2287− ((p->type.t & VT_BTYPE) == VT_LLONG && p->c.ll == 0);
2288−}
2289−
2290−static inline int is_integer_btype(int bt)
2291−{
2292− return (bt == VT_BYTE || bt == VT_SHORT ||
2293− bt == VT_INT || bt == VT_LLONG);
2294−}
2295−
2296−/* check types for comparison or substraction of pointers */
2297−static void check_comparison_pointer_types(SValue *p1, SValue *p2, int op)
2298−{
2299− CType *type1, *type2, tmp_type1, tmp_type2;
2300− int bt1, bt2;
2301−
2302− /* null pointers are accepted for all comparisons as gcc */
2303− if (is_null_pointer(p1) || is_null_pointer(p2))
2304− return;
2305− type1 = &p1->type;
2306− type2 = &p2->type;
2307− bt1 = type1->t & VT_BTYPE;
2308− bt2 = type2->t & VT_BTYPE;
2309− /* accept comparison between pointer and integer with a warning */
2310− if ((is_integer_btype(bt1) || is_integer_btype(bt2)) && op != '-') {
2311− if (op != TOK_LOR && op != TOK_LAND )
2312− warning("comparison between pointer and integer");
2313− return;
2314− }
2315−
2316− /* both must be pointers or implicit function pointers */
2317− if (bt1 == VT_PTR) {
2318− type1 = pointed_type(type1);
2319− } else if (bt1 != VT_FUNC)
2320− goto invalid_operands;
2321−
2322− if (bt2 == VT_PTR) {
2323− type2 = pointed_type(type2);
2324− } else if (bt2 != VT_FUNC) {
2325− invalid_operands:
2326− error("invalid operands to binary %s", get_tok_str(op, NULL));
2327− }
2328− if ((type1->t & VT_BTYPE) == VT_VOID ||
2329− (type2->t & VT_BTYPE) == VT_VOID)
2330− return;
2331− tmp_type1 = *type1;
2332− tmp_type2 = *type2;
2333− tmp_type1.t &= ~(VT_UNSIGNED | VT_CONSTANT | VT_VOLATILE);
2334− tmp_type2.t &= ~(VT_UNSIGNED | VT_CONSTANT | VT_VOLATILE);
2335− if (!is_compatible_types(&tmp_type1, &tmp_type2)) {
2336− /* gcc-like error if '-' is used */
2337− if (op == '-')
2338− goto invalid_operands;
2339− else
2340− warning("comparison of distinct pointer types lacks a cast");
2341− }
2342−}
2343−
2344−/* generic gen_op: handles types problems */
2345−void gen_op(int op)
2346−{
2347− int u, t1, t2, bt1, bt2, t;
2348− CType type1;
2349−
2350− t1 = vtop[-1].type.t;
2351− t2 = vtop[0].type.t;
2352− bt1 = t1 & VT_BTYPE;
2353− bt2 = t2 & VT_BTYPE;
2354−
2355− if (bt1 == VT_PTR || bt2 == VT_PTR) {
2356− /* at least one operand is a pointer */
2357− /* relationnal op: must be both pointers */
2358− if (op >= TOK_ULT && op <= TOK_LOR) {
2359− check_comparison_pointer_types(vtop - 1, vtop, op);
2360− /* pointers are handled are unsigned */
2361−#ifdef TCC_TARGET_X86_64
2362− t = VT_LLONG | VT_UNSIGNED;
2363−#else
2364− t = VT_INT | VT_UNSIGNED;
2365−#endif
2366− goto std_op;
2367− }
2368− /* if both pointers, then it must be the '-' op */
2369− if (bt1 == VT_PTR && bt2 == VT_PTR) {
2370− if (op != '-')
2371− error("cannot use pointers here");
2372− check_comparison_pointer_types(vtop - 1, vtop, op);
2373− /* XXX: check that types are compatible */
2374− u = pointed_size(&vtop[-1].type);
2375− gen_opic(op);
2376− /* set to integer type */
2377−#ifdef TCC_TARGET_X86_64
2378− vtop->type.t = VT_LLONG;
2379−#else
2380− vtop->type.t = VT_INT;
2381−#endif
2382− vpushi(u);
2383− gen_op(TOK_PDIV);
2384− } else {
2385− /* exactly one pointer : must be '+' or '-'. */
2386− if (op != '-' && op != '+')
2387− error("cannot use pointers here");
2388− /* Put pointer as first operand */
2389− if (bt2 == VT_PTR) {
2390− vswap();
2391− swap(&t1, &t2);
2392− }
2393− type1 = vtop[-1].type;
2394−#ifdef TCC_TARGET_X86_64
2395− vpushll(pointed_size(&vtop[-1].type));
2396−#else
2397− /* XXX: cast to int ? (long long case) */
2398− vpushi(pointed_size(&vtop[-1].type));
2399−#endif
2400− gen_op('*');
2401−#ifdef CONFIG_TCC_BCHECK
2402− /* if evaluating constant expression, no code should be
2403− generated, so no bound check */
2404− if (do_bounds_check && !const_wanted) {
2405− /* if bounded pointers, we generate a special code to
2406− test bounds */
2407− if (op == '-') {
2408− vpushi(0);
2409− vswap();
2410− gen_op('-');
2411− }
2412− gen_bounded_ptr_add();
2413− } else
2414−#endif
2415− {
2416− gen_opic(op);
2417− }
2418− /* put again type if gen_opic() swaped operands */
2419− vtop->type = type1;
2420− }
2421− } else if (is_float(bt1) || is_float(bt2)) {
2422− /* compute bigger type and do implicit casts */
2423− if (bt1 == VT_LDOUBLE || bt2 == VT_LDOUBLE) {
2424− t = VT_LDOUBLE;
2425− } else if (bt1 == VT_DOUBLE || bt2 == VT_DOUBLE) {
2426− t = VT_DOUBLE;
2427− } else {
2428− t = VT_FLOAT;
2429− }
2430− /* floats can only be used for a few operations */
2431− if (op != '+' && op != '-' && op != '*' && op != '/' &&
2432− (op < TOK_ULT || op > TOK_GT))
2433− error("invalid operands for binary operation");
2434− goto std_op;
2435− } else if (bt1 == VT_LLONG || bt2 == VT_LLONG) {
2436− /* cast to biggest op */
2437− t = VT_LLONG;
2438− /* convert to unsigned if it does not fit in a long long */
2439− if ((t1 & (VT_BTYPE | VT_UNSIGNED)) == (VT_LLONG | VT_UNSIGNED) ||
2440− (t2 & (VT_BTYPE | VT_UNSIGNED)) == (VT_LLONG | VT_UNSIGNED))
2441− t |= VT_UNSIGNED;
2442− goto std_op;
2443− } else {
2444− /* integer operations */
2445− t = VT_INT;
2446− /* convert to unsigned if it does not fit in an integer */
2447− if ((t1 & (VT_BTYPE | VT_UNSIGNED)) == (VT_INT | VT_UNSIGNED) ||
2448− (t2 & (VT_BTYPE | VT_UNSIGNED)) == (VT_INT | VT_UNSIGNED))
2449− t |= VT_UNSIGNED;
2450− std_op:
2451− /* XXX: currently, some unsigned operations are explicit, so
2452− we modify them here */
2453− if (t & VT_UNSIGNED) {
2454− if (op == TOK_SAR)
2455− op = TOK_SHR;
2456− else if (op == '/')
2457− op = TOK_UDIV;
2458− else if (op == '%')
2459− op = TOK_UMOD;
2460− else if (op == TOK_LT)
2461− op = TOK_ULT;
2462− else if (op == TOK_GT)
2463− op = TOK_UGT;
2464− else if (op == TOK_LE)
2465− op = TOK_ULE;
2466− else if (op == TOK_GE)
2467− op = TOK_UGE;
2468− }
2469− vswap();
2470− type1.t = t;
2471− gen_cast(&type1);
2472− vswap();
2473− /* special case for shifts and long long: we keep the shift as
2474− an integer */
2475− if (op == TOK_SHR || op == TOK_SAR || op == TOK_SHL)
2476− type1.t = VT_INT;
2477− gen_cast(&type1);
2478− if (is_float(t))
2479− gen_opif(op);
2480− else
2481− gen_opic(op);
2482− if (op >= TOK_ULT && op <= TOK_GT) {
2483− /* relationnal op: the result is an int */
2484− vtop->type.t = VT_INT;
2485− } else {
2486− vtop->type.t = t;
2487− }
2488− }
2489−}
2490−
2491−#ifndef TCC_TARGET_ARM
2492−/* generic itof for unsigned long long case */
2493−void gen_cvt_itof1(int t)
2494−{
2495− if ((vtop->type.t & (VT_BTYPE | VT_UNSIGNED)) ==
2496− (VT_LLONG | VT_UNSIGNED)) {
2497−
2498− if (t == VT_FLOAT)
2499− vpush_global_sym(&func_old_type, TOK___floatundisf);
2500−#if LDOUBLE_SIZE != 8
2501− else if (t == VT_LDOUBLE)
2502− vpush_global_sym(&func_old_type, TOK___floatundixf);
2503−#endif
2504− else
2505− vpush_global_sym(&func_old_type, TOK___floatundidf);
2506− vrott(2);
2507− gfunc_call(1);
2508− vpushi(0);
2509− vtop->r = reg_fret(t);
2510− } else {
2511− gen_cvt_itof(t);
2512− }
2513−}
2514−#endif
2515−
2516−/* generic ftoi for unsigned long long case */
2517−void gen_cvt_ftoi1(int t)
2518−{
2519− int st;
2520−
2521− if (t == (VT_LLONG | VT_UNSIGNED)) {
2522− /* not handled natively */
2523− st = vtop->type.t & VT_BTYPE;
2524− if (st == VT_FLOAT)
2525− vpush_global_sym(&func_old_type, TOK___fixunssfdi);
2526−#if LDOUBLE_SIZE != 8
2527− else if (st == VT_LDOUBLE)
2528− vpush_global_sym(&func_old_type, TOK___fixunsxfdi);
2529−#endif
2530− else
2531− vpush_global_sym(&func_old_type, TOK___fixunsdfdi);
2532− vrott(2);
2533− gfunc_call(1);
2534− vpushi(0);
2535− vtop->r = REG_IRET;
2536− vtop->r2 = REG_LRET;
2537− } else {
2538− gen_cvt_ftoi(t);
2539− }
2540−}
2541−
2542−/* force char or short cast */
2543−void force_charshort_cast(int t)
2544−{
2545− int bits, dbt;
2546− dbt = t & VT_BTYPE;
2547− /* XXX: add optimization if lvalue : just change type and offset */
2548− if (dbt == VT_BYTE)
2549− bits = 8;
2550− else
2551− bits = 16;
2552− if (t & VT_UNSIGNED) {
2553− vpushi((1 << bits) - 1);
2554− gen_op('&');
2555− } else {
2556− bits = 32 - bits;
2557− vpushi(bits);
2558− gen_op(TOK_SHL);
2559− /* result must be signed or the SAR is converted to an SHL
2560− This was not the case when "t" was a signed short
2561− and the last value on the stack was an unsigned int */
2562− vtop->type.t &= ~VT_UNSIGNED;
2563− vpushi(bits);
2564− gen_op(TOK_SAR);
2565− }
2566−}
2567−
2568−/* cast 'vtop' to 'type'. Casting to bitfields is forbidden. */
2569−static void gen_cast(CType *type)
2570−{
2571− int sbt, dbt, sf, df, c, p;
2572−
2573− /* special delayed cast for char/short */
2574− /* XXX: in some cases (multiple cascaded casts), it may still
2575− be incorrect */
2576− if (vtop->r & VT_MUSTCAST) {
2577− vtop->r &= ~VT_MUSTCAST;
2578− force_charshort_cast(vtop->type.t);
2579− }
2580−
2581− /* bitfields first get cast to ints */
2582− if (vtop->type.t & VT_BITFIELD) {
2583− gv(RC_INT);
2584− }
2585−
2586− dbt = type->t & (VT_BTYPE | VT_UNSIGNED);
2587− sbt = vtop->type.t & (VT_BTYPE | VT_UNSIGNED);
2588−
2589− if (sbt != dbt) {
2590− sf = is_float(sbt);
2591− df = is_float(dbt);
2592− c = (vtop->r & (VT_VALMASK | VT_LVAL | VT_SYM)) == VT_CONST;
2593− p = (vtop->r & (VT_VALMASK | VT_LVAL | VT_SYM)) == (VT_CONST | VT_SYM);
2594− if (c) {
2595− /* constant case: we can do it now */
2596− /* XXX: in ISOC, cannot do it if error in convert */
2597− if (sbt == VT_FLOAT)
2598− vtop->c.ld = vtop->c.f;
2599− else if (sbt == VT_DOUBLE)
2600− vtop->c.ld = vtop->c.d;
2601−
2602− if (df) {
2603− if ((sbt & VT_BTYPE) == VT_LLONG) {
2604− if (sbt & VT_UNSIGNED)
2605− vtop->c.ld = vtop->c.ull;
2606− else
2607− vtop->c.ld = vtop->c.ll;
2608− } else if(!sf) {
2609− if (sbt & VT_UNSIGNED)
2610− vtop->c.ld = vtop->c.ui;
2611− else
2612− vtop->c.ld = vtop->c.i;
2613− }
2614−
2615− if (dbt == VT_FLOAT)
2616− vtop->c.f = (float)vtop->c.ld;
2617− else if (dbt == VT_DOUBLE)
2618− vtop->c.d = (double)vtop->c.ld;
2619− } else if (sf && dbt == (VT_LLONG|VT_UNSIGNED)) {
2620− vtop->c.ull = (unsigned long long)vtop->c.ld;
2621− } else if (sf && dbt == VT_BOOL) {
2622− vtop->c.i = (vtop->c.ld != 0);
2623− } else {
2624− if(sf)
2625− vtop->c.ll = (long long)vtop->c.ld;
2626− else if (sbt == (VT_LLONG|VT_UNSIGNED))
2627− vtop->c.ll = vtop->c.ull;
2628− else if (sbt & VT_UNSIGNED)
2629− vtop->c.ll = vtop->c.ui;
2630− else if (sbt != VT_LLONG)
2631− vtop->c.ll = vtop->c.i;
2632−
2633− if (dbt == (VT_LLONG|VT_UNSIGNED))
2634− vtop->c.ull = vtop->c.ll;
2635− else if (dbt == VT_BOOL)
2636− vtop->c.i = (vtop->c.ll != 0);
2637− else if (dbt != VT_LLONG) {
2638− int s = 0;
2639− if ((dbt & VT_BTYPE) == VT_BYTE)
2640− s = 24;
2641− else if ((dbt & VT_BTYPE) == VT_SHORT)
2642− s = 16;
2643−
2644− if(dbt & VT_UNSIGNED)
2645− vtop->c.ui = ((unsigned int)vtop->c.ll << s) >> s;
2646− else
2647− vtop->c.i = ((int)vtop->c.ll << s) >> s;
2648− }
2649− }
2650− } else if (p && dbt == VT_BOOL) {
2651− vtop->r = VT_CONST;
2652− vtop->c.i = 1;
2653− } else if (!nocode_wanted) {
2654− /* non constant case: generate code */
2655− if (sf && df) {
2656− /* convert from fp to fp */
2657− gen_cvt_ftof(dbt);
2658− } else if (df) {
2659− /* convert int to fp */
2660− gen_cvt_itof1(dbt);
2661− } else if (sf) {
2662− /* convert fp to int */
2663− if (dbt == VT_BOOL) {
2664− vpushi(0);
2665− gen_op(TOK_NE);
2666− } else {
2667− /* we handle char/short/etc... with generic code */
2668− if (dbt != (VT_INT | VT_UNSIGNED) &&
2669− dbt != (VT_LLONG | VT_UNSIGNED) &&
2670− dbt != VT_LLONG)
2671− dbt = VT_INT;
2672− gen_cvt_ftoi1(dbt);
2673− if (dbt == VT_INT && (type->t & (VT_BTYPE | VT_UNSIGNED)) != dbt) {
2674− /* additional cast for char/short... */
2675− vtop->type.t = dbt;
2676− gen_cast(type);
2677− }
2678− }
2679−#ifndef TCC_TARGET_X86_64
2680− } else if ((dbt & VT_BTYPE) == VT_LLONG) {
2681− if ((sbt & VT_BTYPE) != VT_LLONG) {
2682− /* scalar to long long */
2683− /* machine independent conversion */
2684− gv(RC_INT);
2685− /* generate high word */
2686− if (sbt == (VT_INT | VT_UNSIGNED)) {
2687− vpushi(0);
2688− gv(RC_INT);
2689− } else {
2690− if (sbt == VT_PTR) {
2691− /* cast from pointer to int before we apply
2692− shift operation, which pointers don't support*/
2693− gen_cast(&int_type);
2694− }
2695− gv_dup();
2696− vpushi(31);
2697− gen_op(TOK_SAR);
2698− }
2699− /* patch second register */
2700− vtop[-1].r2 = vtop->r;
2701− vpop();
2702− }
2703−#else
2704− } else if ((dbt & VT_BTYPE) == VT_LLONG ||
2705− (dbt & VT_BTYPE) == VT_PTR) {
2706− /* XXX: not sure if this is perfect... need more tests */
2707− if ((sbt & VT_BTYPE) != VT_LLONG) {
2708− int r = gv(RC_INT);
2709− if (sbt != (VT_INT | VT_UNSIGNED) &&
2710− sbt != VT_PTR && sbt != VT_FUNC) {
2711− /* x86_64 specific: movslq */
2712− o(0x6348);
2713− o(0xc0 + (REG_VALUE(r) << 3) + REG_VALUE(r));
2714− }
2715− }
2716−#endif
2717− } else if (dbt == VT_BOOL) {
2718− /* scalar to bool */
2719− vpushi(0);
2720− gen_op(TOK_NE);
2721− } else if ((dbt & VT_BTYPE) == VT_BYTE ||
2722− (dbt & VT_BTYPE) == VT_SHORT) {
2723− if (sbt == VT_PTR) {
2724− vtop->type.t = VT_INT;
2725− warning("nonportable conversion from pointer to char/short");
2726− }
2727− force_charshort_cast(dbt);
2728− } else if ((dbt & VT_BTYPE) == VT_INT) {
2729− /* scalar to int */
2730− if (sbt == VT_LLONG) {
2731− /* from long long: just take low order word */
2732− lexpand();
2733− vpop();
2734− }
2735− /* if lvalue and single word type, nothing to do because
2736− the lvalue already contains the real type size (see
2737− VT_LVAL_xxx constants) */
2738− }
2739− }
2740− } else if ((dbt & VT_BTYPE) == VT_PTR && !(vtop->r & VT_LVAL)) {
2741− /* if we are casting between pointer types,
2742− we must update the VT_LVAL_xxx size */
2743− vtop->r = (vtop->r & ~VT_LVAL_TYPE)
2744− | (lvalue_type(type->ref->type.t) & VT_LVAL_TYPE);
2745− }
2746− vtop->type = *type;
2747−}
2748−
2749−/* return type size. Put alignment at 'a' */
2750−static int type_size(CType *type, int *a)
2751−{
2752− Sym *s;
2753− int bt;
2754−
2755− bt = type->t & VT_BTYPE;
2756− if (bt == VT_STRUCT) {
2757− /* struct/union */
2758− s = type->ref;
2759− *a = s->r;
2760− return s->c;
2761− } else if (bt == VT_PTR) {
2762− if (type->t & VT_ARRAY) {
2763− int ts;
2764−
2765− s = type->ref;
2766− ts = type_size(&s->type, a);
2767−
2768− if (ts < 0 && s->c < 0)
2769− ts = -ts;
2770−
2771− return ts * s->c;
2772− } else {
2773− *a = PTR_SIZE;
2774− return PTR_SIZE;
2775− }
2776− } else if (bt == VT_LDOUBLE) {
2777− *a = LDOUBLE_ALIGN;
2778− return LDOUBLE_SIZE;
2779− } else if (bt == VT_DOUBLE || bt == VT_LLONG) {
2780−#ifdef TCC_TARGET_I386
2781−#ifdef TCC_TARGET_PE
2782− *a = 8;
2783−#else
2784− *a = 4;
2785−#endif
2786−#elif defined(TCC_TARGET_ARM)
2787−#ifdef TCC_ARM_EABI
2788− *a = 8;
2789−#else
2790− *a = 4;
2791−#endif
2792−#else
2793− *a = 8;
2794−#endif
2795− return 8;
2796− } else if (bt == VT_INT || bt == VT_ENUM || bt == VT_FLOAT) {
2797− *a = 4;
2798− return 4;
2799− } else if (bt == VT_SHORT) {
2800− *a = 2;
2801− return 2;
2802− } else {
2803− /* char, void, function, _Bool */
2804− *a = 1;
2805− return 1;
2806− }
2807−}
2808−
2809−/* return the pointed type of t */
2810−static inline CType *pointed_type(CType *type)
2811−{
2812− return &type->ref->type;
2813−}
2814−
2815−/* modify type so that its it is a pointer to type. */
2816−static void mk_pointer(CType *type)
2817−{
2818− Sym *s;
2819− s = sym_push(SYM_FIELD, type, 0, -1);
2820− type->t = VT_PTR | (type->t & ~VT_TYPE);
2821− type->ref = s;
2822−}
2823−
2824−/* compare function types. OLD functions match any new functions */
2825−static int is_compatible_func(CType *type1, CType *type2)
2826−{
2827− Sym *s1, *s2;
2828−
2829− s1 = type1->ref;
2830− s2 = type2->ref;
2831− if (!is_compatible_types(&s1->type, &s2->type))
2832− return 0;
2833− /* check func_call */
2834− if (FUNC_CALL(s1->r) != FUNC_CALL(s2->r))
2835− return 0;
2836− /* XXX: not complete */
2837− if (s1->c == FUNC_OLD || s2->c == FUNC_OLD)
2838− return 1;
2839− if (s1->c != s2->c)
2840− return 0;
2841− while (s1 != NULL) {
2842− if (s2 == NULL)
2843− return 0;
2844− if (!is_compatible_parameter_types(&s1->type, &s2->type))
2845− return 0;
2846− s1 = s1->next;
2847− s2 = s2->next;
2848− }
2849− if (s2)
2850− return 0;
2851− return 1;
2852−}
2853−
2854−/* return true if type1 and type2 are the same. If unqualified is
2855− true, qualifiers on the types are ignored.
2856−
2857− - enums are not checked as gcc __builtin_types_compatible_p ()
2858− */
2859−static int compare_types(CType *type1, CType *type2, int unqualified)
2860−{
2861− int bt1, t1, t2;
2862−
2863− t1 = type1->t & VT_TYPE;
2864− t2 = type2->t & VT_TYPE;
2865− if (unqualified) {
2866− /* strip qualifiers before comparing */
2867− t1 &= ~(VT_CONSTANT | VT_VOLATILE);
2868− t2 &= ~(VT_CONSTANT | VT_VOLATILE);
2869− }
2870− /* XXX: bitfields ? */
2871− if (t1 != t2)
2872− return 0;
2873− /* test more complicated cases */
2874− bt1 = t1 & VT_BTYPE;
2875− if (bt1 == VT_PTR) {
2876− type1 = pointed_type(type1);
2877− type2 = pointed_type(type2);
2878− return is_compatible_types(type1, type2);
2879− } else if (bt1 == VT_STRUCT) {
2880− return (type1->ref == type2->ref);
2881− } else if (bt1 == VT_FUNC) {
2882− return is_compatible_func(type1, type2);
2883− } else {
2884− return 1;
2885− }
2886−}
2887−
2888−/* return true if type1 and type2 are exactly the same (including
2889− qualifiers).
2890−*/
2891−static int is_compatible_types(CType *type1, CType *type2)
2892−{
2893− return compare_types(type1,type2,0);
2894−}
2895−
2896−/* return true if type1 and type2 are the same (ignoring qualifiers).
2897−*/
2898−static int is_compatible_parameter_types(CType *type1, CType *type2)
2899−{
2900− return compare_types(type1,type2,1);
2901−}
2902−
2903−/* print a type. If 'varstr' is not NULL, then the variable is also
2904− printed in the type */
2905−/* XXX: union */
2906−/* XXX: add array and function pointers */
2907−void type_to_str(char *buf, int buf_size,
2908− CType *type, const char *varstr)
2909−{
2910− int bt, v, t;
2911− Sym *s, *sa;
2912− char buf1[256];
2913− const char *tstr;
2914−
2915− t = type->t & VT_TYPE;
2916− bt = t & VT_BTYPE;
2917− buf[0] = '\0';
2918− if (t & VT_CONSTANT)
2919− pstrcat(buf, buf_size, "const ");
2920− if (t & VT_VOLATILE)
2921− pstrcat(buf, buf_size, "volatile ");
2922− if (t & VT_UNSIGNED)
2923− pstrcat(buf, buf_size, "unsigned ");
2924− switch(bt) {
2925− case VT_VOID:
2926− tstr = "void";
2927− goto add_tstr;
2928− case VT_BOOL:
2929− tstr = "_Bool";
2930− goto add_tstr;
2931− case VT_BYTE:
2932− tstr = "char";
2933− goto add_tstr;
2934− case VT_SHORT:
2935− tstr = "short";
2936− goto add_tstr;
2937− case VT_INT:
2938− tstr = "int";
2939− goto add_tstr;
2940− case VT_LONG:
2941− tstr = "long";
2942− goto add_tstr;
2943− case VT_LLONG:
2944− tstr = "long long";
2945− goto add_tstr;
2946− case VT_FLOAT:
2947− tstr = "float";
2948− goto add_tstr;
2949− case VT_DOUBLE:
2950− tstr = "double";
2951− goto add_tstr;
2952− case VT_LDOUBLE:
2953− tstr = "long double";
2954− add_tstr:
2955− pstrcat(buf, buf_size, tstr);
2956− break;
2957− case VT_ENUM:
2958− case VT_STRUCT:
2959− if (bt == VT_STRUCT)
2960− tstr = "struct ";
2961− else
2962− tstr = "enum ";
2963− pstrcat(buf, buf_size, tstr);
2964− v = type->ref->v & ~SYM_STRUCT;
2965− if (v >= SYM_FIRST_ANOM)
2966− pstrcat(buf, buf_size, "<anonymous>");
2967− else
2968− pstrcat(buf, buf_size, get_tok_str(v, NULL));
2969− break;
2970− case VT_FUNC:
2971− s = type->ref;
2972− type_to_str(buf, buf_size, &s->type, varstr);
2973− pstrcat(buf, buf_size, "(");
2974− sa = s->next;
2975− while (sa != NULL) {
2976− type_to_str(buf1, sizeof(buf1), &sa->type, NULL);
2977− pstrcat(buf, buf_size, buf1);
2978− sa = sa->next;
2979− if (sa)
2980− pstrcat(buf, buf_size, ", ");
2981− }
2982− pstrcat(buf, buf_size, ")");
2983− goto no_var;
2984− case VT_PTR:
2985− s = type->ref;
2986− pstrcpy(buf1, sizeof(buf1), "*");
2987− if (varstr)
2988− pstrcat(buf1, sizeof(buf1), varstr);
2989− type_to_str(buf, buf_size, &s->type, buf1);
2990− goto no_var;
2991− }
2992− if (varstr) {
2993− pstrcat(buf, buf_size, " ");
2994− pstrcat(buf, buf_size, varstr);
2995− }
2996− no_var: ;
2997−}
2998−
2999−/* verify type compatibility to store vtop in 'dt' type, and generate
3000− casts if needed. */
3001−static void gen_assign_cast(CType *dt)
3002−{
3003− CType *st, *type1, *type2, tmp_type1, tmp_type2;
3004− char buf1[256], buf2[256];
3005− int dbt, sbt;
3006−
3007− st = &vtop->type; /* source type */
3008− dbt = dt->t & VT_BTYPE;
3009− sbt = st->t & VT_BTYPE;
3010− if (dt->t & VT_CONSTANT)
3011− warning("assignment of read-only location");
3012− switch(dbt) {
3013− case VT_PTR:
3014− /* special cases for pointers */
3015− /* '0' can also be a pointer */
3016− if (is_null_pointer(vtop))
3017− goto type_ok;
3018− /* accept implicit pointer to integer cast with warning */
3019− if (is_integer_btype(sbt)) {
3020− warning("assignment makes pointer from integer without a cast");
3021− goto type_ok;
3022− }
3023− type1 = pointed_type(dt);
3024− /* a function is implicitely a function pointer */
3025− if (sbt == VT_FUNC) {
3026− if ((type1->t & VT_BTYPE) != VT_VOID &&
3027− !is_compatible_types(pointed_type(dt), st))
3028− goto error;
3029− else
3030− goto type_ok;
3031− }
3032− if (sbt != VT_PTR)
3033− goto error;
3034− type2 = pointed_type(st);
3035− if ((type1->t & VT_BTYPE) == VT_VOID ||
3036− (type2->t & VT_BTYPE) == VT_VOID) {
3037− /* void * can match anything */
3038− } else {
3039− /* exact type match, except for unsigned */
3040− tmp_type1 = *type1;
3041− tmp_type2 = *type2;
3042− tmp_type1.t &= ~(VT_UNSIGNED | VT_CONSTANT | VT_VOLATILE);
3043− tmp_type2.t &= ~(VT_UNSIGNED | VT_CONSTANT | VT_VOLATILE);
3044− if (!is_compatible_types(&tmp_type1, &tmp_type2))
3045− warning("assignment from incompatible pointer type");
3046− }
3047− /* check const and volatile */
3048− if ((!(type1->t & VT_CONSTANT) && (type2->t & VT_CONSTANT)) ||
3049− (!(type1->t & VT_VOLATILE) && (type2->t & VT_VOLATILE)))
3050− warning("assignment discards qualifiers from pointer target type");
3051− break;
3052− case VT_BYTE:
3053− case VT_SHORT:
3054− case VT_INT:
3055− case VT_LLONG:
3056− if (sbt == VT_PTR || sbt == VT_FUNC) {
3057− warning("assignment makes integer from pointer without a cast");
3058− }
3059− /* XXX: more tests */
3060− break;
3061− case VT_STRUCT:
3062− tmp_type1 = *dt;
3063− tmp_type2 = *st;
3064− tmp_type1.t &= ~(VT_CONSTANT | VT_VOLATILE);
3065− tmp_type2.t &= ~(VT_CONSTANT | VT_VOLATILE);
3066− if (!is_compatible_types(&tmp_type1, &tmp_type2)) {
3067− error:
3068− type_to_str(buf1, sizeof(buf1), st, NULL);
3069− type_to_str(buf2, sizeof(buf2), dt, NULL);
3070− error("cannot cast '%s' to '%s'", buf1, buf2);
3071− }
3072− break;
3073− }
3074− type_ok:
3075− gen_cast(dt);
3076−}
3077−
3078−/* store vtop in lvalue pushed on stack */
3079−void vstore(void)
3080−{
3081− int sbt, dbt, ft, r, t, size, align, bit_size, bit_pos, rc, delayed_cast;
3082−
3083− ft = vtop[-1].type.t;
3084− sbt = vtop->type.t & VT_BTYPE;
3085− dbt = ft & VT_BTYPE;
3086− if (((sbt == VT_INT || sbt == VT_SHORT) && dbt == VT_BYTE) ||
3087− (sbt == VT_INT && dbt == VT_SHORT)) {
3088− /* optimize char/short casts */
3089− delayed_cast = VT_MUSTCAST;
3090− vtop->type.t = ft & (VT_TYPE & ~(VT_BITFIELD | (-1 << VT_STRUCT_SHIFT)));
3091− /* XXX: factorize */
3092− if (ft & VT_CONSTANT)
3093− warning("assignment of read-only location");
3094− } else {
3095− delayed_cast = 0;
3096− if (!(ft & VT_BITFIELD))
3097− gen_assign_cast(&vtop[-1].type);
3098− }
3099−
3100− if (sbt == VT_STRUCT) {
3101− /* if structure, only generate pointer */
3102− /* structure assignment : generate memcpy */
3103− /* XXX: optimize if small size */
3104− if (!nocode_wanted) {
3105− size = type_size(&vtop->type, &align);
3106−
3107−#ifdef TCC_ARM_EABI
3108− if(!(align & 7))
3109− vpush_global_sym(&func_old_type, TOK_memcpy8);
3110− else if(!(align & 3))
3111− vpush_global_sym(&func_old_type, TOK_memcpy4);
3112− else
3113−#endif
3114− vpush_global_sym(&func_old_type, TOK_memcpy);
3115−
3116− /* destination */
3117− vpushv(vtop - 2);
3118− vtop->type.t = VT_PTR;
3119− gaddrof();
3120− /* source */
3121− vpushv(vtop - 2);
3122− vtop->type.t = VT_PTR;
3123− gaddrof();
3124− /* type size */
3125− vpushi(size);
3126− gfunc_call(3);
3127−
3128− vswap();
3129− vpop();
3130− } else {
3131− vswap();
3132− vpop();
3133− }
3134− /* leave source on stack */
3135− } else if (ft & VT_BITFIELD) {
3136− /* bitfield store handling */
3137− bit_pos = (ft >> VT_STRUCT_SHIFT) & 0x3f;
3138− bit_size = (ft >> (VT_STRUCT_SHIFT + 6)) & 0x3f;
3139− /* remove bit field info to avoid loops */
3140− vtop[-1].type.t = ft & ~(VT_BITFIELD | (-1 << VT_STRUCT_SHIFT));
3141−
3142− /* duplicate source into other register */
3143− gv_dup();
3144− vswap();
3145− vrott(3);
3146−
3147− if((ft & VT_BTYPE) == VT_BOOL) {
3148− gen_cast(&vtop[-1].type);
3149− vtop[-1].type.t = (vtop[-1].type.t & ~VT_BTYPE) | (VT_BYTE | VT_UNSIGNED);
3150− }
3151−
3152− /* duplicate destination */
3153− vdup();
3154− vtop[-1] = vtop[-2];
3155−
3156− /* mask and shift source */
3157− if((ft & VT_BTYPE) != VT_BOOL) {
3158− if((ft & VT_BTYPE) == VT_LLONG) {
3159− vpushll((1ULL << bit_size) - 1ULL);
3160− } else {
3161− vpushi((1 << bit_size) - 1);
3162− }
3163− gen_op('&');
3164− }
3165− vpushi(bit_pos);
3166− gen_op(TOK_SHL);
3167− /* load destination, mask and or with source */
3168− vswap();
3169− if((ft & VT_BTYPE) == VT_LLONG) {
3170− vpushll(~(((1ULL << bit_size) - 1ULL) << bit_pos));
3171− } else {
3172− vpushi(~(((1 << bit_size) - 1) << bit_pos));
3173− }
3174− gen_op('&');
3175− gen_op('|');
3176− /* store result */
3177− vstore();
3178−
3179− /* pop off shifted source from "duplicate source..." above */
3180− vpop();
3181−
3182− } else {
3183−#ifdef CONFIG_TCC_BCHECK
3184− /* bound check case */
3185− if (vtop[-1].r & VT_MUSTBOUND) {
3186− vswap();
3187− gbound();
3188− vswap();
3189− }
3190−#endif
3191− if (!nocode_wanted) {
3192− rc = RC_INT;
3193− if (is_float(ft)) {
3194− rc = RC_FLOAT;
3195−#ifdef TCC_TARGET_X86_64
3196− if ((ft & VT_BTYPE) == VT_LDOUBLE) {
3197− rc = RC_ST0;
3198− }
3199−#endif
3200− }
3201− r = gv(rc); /* generate value */
3202− /* if lvalue was saved on stack, must read it */
3203− if ((vtop[-1].r & VT_VALMASK) == VT_LLOCAL) {
3204− SValue sv;
3205− t = get_reg(RC_INT);
3206−#ifdef TCC_TARGET_X86_64
3207− sv.type.t = VT_PTR;
3208−#else
3209− sv.type.t = VT_INT;
3210−#endif
3211− sv.r = VT_LOCAL | VT_LVAL;
3212− sv.c.ul = vtop[-1].c.ul;
3213− load(t, &sv);
3214− vtop[-1].r = t | VT_LVAL;
3215− }
3216− store(r, vtop - 1);
3217−#ifndef TCC_TARGET_X86_64
3218− /* two word case handling : store second register at word + 4 */
3219− if ((ft & VT_BTYPE) == VT_LLONG) {
3220− vswap();
3221− /* convert to int to increment easily */
3222− vtop->type.t = VT_INT;
3223− gaddrof();
3224− vpushi(4);
3225− gen_op('+');
3226− vtop->r |= VT_LVAL;
3227− vswap();
3228− /* XXX: it works because r2 is spilled last ! */
3229− store(vtop->r2, vtop - 1);
3230− }
3231−#endif
3232− }
3233− vswap();
3234− vtop--; /* NOT vpop() because on x86 it would flush the fp stack */
3235− vtop->r |= delayed_cast;
3236− }
3237−}
3238−
3239−/* post defines POST/PRE add. c is the token ++ or -- */
3240−void inc(int post, int c)
3241−{
3242− test_lvalue();
3243− vdup(); /* save lvalue */
3244− if (post) {
3245− gv_dup(); /* duplicate value */
3246− vrotb(3);
3247− vrotb(3);
3248− }
3249− /* add constant */
3250− vpushi(c - TOK_MID);
3251− gen_op('+');
3252− vstore(); /* store value */
3253− if (post)
3254− vpop(); /* if post op, return saved value */
3255−}
3256−
3257−/* Parse GNUC __attribute__ extension. Currently, the following
3258− extensions are recognized:
3259− - aligned(n) : set data/function alignment.
3260− - packed : force data alignment to 1
3261− - section(x) : generate data/code in this section.
3262− - unused : currently ignored, but may be used someday.
3263− - regparm(n) : pass function parameters in registers (i386 only)
3264− */
3265−static void parse_attribute(AttributeDef *ad)
3266−{
3267− int t, n;
3268−
3269− while (tok == TOK_ATTRIBUTE1 || tok == TOK_ATTRIBUTE2) {
3270− next();
3271− skip('(');
3272− skip('(');
3273− while (tok != ')') {
3274− if (tok < TOK_IDENT)
3275− expect("attribute name");
3276− t = tok;
3277− next();
3278− switch(t) {
3279− case TOK_SECTION1:
3280− case TOK_SECTION2:
3281− skip('(');
3282− if (tok != TOK_STR)
3283− expect("section name");
3284− ad->section = find_section(tcc_state, (char *)tokc.cstr->data);
3285− next();
3286− skip(')');
3287− break;
3288− case TOK_ALIGNED1:
3289− case TOK_ALIGNED2:
3290− if (tok == '(') {
3291− next();
3292− n = expr_const();
3293− if (n <= 0 || (n & (n - 1)) != 0)
3294− error("alignment must be a positive power of two");
3295− skip(')');
3296− } else {
3297− n = MAX_ALIGN;
3298− }
3299− ad->aligned = n;
3300− break;
3301− case TOK_PACKED1:
3302− case TOK_PACKED2:
3303− ad->packed = 1;
3304− break;
3305− case TOK_UNUSED1:
3306− case TOK_UNUSED2:
3307− /* currently, no need to handle it because tcc does not
3308− track unused objects */
3309− break;
3310− case TOK_NORETURN1:
3311− case TOK_NORETURN2:
3312− /* currently, no need to handle it because tcc does not
3313− track unused objects */
3314− break;
3315− case TOK_CDECL1:
3316− case TOK_CDECL2:
3317− case TOK_CDECL3:
3318− FUNC_CALL(ad->func_attr) = FUNC_CDECL;
3319− break;
3320− case TOK_STDCALL1:
3321− case TOK_STDCALL2:
3322− case TOK_STDCALL3:
3323− FUNC_CALL(ad->func_attr) = FUNC_STDCALL;
3324− break;
3325−#ifdef TCC_TARGET_I386
3326− case TOK_REGPARM1:
3327− case TOK_REGPARM2:
3328− skip('(');
3329− n = expr_const();
3330− if (n > 3)
3331− n = 3;
3332− else if (n < 0)
3333− n = 0;
3334− if (n > 0)
3335− FUNC_CALL(ad->func_attr) = FUNC_FASTCALL1 + n - 1;
3336− skip(')');
3337− break;
3338− case TOK_FASTCALL1:
3339− case TOK_FASTCALL2:
3340− case TOK_FASTCALL3:
3341− FUNC_CALL(ad->func_attr) = FUNC_FASTCALLW;
3342− break;
3343−#endif
3344− case TOK_DLLEXPORT:
3345− FUNC_EXPORT(ad->func_attr) = 1;
3346− break;
3347− default:
3348− if (tcc_state->warn_unsupported)
3349− warning("'%s' attribute ignored", get_tok_str(t, NULL));
3350− /* skip parameters */
3351− if (tok == '(') {
3352− int parenthesis = 0;
3353− do {
3354− if (tok == '(')
3355− parenthesis++;
3356− else if (tok == ')')
3357− parenthesis--;
3358− next();
3359− } while (parenthesis && tok != -1);
3360− }
3361− break;
3362− }
3363− if (tok != ',')
3364− break;
3365− next();
3366− }
3367− skip(')');
3368− skip(')');
3369− }
3370−}
3371−
3372−/* enum/struct/union declaration. u is either VT_ENUM or VT_STRUCT */
3373−static void struct_decl(CType *type, int u)
3374−{
3375− int a, v, size, align, maxalign, c, offset;
3376− int bit_size, bit_pos, bsize, bt, lbit_pos, prevbt;
3377− Sym *s, *ss, *ass, **ps;
3378− AttributeDef ad;
3379− CType type1, btype;
3380−
3381− a = tok; /* save decl type */
3382− next();
3383− if (tok != '{') {
3384− v = tok;
3385− next();
3386− /* struct already defined ? return it */
3387− if (v < TOK_IDENT)
3388− expect("struct/union/enum name");
3389− s = struct_find(v);
3390− if (s) {
3391− if (s->type.t != a)
3392− error("invalid type");
3393− goto do_decl;
3394− }
3395− } else {
3396− v = anon_sym++;
3397− }
3398− type1.t = a;
3399− /* we put an undefined size for struct/union */
3400− s = sym_push(v | SYM_STRUCT, &type1, 0, -1);
3401− s->r = 0; /* default alignment is zero as gcc */
3402− /* put struct/union/enum name in type */
3403− do_decl:
3404− type->t = u;
3405− type->ref = s;
3406−
3407− if (tok == '{') {
3408− next();
3409− if (s->c != -1)
3410− error("struct/union/enum already defined");
3411− /* cannot be empty */
3412− c = 0;
3413− /* non empty enums are not allowed */
3414− if (a == TOK_ENUM) {
3415− for(;;) {
3416− v = tok;
3417− if (v < TOK_UIDENT)
3418− expect("identifier");
3419− next();
3420− if (tok == '=') {
3421− next();
3422− c = expr_const();
3423− }
3424− /* enum symbols have static storage */
3425− ss = sym_push(v, &int_type, VT_CONST, c);
3426− ss->type.t |= VT_STATIC;
3427− if (tok != ',')
3428− break;
3429− next();
3430− c++;
3431− /* NOTE: we accept a trailing comma */
3432− if (tok == '}')
3433− break;
3434− }
3435− skip('}');
3436− } else {
3437− maxalign = 1;
3438− ps = &s->next;
3439− prevbt = VT_INT;
3440− bit_pos = 0;
3441− offset = 0;
3442− while (tok != '}') {
3443− parse_btype(&btype, &ad);
3444− while (1) {
3445− bit_size = -1;
3446− v = 0;
3447− type1 = btype;
3448− if (tok != ':') {
3449− type_decl(&type1, &ad, &v, TYPE_DIRECT | TYPE_ABSTRACT);
3450− if (v == 0 && (type1.t & VT_BTYPE) != VT_STRUCT)
3451− expect("identifier");
3452− if ((type1.t & VT_BTYPE) == VT_FUNC ||
3453− (type1.t & (VT_TYPEDEF | VT_STATIC | VT_EXTERN | VT_INLINE)))
3454− error("invalid type for '%s'",
3455− get_tok_str(v, NULL));
3456− }
3457− if (tok == ':') {
3458− next();
3459− bit_size = expr_const();
3460− /* XXX: handle v = 0 case for messages */
3461− if (bit_size < 0)
3462− error("negative width in bit-field '%s'",
3463− get_tok_str(v, NULL));
3464− if (v && bit_size == 0)
3465− error("zero width for bit-field '%s'",
3466− get_tok_str(v, NULL));
3467− }
3468− size = type_size(&type1, &align);
3469− if (ad.aligned) {
3470− if (align < ad.aligned)
3471− align = ad.aligned;
3472− } else if (ad.packed) {
3473− align = 1;
3474− } else if (*tcc_state->pack_stack_ptr) {
3475− if (align > *tcc_state->pack_stack_ptr)
3476− align = *tcc_state->pack_stack_ptr;
3477− }
3478− lbit_pos = 0;
3479− if (bit_size >= 0) {
3480− bt = type1.t & VT_BTYPE;
3481− if (bt != VT_INT &&
3482− bt != VT_BYTE &&
3483− bt != VT_SHORT &&
3484− bt != VT_BOOL &&
3485− bt != VT_ENUM &&
3486− bt != VT_LLONG)
3487− error("bitfields must have scalar type");
3488− bsize = size * 8;
3489− if (bit_size > bsize) {
3490− error("width of '%s' exceeds its type",
3491− get_tok_str(v, NULL));
3492− } else if (bit_size == bsize) {
3493− /* no need for bit fields */
3494− bit_pos = 0;
3495− } else if (bit_size == 0) {
3496− /* XXX: what to do if only padding in a
3497− structure ? */
3498− /* zero size: means to pad */
3499− bit_pos = 0;
3500− } else {
3501− /* we do not have enough room ?
3502− did the type change?
3503− is it a union? */
3504− if ((bit_pos + bit_size) > bsize ||
3505− bt != prevbt || a == TOK_UNION)
3506− bit_pos = 0;
3507− lbit_pos = bit_pos;
3508− /* XXX: handle LSB first */
3509− type1.t |= VT_BITFIELD |
3510− (bit_pos << VT_STRUCT_SHIFT) |
3511− (bit_size << (VT_STRUCT_SHIFT + 6));
3512− bit_pos += bit_size;
3513− }
3514− prevbt = bt;
3515− } else {
3516− bit_pos = 0;
3517− }
3518− if (v != 0 || (type1.t & VT_BTYPE) == VT_STRUCT) {
3519− /* add new memory data only if starting
3520− bit field */
3521− if (lbit_pos == 0) {
3522− if (a == TOK_STRUCT) {
3523− c = (c + align - 1) & -align;
3524− offset = c;
3525− if (size > 0)
3526− c += size;
3527− } else {
3528− offset = 0;
3529− if (size > c)
3530− c = size;
3531− }
3532− if (align > maxalign)
3533− maxalign = align;
3534− }
3535−#if 0
3536− printf("add field %s offset=%d",
3537− get_tok_str(v, NULL), offset);
3538− if (type1.t & VT_BITFIELD) {
3539− printf(" pos=%d size=%d",
3540− (type1.t >> VT_STRUCT_SHIFT) & 0x3f,
3541− (type1.t >> (VT_STRUCT_SHIFT + 6)) & 0x3f);
3542− }
3543− printf("\n");
3544−#endif
3545− }
3546− if (v == 0 && (type1.t & VT_BTYPE) == VT_STRUCT) {
3547− ass = type1.ref;
3548− while ((ass = ass->next) != NULL) {
3549− ss = sym_push(ass->v, &ass->type, 0, offset + ass->c);
3550− *ps = ss;
3551− ps = &ss->next;
3552− }
3553− } else if (v) {
3554− ss = sym_push(v | SYM_FIELD, &type1, 0, offset);
3555− *ps = ss;
3556− ps = &ss->next;
3557− }
3558− if (tok == ';' || tok == TOK_EOF)
3559− break;
3560− skip(',');
3561− }
3562− skip(';');
3563− }
3564− skip('}');
3565− /* store size and alignment */
3566− s->c = (c + maxalign - 1) & -maxalign;
3567− s->r = maxalign;
3568− }
3569− }
3570−}
3571−
3572−/* return 0 if no type declaration. otherwise, return the basic type
3573− and skip it.
3574− */
3575−static int parse_btype(CType *type, AttributeDef *ad)
3576−{
3577− int t, u, type_found, typespec_found, typedef_found;
3578− Sym *s;
3579− CType type1;
3580−
3581− memset(ad, 0, sizeof(AttributeDef));
3582− type_found = 0;
3583− typespec_found = 0;
3584− typedef_found = 0;
3585− t = 0;
3586− while(1) {
3587− switch(tok) {
3588− case TOK_EXTENSION:
3589− /* currently, we really ignore extension */
3590− next();
3591− continue;
3592−
3593− /* basic types */
3594− case TOK_CHAR:
3595− u = VT_BYTE;
3596− basic_type:
3597− next();
3598− basic_type1:
3599− if ((t & VT_BTYPE) != 0)
3600− error("too many basic types");
3601− t |= u;
3602− typespec_found = 1;
3603− break;
3604− case TOK_VOID:
3605− u = VT_VOID;
3606− goto basic_type;
3607− case TOK_SHORT:
3608− u = VT_SHORT;
3609− goto basic_type;
3610− case TOK_INT:
3611− next();
3612− typespec_found = 1;
3613− break;
3614− case TOK_LONG:
3615− next();
3616− if ((t & VT_BTYPE) == VT_DOUBLE) {
3617− t = (t & ~VT_BTYPE) | VT_LDOUBLE;
3618− } else if ((t & VT_BTYPE) == VT_LONG) {
3619− t = (t & ~VT_BTYPE) | VT_LLONG;
3620− } else {
3621− u = VT_LONG;
3622− goto basic_type1;
3623− }
3624− break;
3625− case TOK_BOOL:
3626− u = VT_BOOL;
3627− goto basic_type;
3628− case TOK_FLOAT:
3629− u = VT_FLOAT;
3630− goto basic_type;
3631− case TOK_DOUBLE:
3632− next();
3633− if ((t & VT_BTYPE) == VT_LONG) {
3634− t = (t & ~VT_BTYPE) | VT_LDOUBLE;
3635− } else {
3636− u = VT_DOUBLE;
3637− goto basic_type1;
3638− }
3639− break;
3640− case TOK_ENUM:
3641− struct_decl(&type1, VT_ENUM);
3642− basic_type2:
3643− u = type1.t;
3644− type->ref = type1.ref;
3645− goto basic_type1;
3646− case TOK_STRUCT:
3647− case TOK_UNION:
3648− struct_decl(&type1, VT_STRUCT);
3649− goto basic_type2;
3650−
3651− /* type modifiers */
3652− case TOK_CONST1:
3653− case TOK_CONST2:
3654− case TOK_CONST3:
3655− t |= VT_CONSTANT;
3656− next();
3657− break;
3658− case TOK_VOLATILE1:
3659− case TOK_VOLATILE2:
3660− case TOK_VOLATILE3:
3661− t |= VT_VOLATILE;
3662− next();
3663− break;
3664− case TOK_SIGNED1:
3665− case TOK_SIGNED2:
3666− case TOK_SIGNED3:
3667− typespec_found = 1;
3668− t |= VT_SIGNED;
3669− next();
3670− break;
3671− case TOK_REGISTER:
3672− case TOK_AUTO:
3673− case TOK_RESTRICT1:
3674− case TOK_RESTRICT2:
3675− case TOK_RESTRICT3:
3676− next();
3677− break;
3678− case TOK_UNSIGNED:
3679− t |= VT_UNSIGNED;
3680− next();
3681− typespec_found = 1;
3682− break;
3683−
3684− /* storage */
3685− case TOK_EXTERN:
3686− t |= VT_EXTERN;
3687− next();
3688− break;
3689− case TOK_STATIC:
3690− t |= VT_STATIC;
3691− next();
3692− break;
3693− case TOK_TYPEDEF:
3694− t |= VT_TYPEDEF;
3695− next();
3696− break;
3697− case TOK_INLINE1:
3698− case TOK_INLINE2:
3699− case TOK_INLINE3:
3700− t |= VT_INLINE;
3701− next();
3702− break;
3703−
3704− /* GNUC attribute */
3705− case TOK_ATTRIBUTE1:
3706− case TOK_ATTRIBUTE2:
3707− parse_attribute(ad);
3708− break;
3709− /* GNUC typeof */
3710− case TOK_TYPEOF1:
3711− case TOK_TYPEOF2:
3712− case TOK_TYPEOF3:
3713− next();
3714− parse_expr_type(&type1);
3715− goto basic_type2;
3716− default:
3717− if (typespec_found || typedef_found)
3718− goto the_end;
3719− s = sym_find(tok);
3720− if (!s || !(s->type.t & VT_TYPEDEF))
3721− goto the_end;
3722− typedef_found = 1;
3723− t |= (s->type.t & ~VT_TYPEDEF);
3724− type->ref = s->type.ref;
3725− next();
3726− typespec_found = 1;
3727− break;
3728− }
3729− type_found = 1;
3730− }
3731−the_end:
3732− if ((t & (VT_SIGNED|VT_UNSIGNED)) == (VT_SIGNED|VT_UNSIGNED))
3733− error("signed and unsigned modifier");
3734− if (tcc_state->char_is_unsigned) {
3735− if ((t & (VT_SIGNED|VT_UNSIGNED|VT_BTYPE)) == VT_BYTE)
3736− t |= VT_UNSIGNED;
3737− }
3738− t &= ~VT_SIGNED;
3739−
3740− /* long is never used as type */
3741− if ((t & VT_BTYPE) == VT_LONG)
3742−#ifndef TCC_TARGET_X86_64
3743− t = (t & ~VT_BTYPE) | VT_INT;
3744−#else
3745− t = (t & ~VT_BTYPE) | VT_LLONG;
3746−#endif
3747− type->t = t;
3748− return type_found;
3749−}
3750−
3751−/* convert a function parameter type (array to pointer and function to
3752− function pointer) */
3753−static inline void convert_parameter_type(CType *pt)
3754−{
3755− /* remove const and volatile qualifiers (XXX: const could be used
3756− to indicate a const function parameter */
3757− pt->t &= ~(VT_CONSTANT | VT_VOLATILE);
3758− /* array must be transformed to pointer according to ANSI C */
3759− pt->t &= ~VT_ARRAY;
3760− if ((pt->t & VT_BTYPE) == VT_FUNC) {
3761− mk_pointer(pt);
3762− }
3763−}
3764−
3765−static void post_type(CType *type, AttributeDef *ad)
3766−{
3767− int n, l, t1, arg_size, align;
3768− Sym **plast, *s, *first;
3769− AttributeDef ad1;
3770− CType pt;
3771−
3772− if (tok == '(') {
3773− /* function declaration */
3774− next();
3775− l = 0;
3776− first = NULL;
3777− plast = &first;
3778− arg_size = 0;
3779− if (tok != ')') {
3780− for(;;) {
3781− /* read param name and compute offset */
3782− if (l != FUNC_OLD) {
3783− if (!parse_btype(&pt, &ad1)) {
3784− if (l) {
3785− error("invalid type");
3786− } else {
3787− l = FUNC_OLD;
3788− goto old_proto;
3789− }
3790− }
3791− l = FUNC_NEW;
3792− if ((pt.t & VT_BTYPE) == VT_VOID && tok == ')')
3793− break;
3794− type_decl(&pt, &ad1, &n, TYPE_DIRECT | TYPE_ABSTRACT);
3795− if ((pt.t & VT_BTYPE) == VT_VOID)
3796− error("parameter declared as void");
3797− arg_size += (type_size(&pt, &align) + 3) & ~3;
3798− } else {
3799− old_proto:
3800− n = tok;
3801− if (n < TOK_UIDENT)
3802− expect("identifier");
3803− pt.t = VT_INT;
3804− next();
3805− }
3806− convert_parameter_type(&pt);
3807− s = sym_push(n | SYM_FIELD, &pt, 0, 0);
3808− *plast = s;
3809− plast = &s->next;
3810− if (tok == ')')
3811− break;
3812− skip(',');
3813− if (l == FUNC_NEW && tok == TOK_DOTS) {
3814− l = FUNC_ELLIPSIS;
3815− next();
3816− break;
3817− }
3818− }
3819− }
3820− /* if no parameters, then old type prototype */
3821− if (l == 0)
3822− l = FUNC_OLD;
3823− skip(')');
3824− t1 = type->t & VT_STORAGE;
3825− /* NOTE: const is ignored in returned type as it has a special
3826− meaning in gcc / C++ */
3827− type->t &= ~(VT_STORAGE | VT_CONSTANT);
3828− post_type(type, ad);
3829− /* we push a anonymous symbol which will contain the function prototype */
3830− FUNC_ARGS(ad->func_attr) = arg_size;
3831− s = sym_push(SYM_FIELD, type, ad->func_attr, l);
3832− s->next = first;
3833− type->t = t1 | VT_FUNC;
3834− type->ref = s;
3835− } else if (tok == '[') {
3836− /* array definition */
3837− next();
3838− if (tok == TOK_RESTRICT1)
3839− next();
3840− n = -1;
3841− if (tok != ']') {
3842− n = expr_const();
3843− if (n < 0)
3844− error("invalid array size");
3845− }
3846− skip(']');
3847− /* parse next post type */
3848− t1 = type->t & VT_STORAGE;
3849− type->t &= ~VT_STORAGE;
3850− post_type(type, ad);
3851−
3852− /* we push a anonymous symbol which will contain the array
3853− element type */
3854− s = sym_push(SYM_FIELD, type, 0, n);
3855− type->t = t1 | VT_ARRAY | VT_PTR;
3856− type->ref = s;
3857− }
3858−}
3859−
3860−/* Parse a type declaration (except basic type), and return the type
3861− in 'type'. 'td' is a bitmask indicating which kind of type decl is
3862− expected. 'type' should contain the basic type. 'ad' is the
3863− attribute definition of the basic type. It can be modified by
3864− type_decl().
3865− */
3866−static void type_decl(CType *type, AttributeDef *ad, int *v, int td)
3867−{
3868− Sym *s;
3869− CType type1, *type2;
3870− int qualifiers;
3871−
3872− while (tok == '*') {
3873− qualifiers = 0;
3874− redo:
3875− next();
3876− switch(tok) {
3877− case TOK_CONST1:
3878− case TOK_CONST2:
3879− case TOK_CONST3:
3880− qualifiers |= VT_CONSTANT;
3881− goto redo;
3882− case TOK_VOLATILE1:
3883− case TOK_VOLATILE2:
3884− case TOK_VOLATILE3:
3885− qualifiers |= VT_VOLATILE;
3886− goto redo;
3887− case TOK_RESTRICT1:
3888− case TOK_RESTRICT2:
3889− case TOK_RESTRICT3:
3890− goto redo;
3891− }
3892− mk_pointer(type);
3893− type->t |= qualifiers;
3894− }
3895−
3896− /* XXX: clarify attribute handling */
3897− if (tok == TOK_ATTRIBUTE1 || tok == TOK_ATTRIBUTE2)
3898− parse_attribute(ad);
3899−
3900− /* recursive type */
3901− /* XXX: incorrect if abstract type for functions (e.g. 'int ()') */
3902− type1.t = 0; /* XXX: same as int */
3903− if (tok == '(') {
3904− next();
3905− /* XXX: this is not correct to modify 'ad' at this point, but
3906− the syntax is not clear */
3907− if (tok == TOK_ATTRIBUTE1 || tok == TOK_ATTRIBUTE2)
3908− parse_attribute(ad);
3909− type_decl(&type1, ad, v, td);
3910− skip(')');
3911− } else {
3912− /* type identifier */
3913− if (tok >= TOK_IDENT && (td & TYPE_DIRECT)) {
3914− *v = tok;
3915− next();
3916− } else {
3917− if (!(td & TYPE_ABSTRACT))
3918− expect("identifier");
3919− *v = 0;
3920− }
3921− }
3922− post_type(type, ad);
3923− if (tok == TOK_ATTRIBUTE1 || tok == TOK_ATTRIBUTE2)
3924− parse_attribute(ad);
3925− if (!type1.t)
3926− return;
3927− /* append type at the end of type1 */
3928− type2 = &type1;
3929− for(;;) {
3930− s = type2->ref;
3931− type2 = &s->type;
3932− if (!type2->t) {
3933− *type2 = *type;
3934− break;
3935− }
3936− }
3937− *type = type1;
3938−}
3939−
3940−/* compute the lvalue VT_LVAL_xxx needed to match type t. */
3941−static int lvalue_type(int t)
3942−{
3943− int bt, r;
3944− r = VT_LVAL;
3945− bt = t & VT_BTYPE;
3946− if (bt == VT_BYTE || bt == VT_BOOL)
3947− r |= VT_LVAL_BYTE;
3948− else if (bt == VT_SHORT)
3949− r |= VT_LVAL_SHORT;
3950− else
3951− return r;
3952− if (t & VT_UNSIGNED)
3953− r |= VT_LVAL_UNSIGNED;
3954− return r;
3955−}
3956−
3957−/* indirection with full error checking and bound check */
3958−static void indir(void)
3959−{
3960− if ((vtop->type.t & VT_BTYPE) != VT_PTR) {
3961− if ((vtop->type.t & VT_BTYPE) == VT_FUNC)
3962− return;
3963− expect("pointer");
3964− }
3965− if ((vtop->r & VT_LVAL) && !nocode_wanted)
3966− gv(RC_INT);
3967− vtop->type = *pointed_type(&vtop->type);
3968− /* Arrays and functions are never lvalues */
3969− if (!(vtop->type.t & VT_ARRAY)
3970− && (vtop->type.t & VT_BTYPE) != VT_FUNC) {
3971− vtop->r |= lvalue_type(vtop->type.t);
3972− /* if bound checking, the referenced pointer must be checked */
3973− if (do_bounds_check)
3974− vtop->r |= VT_MUSTBOUND;
3975− }
3976−}
3977−
3978−/* pass a parameter to a function and do type checking and casting */
3979−static void gfunc_param_typed(Sym *func, Sym *arg)
3980−{
3981− int func_type;
3982− CType type;
3983−
3984− func_type = func->c;
3985− if (func_type == FUNC_OLD ||
3986− (func_type == FUNC_ELLIPSIS && arg == NULL)) {
3987− /* default casting : only need to convert float to double */
3988− if ((vtop->type.t & VT_BTYPE) == VT_FLOAT) {
3989− type.t = VT_DOUBLE;
3990− gen_cast(&type);
3991− }
3992− } else if (arg == NULL) {
3993− error("too many arguments to function");
3994− } else {
3995− type = arg->type;
3996− type.t &= ~VT_CONSTANT; /* need to do that to avoid false warning */
3997− gen_assign_cast(&type);
3998− }
3999−}
4000−
4001−/* parse an expression of the form '(type)' or '(expr)' and return its
4002− type */
4003−static void parse_expr_type(CType *type)
4004−{
4005− int n;
4006− AttributeDef ad;
4007−
4008− skip('(');
4009− if (parse_btype(type, &ad)) {
4010− type_decl(type, &ad, &n, TYPE_ABSTRACT);
4011− } else {
4012− expr_type(type);
4013− }
4014− skip(')');
4015−}
4016−
4017−static void parse_type(CType *type)
4018−{
4019− AttributeDef ad;
4020− int n;
4021−
4022− if (!parse_btype(type, &ad)) {
4023− expect("type");
4024− }
4025− type_decl(type, &ad, &n, TYPE_ABSTRACT);
4026−}
4027−
4028−static void vpush_tokc(int t)
4029−{
4030− CType type;
4031− type.t = t;
4032− vsetc(&type, VT_CONST, &tokc);
4033−}
4034−
4035−static void unary(void)
4036−{
4037− int n, t, align, size, r;
4038− CType type;
4039− Sym *s;
4040− AttributeDef ad;
4041−
4042− /* XXX: GCC 2.95.3 does not generate a table although it should be
4043− better here */
4044− tok_next:
4045− switch(tok) {
4046− case TOK_EXTENSION:
4047− next();
4048− goto tok_next;
4049− case TOK_CINT:
4050− case TOK_CCHAR:
4051− case TOK_LCHAR:
4052− vpushi(tokc.i);
4053− next();
4054− break;
4055− case TOK_CUINT:
4056− vpush_tokc(VT_INT | VT_UNSIGNED);
4057− next();
4058− break;
4059− case TOK_CLLONG:
4060− vpush_tokc(VT_LLONG);
4061− next();
4062− break;
4063− case TOK_CULLONG:
4064− vpush_tokc(VT_LLONG | VT_UNSIGNED);
4065− next();
4066− break;
4067− case TOK_CFLOAT:
4068− vpush_tokc(VT_FLOAT);
4069− next();
4070− break;
4071− case TOK_CDOUBLE:
4072− vpush_tokc(VT_DOUBLE);
4073− next();
4074− break;
4075− case TOK_CLDOUBLE:
4076− vpush_tokc(VT_LDOUBLE);
4077− next();
4078− break;
4079− case TOK___FUNCTION__:
4080− if (!gnu_ext)
4081− goto tok_identifier;
4082− /* fall thru */
4083− case TOK___FUNC__:
4084− {
4085− void *ptr;
4086− int len;
4087− /* special function name identifier */
4088− len = strlen(funcname) + 1;
4089− /* generate char[len] type */
4090− type.t = VT_BYTE;
4091− mk_pointer(&type);
4092− type.t |= VT_ARRAY;
4093− type.ref->c = len;
4094− vpush_ref(&type, data_section, data_section->data_offset, len);
4095− ptr = section_ptr_add(data_section, len);
4096− memcpy(ptr, funcname, len);
4097− next();
4098− }
4099− break;
4100− case TOK_LSTR:
4101−#ifdef TCC_TARGET_PE
4102− t = VT_SHORT | VT_UNSIGNED;
4103−#else
4104− t = VT_INT;
4105−#endif
4106− goto str_init;
4107− case TOK_STR:
4108− /* string parsing */
4109− t = VT_BYTE;
4110− str_init:
4111− if (tcc_state->warn_write_strings)
4112− t |= VT_CONSTANT;
4113− type.t = t;
4114− mk_pointer(&type);
4115− type.t |= VT_ARRAY;
4116− memset(&ad, 0, sizeof(AttributeDef));
4117− decl_initializer_alloc(&type, &ad, VT_CONST, 2, 0, 0);
4118− break;
4119− case '(':
4120− next();
4121− /* cast ? */
4122− if (parse_btype(&type, &ad)) {
4123− type_decl(&type, &ad, &n, TYPE_ABSTRACT);
4124− skip(')');
4125− /* check ISOC99 compound literal */
4126− if (tok == '{') {
4127− /* data is allocated locally by default */
4128− if (global_expr)
4129− r = VT_CONST;
4130− else
4131− r = VT_LOCAL;
4132− /* all except arrays are lvalues */
4133− if (!(type.t & VT_ARRAY))
4134− r |= lvalue_type(type.t);
4135− memset(&ad, 0, sizeof(AttributeDef));
4136− decl_initializer_alloc(&type, &ad, r, 1, 0, 0);
4137− } else {
4138− unary();
4139− gen_cast(&type);
4140− }
4141− } else if (tok == '{') {
4142− /* save all registers */
4143− save_regs(0);
4144− /* statement expression : we do not accept break/continue
4145− inside as GCC does */
4146− block(NULL, NULL, NULL, NULL, 0, 1);
4147− skip(')');
4148− } else {
4149− gexpr();
4150− skip(')');
4151− }
4152− break;
4153− case '*':
4154− next();
4155− unary();
4156− indir();
4157− break;
4158− case '&':
4159− next();
4160− unary();
4161− /* functions names must be treated as function pointers,
4162− except for unary '&' and sizeof. Since we consider that
4163− functions are not lvalues, we only have to handle it
4164− there and in function calls. */
4165− /* arrays can also be used although they are not lvalues */
4166− if ((vtop->type.t & VT_BTYPE) != VT_FUNC &&
4167− !(vtop->type.t & VT_ARRAY) && !(vtop->type.t & VT_LLOCAL))
4168− test_lvalue();
4169− mk_pointer(&vtop->type);
4170− gaddrof();
4171− break;
4172− case '!':
4173− next();
4174− unary();
4175− if ((vtop->r & (VT_VALMASK | VT_LVAL | VT_SYM)) == VT_CONST) {
4176− CType boolean;
4177− boolean.t = VT_BOOL;
4178− gen_cast(&boolean);
4179− vtop->c.i = !vtop->c.i;
4180− } else if ((vtop->r & VT_VALMASK) == VT_CMP)
4181− vtop->c.i = vtop->c.i ^ 1;
4182− else {
4183− save_regs(1);
4184− vseti(VT_JMP, gtst(1, 0));
4185− }
4186− break;
4187− case '~':
4188− next();
4189− unary();
4190− vpushi(-1);
4191− gen_op('^');
4192− break;
4193− case '+':
4194− next();
4195− /* in order to force cast, we add zero */
4196− unary();
4197− if ((vtop->type.t & VT_BTYPE) == VT_PTR)
4198− error("pointer not accepted for unary plus");
4199− vpushi(0);
4200− gen_op('+');
4201− break;
4202− case TOK_SIZEOF:
4203− case TOK_ALIGNOF1:
4204− case TOK_ALIGNOF2:
4205− t = tok;
4206− next();
4207− if (tok == '(') {
4208− parse_expr_type(&type);
4209− } else {
4210− unary_type(&type);
4211− }
4212− size = type_size(&type, &align);
4213− if (t == TOK_SIZEOF) {
4214− if (size < 0)
4215− error("sizeof applied to an incomplete type");
4216− vpushi(size);
4217− } else {
4218− vpushi(align);
4219− }
4220− vtop->type.t |= VT_UNSIGNED;
4221− break;
4222−
4223− case TOK_builtin_types_compatible_p:
4224− {
4225− CType type1, type2;
4226− next();
4227− skip('(');
4228− parse_type(&type1);
4229− skip(',');
4230− parse_type(&type2);
4231− skip(')');
4232− type1.t &= ~(VT_CONSTANT | VT_VOLATILE);
4233− type2.t &= ~(VT_CONSTANT | VT_VOLATILE);
4234− vpushi(is_compatible_types(&type1, &type2));
4235− }
4236− break;
4237− case TOK_builtin_constant_p:
4238− {
4239− int saved_nocode_wanted, res;
4240− next();
4241− skip('(');
4242− saved_nocode_wanted = nocode_wanted;
4243− nocode_wanted = 1;
4244− gexpr();
4245− res = (vtop->r & (VT_VALMASK | VT_LVAL | VT_SYM)) == VT_CONST;
4246− vpop();
4247− nocode_wanted = saved_nocode_wanted;
4248− skip(')');
4249− vpushi(res);
4250− }
4251− break;
4252− case TOK_builtin_frame_address:
4253− {
4254− CType type;
4255− next();
4256− skip('(');
4257− if (tok != TOK_CINT) {
4258− error("__builtin_frame_address only takes integers");
4259− }
4260− if (tokc.i != 0) {
4261− error("TCC only supports __builtin_frame_address(0)");
4262− }
4263− next();
4264− skip(')');
4265− type.t = VT_VOID;
4266− mk_pointer(&type);
4267− vset(&type, VT_LOCAL, 0);
4268− }
4269− break;
4270−#ifdef TCC_TARGET_X86_64
4271− case TOK_builtin_malloc:
4272− tok = TOK_malloc;
4273− goto tok_identifier;
4274− case TOK_builtin_free:
4275− tok = TOK_free;
4276− goto tok_identifier;
4277−#endif
4278− case TOK_INC:
4279− case TOK_DEC:
4280− t = tok;
4281− next();
4282− unary();
4283− inc(0, t);
4284− break;
4285− case '-':
4286− next();
4287− vpushi(0);
4288− unary();
4289− gen_op('-');
4290− break;
4291− case TOK_LAND:
4292− if (!gnu_ext)
4293− goto tok_identifier;
4294− next();
4295− /* allow to take the address of a label */
4296− if (tok < TOK_UIDENT)
4297− expect("label identifier");
4298− s = label_find(tok);
4299− if (!s) {
4300− s = label_push(&global_label_stack, tok, LABEL_FORWARD);
4301− } else {
4302− if (s->r == LABEL_DECLARED)
4303− s->r = LABEL_FORWARD;
4304− }
4305− if (!s->type.t) {
4306− s->type.t = VT_VOID;
4307− mk_pointer(&s->type);
4308− s->type.t |= VT_STATIC;
4309− }
4310− vset(&s->type, VT_CONST | VT_SYM, 0);
4311− vtop->sym = s;
4312− next();
4313− break;
4314− default:
4315− tok_identifier:
4316− t = tok;
4317− next();
4318− if (t < TOK_UIDENT)
4319− expect("identifier");
4320− s = sym_find(t);
4321− if (!s) {
4322− if (tok != '(')
4323− error("'%s' undeclared", get_tok_str(t, NULL));
4324− /* for simple function calls, we tolerate undeclared
4325− external reference to int() function */
4326− if (tcc_state->warn_implicit_function_declaration)
4327− warning("implicit declaration of function '%s'",
4328− get_tok_str(t, NULL));
4329− s = external_global_sym(t, &func_old_type, 0);
4330− }
4331− if ((s->type.t & (VT_STATIC | VT_INLINE | VT_BTYPE)) ==
4332− (VT_STATIC | VT_INLINE | VT_FUNC)) {
4333− /* if referencing an inline function, then we generate a
4334− symbol to it if not already done. It will have the
4335− effect to generate code for it at the end of the
4336− compilation unit. Inline function as always
4337− generated in the text section. */
4338− if (!s->c)
4339− put_extern_sym(s, text_section, 0, 0);
4340− r = VT_SYM | VT_CONST;
4341− } else {
4342− r = s->r;
4343− }
4344− vset(&s->type, r, s->c);
4345− /* if forward reference, we must point to s */
4346− if (vtop->r & VT_SYM) {
4347− vtop->sym = s;
4348− vtop->c.ul = 0;
4349− }
4350− break;
4351− }
4352−
4353− /* post operations */
4354− while (1) {
4355− if (tok == TOK_INC || tok == TOK_DEC) {
4356− inc(1, tok);
4357− next();
4358− } else if (tok == '.' || tok == TOK_ARROW) {
4359− /* field */
4360− if (tok == TOK_ARROW)
4361− indir();
4362− test_lvalue();
4363− gaddrof();
4364− next();
4365− /* expect pointer on structure */
4366− if ((vtop->type.t & VT_BTYPE) != VT_STRUCT)
4367− expect("struct or union");
4368− s = vtop->type.ref;
4369− /* find field */
4370− tok |= SYM_FIELD;
4371− while ((s = s->next) != NULL) {
4372− if (s->v == tok)
4373− break;
4374− }
4375− if (!s)
4376− error("field not found: %s", get_tok_str(tok & ~SYM_FIELD, NULL));
4377− /* add field offset to pointer */
4378− vtop->type = char_pointer_type; /* change type to 'char *' */
4379− vpushi(s->c);
4380− gen_op('+');
4381− /* change type to field type, and set to lvalue */
4382− vtop->type = s->type;
4383− /* an array is never an lvalue */
4384− if (!(vtop->type.t & VT_ARRAY)) {
4385− vtop->r |= lvalue_type(vtop->type.t);
4386− /* if bound checking, the referenced pointer must be checked */
4387− if (do_bounds_check)
4388− vtop->r |= VT_MUSTBOUND;
4389− }
4390− next();
4391− } else if (tok == '[') {
4392− next();
4393− gexpr();
4394− gen_op('+');
4395− indir();
4396− skip(']');
4397− } else if (tok == '(') {
4398− SValue ret;
4399− Sym *sa;
4400− int nb_args;
4401−
4402− /* function call */
4403− if ((vtop->type.t & VT_BTYPE) != VT_FUNC) {
4404− /* pointer test (no array accepted) */
4405− if ((vtop->type.t & (VT_BTYPE | VT_ARRAY)) == VT_PTR) {
4406− vtop->type = *pointed_type(&vtop->type);
4407− if ((vtop->type.t & VT_BTYPE) != VT_FUNC)
4408− goto error_func;
4409− } else {
4410− error_func:
4411− expect("function pointer");
4412− }
4413− } else {
4414− vtop->r &= ~VT_LVAL; /* no lvalue */
4415− }
4416− /* get return type */
4417− s = vtop->type.ref;
4418− next();
4419− sa = s->next; /* first parameter */
4420− nb_args = 0;
4421− ret.r2 = VT_CONST;
4422− /* compute first implicit argument if a structure is returned */
4423− if ((s->type.t & VT_BTYPE) == VT_STRUCT) {
4424− /* get some space for the returned structure */
4425− size = type_size(&s->type, &align);
4426− loc = (loc - size) & -align;
4427− ret.type = s->type;
4428− ret.r = VT_LOCAL | VT_LVAL;
4429− /* pass it as 'int' to avoid structure arg passing
4430− problems */
4431− vseti(VT_LOCAL, loc);
4432− ret.c = vtop->c;
4433− nb_args++;
4434− } else {
4435− ret.type = s->type;
4436− /* return in register */
4437− if (is_float(ret.type.t)) {
4438− ret.r = reg_fret(ret.type.t);
4439− } else {
4440− if ((ret.type.t & VT_BTYPE) == VT_LLONG)
4441− ret.r2 = REG_LRET;
4442− ret.r = REG_IRET;
4443− }
4444− ret.c.i = 0;
4445− }
4446− if (tok != ')') {
4447− for(;;) {
4448− expr_eq();
4449− gfunc_param_typed(s, sa);
4450− nb_args++;
4451− if (sa)
4452− sa = sa->next;
4453− if (tok == ')')
4454− break;
4455− skip(',');
4456− }
4457− }
4458− if (sa)
4459− error("too few arguments to function");
4460− skip(')');
4461− if (!nocode_wanted) {
4462− gfunc_call(nb_args);
4463− } else {
4464− vtop -= (nb_args + 1);
4465− }
4466− /* return value */
4467− vsetc(&ret.type, ret.r, &ret.c);
4468− vtop->r2 = ret.r2;
4469− } else {
4470− break;
4471− }
4472− }
4473−}
4474−
4475−static void uneq(void)
4476−{
4477− int t;
4478−
4479− unary();
4480− if (tok == '=' ||
4481− (tok >= TOK_A_MOD && tok <= TOK_A_DIV) ||
4482− tok == TOK_A_XOR || tok == TOK_A_OR ||
4483− tok == TOK_A_SHL || tok == TOK_A_SAR) {
4484− test_lvalue();
4485− t = tok;
4486− next();
4487− if (t == '=') {
4488− expr_eq();
4489− } else {
4490− vdup();
4491− expr_eq();
4492− gen_op(t & 0x7f);
4493− }
4494− vstore();
4495− }
4496−}
4497−
4498−static void expr_prod(void)
4499−{
4500− int t;
4501−
4502− uneq();
4503− while (tok == '*' || tok == '/' || tok == '%') {
4504− t = tok;
4505− next();
4506− uneq();
4507− gen_op(t);
4508− }
4509−}
4510−
4511−static void expr_sum(void)
4512−{
4513− int t;
4514−
4515− expr_prod();
4516− while (tok == '+' || tok == '-') {
4517− t = tok;
4518− next();
4519− expr_prod();
4520− gen_op(t);
4521− }
4522−}
4523−
4524−static void expr_shift(void)
4525−{
4526− int t;
4527−
4528− expr_sum();
4529− while (tok == TOK_SHL || tok == TOK_SAR) {
4530− t = tok;
4531− next();
4532− expr_sum();
4533− gen_op(t);
4534− }
4535−}
4536−
4537−static void expr_cmp(void)
4538−{
4539− int t;
4540−
4541− expr_shift();
4542− while ((tok >= TOK_ULE && tok <= TOK_GT) ||
4543− tok == TOK_ULT || tok == TOK_UGE) {
4544− t = tok;
4545− next();
4546− expr_shift();
4547− gen_op(t);
4548− }
4549−}
4550−
4551−static void expr_cmpeq(void)
4552−{
4553− int t;
4554−
4555− expr_cmp();
4556− while (tok == TOK_EQ || tok == TOK_NE) {
4557− t = tok;
4558− next();
4559− expr_cmp();
4560− gen_op(t);
4561− }
4562−}
4563−
4564−static void expr_and(void)
4565−{
4566− expr_cmpeq();
4567− while (tok == '&') {
4568− next();
4569− expr_cmpeq();
4570− gen_op('&');
4571− }
4572−}
4573−
4574−static void expr_xor(void)
4575−{
4576− expr_and();
4577− while (tok == '^') {
4578− next();
4579− expr_and();
4580− gen_op('^');
4581− }
4582−}
4583−
4584−static void expr_or(void)
4585−{
4586− expr_xor();
4587− while (tok == '|') {
4588− next();
4589− expr_xor();
4590− gen_op('|');
4591− }
4592−}
4593−
4594−/* XXX: fix this mess */
4595−static void expr_land_const(void)
4596−{
4597− expr_or();
4598− while (tok == TOK_LAND) {
4599− next();
4600− expr_or();
4601− gen_op(TOK_LAND);
4602− }
4603−}
4604−
4605−/* XXX: fix this mess */
4606−static void expr_lor_const(void)
4607−{
4608− expr_land_const();
4609− while (tok == TOK_LOR) {
4610− next();
4611− expr_land_const();
4612− gen_op(TOK_LOR);
4613− }
4614−}
4615−
4616−/* only used if non constant */
4617−static void expr_land(void)
4618−{
4619− int t;
4620−
4621− expr_or();
4622− if (tok == TOK_LAND) {
4623− t = 0;
4624− save_regs(1);
4625− for(;;) {
4626− t = gtst(1, t);
4627− if (tok != TOK_LAND) {
4628− vseti(VT_JMPI, t);
4629− break;
4630− }
4631− next();
4632− expr_or();
4633− }
4634− }
4635−}
4636−
4637−static void expr_lor(void)
4638−{
4639− int t;
4640−
4641− expr_land();
4642− if (tok == TOK_LOR) {
4643− t = 0;
4644− save_regs(1);
4645− for(;;) {
4646− t = gtst(0, t);
4647− if (tok != TOK_LOR) {
4648− vseti(VT_JMP, t);
4649− break;
4650− }
4651− next();
4652− expr_land();
4653− }
4654− }
4655−}
4656−
4657−/* XXX: better constant handling */
4658−static void expr_eq(void)
4659−{
4660− int tt, u, r1, r2, rc, t1, t2, bt1, bt2;
4661− SValue sv;
4662− CType type, type1, type2;
4663−
4664− if (const_wanted) {
4665− expr_lor_const();
4666− if (tok == '?') {
4667− CType boolean;
4668− int c;
4669− boolean.t = VT_BOOL;
4670− vdup();
4671− gen_cast(&boolean);
4672− c = vtop->c.i;
4673− vpop();
4674− next();
4675− if (tok != ':' || !gnu_ext) {
4676− vpop();
4677− gexpr();
4678− }
4679− if (!c)
4680− vpop();
4681− skip(':');
4682− expr_eq();
4683− if (c)
4684− vpop();
4685− }
4686− } else {
4687− expr_lor();
4688− if (tok == '?') {
4689− next();
4690− if (vtop != vstack) {
4691− /* needed to avoid having different registers saved in
4692− each branch */
4693− if (is_float(vtop->type.t)) {
4694− rc = RC_FLOAT;
4695−#ifdef TCC_TARGET_X86_64
4696− if ((vtop->type.t & VT_BTYPE) == VT_LDOUBLE) {
4697− rc = RC_ST0;
4698− }
4699−#endif
4700− }
4701− else
4702− rc = RC_INT;
4703− gv(rc);
4704− save_regs(1);
4705− }
4706− if (tok == ':' && gnu_ext) {
4707− gv_dup();
4708− tt = gtst(1, 0);
4709− } else {
4710− tt = gtst(1, 0);
4711− gexpr();
4712− }
4713− type1 = vtop->type;
4714− sv = *vtop; /* save value to handle it later */
4715− vtop--; /* no vpop so that FP stack is not flushed */
4716− skip(':');
4717− u = gjmp(0);
4718− gsym(tt);
4719− expr_eq();
4720− type2 = vtop->type;
4721−
4722− t1 = type1.t;
4723− bt1 = t1 & VT_BTYPE;
4724− t2 = type2.t;
4725− bt2 = t2 & VT_BTYPE;
4726− /* cast operands to correct type according to ISOC rules */
4727− if (is_float(bt1) || is_float(bt2)) {
4728− if (bt1 == VT_LDOUBLE || bt2 == VT_LDOUBLE) {
4729− type.t = VT_LDOUBLE;
4730− } else if (bt1 == VT_DOUBLE || bt2 == VT_DOUBLE) {
4731− type.t = VT_DOUBLE;
4732− } else {
4733− type.t = VT_FLOAT;
4734− }
4735− } else if (bt1 == VT_LLONG || bt2 == VT_LLONG) {
4736− /* cast to biggest op */
4737− type.t = VT_LLONG;
4738− /* convert to unsigned if it does not fit in a long long */
4739− if ((t1 & (VT_BTYPE | VT_UNSIGNED)) == (VT_LLONG | VT_UNSIGNED) ||
4740− (t2 & (VT_BTYPE | VT_UNSIGNED)) == (VT_LLONG | VT_UNSIGNED))
4741− type.t |= VT_UNSIGNED;
4742− } else if (bt1 == VT_PTR || bt2 == VT_PTR) {
4743− /* XXX: test pointer compatibility */
4744− type = type1;
4745− } else if (bt1 == VT_FUNC || bt2 == VT_FUNC) {
4746− /* XXX: test function pointer compatibility */
4747− type = type1;
4748− } else if (bt1 == VT_STRUCT || bt2 == VT_STRUCT) {
4749− /* XXX: test structure compatibility */
4750− type = type1;
4751− } else if (bt1 == VT_VOID || bt2 == VT_VOID) {
4752− /* NOTE: as an extension, we accept void on only one side */
4753− type.t = VT_VOID;
4754− } else {
4755− /* integer operations */
4756− type.t = VT_INT;
4757− /* convert to unsigned if it does not fit in an integer */
4758− if ((t1 & (VT_BTYPE | VT_UNSIGNED)) == (VT_INT | VT_UNSIGNED) ||
4759− (t2 & (VT_BTYPE | VT_UNSIGNED)) == (VT_INT | VT_UNSIGNED))
4760− type.t |= VT_UNSIGNED;
4761− }
4762−
4763− /* now we convert second operand */
4764− gen_cast(&type);
4765− if (VT_STRUCT == (vtop->type.t & VT_BTYPE))
4766− gaddrof();
4767− rc = RC_INT;
4768− if (is_float(type.t)) {
4769− rc = RC_FLOAT;
4770−#ifdef TCC_TARGET_X86_64
4771− if ((type.t & VT_BTYPE) == VT_LDOUBLE) {
4772− rc = RC_ST0;
4773− }
4774−#endif
4775− } else if ((type.t & VT_BTYPE) == VT_LLONG) {
4776− /* for long longs, we use fixed registers to avoid having
4777− to handle a complicated move */
4778− rc = RC_IRET;
4779− }
4780−
4781− r2 = gv(rc);
4782− /* this is horrible, but we must also convert first
4783− operand */
4784− tt = gjmp(0);
4785− gsym(u);
4786− /* put again first value and cast it */
4787− *vtop = sv;
4788− gen_cast(&type);
4789− if (VT_STRUCT == (vtop->type.t & VT_BTYPE))
4790− gaddrof();
4791− r1 = gv(rc);
4792− move_reg(r2, r1);
4793− vtop->r = r2;
4794− gsym(tt);
4795− }
4796− }
4797−}
4798−
4799−static void gexpr(void)
4800−{
4801− while (1) {
4802− expr_eq();
4803− if (tok != ',')
4804− break;
4805− vpop();
4806− next();
4807− }
4808−}
4809−
4810−/* parse an expression and return its type without any side effect. */
4811−static void expr_type(CType *type)
4812−{
4813− int saved_nocode_wanted;
4814−
4815− saved_nocode_wanted = nocode_wanted;
4816− nocode_wanted = 1;
4817− gexpr();
4818− *type = vtop->type;
4819− vpop();
4820− nocode_wanted = saved_nocode_wanted;
4821−}
4822−
4823−/* parse a unary expression and return its type without any side
4824− effect. */
4825−static void unary_type(CType *type)
4826−{
4827− int a;
4828−
4829− a = nocode_wanted;
4830− nocode_wanted = 1;
4831− unary();
4832− *type = vtop->type;
4833− vpop();
4834− nocode_wanted = a;
4835−}
4836−
4837−/* parse a constant expression and return value in vtop. */
4838−static void expr_const1(void)
4839−{
4840− int a;
4841− a = const_wanted;
4842− const_wanted = 1;
4843− expr_eq();
4844− const_wanted = a;
4845−}
4846−
4847−/* parse an integer constant and return its value. */
4848−static int expr_const(void)
4849−{
4850− int c;
4851− expr_const1();
4852− if ((vtop->r & (VT_VALMASK | VT_LVAL | VT_SYM)) != VT_CONST)
4853− expect("constant expression");
4854− c = vtop->c.i;
4855− vpop();
4856− return c;
4857−}
4858−
4859−/* return the label token if current token is a label, otherwise
4860− return zero */
4861−static int is_label(void)
4862−{
4863− int last_tok;
4864−
4865− /* fast test first */
4866− if (tok < TOK_UIDENT)
4867− return 0;
4868− /* no need to save tokc because tok is an identifier */
4869− last_tok = tok;
4870− next();
4871− if (tok == ':') {
4872− next();
4873− return last_tok;
4874− } else {
4875− unget_tok(last_tok);
4876− return 0;
4877− }
4878−}
4879−
4880−static void block(int *bsym, int *csym, int *case_sym, int *def_sym,
4881− int case_reg, int is_expr)
4882−{
4883− int a, b, c, d;
4884− Sym *s;
4885−
4886− /* generate line number info */
4887− if (do_debug &&
4888− (last_line_num != file->line_num || last_ind != ind)) {
4889− put_stabn(N_SLINE, 0, file->line_num, ind - func_ind);
4890− last_ind = ind;
4891− last_line_num = file->line_num;
4892− }
4893−
4894− if (is_expr) {
4895− /* default return value is (void) */
4896− vpushi(0);
4897− vtop->type.t = VT_VOID;
4898− }
4899−
4900− if (tok == TOK_IF) {
4901− /* if test */
4902− next();
4903− skip('(');
4904− gexpr();
4905− skip(')');
4906− a = gtst(1, 0);
4907− block(bsym, csym, case_sym, def_sym, case_reg, 0);
4908− c = tok;
4909− if (c == TOK_ELSE) {
4910− next();
4911− d = gjmp(0);
4912− gsym(a);
4913− block(bsym, csym, case_sym, def_sym, case_reg, 0);
4914− gsym(d); /* patch else jmp */
4915− } else
4916− gsym(a);
4917− } else if (tok == TOK_WHILE) {
4918− next();
4919− d = ind;
4920− skip('(');
4921− gexpr();
4922− skip(')');
4923− a = gtst(1, 0);
4924− b = 0;
4925− block(&a, &b, case_sym, def_sym, case_reg, 0);
4926− gjmp_addr(d);
4927− gsym(a);
4928− gsym_addr(b, d);
4929− } else if (tok == '{') {
4930− Sym *llabel;
4931−
4932− next();
4933− /* record local declaration stack position */
4934− s = local_stack;
4935− llabel = local_label_stack;
4936− /* handle local labels declarations */
4937− if (tok == TOK_LABEL) {
4938− next();
4939− for(;;) {
4940− if (tok < TOK_UIDENT)
4941− expect("label identifier");
4942− label_push(&local_label_stack, tok, LABEL_DECLARED);
4943− next();
4944− if (tok == ',') {
4945− next();
4946− } else {
4947− skip(';');
4948− break;
4949− }
4950− }
4951− }
4952− while (tok != '}') {
4953− decl(VT_LOCAL);
4954− if (tok != '}') {
4955− if (is_expr)
4956− vpop();
4957− block(bsym, csym, case_sym, def_sym, case_reg, is_expr);
4958− }
4959− }
4960− /* pop locally defined labels */
4961− label_pop(&local_label_stack, llabel);
4962− /* pop locally defined symbols */
4963− if(is_expr) {
4964− /* XXX: this solution makes only valgrind happy...
4965− triggered by gcc.c-torture/execute/20000917-1.c */
4966− Sym *p;
4967− switch(vtop->type.t & VT_BTYPE) {
4968− case VT_PTR:
4969− case VT_STRUCT:
4970− case VT_ENUM:
4971− case VT_FUNC:
4972− for(p=vtop->type.ref;p;p=p->prev)
4973− if(p->prev==s)
4974− error("unsupported expression type");
4975− }
4976− }
4977− sym_pop(&local_stack, s);
4978− next();
4979− } else if (tok == TOK_RETURN) {
4980− next();
4981− if (tok != ';') {
4982− gexpr();
4983− gen_assign_cast(&func_vt);
4984− if ((func_vt.t & VT_BTYPE) == VT_STRUCT) {
4985− CType type;
4986− /* if returning structure, must copy it to implicit
4987− first pointer arg location */
4988−#ifdef TCC_ARM_EABI
4989− int align, size;
4990− size = type_size(&func_vt,&align);
4991− if(size <= 4)
4992− {
4993− if((vtop->r != (VT_LOCAL | VT_LVAL) || (vtop->c.i & 3))
4994− && (align & 3))
4995− {
4996− int addr;
4997− loc = (loc - size) & -4;
4998− addr = loc;
4999− type = func_vt;
5000− vset(&type, VT_LOCAL | VT_LVAL, addr);
5001− vswap();
5002− vstore();
5003− vset(&int_type, VT_LOCAL | VT_LVAL, addr);
5004− }
5005− vtop->type = int_type;
5006− gv(RC_IRET);
5007− } else {
5008−#endif
5009− type = func_vt;
5010− mk_pointer(&type);
5011− vset(&type, VT_LOCAL | VT_LVAL, func_vc);
5012− indir();
5013− vswap();
5014− /* copy structure value to pointer */
5015− vstore();
5016−#ifdef TCC_ARM_EABI
5017− }
5018−#endif
5019− } else if (is_float(func_vt.t)) {
5020− gv(rc_fret(func_vt.t));
5021− } else {
5022− gv(RC_IRET);
5023− }
5024− vtop--; /* NOT vpop() because on x86 it would flush the fp stack */
5025− }
5026− skip(';');
5027− rsym = gjmp(rsym); /* jmp */
5028− } else if (tok == TOK_BREAK) {
5029− /* compute jump */
5030− if (!bsym)
5031− error("cannot break");
5032− *bsym = gjmp(*bsym);
5033− next();
5034− skip(';');
5035− } else if (tok == TOK_CONTINUE) {
5036− /* compute jump */
5037− if (!csym)
5038− error("cannot continue");
5039− *csym = gjmp(*csym);
5040− next();
5041− skip(';');
5042− } else if (tok == TOK_FOR) {
5043− int e;
5044− next();
5045− skip('(');
5046− if (tok != ';') {
5047− gexpr();
5048− vpop();
5049− }
5050− skip(';');
5051− d = ind;
5052− c = ind;
5053− a = 0;
5054− b = 0;
5055− if (tok != ';') {
5056− gexpr();
5057− a = gtst(1, 0);
5058− }
5059− skip(';');
5060− if (tok != ')') {
5061− e = gjmp(0);
5062− c = ind;
5063− gexpr();
5064− vpop();
5065− gjmp_addr(d);
5066− gsym(e);
5067− }
5068− skip(')');
5069− block(&a, &b, case_sym, def_sym, case_reg, 0);
5070− gjmp_addr(c);
5071− gsym(a);
5072− gsym_addr(b, c);
5073− } else
5074− if (tok == TOK_DO) {
5075− next();
5076− a = 0;
5077− b = 0;
5078− d = ind;
5079− block(&a, &b, case_sym, def_sym, case_reg, 0);
5080− skip(TOK_WHILE);
5081− skip('(');
5082− gsym(b);
5083− gexpr();
5084− c = gtst(0, 0);
5085− gsym_addr(c, d);
5086− skip(')');
5087− gsym(a);
5088− skip(';');
5089− } else
5090− if (tok == TOK_SWITCH) {
5091− next();
5092− skip('(');
5093− gexpr();
5094− /* XXX: other types than integer */
5095− case_reg = gv(RC_INT);
5096− vpop();
5097− skip(')');
5098− a = 0;
5099− b = gjmp(0); /* jump to first case */
5100− c = 0;
5101− block(&a, csym, &b, &c, case_reg, 0);
5102− /* if no default, jmp after switch */
5103− if (c == 0)
5104− c = ind;
5105− /* default label */
5106− gsym_addr(b, c);
5107− /* break label */
5108− gsym(a);
5109− } else
5110− if (tok == TOK_CASE) {
5111− int v1, v2;
5112− if (!case_sym)
5113− expect("switch");
5114− next();
5115− v1 = expr_const();
5116− v2 = v1;
5117− if (gnu_ext && tok == TOK_DOTS) {
5118− next();
5119− v2 = expr_const();
5120− if (v2 < v1)
5121− warning("empty case range");
5122− }
5123− /* since a case is like a label, we must skip it with a jmp */
5124− b = gjmp(0);
5125− gsym(*case_sym);
5126− vseti(case_reg, 0);
5127− vpushi(v1);
5128− if (v1 == v2) {
5129− gen_op(TOK_EQ);
5130− *case_sym = gtst(1, 0);
5131− } else {
5132− gen_op(TOK_GE);
5133− *case_sym = gtst(1, 0);
5134− vseti(case_reg, 0);
5135− vpushi(v2);
5136− gen_op(TOK_LE);
5137− *case_sym = gtst(1, *case_sym);
5138− }
5139− gsym(b);
5140− skip(':');
5141− is_expr = 0;
5142− goto block_after_label;
5143− } else
5144− if (tok == TOK_DEFAULT) {
5145− next();
5146− skip(':');
5147− if (!def_sym)
5148− expect("switch");
5149− if (*def_sym)
5150− error("too many 'default'");
5151− *def_sym = ind;
5152− is_expr = 0;
5153− goto block_after_label;
5154− } else
5155− if (tok == TOK_GOTO) {
5156− next();
5157− if (tok == '*' && gnu_ext) {
5158− /* computed goto */
5159− next();
5160− gexpr();
5161− if ((vtop->type.t & VT_BTYPE) != VT_PTR)
5162− expect("pointer");
5163− ggoto();
5164− } else if (tok >= TOK_UIDENT) {
5165− s = label_find(tok);
5166− /* put forward definition if needed */
5167− if (!s) {
5168− s = label_push(&global_label_stack, tok, LABEL_FORWARD);
5169− } else {
5170− if (s->r == LABEL_DECLARED)
5171− s->r = LABEL_FORWARD;
5172− }
5173− /* label already defined */
5174− if (s->r & LABEL_FORWARD)
5175− s->next = (void *)gjmp((long)s->next);
5176− else
5177− gjmp_addr((long)s->next);
5178− next();
5179− } else {
5180− expect("label identifier");
5181− }
5182− skip(';');
5183− } else if (tok == TOK_ASM1 || tok == TOK_ASM2 || tok == TOK_ASM3) {
5184− asm_instr();
5185− } else {
5186− b = is_label();
5187− if (b) {
5188− /* label case */
5189− s = label_find(b);
5190− if (s) {
5191− if (s->r == LABEL_DEFINED)
5192− error("duplicate label '%s'", get_tok_str(s->v, NULL));
5193− gsym((long)s->next);
5194− s->r = LABEL_DEFINED;
5195− } else {
5196− s = label_push(&global_label_stack, b, LABEL_DEFINED);
5197− }
5198− s->next = (void *)ind;
5199− /* we accept this, but it is a mistake */
5200− block_after_label:
5201− if (tok == '}') {
5202− warning("deprecated use of label at end of compound statement");
5203− } else {
5204− if (is_expr)
5205− vpop();
5206− block(bsym, csym, case_sym, def_sym, case_reg, is_expr);
5207− }
5208− } else {
5209− /* expression case */
5210− if (tok != ';') {
5211− if (is_expr) {
5212− vpop();
5213− gexpr();
5214− } else {
5215− gexpr();
5216− vpop();
5217− }
5218− }
5219− skip(';');
5220− }
5221− }
5222−}
5223−
5224−/* t is the array or struct type. c is the array or struct
5225− address. cur_index/cur_field is the pointer to the current
5226− value. 'size_only' is true if only size info is needed (only used
5227− in arrays) */
5228−static void decl_designator(CType *type, Section *sec, unsigned long c,
5229− int *cur_index, Sym **cur_field,
5230− int size_only)
5231−{
5232− Sym *s, *f;
5233− int notfirst, index, index_last, align, l, nb_elems, elem_size;
5234− CType type1;
5235−
5236− notfirst = 0;
5237− elem_size = 0;
5238− nb_elems = 1;
5239− if (gnu_ext && (l = is_label()) != 0)
5240− goto struct_field;
5241− while (tok == '[' || tok == '.') {
5242− if (tok == '[') {
5243− if (!(type->t & VT_ARRAY))
5244− expect("array type");
5245− s = type->ref;
5246− next();
5247− index = expr_const();
5248− if (index < 0 || (s->c >= 0 && index >= s->c))
5249− expect("invalid index");
5250− if (tok == TOK_DOTS && gnu_ext) {
5251− next();
5252− index_last = expr_const();
5253− if (index_last < 0 ||
5254− (s->c >= 0 && index_last >= s->c) ||
5255− index_last < index)
5256− expect("invalid index");
5257− } else {
5258− index_last = index;
5259− }
5260− skip(']');
5261− if (!notfirst)
5262− *cur_index = index_last;
5263− type = pointed_type(type);
5264− elem_size = type_size(type, &align);
5265− c += index * elem_size;
5266− /* NOTE: we only support ranges for last designator */
5267− nb_elems = index_last - index + 1;
5268− if (nb_elems != 1) {
5269− notfirst = 1;
5270− break;
5271− }
5272− } else {
5273− next();
5274− l = tok;
5275− next();
5276− struct_field:
5277− if ((type->t & VT_BTYPE) != VT_STRUCT)
5278− expect("struct/union type");
5279− s = type->ref;
5280− l |= SYM_FIELD;
5281− f = s->next;
5282− while (f) {
5283− if (f->v == l)
5284− break;
5285− f = f->next;
5286− }
5287− if (!f)
5288− expect("field");
5289− if (!notfirst)
5290− *cur_field = f;
5291− /* XXX: fix this mess by using explicit storage field */
5292− type1 = f->type;
5293− type1.t |= (type->t & ~VT_TYPE);
5294− type = &type1;
5295− c += f->c;
5296− }
5297− notfirst = 1;
5298− }
5299− if (notfirst) {
5300− if (tok == '=') {
5301− next();
5302− } else {
5303− if (!gnu_ext)
5304− expect("=");
5305− }
5306− } else {
5307− if (type->t & VT_ARRAY) {
5308− index = *cur_index;
5309− type = pointed_type(type);
5310− c += index * type_size(type, &align);
5311− } else {
5312− f = *cur_field;
5313− if (!f)
5314− error("too many field init");
5315− /* XXX: fix this mess by using explicit storage field */
5316− type1 = f->type;
5317− type1.t |= (type->t & ~VT_TYPE);
5318− type = &type1;
5319− c += f->c;
5320− }
5321− }
5322− decl_initializer(type, sec, c, 0, size_only);
5323−
5324− /* XXX: make it more general */
5325− if (!size_only && nb_elems > 1) {
5326− unsigned long c_end;
5327− uint8_t *src, *dst;
5328− int i;
5329−
5330− if (!sec)
5331− error("range init not supported yet for dynamic storage");
5332− c_end = c + nb_elems * elem_size;
5333− if (c_end > sec->data_allocated)
5334− section_realloc(sec, c_end);
5335− src = sec->data + c;
5336− dst = src;
5337− for(i = 1; i < nb_elems; i++) {
5338− dst += elem_size;
5339− memcpy(dst, src, elem_size);
5340− }
5341− }
5342−}
5343−
5344−#define EXPR_VAL 0
5345−#define EXPR_CONST 1
5346−#define EXPR_ANY 2
5347−
5348−/* store a value or an expression directly in global data or in local array */
5349−static void init_putv(CType *type, Section *sec, unsigned long c,
5350− int v, int expr_type)
5351−{
5352− int saved_global_expr, bt, bit_pos, bit_size;
5353− void *ptr;
5354− unsigned long long bit_mask;
5355− CType dtype;
5356−
5357− switch(expr_type) {
5358− case EXPR_VAL:
5359− vpushi(v);
5360− break;
5361− case EXPR_CONST:
5362− /* compound literals must be allocated globally in this case */
5363− saved_global_expr = global_expr;
5364− global_expr = 1;
5365− expr_const1();
5366− global_expr = saved_global_expr;
5367− /* NOTE: symbols are accepted */
5368− if ((vtop->r & (VT_VALMASK | VT_LVAL)) != VT_CONST)
5369− error("initializer element is not constant");
5370− break;
5371− case EXPR_ANY:
5372− expr_eq();
5373− break;
5374− }
5375−
5376− dtype = *type;
5377− dtype.t &= ~VT_CONSTANT; /* need to do that to avoid false warning */
5378−
5379− if (sec) {
5380− /* XXX: not portable */
5381− /* XXX: generate error if incorrect relocation */
5382− gen_assign_cast(&dtype);
5383− bt = type->t & VT_BTYPE;
5384− /* we'll write at most 12 bytes */
5385− if (c + 12 > sec->data_allocated) {
5386− section_realloc(sec, c + 12);
5387− }
5388− ptr = sec->data + c;
5389− /* XXX: make code faster ? */
5390− if (!(type->t & VT_BITFIELD)) {
5391− bit_pos = 0;
5392− bit_size = 32;
5393− bit_mask = -1LL;
5394− } else {
5395− bit_pos = (vtop->type.t >> VT_STRUCT_SHIFT) & 0x3f;
5396− bit_size = (vtop->type.t >> (VT_STRUCT_SHIFT + 6)) & 0x3f;
5397− bit_mask = (1LL << bit_size) - 1;
5398− }
5399− if ((vtop->r & VT_SYM) &&
5400− (bt == VT_BYTE ||
5401− bt == VT_SHORT ||
5402− bt == VT_DOUBLE ||
5403− bt == VT_LDOUBLE ||
5404− bt == VT_LLONG ||
5405− (bt == VT_INT && bit_size != 32)))
5406− error("initializer element is not computable at load time");
5407− switch(bt) {
5408− case VT_BOOL:
5409− vtop->c.i = (vtop->c.i != 0);
5410− case VT_BYTE:
5411− *(char *)ptr |= (vtop->c.i & bit_mask) << bit_pos;
5412− break;
5413− case VT_SHORT:
5414− *(short *)ptr |= (vtop->c.i & bit_mask) << bit_pos;
5415− break;
5416− case VT_DOUBLE:
5417− *(double *)ptr = vtop->c.d;
5418− break;
5419− case VT_LDOUBLE:
5420− *(long double *)ptr = vtop->c.ld;
5421− break;
5422− case VT_LLONG:
5423− *(long long *)ptr |= (vtop->c.ll & bit_mask) << bit_pos;
5424− break;
5425− default:
5426− if (vtop->r & VT_SYM) {
5427− greloc(sec, vtop->sym, c, R_DATA_32);
5428− }
5429− *(int *)ptr |= (vtop->c.i & bit_mask) << bit_pos;
5430− break;
5431− }
5432− vtop--;
5433− } else {
5434− vset(&dtype, VT_LOCAL|VT_LVAL, c);
5435− vswap();
5436− vstore();
5437− vpop();
5438− }
5439−}
5440−
5441−/* put zeros for variable based init */
5442−static void init_putz(CType *t, Section *sec, unsigned long c, int size)
5443−{
5444− if (sec) {
5445− /* nothing to do because globals are already set to zero */
5446− } else {
5447− vpush_global_sym(&func_old_type, TOK_memset);
5448− vseti(VT_LOCAL, c);
5449− vpushi(0);
5450− vpushi(size);
5451− gfunc_call(3);
5452− }
5453−}
5454−
5455−/* 't' contains the type and storage info. 'c' is the offset of the
5456− object in section 'sec'. If 'sec' is NULL, it means stack based
5457− allocation. 'first' is true if array '{' must be read (multi
5458− dimension implicit array init handling). 'size_only' is true if
5459− size only evaluation is wanted (only for arrays). */
5460−static void decl_initializer(CType *type, Section *sec, unsigned long c,
5461− int first, int size_only)
5462−{
5463− int index, array_length, n, no_oblock, nb, parlevel, i;
5464− int size1, align1, expr_type;
5465− Sym *s, *f;
5466− CType *t1;
5467−
5468− if (type->t & VT_ARRAY) {
5469− s = type->ref;
5470− n = s->c;
5471− array_length = 0;
5472− t1 = pointed_type(type);
5473− size1 = type_size(t1, &align1);
5474−
5475− no_oblock = 1;
5476− if ((first && tok != TOK_LSTR && tok != TOK_STR) ||
5477− tok == '{') {
5478− skip('{');
5479− no_oblock = 0;
5480− }
5481−
5482− /* only parse strings here if correct type (otherwise: handle
5483− them as ((w)char *) expressions */
5484− if ((tok == TOK_LSTR &&
5485−#ifdef TCC_TARGET_PE
5486− (t1->t & VT_BTYPE) == VT_SHORT && (t1->t & VT_UNSIGNED)
5487−#else
5488− (t1->t & VT_BTYPE) == VT_INT
5489−#endif
5490− ) || (tok == TOK_STR && (t1->t & VT_BTYPE) == VT_BYTE)) {
5491− while (tok == TOK_STR || tok == TOK_LSTR) {
5492− int cstr_len, ch;
5493− CString *cstr;
5494−
5495− cstr = tokc.cstr;
5496− /* compute maximum number of chars wanted */
5497− if (tok == TOK_STR)
5498− cstr_len = cstr->size;
5499− else
5500− cstr_len = cstr->size / sizeof(nwchar_t);
5501− cstr_len--;
5502− nb = cstr_len;
5503− if (n >= 0 && nb > (n - array_length))
5504− nb = n - array_length;
5505− if (!size_only) {
5506− if (cstr_len > nb)
5507− warning("initializer-string for array is too long");
5508− /* in order to go faster for common case (char
5509− string in global variable, we handle it
5510− specifically */
5511− if (sec && tok == TOK_STR && size1 == 1) {
5512− memcpy(sec->data + c + array_length, cstr->data, nb);
5513− } else {
5514− for(i=0;i<nb;i++) {
5515− if (tok == TOK_STR)
5516− ch = ((unsigned char *)cstr->data)[i];
5517− else
5518− ch = ((nwchar_t *)cstr->data)[i];
5519− init_putv(t1, sec, c + (array_length + i) * size1,
5520− ch, EXPR_VAL);
5521− }
5522− }
5523− }
5524− array_length += nb;
5525− next();
5526− }
5527− /* only add trailing zero if enough storage (no
5528− warning in this case since it is standard) */
5529− if (n < 0 || array_length < n) {
5530− if (!size_only) {
5531− init_putv(t1, sec, c + (array_length * size1), 0, EXPR_VAL);
5532− }
5533− array_length++;
5534− }
5535− } else {
5536− index = 0;
5537− while (tok != '}') {
5538− decl_designator(type, sec, c, &index, NULL, size_only);
5539− if (n >= 0 && index >= n)
5540− error("index too large");
5541− /* must put zero in holes (note that doing it that way
5542− ensures that it even works with designators) */
5543− if (!size_only && array_length < index) {
5544− init_putz(t1, sec, c + array_length * size1,
5545− (index - array_length) * size1);
5546− }
5547− index++;
5548− if (index > array_length)
5549− array_length = index;
5550− /* special test for multi dimensional arrays (may not
5551− be strictly correct if designators are used at the
5552− same time) */
5553− if (index >= n && no_oblock)
5554− break;
5555− if (tok == '}')
5556− break;
5557− skip(',');
5558− }
5559− }
5560− if (!no_oblock)
5561− skip('}');
5562− /* put zeros at the end */
5563− if (!size_only && n >= 0 && array_length < n) {
5564− init_putz(t1, sec, c + array_length * size1,
5565− (n - array_length) * size1);
5566− }
5567− /* patch type size if needed */
5568− if (n < 0)
5569− s->c = array_length;
5570− } else if ((type->t & VT_BTYPE) == VT_STRUCT &&
5571− (sec || !first || tok == '{')) {
5572− int par_count;
5573−
5574− /* NOTE: the previous test is a specific case for automatic
5575− struct/union init */
5576− /* XXX: union needs only one init */
5577−
5578− /* XXX: this test is incorrect for local initializers
5579− beginning with ( without {. It would be much more difficult
5580− to do it correctly (ideally, the expression parser should
5581− be used in all cases) */
5582− par_count = 0;
5583− if (tok == '(') {
5584− AttributeDef ad1;
5585− CType type1;
5586− next();
5587− while (tok == '(') {
5588− par_count++;
5589− next();
5590− }
5591− if (!parse_btype(&type1, &ad1))
5592− expect("cast");
5593− type_decl(&type1, &ad1, &n, TYPE_ABSTRACT);
5594−#if 0
5595− if (!is_assignable_types(type, &type1))
5596− error("invalid type for cast");
5597−#endif
5598− skip(')');
5599− }
5600− no_oblock = 1;
5601− if (first || tok == '{') {
5602− skip('{');
5603− no_oblock = 0;
5604− }
5605− s = type->ref;
5606− f = s->next;
5607− array_length = 0;
5608− index = 0;
5609− n = s->c;
5610− while (tok != '}') {
5611− decl_designator(type, sec, c, NULL, &f, size_only);
5612− index = f->c;
5613− if (!size_only && array_length < index) {
5614− init_putz(type, sec, c + array_length,
5615− index - array_length);
5616− }
5617− index = index + type_size(&f->type, &align1);
5618− if (index > array_length)
5619− array_length = index;
5620− f = f->next;
5621− if (no_oblock && f == NULL)
5622− break;
5623− if (tok == '}')
5624− break;
5625− skip(',');
5626− }
5627− /* put zeros at the end */
5628− if (!size_only && array_length < n) {
5629− init_putz(type, sec, c + array_length,
5630− n - array_length);
5631− }
5632− if (!no_oblock)
5633− skip('}');
5634− while (par_count) {
5635− skip(')');
5636− par_count--;
5637− }
5638− } else if (tok == '{') {
5639− next();
5640− decl_initializer(type, sec, c, first, size_only);
5641− skip('}');
5642− } else if (size_only) {
5643− /* just skip expression */
5644− parlevel = 0;
5645− while ((parlevel > 0 || (tok != '}' && tok != ',')) &&
5646− tok != -1) {
5647− if (tok == '(')
5648− parlevel++;
5649− else if (tok == ')')
5650− parlevel--;
5651− next();
5652− }
5653− } else {
5654− /* currently, we always use constant expression for globals
5655− (may change for scripting case) */
5656− expr_type = EXPR_CONST;
5657− if (!sec)
5658− expr_type = EXPR_ANY;
5659− init_putv(type, sec, c, 0, expr_type);
5660− }
5661−}
5662−
5663−/* parse an initializer for type 't' if 'has_init' is non zero, and
5664− allocate space in local or global data space ('r' is either
5665− VT_LOCAL or VT_CONST). If 'v' is non zero, then an associated
5666− variable 'v' of scope 'scope' is declared before initializers are
5667− parsed. If 'v' is zero, then a reference to the new object is put
5668− in the value stack. If 'has_init' is 2, a special parsing is done
5669− to handle string constants. */
5670−static void decl_initializer_alloc(CType *type, AttributeDef *ad, int r,
5671− int has_init, int v, int scope)
5672−{
5673− int size, align, addr, data_offset;
5674− int level;
5675− ParseState saved_parse_state = {0};
5676− TokenString init_str;
5677− Section *sec;
5678−
5679− size = type_size(type, &align);
5680− /* If unknown size, we must evaluate it before
5681− evaluating initializers because
5682− initializers can generate global data too
5683− (e.g. string pointers or ISOC99 compound
5684− literals). It also simplifies local
5685− initializers handling */
5686− tok_str_new(&init_str);
5687− if (size < 0) {
5688− if (!has_init)
5689− error("unknown type size");
5690− /* get all init string */
5691− if (has_init == 2) {
5692− /* only get strings */
5693− while (tok == TOK_STR || tok == TOK_LSTR) {
5694− tok_str_add_tok(&init_str);
5695− next();
5696− }
5697− } else {
5698− level = 0;
5699− while (level > 0 || (tok != ',' && tok != ';')) {
5700− if (tok < 0)
5701− error("unexpected end of file in initializer");
5702− tok_str_add_tok(&init_str);
5703− if (tok == '{')
5704− level++;
5705− else if (tok == '}') {
5706− level--;
5707− if (level <= 0) {
5708− next();
5709− break;
5710− }
5711− }
5712− next();
5713− }
5714− }
5715− tok_str_add(&init_str, -1);
5716− tok_str_add(&init_str, 0);
5717−
5718− /* compute size */
5719− save_parse_state(&saved_parse_state);
5720−
5721− macro_ptr = init_str.str;
5722− next();
5723− decl_initializer(type, NULL, 0, 1, 1);
5724− /* prepare second initializer parsing */
5725− macro_ptr = init_str.str;
5726− next();
5727−
5728− /* if still unknown size, error */
5729− size = type_size(type, &align);
5730− if (size < 0)
5731− error("unknown type size");
5732− }
5733− /* take into account specified alignment if bigger */
5734− if (ad->aligned) {
5735− if (ad->aligned > align)
5736− align = ad->aligned;
5737− } else if (ad->packed) {
5738− align = 1;
5739− }
5740− if ((r & VT_VALMASK) == VT_LOCAL) {
5741− sec = NULL;
5742− if (do_bounds_check && (type->t & VT_ARRAY))
5743− loc--;
5744− loc = (loc - size) & -align;
5745− addr = loc;
5746− /* handles bounds */
5747− /* XXX: currently, since we do only one pass, we cannot track
5748− '&' operators, so we add only arrays */
5749− if (do_bounds_check && (type->t & VT_ARRAY)) {
5750− unsigned long *bounds_ptr;
5751− /* add padding between regions */
5752− loc--;
5753− /* then add local bound info */
5754− bounds_ptr = section_ptr_add(lbounds_section, 2 * sizeof(unsigned long));
5755− bounds_ptr[0] = addr;
5756− bounds_ptr[1] = size;
5757− }
5758− if (v) {
5759− /* local variable */
5760− sym_push(v, type, r, addr);
5761− } else {
5762− /* push local reference */
5763− vset(type, r, addr);
5764− }
5765− } else {
5766− Sym *sym;
5767−
5768− sym = NULL;
5769− if (v && scope == VT_CONST) {
5770− /* see if the symbol was already defined */
5771− sym = sym_find(v);
5772− if (sym) {
5773− if (!is_compatible_types(&sym->type, type))
5774− error("incompatible types for redefinition of '%s'",
5775− get_tok_str(v, NULL));
5776− if (sym->type.t & VT_EXTERN) {
5777− /* if the variable is extern, it was not allocated */
5778− sym->type.t &= ~VT_EXTERN;
5779− /* set array size if it was ommited in extern
5780− declaration */
5781− if ((sym->type.t & VT_ARRAY) &&
5782− sym->type.ref->c < 0 &&
5783− type->ref->c >= 0)
5784− sym->type.ref->c = type->ref->c;
5785− } else {
5786− /* we accept several definitions of the same
5787− global variable. this is tricky, because we
5788− must play with the SHN_COMMON type of the symbol */
5789− /* XXX: should check if the variable was already
5790− initialized. It is incorrect to initialized it
5791− twice */
5792− /* no init data, we won't add more to the symbol */
5793− if (!has_init)
5794− goto no_alloc;
5795− }
5796− }
5797− }
5798−
5799− /* allocate symbol in corresponding section */
5800− sec = ad->section;
5801− if (!sec) {
5802− if (has_init)
5803− sec = data_section;
5804− else if (tcc_state->nocommon)
5805− sec = bss_section;
5806− }
5807− if (sec) {
5808− data_offset = sec->data_offset;
5809− data_offset = (data_offset + align - 1) & -align;
5810− addr = data_offset;
5811− /* very important to increment global pointer at this time
5812− because initializers themselves can create new initializers */
5813− data_offset += size;
5814− /* add padding if bound check */
5815− if (do_bounds_check)
5816− data_offset++;
5817− sec->data_offset = data_offset;
5818− /* allocate section space to put the data */
5819− if (sec->sh_type != SHT_NOBITS &&
5820− data_offset > sec->data_allocated)
5821− section_realloc(sec, data_offset);
5822− /* align section if needed */
5823− if (align > sec->sh_addralign)
5824− sec->sh_addralign = align;
5825− } else {
5826− addr = 0; /* avoid warning */
5827− }
5828−
5829− if (v) {
5830− if (scope != VT_CONST || !sym) {
5831− sym = sym_push(v, type, r | VT_SYM, 0);
5832− }
5833− /* update symbol definition */
5834− if (sec) {
5835− put_extern_sym(sym, sec, addr, size);
5836− } else {
5837− ElfW(Sym) *esym;
5838− /* put a common area */
5839− put_extern_sym(sym, NULL, align, size);
5840− /* XXX: find a nicer way */
5841− esym = &((ElfW(Sym) *)symtab_section->data)[sym->c];
5842− esym->st_shndx = SHN_COMMON;
5843− }
5844− } else {
5845− CValue cval;
5846−
5847− /* push global reference */
5848− sym = get_sym_ref(type, sec, addr, size);
5849− cval.ul = 0;
5850− vsetc(type, VT_CONST | VT_SYM, &cval);
5851− vtop->sym = sym;
5852− }
5853−
5854− /* handles bounds now because the symbol must be defined
5855− before for the relocation */
5856− if (do_bounds_check) {
5857− unsigned long *bounds_ptr;
5858−
5859− greloc(bounds_section, sym, bounds_section->data_offset, R_DATA_32);
5860− /* then add global bound info */
5861− bounds_ptr = section_ptr_add(bounds_section, 2 * sizeof(long));
5862− bounds_ptr[0] = 0; /* relocated */
5863− bounds_ptr[1] = size;
5864− }
5865− }
5866− if (has_init) {
5867− decl_initializer(type, sec, addr, 1, 0);
5868− /* restore parse state if needed */
5869− if (init_str.str) {
5870− tok_str_free(init_str.str);
5871− restore_parse_state(&saved_parse_state);
5872− }
5873− }
5874− no_alloc: ;
5875−}
5876−
5877−void put_func_debug(Sym *sym)
5878−{
5879− char buf[512];
5880−
5881− /* stabs info */
5882− /* XXX: we put here a dummy type */
5883− snprintf(buf, sizeof(buf), "%s:%c1",
5884− funcname, sym->type.t & VT_STATIC ? 'f' : 'F');
5885− put_stabs_r(buf, N_FUN, 0, file->line_num, 0,
5886− cur_text_section, sym->c);
5887− /* //gr gdb wants a line at the function */
5888− put_stabn(N_SLINE, 0, file->line_num, 0);
5889− last_ind = 0;
5890− last_line_num = 0;
5891−}
5892−
5893−/* parse an old style function declaration list */
5894−/* XXX: check multiple parameter */
5895−static void func_decl_list(Sym *func_sym)
5896−{
5897− AttributeDef ad;
5898− int v;
5899− Sym *s;
5900− CType btype, type;
5901−
5902− /* parse each declaration */
5903− while (tok != '{' && tok != ';' && tok != ',' && tok != TOK_EOF) {
5904− if (!parse_btype(&btype, &ad))
5905− expect("declaration list");
5906− if (((btype.t & VT_BTYPE) == VT_ENUM ||
5907− (btype.t & VT_BTYPE) == VT_STRUCT) &&
5908− tok == ';') {
5909− /* we accept no variable after */
5910− } else {
5911− for(;;) {
5912− type = btype;
5913− type_decl(&type, &ad, &v, TYPE_DIRECT);
5914− /* find parameter in function parameter list */
5915− s = func_sym->next;
5916− while (s != NULL) {
5917− if ((s->v & ~SYM_FIELD) == v)
5918− goto found;
5919− s = s->next;
5920− }
5921− error("declaration for parameter '%s' but no such parameter",
5922− get_tok_str(v, NULL));
5923− found:
5924− /* check that no storage specifier except 'register' was given */
5925− if (type.t & VT_STORAGE)
5926− error("storage class specified for '%s'", get_tok_str(v, NULL));
5927− convert_parameter_type(&type);
5928− /* we can add the type (NOTE: it could be local to the function) */
5929− s->type = type;
5930− /* accept other parameters */
5931− if (tok == ',')
5932− next();
5933− else
5934− break;
5935− }
5936− }
5937− skip(';');
5938− }
5939−}
5940−
5941−/* parse a function defined by symbol 'sym' and generate its code in
5942− 'cur_text_section' */
5943−static void gen_function(Sym *sym)
5944−{
5945− int saved_nocode_wanted = nocode_wanted;
5946− nocode_wanted = 0;
5947− ind = cur_text_section->data_offset;
5948− /* NOTE: we patch the symbol size later */
5949− put_extern_sym(sym, cur_text_section, ind, 0);
5950− funcname = get_tok_str(sym->v, NULL);
5951− func_ind = ind;
5952− /* put debug symbol */
5953− if (do_debug)
5954− put_func_debug(sym);
5955− /* push a dummy symbol to enable local sym storage */
5956− sym_push2(&local_stack, SYM_FIELD, 0, 0);
5957− gfunc_prolog(&sym->type);
5958− rsym = 0;
5959− block(NULL, NULL, NULL, NULL, 0, 0);
5960− gsym(rsym);
5961− gfunc_epilog();
5962− cur_text_section->data_offset = ind;
5963− label_pop(&global_label_stack, NULL);
5964− sym_pop(&local_stack, NULL); /* reset local stack */
5965− /* end of function */
5966− /* patch symbol size */
5967− ((ElfW(Sym) *)symtab_section->data)[sym->c].st_size =
5968− ind - func_ind;
5969− if (do_debug) {
5970− put_stabn(N_FUN, 0, 0, ind - func_ind);
5971− }
5972− /* It's better to crash than to generate wrong code */
5973− cur_text_section = NULL;
5974− funcname = ""; /* for safety */
5975− func_vt.t = VT_VOID; /* for safety */
5976− ind = 0; /* for safety */
5977− nocode_wanted = saved_nocode_wanted;
5978−}
5979−
5980−static void gen_inline_functions(void)
5981−{
5982− Sym *sym;
5983− CType *type;
5984− int *str, inline_generated;
5985−
5986− /* iterate while inline function are referenced */
5987− for(;;) {
5988− inline_generated = 0;
5989− for(sym = global_stack; sym != NULL; sym = sym->prev) {
5990− type = &sym->type;
5991− if (((type->t & VT_BTYPE) == VT_FUNC) &&
5992− (type->t & (VT_STATIC | VT_INLINE)) ==
5993− (VT_STATIC | VT_INLINE) &&
5994− sym->c != 0) {
5995− /* the function was used: generate its code and
5996− convert it to a normal function */
5997− str = INLINE_DEF(sym->r);
5998− sym->r = VT_SYM | VT_CONST;
5999− sym->type.t &= ~VT_INLINE;
6000−
6001− macro_ptr = str;
6002− next();
6003− cur_text_section = text_section;
6004− gen_function(sym);
6005− macro_ptr = NULL; /* fail safe */
6006−
6007− tok_str_free(str);
6008− inline_generated = 1;
6009− }
6010− }
6011− if (!inline_generated)
6012− break;
6013− }
6014−
6015− /* free all remaining inline function tokens */
6016− for(sym = global_stack; sym != NULL; sym = sym->prev) {
6017− type = &sym->type;
6018− if (((type->t & VT_BTYPE) == VT_FUNC) &&
6019− (type->t & (VT_STATIC | VT_INLINE)) ==
6020− (VT_STATIC | VT_INLINE)) {
6021− //gr printf("sym %d %s\n", sym->r, get_tok_str(sym->v, NULL));
6022− if (sym->r == (VT_SYM | VT_CONST)) //gr beware!
6023− continue;
6024− str = INLINE_DEF(sym->r);
6025− tok_str_free(str);
6026− sym->r = 0; /* fail safe */
6027− }
6028− }
6029−}
6030−
6031−/* 'l' is VT_LOCAL or VT_CONST to define default storage type */
6032−static void decl(int l)
6033−{
6034− int v, has_init, r;
6035− CType type, btype;
6036− Sym *sym;
6037− AttributeDef ad;
6038−
6039− while (1) {
6040− if (!parse_btype(&btype, &ad)) {
6041− /* skip redundant ';' */
6042− /* XXX: find more elegant solution */
6043− if (tok == ';') {
6044− next();
6045− continue;
6046− }
6047− if (l == VT_CONST &&
6048− (tok == TOK_ASM1 || tok == TOK_ASM2 || tok == TOK_ASM3)) {
6049− /* global asm block */
6050− asm_global_instr();
6051− continue;
6052− }
6053− /* special test for old K&R protos without explicit int
6054− type. Only accepted when defining global data */
6055− if (l == VT_LOCAL || tok < TOK_DEFINE)
6056− break;
6057− btype.t = VT_INT;
6058− }
6059− if (((btype.t & VT_BTYPE) == VT_ENUM ||
6060− (btype.t & VT_BTYPE) == VT_STRUCT) &&
6061− tok == ';') {
6062− /* we accept no variable after */
6063− next();
6064− continue;
6065− }
6066− while (1) { /* iterate thru each declaration */
6067− type = btype;
6068− type_decl(&type, &ad, &v, TYPE_DIRECT);
6069−#if 0
6070− {
6071− char buf[500];
6072− type_to_str(buf, sizeof(buf), t, get_tok_str(v, NULL));
6073− printf("type = '%s'\n", buf);
6074− }
6075−#endif
6076− if ((type.t & VT_BTYPE) == VT_FUNC) {
6077− /* if old style function prototype, we accept a
6078− declaration list */
6079− sym = type.ref;
6080− if (sym->c == FUNC_OLD)
6081− func_decl_list(sym);
6082− }
6083−
6084− if (tok == '{') {
6085− if (l == VT_LOCAL)
6086− error("cannot use local functions");
6087− if ((type.t & VT_BTYPE) != VT_FUNC)
6088− expect("function definition");
6089−
6090− /* reject abstract declarators in function definition */
6091− sym = type.ref;
6092− while ((sym = sym->next) != NULL)
6093− if (!(sym->v & ~SYM_FIELD))
6094− expect("identifier");
6095−
6096− /* XXX: cannot do better now: convert extern line to static inline */
6097− if ((type.t & (VT_EXTERN | VT_INLINE)) == (VT_EXTERN | VT_INLINE))
6098− type.t = (type.t & ~VT_EXTERN) | VT_STATIC;
6099−
6100− sym = sym_find(v);
6101− if (sym) {
6102− if ((sym->type.t & VT_BTYPE) != VT_FUNC)
6103− goto func_error1;
6104− /* specific case: if not func_call defined, we put
6105− the one of the prototype */

110 more lines aren’t shown here.

tccgen.c+5102−0
@@ -18,3 +18,5105 @@ · 17 unmodified lines
1818 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
1919 */
2020
21+void swap(int *p, int *q)
22+{
23+ int t;
24+ t = *p;
25+ *p = *q;
26+ *q = t;
27+}
28+
29+void vsetc(CType *type, int r, CValue *vc)
30+{
31+ int v;
32+
33+ if (vtop >= vstack + (VSTACK_SIZE - 1))
34+ error("memory full");
35+ /* cannot let cpu flags if other instruction are generated. Also
36+ avoid leaving VT_JMP anywhere except on the top of the stack
37+ because it would complicate the code generator. */
38+ if (vtop >= vstack) {
39+ v = vtop->r & VT_VALMASK;
40+ if (v == VT_CMP || (v & ~1) == VT_JMP)
41+ gv(RC_INT);
42+ }
43+ vtop++;
44+ vtop->type = *type;
45+ vtop->r = r;
46+ vtop->r2 = VT_CONST;
47+ vtop->c = *vc;
48+}
49+
50+/* push integer constant */
51+void vpushi(int v)
52+{
53+ CValue cval;
54+ cval.i = v;
55+ vsetc(&int_type, VT_CONST, &cval);
56+}
57+
58+/* push long long constant */
59+void vpushll(long long v)
60+{
61+ CValue cval;
62+ CType ctype;
63+ ctype.t = VT_LLONG;
64+ cval.ull = v;
65+ vsetc(&ctype, VT_CONST, &cval);
66+}
67+
68+/* Return a static symbol pointing to a section */
69+static Sym *get_sym_ref(CType *type, Section *sec,
70+ unsigned long offset, unsigned long size)
71+{
72+ int v;
73+ Sym *sym;
74+
75+ v = anon_sym++;
76+ sym = global_identifier_push(v, type->t | VT_STATIC, 0);
77+ sym->type.ref = type->ref;
78+ sym->r = VT_CONST | VT_SYM;
79+ put_extern_sym(sym, sec, offset, size);
80+ return sym;
81+}
82+
83+/* push a reference to a section offset by adding a dummy symbol */
84+static void vpush_ref(CType *type, Section *sec, unsigned long offset, unsigned long size)
85+{
86+ CValue cval;
87+
88+ cval.ul = 0;
89+ vsetc(type, VT_CONST | VT_SYM, &cval);
90+ vtop->sym = get_sym_ref(type, sec, offset, size);
91+}
92+
93+/* define a new external reference to a symbol 'v' of type 'u' */
94+static Sym *external_global_sym(int v, CType *type, int r)
95+{
96+ Sym *s;
97+
98+ s = sym_find(v);
99+ if (!s) {
100+ /* push forward reference */
101+ s = global_identifier_push(v, type->t | VT_EXTERN, 0);
102+ s->type.ref = type->ref;
103+ s->r = r | VT_CONST | VT_SYM;
104+ }
105+ return s;
106+}
107+
108+/* define a new external reference to a symbol 'v' of type 'u' */
109+static Sym *external_sym(int v, CType *type, int r)
110+{
111+ Sym *s;
112+
113+ s = sym_find(v);
114+ if (!s) {
115+ /* push forward reference */
116+ s = sym_push(v, type, r | VT_CONST | VT_SYM, 0);
117+ s->type.t |= VT_EXTERN;
118+ } else {
119+ if (!is_compatible_types(&s->type, type))
120+ error("incompatible types for redefinition of '%s'",
121+ get_tok_str(v, NULL));
122+ }
123+ return s;
124+}
125+
126+/* push a reference to global symbol v */
127+static void vpush_global_sym(CType *type, int v)
128+{
129+ Sym *sym;
130+ CValue cval;
131+
132+ sym = external_global_sym(v, type, 0);
133+ cval.ul = 0;
134+ vsetc(type, VT_CONST | VT_SYM, &cval);
135+ vtop->sym = sym;
136+}
137+
138+void vset(CType *type, int r, int v)
139+{
140+ CValue cval;
141+
142+ cval.i = v;
143+ vsetc(type, r, &cval);
144+}
145+
146+void vseti(int r, int v)
147+{
148+ CType type;
149+ type.t = VT_INT;
150+ vset(&type, r, v);
151+}
152+
153+void vswap(void)
154+{
155+ SValue tmp;
156+
157+ tmp = vtop[0];
158+ vtop[0] = vtop[-1];
159+ vtop[-1] = tmp;
160+}
161+
162+void vpushv(SValue *v)
163+{
164+ if (vtop >= vstack + (VSTACK_SIZE - 1))
165+ error("memory full");
166+ vtop++;
167+ *vtop = *v;
168+}
169+
170+void vdup(void)
171+{
172+ vpushv(vtop);
173+}
174+
175+/* save r to the memory stack, and mark it as being free */
176+void save_reg(int r)
177+{
178+ int l, saved, size, align;
179+ SValue *p, sv;
180+ CType *type;
181+
182+ /* modify all stack values */
183+ saved = 0;
184+ l = 0;
185+ for(p=vstack;p<=vtop;p++) {
186+ if ((p->r & VT_VALMASK) == r ||
187+ ((p->type.t & VT_BTYPE) == VT_LLONG && (p->r2 & VT_VALMASK) == r)) {
188+ /* must save value on stack if not already done */
189+ if (!saved) {
190+ /* NOTE: must reload 'r' because r might be equal to r2 */
191+ r = p->r & VT_VALMASK;
192+ /* store register in the stack */
193+ type = &p->type;
194+ if ((p->r & VT_LVAL) ||
195+ (!is_float(type->t) && (type->t & VT_BTYPE) != VT_LLONG))
196+#ifdef TCC_TARGET_X86_64
197+ type = &char_pointer_type;
198+#else
199+ type = &int_type;
200+#endif
201+ size = type_size(type, &align);
202+ loc = (loc - size) & -align;
203+ sv.type.t = type->t;
204+ sv.r = VT_LOCAL | VT_LVAL;
205+ sv.c.ul = loc;
206+ store(r, &sv);
207+#if defined(TCC_TARGET_I386) || defined(TCC_TARGET_X86_64)
208+ /* x86 specific: need to pop fp register ST0 if saved */
209+ if (r == TREG_ST0) {
210+ o(0xd9dd); /* fstp %st(1) */
211+ }
212+#endif
213+#ifndef TCC_TARGET_X86_64
214+ /* special long long case */
215+ if ((type->t & VT_BTYPE) == VT_LLONG) {
216+ sv.c.ul += 4;
217+ store(p->r2, &sv);
218+ }
219+#endif
220+ l = loc;
221+ saved = 1;
222+ }
223+ /* mark that stack entry as being saved on the stack */
224+ if (p->r & VT_LVAL) {
225+ /* also clear the bounded flag because the
226+ relocation address of the function was stored in
227+ p->c.ul */
228+ p->r = (p->r & ~(VT_VALMASK | VT_BOUNDED)) | VT_LLOCAL;
229+ } else {
230+ p->r = lvalue_type(p->type.t) | VT_LOCAL;
231+ }
232+ p->r2 = VT_CONST;
233+ p->c.ul = l;
234+ }
235+ }
236+}
237+
238+/* find a register of class 'rc2' with at most one reference on stack.
239+ * If none, call get_reg(rc) */
240+int get_reg_ex(int rc, int rc2)
241+{
242+ int r;
243+ SValue *p;
244+
245+ for(r=0;r<NB_REGS;r++) {
246+ if (reg_classes[r] & rc2) {
247+ int n;
248+ n=0;
249+ for(p = vstack; p <= vtop; p++) {
250+ if ((p->r & VT_VALMASK) == r ||
251+ (p->r2 & VT_VALMASK) == r)
252+ n++;
253+ }
254+ if (n <= 1)
255+ return r;
256+ }
257+ }
258+ return get_reg(rc);
259+}
260+
261+/* find a free register of class 'rc'. If none, save one register */
262+int get_reg(int rc)
263+{
264+ int r;
265+ SValue *p;
266+
267+ /* find a free register */
268+ for(r=0;r<NB_REGS;r++) {
269+ if (reg_classes[r] & rc) {
270+ for(p=vstack;p<=vtop;p++) {
271+ if ((p->r & VT_VALMASK) == r ||
272+ (p->r2 & VT_VALMASK) == r)
273+ goto notfound;
274+ }
275+ return r;
276+ }
277+ notfound: ;
278+ }
279+
280+ /* no register left : free the first one on the stack (VERY
281+ IMPORTANT to start from the bottom to ensure that we don't
282+ spill registers used in gen_opi()) */
283+ for(p=vstack;p<=vtop;p++) {
284+ r = p->r & VT_VALMASK;
285+ if (r < VT_CONST && (reg_classes[r] & rc))
286+ goto save_found;
287+ /* also look at second register (if long long) */
288+ r = p->r2 & VT_VALMASK;
289+ if (r < VT_CONST && (reg_classes[r] & rc)) {
290+ save_found:
291+ save_reg(r);
292+ return r;
293+ }
294+ }
295+ /* Should never comes here */
296+ return -1;
297+}
298+
299+/* save registers up to (vtop - n) stack entry */
300+void save_regs(int n)
301+{
302+ int r;
303+ SValue *p, *p1;
304+ p1 = vtop - n;
305+ for(p = vstack;p <= p1; p++) {
306+ r = p->r & VT_VALMASK;
307+ if (r < VT_CONST) {
308+ save_reg(r);
309+ }
310+ }
311+}
312+
313+/* move register 's' to 'r', and flush previous value of r to memory
314+ if needed */
315+void move_reg(int r, int s)
316+{
317+ SValue sv;
318+
319+ if (r != s) {
320+ save_reg(r);
321+ sv.type.t = VT_INT;
322+ sv.r = s;
323+ sv.c.ul = 0;
324+ load(r, &sv);
325+ }
326+}
327+
328+/* get address of vtop (vtop MUST BE an lvalue) */
329+void gaddrof(void)
330+{
331+ vtop->r &= ~VT_LVAL;
332+ /* tricky: if saved lvalue, then we can go back to lvalue */
333+ if ((vtop->r & VT_VALMASK) == VT_LLOCAL)
334+ vtop->r = (vtop->r & ~(VT_VALMASK | VT_LVAL_TYPE)) | VT_LOCAL | VT_LVAL;
335+}
336+
337+#ifdef CONFIG_TCC_BCHECK
338+/* generate lvalue bound code */
339+void gbound(void)
340+{
341+ int lval_type;
342+ CType type1;
343+
344+ vtop->r &= ~VT_MUSTBOUND;
345+ /* if lvalue, then use checking code before dereferencing */
346+ if (vtop->r & VT_LVAL) {
347+ /* if not VT_BOUNDED value, then make one */
348+ if (!(vtop->r & VT_BOUNDED)) {
349+ lval_type = vtop->r & (VT_LVAL_TYPE | VT_LVAL);
350+ /* must save type because we must set it to int to get pointer */
351+ type1 = vtop->type;
352+ vtop->type.t = VT_INT;
353+ gaddrof();
354+ vpushi(0);
355+ gen_bounded_ptr_add();
356+ vtop->r |= lval_type;
357+ vtop->type = type1;
358+ }
359+ /* then check for dereferencing */
360+ gen_bounded_ptr_deref();
361+ }
362+}
363+#endif
364+
365+/* store vtop a register belonging to class 'rc'. lvalues are
366+ converted to values. Cannot be used if cannot be converted to
367+ register value (such as structures). */
368+int gv(int rc)
369+{
370+ int r, rc2, bit_pos, bit_size, size, align, i;
371+
372+ /* NOTE: get_reg can modify vstack[] */
373+ if (vtop->type.t & VT_BITFIELD) {
374+ CType type;
375+ int bits = 32;
376+ bit_pos = (vtop->type.t >> VT_STRUCT_SHIFT) & 0x3f;
377+ bit_size = (vtop->type.t >> (VT_STRUCT_SHIFT + 6)) & 0x3f;
378+ /* remove bit field info to avoid loops */
379+ vtop->type.t &= ~(VT_BITFIELD | (-1 << VT_STRUCT_SHIFT));
380+ /* cast to int to propagate signedness in following ops */
381+ if ((vtop->type.t & VT_BTYPE) == VT_LLONG) {
382+ type.t = VT_LLONG;
383+ bits = 64;
384+ } else
385+ type.t = VT_INT;
386+ if((vtop->type.t & VT_UNSIGNED) ||
387+ (vtop->type.t & VT_BTYPE) == VT_BOOL)
388+ type.t |= VT_UNSIGNED;
389+ gen_cast(&type);
390+ /* generate shifts */
391+ vpushi(bits - (bit_pos + bit_size));
392+ gen_op(TOK_SHL);
393+ vpushi(bits - bit_size);
394+ /* NOTE: transformed to SHR if unsigned */
395+ gen_op(TOK_SAR);
396+ r = gv(rc);
397+ } else {
398+ if (is_float(vtop->type.t) &&
399+ (vtop->r & (VT_VALMASK | VT_LVAL)) == VT_CONST) {
400+ Sym *sym;
401+ int *ptr;
402+ unsigned long offset;
403+#if defined(TCC_TARGET_ARM) && !defined(TCC_ARM_VFP)
404+ CValue check;
405+#endif
406+
407+ /* XXX: unify with initializers handling ? */
408+ /* CPUs usually cannot use float constants, so we store them
409+ generically in data segment */
410+ size = type_size(&vtop->type, &align);
411+ offset = (data_section->data_offset + align - 1) & -align;
412+ data_section->data_offset = offset;
413+ /* XXX: not portable yet */
414+#if defined(__i386__) || defined(__x86_64__)
415+ /* Zero pad x87 tenbyte long doubles */
416+ if (size == LDOUBLE_SIZE)
417+ vtop->c.tab[2] &= 0xffff;
418+#endif
419+ ptr = section_ptr_add(data_section, size);
420+ size = size >> 2;
421+#if defined(TCC_TARGET_ARM) && !defined(TCC_ARM_VFP)
422+ check.d = 1;
423+ if(check.tab[0])
424+ for(i=0;i<size;i++)
425+ ptr[i] = vtop->c.tab[size-1-i];
426+ else
427+#endif
428+ for(i=0;i<size;i++)
429+ ptr[i] = vtop->c.tab[i];
430+ sym = get_sym_ref(&vtop->type, data_section, offset, size << 2);
431+ vtop->r |= VT_LVAL | VT_SYM;
432+ vtop->sym = sym;
433+ vtop->c.ul = 0;
434+ }
435+#ifdef CONFIG_TCC_BCHECK
436+ if (vtop->r & VT_MUSTBOUND)
437+ gbound();
438+#endif
439+
440+ r = vtop->r & VT_VALMASK;
441+ rc2 = RC_INT;
442+ if (rc == RC_IRET)
443+ rc2 = RC_LRET;
444+ /* need to reload if:
445+ - constant
446+ - lvalue (need to dereference pointer)
447+ - already a register, but not in the right class */
448+ if (r >= VT_CONST ||
449+ (vtop->r & VT_LVAL) ||
450+ !(reg_classes[r] & rc) ||
451+ ((vtop->type.t & VT_BTYPE) == VT_LLONG &&
452+ !(reg_classes[vtop->r2] & rc2))) {
453+ r = get_reg(rc);
454+#ifndef TCC_TARGET_X86_64
455+ if ((vtop->type.t & VT_BTYPE) == VT_LLONG) {
456+ int r2;
457+ unsigned long long ll;
458+ /* two register type load : expand to two words
459+ temporarily */
460+ if ((vtop->r & (VT_VALMASK | VT_LVAL)) == VT_CONST) {
461+ /* load constant */
462+ ll = vtop->c.ull;
463+ vtop->c.ui = ll; /* first word */
464+ load(r, vtop);
465+ vtop->r = r; /* save register value */
466+ vpushi(ll >> 32); /* second word */
467+ } else if (r >= VT_CONST || /* XXX: test to VT_CONST incorrect ? */
468+ (vtop->r & VT_LVAL)) {
469+ /* We do not want to modifier the long long
470+ pointer here, so the safest (and less
471+ efficient) is to save all the other registers
472+ in the stack. XXX: totally inefficient. */
473+ save_regs(1);
474+ /* load from memory */
475+ load(r, vtop);
476+ vdup();
477+ vtop[-1].r = r; /* save register value */
478+ /* increment pointer to get second word */
479+ vtop->type.t = VT_INT;
480+ gaddrof();
481+ vpushi(4);
482+ gen_op('+');
483+ vtop->r |= VT_LVAL;
484+ } else {
485+ /* move registers */
486+ load(r, vtop);
487+ vdup();
488+ vtop[-1].r = r; /* save register value */
489+ vtop->r = vtop[-1].r2;
490+ }
491+ /* allocate second register */
492+ r2 = get_reg(rc2);
493+ load(r2, vtop);
494+ vpop();
495+ /* write second register */
496+ vtop->r2 = r2;
497+ } else
498+#endif
499+ if ((vtop->r & VT_LVAL) && !is_float(vtop->type.t)) {
500+ int t1, t;
501+ /* lvalue of scalar type : need to use lvalue type
502+ because of possible cast */
503+ t = vtop->type.t;
504+ t1 = t;
505+ /* compute memory access type */
506+ if (vtop->r & VT_LVAL_BYTE)
507+ t = VT_BYTE;
508+ else if (vtop->r & VT_LVAL_SHORT)
509+ t = VT_SHORT;
510+ if (vtop->r & VT_LVAL_UNSIGNED)
511+ t |= VT_UNSIGNED;
512+ vtop->type.t = t;
513+ load(r, vtop);
514+ /* restore wanted type */
515+ vtop->type.t = t1;
516+ } else {
517+ /* one register type load */
518+ load(r, vtop);
519+ }
520+ }
521+ vtop->r = r;
522+#ifdef TCC_TARGET_C67
523+ /* uses register pairs for doubles */
524+ if ((vtop->type.t & VT_BTYPE) == VT_DOUBLE)
525+ vtop->r2 = r+1;
526+#endif
527+ }
528+ return r;
529+}
530+
531+/* generate vtop[-1] and vtop[0] in resp. classes rc1 and rc2 */
532+void gv2(int rc1, int rc2)
533+{
534+ int v;
535+
536+ /* generate more generic register first. But VT_JMP or VT_CMP
537+ values must be generated first in all cases to avoid possible
538+ reload errors */
539+ v = vtop[0].r & VT_VALMASK;
540+ if (v != VT_CMP && (v & ~1) != VT_JMP && rc1 <= rc2) {
541+ vswap();
542+ gv(rc1);
543+ vswap();
544+ gv(rc2);
545+ /* test if reload is needed for first register */
546+ if ((vtop[-1].r & VT_VALMASK) >= VT_CONST) {
547+ vswap();
548+ gv(rc1);
549+ vswap();
550+ }
551+ } else {
552+ gv(rc2);
553+ vswap();
554+ gv(rc1);
555+ vswap();
556+ /* test if reload is needed for first register */
557+ if ((vtop[0].r & VT_VALMASK) >= VT_CONST) {
558+ gv(rc2);
559+ }
560+ }
561+}
562+
563+/* wrapper around RC_FRET to return a register by type */
564+int rc_fret(int t)
565+{
566+#ifdef TCC_TARGET_X86_64
567+ if (t == VT_LDOUBLE) {
568+ return RC_ST0;
569+ }
570+#endif
571+ return RC_FRET;
572+}
573+
574+/* wrapper around REG_FRET to return a register by type */
575+int reg_fret(int t)
576+{
577+#ifdef TCC_TARGET_X86_64
578+ if (t == VT_LDOUBLE) {
579+ return TREG_ST0;
580+ }
581+#endif
582+ return REG_FRET;
583+}
584+
585+/* expand long long on stack in two int registers */
586+void lexpand(void)
587+{
588+ int u;
589+
590+ u = vtop->type.t & VT_UNSIGNED;
591+ gv(RC_INT);
592+ vdup();
593+ vtop[0].r = vtop[-1].r2;
594+ vtop[0].r2 = VT_CONST;
595+ vtop[-1].r2 = VT_CONST;
596+ vtop[0].type.t = VT_INT | u;
597+ vtop[-1].type.t = VT_INT | u;
598+}
599+
600+#ifdef TCC_TARGET_ARM
601+/* expand long long on stack */
602+void lexpand_nr(void)
603+{
604+ int u,v;
605+
606+ u = vtop->type.t & VT_UNSIGNED;
607+ vdup();
608+ vtop->r2 = VT_CONST;
609+ vtop->type.t = VT_INT | u;
610+ v=vtop[-1].r & (VT_VALMASK | VT_LVAL);
611+ if (v == VT_CONST) {
612+ vtop[-1].c.ui = vtop->c.ull;
613+ vtop->c.ui = vtop->c.ull >> 32;
614+ vtop->r = VT_CONST;
615+ } else if (v == (VT_LVAL|VT_CONST) || v == (VT_LVAL|VT_LOCAL)) {
616+ vtop->c.ui += 4;
617+ vtop->r = vtop[-1].r;
618+ } else if (v > VT_CONST) {
619+ vtop--;
620+ lexpand();
621+ } else
622+ vtop->r = vtop[-1].r2;
623+ vtop[-1].r2 = VT_CONST;
624+ vtop[-1].type.t = VT_INT | u;
625+}
626+#endif
627+
628+/* build a long long from two ints */
629+void lbuild(int t)
630+{
631+ gv2(RC_INT, RC_INT);
632+ vtop[-1].r2 = vtop[0].r;
633+ vtop[-1].type.t = t;
634+ vpop();
635+}
636+
637+/* rotate n first stack elements to the bottom
638+ I1 ... In -> I2 ... In I1 [top is right]
639+*/
640+void vrotb(int n)
641+{
642+ int i;
643+ SValue tmp;
644+
645+ tmp = vtop[-n + 1];
646+ for(i=-n+1;i!=0;i++)
647+ vtop[i] = vtop[i+1];
648+ vtop[0] = tmp;
649+}
650+
651+/* rotate n first stack elements to the top
652+ I1 ... In -> In I1 ... I(n-1) [top is right]
653+ */
654+void vrott(int n)
655+{
656+ int i;
657+ SValue tmp;
658+
659+ tmp = vtop[0];
660+ for(i = 0;i < n - 1; i++)
661+ vtop[-i] = vtop[-i - 1];
662+ vtop[-n + 1] = tmp;
663+}
664+
665+#ifdef TCC_TARGET_ARM
666+/* like vrott but in other direction
667+ In ... I1 -> I(n-1) ... I1 In [top is right]
668+ */
669+void vnrott(int n)
670+{
671+ int i;
672+ SValue tmp;
673+
674+ tmp = vtop[-n + 1];
675+ for(i = n - 1; i > 0; i--)
676+ vtop[-i] = vtop[-i + 1];
677+ vtop[0] = tmp;
678+}
679+#endif
680+
681+/* pop stack value */
682+void vpop(void)
683+{
684+ int v;
685+ v = vtop->r & VT_VALMASK;
686+#if defined(TCC_TARGET_I386) || defined(TCC_TARGET_X86_64)
687+ /* for x86, we need to pop the FP stack */
688+ if (v == TREG_ST0 && !nocode_wanted) {
689+ o(0xd9dd); /* fstp %st(1) */
690+ } else
691+#endif
692+ if (v == VT_JMP || v == VT_JMPI) {
693+ /* need to put correct jump if && or || without test */
694+ gsym(vtop->c.ul);
695+ }
696+ vtop--;
697+}
698+
699+/* convert stack entry to register and duplicate its value in another
700+ register */
701+void gv_dup(void)
702+{
703+ int rc, t, r, r1;
704+ SValue sv;
705+
706+ t = vtop->type.t;
707+ if ((t & VT_BTYPE) == VT_LLONG) {
708+ lexpand();
709+ gv_dup();
710+ vswap();
711+ vrotb(3);
712+ gv_dup();
713+ vrotb(4);
714+ /* stack: H L L1 H1 */
715+ lbuild(t);
716+ vrotb(3);
717+ vrotb(3);
718+ vswap();
719+ lbuild(t);
720+ vswap();
721+ } else {
722+ /* duplicate value */
723+ rc = RC_INT;
724+ sv.type.t = VT_INT;
725+ if (is_float(t)) {
726+ rc = RC_FLOAT;
727+#ifdef TCC_TARGET_X86_64
728+ if ((t & VT_BTYPE) == VT_LDOUBLE) {
729+ rc = RC_ST0;
730+ }
731+#endif
732+ sv.type.t = t;
733+ }
734+ r = gv(rc);
735+ r1 = get_reg(rc);
736+ sv.r = r;
737+ sv.c.ul = 0;
738+ load(r1, &sv); /* move r to r1 */
739+ vdup();
740+ /* duplicates value */
741+ vtop->r = r1;
742+ }
743+}
744+
745+#ifndef TCC_TARGET_X86_64
746+/* generate CPU independent (unsigned) long long operations */
747+void gen_opl(int op)
748+{
749+ int t, a, b, op1, c, i;
750+ int func;
751+ unsigned short reg_iret = REG_IRET;
752+ unsigned short reg_lret = REG_LRET;
753+ SValue tmp;
754+
755+ switch(op) {
756+ case '/':
757+ case TOK_PDIV:
758+ func = TOK___divdi3;
759+ goto gen_func;
760+ case TOK_UDIV:
761+ func = TOK___udivdi3;
762+ goto gen_func;
763+ case '%':
764+ func = TOK___moddi3;
765+ goto gen_mod_func;
766+ case TOK_UMOD:
767+ func = TOK___umoddi3;
768+ gen_mod_func:
769+#ifdef TCC_ARM_EABI
770+ reg_iret = TREG_R2;
771+ reg_lret = TREG_R3;
772+#endif
773+ gen_func:
774+ /* call generic long long function */
775+ vpush_global_sym(&func_old_type, func);
776+ vrott(3);
777+ gfunc_call(2);
778+ vpushi(0);
779+ vtop->r = reg_iret;
780+ vtop->r2 = reg_lret;
781+ break;
782+ case '^':
783+ case '&':
784+ case '|':
785+ case '*':
786+ case '+':
787+ case '-':
788+ t = vtop->type.t;
789+ vswap();
790+ lexpand();
791+ vrotb(3);
792+ lexpand();
793+ /* stack: L1 H1 L2 H2 */
794+ tmp = vtop[0];
795+ vtop[0] = vtop[-3];
796+ vtop[-3] = tmp;
797+ tmp = vtop[-2];
798+ vtop[-2] = vtop[-3];
799+ vtop[-3] = tmp;
800+ vswap();
801+ /* stack: H1 H2 L1 L2 */
802+ if (op == '*') {
803+ vpushv(vtop - 1);
804+ vpushv(vtop - 1);
805+ gen_op(TOK_UMULL);
806+ lexpand();
807+ /* stack: H1 H2 L1 L2 ML MH */
808+ for(i=0;i<4;i++)
809+ vrotb(6);
810+ /* stack: ML MH H1 H2 L1 L2 */
811+ tmp = vtop[0];
812+ vtop[0] = vtop[-2];
813+ vtop[-2] = tmp;
814+ /* stack: ML MH H1 L2 H2 L1 */
815+ gen_op('*');
816+ vrotb(3);
817+ vrotb(3);
818+ gen_op('*');
819+ /* stack: ML MH M1 M2 */
820+ gen_op('+');
821+ gen_op('+');
822+ } else if (op == '+' || op == '-') {
823+ /* XXX: add non carry method too (for MIPS or alpha) */
824+ if (op == '+')
825+ op1 = TOK_ADDC1;
826+ else
827+ op1 = TOK_SUBC1;
828+ gen_op(op1);
829+ /* stack: H1 H2 (L1 op L2) */
830+ vrotb(3);
831+ vrotb(3);
832+ gen_op(op1 + 1); /* TOK_xxxC2 */
833+ } else {
834+ gen_op(op);
835+ /* stack: H1 H2 (L1 op L2) */
836+ vrotb(3);
837+ vrotb(3);
838+ /* stack: (L1 op L2) H1 H2 */
839+ gen_op(op);
840+ /* stack: (L1 op L2) (H1 op H2) */
841+ }
842+ /* stack: L H */
843+ lbuild(t);
844+ break;
845+ case TOK_SAR:
846+ case TOK_SHR:
847+ case TOK_SHL:
848+ if ((vtop->r & (VT_VALMASK | VT_LVAL | VT_SYM)) == VT_CONST) {
849+ t = vtop[-1].type.t;
850+ vswap();
851+ lexpand();
852+ vrotb(3);
853+ /* stack: L H shift */
854+ c = (int)vtop->c.i;
855+ /* constant: simpler */
856+ /* NOTE: all comments are for SHL. the other cases are
857+ done by swaping words */
858+ vpop();
859+ if (op != TOK_SHL)
860+ vswap();
861+ if (c >= 32) {
862+ /* stack: L H */
863+ vpop();
864+ if (c > 32) {
865+ vpushi(c - 32);
866+ gen_op(op);
867+ }
868+ if (op != TOK_SAR) {
869+ vpushi(0);
870+ } else {
871+ gv_dup();
872+ vpushi(31);
873+ gen_op(TOK_SAR);
874+ }
875+ vswap();
876+ } else {
877+ vswap();
878+ gv_dup();
879+ /* stack: H L L */
880+ vpushi(c);
881+ gen_op(op);
882+ vswap();
883+ vpushi(32 - c);
884+ if (op == TOK_SHL)
885+ gen_op(TOK_SHR);
886+ else
887+ gen_op(TOK_SHL);
888+ vrotb(3);
889+ /* stack: L L H */
890+ vpushi(c);
891+ if (op == TOK_SHL)
892+ gen_op(TOK_SHL);
893+ else
894+ gen_op(TOK_SHR);
895+ gen_op('|');
896+ }
897+ if (op != TOK_SHL)
898+ vswap();
899+ lbuild(t);
900+ } else {
901+ /* XXX: should provide a faster fallback on x86 ? */
902+ switch(op) {
903+ case TOK_SAR:
904+ func = TOK___ashrdi3;
905+ goto gen_func;
906+ case TOK_SHR:
907+ func = TOK___lshrdi3;
908+ goto gen_func;
909+ case TOK_SHL:
910+ func = TOK___ashldi3;
911+ goto gen_func;
912+ }
913+ }
914+ break;
915+ default:
916+ /* compare operations */
917+ t = vtop->type.t;
918+ vswap();
919+ lexpand();
920+ vrotb(3);
921+ lexpand();
922+ /* stack: L1 H1 L2 H2 */
923+ tmp = vtop[-1];
924+ vtop[-1] = vtop[-2];
925+ vtop[-2] = tmp;
926+ /* stack: L1 L2 H1 H2 */
927+ /* compare high */
928+ op1 = op;
929+ /* when values are equal, we need to compare low words. since
930+ the jump is inverted, we invert the test too. */
931+ if (op1 == TOK_LT)
932+ op1 = TOK_LE;
933+ else if (op1 == TOK_GT)
934+ op1 = TOK_GE;
935+ else if (op1 == TOK_ULT)
936+ op1 = TOK_ULE;
937+ else if (op1 == TOK_UGT)
938+ op1 = TOK_UGE;
939+ a = 0;
940+ b = 0;
941+ gen_op(op1);
942+ if (op1 != TOK_NE) {
943+ a = gtst(1, 0);
944+ }
945+ if (op != TOK_EQ) {
946+ /* generate non equal test */
947+ /* XXX: NOT PORTABLE yet */
948+ if (a == 0) {
949+ b = gtst(0, 0);
950+ } else {
951+#if defined(TCC_TARGET_I386)
952+ b = psym(0x850f, 0);
953+#elif defined(TCC_TARGET_ARM)
954+ b = ind;
955+ o(0x1A000000 | encbranch(ind, 0, 1));
956+#elif defined(TCC_TARGET_C67)
957+ error("not implemented");
958+#else
959+#error not supported
960+#endif
961+ }
962+ }
963+ /* compare low. Always unsigned */
964+ op1 = op;
965+ if (op1 == TOK_LT)
966+ op1 = TOK_ULT;
967+ else if (op1 == TOK_LE)
968+ op1 = TOK_ULE;
969+ else if (op1 == TOK_GT)
970+ op1 = TOK_UGT;
971+ else if (op1 == TOK_GE)
972+ op1 = TOK_UGE;
973+ gen_op(op1);
974+ a = gtst(1, a);
975+ gsym(b);
976+ vseti(VT_JMPI, a);
977+ break;
978+ }
979+}
980+#endif
981+
982+/* handle integer constant optimizations and various machine
983+ independent opt */
984+void gen_opic(int op)
985+{
986+ int c1, c2, t1, t2, n;
987+ SValue *v1, *v2;
988+ long long l1, l2;
989+ typedef unsigned long long U;
990+
991+ v1 = vtop - 1;
992+ v2 = vtop;
993+ t1 = v1->type.t & VT_BTYPE;
994+ t2 = v2->type.t & VT_BTYPE;
995+
996+ if (t1 == VT_LLONG)
997+ l1 = v1->c.ll;
998+ else if (v1->type.t & VT_UNSIGNED)
999+ l1 = v1->c.ui;
1000+ else
1001+ l1 = v1->c.i;
1002+
1003+ if (t2 == VT_LLONG)
1004+ l2 = v2->c.ll;
1005+ else if (v2->type.t & VT_UNSIGNED)
1006+ l2 = v2->c.ui;
1007+ else
1008+ l2 = v2->c.i;
1009+
1010+ /* currently, we cannot do computations with forward symbols */
1011+ c1 = (v1->r & (VT_VALMASK | VT_LVAL | VT_SYM)) == VT_CONST;
1012+ c2 = (v2->r & (VT_VALMASK | VT_LVAL | VT_SYM)) == VT_CONST;
1013+ if (c1 && c2) {
1014+ switch(op) {
1015+ case '+': l1 += l2; break;
1016+ case '-': l1 -= l2; break;
1017+ case '&': l1 &= l2; break;
1018+ case '^': l1 ^= l2; break;
1019+ case '|': l1 |= l2; break;
1020+ case '*': l1 *= l2; break;
1021+
1022+ case TOK_PDIV:
1023+ case '/':
1024+ case '%':
1025+ case TOK_UDIV:
1026+ case TOK_UMOD:
1027+ /* if division by zero, generate explicit division */
1028+ if (l2 == 0) {
1029+ if (const_wanted)
1030+ error("division by zero in constant");
1031+ goto general_case;
1032+ }
1033+ switch(op) {
1034+ default: l1 /= l2; break;
1035+ case '%': l1 %= l2; break;
1036+ case TOK_UDIV: l1 = (U)l1 / l2; break;
1037+ case TOK_UMOD: l1 = (U)l1 % l2; break;
1038+ }
1039+ break;
1040+ case TOK_SHL: l1 <<= l2; break;
1041+ case TOK_SHR: l1 = (U)l1 >> l2; break;
1042+ case TOK_SAR: l1 >>= l2; break;
1043+ /* tests */
1044+ case TOK_ULT: l1 = (U)l1 < (U)l2; break;
1045+ case TOK_UGE: l1 = (U)l1 >= (U)l2; break;
1046+ case TOK_EQ: l1 = l1 == l2; break;
1047+ case TOK_NE: l1 = l1 != l2; break;
1048+ case TOK_ULE: l1 = (U)l1 <= (U)l2; break;
1049+ case TOK_UGT: l1 = (U)l1 > (U)l2; break;
1050+ case TOK_LT: l1 = l1 < l2; break;
1051+ case TOK_GE: l1 = l1 >= l2; break;
1052+ case TOK_LE: l1 = l1 <= l2; break;
1053+ case TOK_GT: l1 = l1 > l2; break;
1054+ /* logical */
1055+ case TOK_LAND: l1 = l1 && l2; break;
1056+ case TOK_LOR: l1 = l1 || l2; break;
1057+ default:
1058+ goto general_case;
1059+ }
1060+ v1->c.ll = l1;
1061+ vtop--;
1062+ } else {
1063+ /* if commutative ops, put c2 as constant */
1064+ if (c1 && (op == '+' || op == '&' || op == '^' ||
1065+ op == '|' || op == '*')) {
1066+ vswap();
1067+ c2 = c1; //c = c1, c1 = c2, c2 = c;
1068+ l2 = l1; //l = l1, l1 = l2, l2 = l;
1069+ }
1070+ /* Filter out NOP operations like x*1, x-0, x&-1... */
1071+ if (c2 && (((op == '*' || op == '/' || op == TOK_UDIV ||
1072+ op == TOK_PDIV) &&
1073+ l2 == 1) ||
1074+ ((op == '+' || op == '-' || op == '|' || op == '^' ||
1075+ op == TOK_SHL || op == TOK_SHR || op == TOK_SAR) &&
1076+ l2 == 0) ||
1077+ (op == '&' &&
1078+ l2 == -1))) {
1079+ /* nothing to do */
1080+ vtop--;
1081+ } else if (c2 && (op == '*' || op == TOK_PDIV || op == TOK_UDIV)) {
1082+ /* try to use shifts instead of muls or divs */
1083+ if (l2 > 0 && (l2 & (l2 - 1)) == 0) {
1084+ n = -1;
1085+ while (l2) {
1086+ l2 >>= 1;
1087+ n++;
1088+ }
1089+ vtop->c.ll = n;
1090+ if (op == '*')
1091+ op = TOK_SHL;
1092+ else if (op == TOK_PDIV)
1093+ op = TOK_SAR;
1094+ else
1095+ op = TOK_SHR;
1096+ }
1097+ goto general_case;
1098+ } else if (c2 && (op == '+' || op == '-') &&
1099+ ((vtop[-1].r & (VT_VALMASK | VT_LVAL | VT_SYM)) ==
1100+ (VT_CONST | VT_SYM) ||
1101+ (vtop[-1].r & (VT_VALMASK | VT_LVAL)) == VT_LOCAL)) {
1102+ /* symbol + constant case */
1103+ if (op == '-')
1104+ l2 = -l2;
1105+ vtop--;
1106+ vtop->c.ll += l2;
1107+ } else {
1108+ general_case:
1109+ if (!nocode_wanted) {
1110+ /* call low level op generator */
1111+ if (t1 == VT_LLONG || t2 == VT_LLONG)
1112+ gen_opl(op);
1113+ else
1114+ gen_opi(op);
1115+ } else {
1116+ vtop--;
1117+ }
1118+ }
1119+ }
1120+}
1121+
1122+/* generate a floating point operation with constant propagation */
1123+void gen_opif(int op)
1124+{
1125+ int c1, c2;
1126+ SValue *v1, *v2;
1127+ long double f1, f2;
1128+
1129+ v1 = vtop - 1;
1130+ v2 = vtop;
1131+ /* currently, we cannot do computations with forward symbols */
1132+ c1 = (v1->r & (VT_VALMASK | VT_LVAL | VT_SYM)) == VT_CONST;
1133+ c2 = (v2->r & (VT_VALMASK | VT_LVAL | VT_SYM)) == VT_CONST;
1134+ if (c1 && c2) {
1135+ if (v1->type.t == VT_FLOAT) {
1136+ f1 = v1->c.f;
1137+ f2 = v2->c.f;
1138+ } else if (v1->type.t == VT_DOUBLE) {
1139+ f1 = v1->c.d;
1140+ f2 = v2->c.d;
1141+ } else {
1142+ f1 = v1->c.ld;
1143+ f2 = v2->c.ld;
1144+ }
1145+
1146+ /* NOTE: we only do constant propagation if finite number (not
1147+ NaN or infinity) (ANSI spec) */
1148+ if (!ieee_finite(f1) || !ieee_finite(f2))
1149+ goto general_case;
1150+
1151+ switch(op) {
1152+ case '+': f1 += f2; break;
1153+ case '-': f1 -= f2; break;
1154+ case '*': f1 *= f2; break;
1155+ case '/':
1156+ if (f2 == 0.0) {
1157+ if (const_wanted)
1158+ error("division by zero in constant");
1159+ goto general_case;
1160+ }
1161+ f1 /= f2;
1162+ break;
1163+ /* XXX: also handles tests ? */
1164+ default:
1165+ goto general_case;
1166+ }
1167+ /* XXX: overflow test ? */
1168+ if (v1->type.t == VT_FLOAT) {
1169+ v1->c.f = f1;
1170+ } else if (v1->type.t == VT_DOUBLE) {
1171+ v1->c.d = f1;
1172+ } else {
1173+ v1->c.ld = f1;
1174+ }
1175+ vtop--;
1176+ } else {
1177+ general_case:
1178+ if (!nocode_wanted) {
1179+ gen_opf(op);
1180+ } else {
1181+ vtop--;
1182+ }
1183+ }
1184+}
1185+
1186+static int pointed_size(CType *type)
1187+{
1188+ int align;
1189+ return type_size(pointed_type(type), &align);
1190+}
1191+
1192+static inline int is_null_pointer(SValue *p)
1193+{
1194+ if ((p->r & (VT_VALMASK | VT_LVAL | VT_SYM)) != VT_CONST)
1195+ return 0;
1196+ return ((p->type.t & VT_BTYPE) == VT_INT && p->c.i == 0) ||
1197+ ((p->type.t & VT_BTYPE) == VT_LLONG && p->c.ll == 0);
1198+}
1199+
1200+static inline int is_integer_btype(int bt)
1201+{
1202+ return (bt == VT_BYTE || bt == VT_SHORT ||
1203+ bt == VT_INT || bt == VT_LLONG);
1204+}
1205+
1206+/* check types for comparison or substraction of pointers */
1207+static void check_comparison_pointer_types(SValue *p1, SValue *p2, int op)
1208+{
1209+ CType *type1, *type2, tmp_type1, tmp_type2;
1210+ int bt1, bt2;
1211+
1212+ /* null pointers are accepted for all comparisons as gcc */
1213+ if (is_null_pointer(p1) || is_null_pointer(p2))
1214+ return;
1215+ type1 = &p1->type;
1216+ type2 = &p2->type;
1217+ bt1 = type1->t & VT_BTYPE;
1218+ bt2 = type2->t & VT_BTYPE;
1219+ /* accept comparison between pointer and integer with a warning */
1220+ if ((is_integer_btype(bt1) || is_integer_btype(bt2)) && op != '-') {
1221+ if (op != TOK_LOR && op != TOK_LAND )
1222+ warning("comparison between pointer and integer");
1223+ return;
1224+ }
1225+
1226+ /* both must be pointers or implicit function pointers */
1227+ if (bt1 == VT_PTR) {
1228+ type1 = pointed_type(type1);
1229+ } else if (bt1 != VT_FUNC)
1230+ goto invalid_operands;
1231+
1232+ if (bt2 == VT_PTR) {
1233+ type2 = pointed_type(type2);
1234+ } else if (bt2 != VT_FUNC) {
1235+ invalid_operands:
1236+ error("invalid operands to binary %s", get_tok_str(op, NULL));
1237+ }
1238+ if ((type1->t & VT_BTYPE) == VT_VOID ||
1239+ (type2->t & VT_BTYPE) == VT_VOID)
1240+ return;
1241+ tmp_type1 = *type1;
1242+ tmp_type2 = *type2;
1243+ tmp_type1.t &= ~(VT_UNSIGNED | VT_CONSTANT | VT_VOLATILE);
1244+ tmp_type2.t &= ~(VT_UNSIGNED | VT_CONSTANT | VT_VOLATILE);
1245+ if (!is_compatible_types(&tmp_type1, &tmp_type2)) {
1246+ /* gcc-like error if '-' is used */
1247+ if (op == '-')
1248+ goto invalid_operands;
1249+ else
1250+ warning("comparison of distinct pointer types lacks a cast");
1251+ }
1252+}
1253+
1254+/* generic gen_op: handles types problems */
1255+void gen_op(int op)
1256+{
1257+ int u, t1, t2, bt1, bt2, t;
1258+ CType type1;
1259+
1260+ t1 = vtop[-1].type.t;
1261+ t2 = vtop[0].type.t;
1262+ bt1 = t1 & VT_BTYPE;
1263+ bt2 = t2 & VT_BTYPE;
1264+
1265+ if (bt1 == VT_PTR || bt2 == VT_PTR) {
1266+ /* at least one operand is a pointer */
1267+ /* relationnal op: must be both pointers */
1268+ if (op >= TOK_ULT && op <= TOK_LOR) {
1269+ check_comparison_pointer_types(vtop - 1, vtop, op);
1270+ /* pointers are handled are unsigned */
1271+#ifdef TCC_TARGET_X86_64
1272+ t = VT_LLONG | VT_UNSIGNED;
1273+#else
1274+ t = VT_INT | VT_UNSIGNED;
1275+#endif
1276+ goto std_op;
1277+ }
1278+ /* if both pointers, then it must be the '-' op */
1279+ if (bt1 == VT_PTR && bt2 == VT_PTR) {
1280+ if (op != '-')
1281+ error("cannot use pointers here");
1282+ check_comparison_pointer_types(vtop - 1, vtop, op);
1283+ /* XXX: check that types are compatible */
1284+ u = pointed_size(&vtop[-1].type);
1285+ gen_opic(op);
1286+ /* set to integer type */
1287+#ifdef TCC_TARGET_X86_64
1288+ vtop->type.t = VT_LLONG;
1289+#else
1290+ vtop->type.t = VT_INT;
1291+#endif
1292+ vpushi(u);
1293+ gen_op(TOK_PDIV);
1294+ } else {
1295+ /* exactly one pointer : must be '+' or '-'. */
1296+ if (op != '-' && op != '+')
1297+ error("cannot use pointers here");
1298+ /* Put pointer as first operand */
1299+ if (bt2 == VT_PTR) {
1300+ vswap();
1301+ swap(&t1, &t2);
1302+ }
1303+ type1 = vtop[-1].type;
1304+#ifdef TCC_TARGET_X86_64
1305+ vpushll(pointed_size(&vtop[-1].type));
1306+#else
1307+ /* XXX: cast to int ? (long long case) */
1308+ vpushi(pointed_size(&vtop[-1].type));
1309+#endif
1310+ gen_op('*');
1311+#ifdef CONFIG_TCC_BCHECK
1312+ /* if evaluating constant expression, no code should be
1313+ generated, so no bound check */
1314+ if (do_bounds_check && !const_wanted) {
1315+ /* if bounded pointers, we generate a special code to
1316+ test bounds */
1317+ if (op == '-') {
1318+ vpushi(0);
1319+ vswap();
1320+ gen_op('-');
1321+ }
1322+ gen_bounded_ptr_add();
1323+ } else
1324+#endif
1325+ {
1326+ gen_opic(op);
1327+ }
1328+ /* put again type if gen_opic() swaped operands */
1329+ vtop->type = type1;
1330+ }
1331+ } else if (is_float(bt1) || is_float(bt2)) {
1332+ /* compute bigger type and do implicit casts */
1333+ if (bt1 == VT_LDOUBLE || bt2 == VT_LDOUBLE) {
1334+ t = VT_LDOUBLE;
1335+ } else if (bt1 == VT_DOUBLE || bt2 == VT_DOUBLE) {
1336+ t = VT_DOUBLE;
1337+ } else {
1338+ t = VT_FLOAT;
1339+ }
1340+ /* floats can only be used for a few operations */
1341+ if (op != '+' && op != '-' && op != '*' && op != '/' &&
1342+ (op < TOK_ULT || op > TOK_GT))
1343+ error("invalid operands for binary operation");
1344+ goto std_op;
1345+ } else if (bt1 == VT_LLONG || bt2 == VT_LLONG) {
1346+ /* cast to biggest op */
1347+ t = VT_LLONG;
1348+ /* convert to unsigned if it does not fit in a long long */
1349+ if ((t1 & (VT_BTYPE | VT_UNSIGNED)) == (VT_LLONG | VT_UNSIGNED) ||
1350+ (t2 & (VT_BTYPE | VT_UNSIGNED)) == (VT_LLONG | VT_UNSIGNED))
1351+ t |= VT_UNSIGNED;
1352+ goto std_op;
1353+ } else {
1354+ /* integer operations */
1355+ t = VT_INT;
1356+ /* convert to unsigned if it does not fit in an integer */
1357+ if ((t1 & (VT_BTYPE | VT_UNSIGNED)) == (VT_INT | VT_UNSIGNED) ||
1358+ (t2 & (VT_BTYPE | VT_UNSIGNED)) == (VT_INT | VT_UNSIGNED))
1359+ t |= VT_UNSIGNED;
1360+ std_op:
1361+ /* XXX: currently, some unsigned operations are explicit, so
1362+ we modify them here */
1363+ if (t & VT_UNSIGNED) {
1364+ if (op == TOK_SAR)
1365+ op = TOK_SHR;
1366+ else if (op == '/')
1367+ op = TOK_UDIV;
1368+ else if (op == '%')
1369+ op = TOK_UMOD;
1370+ else if (op == TOK_LT)
1371+ op = TOK_ULT;
1372+ else if (op == TOK_GT)
1373+ op = TOK_UGT;
1374+ else if (op == TOK_LE)
1375+ op = TOK_ULE;
1376+ else if (op == TOK_GE)
1377+ op = TOK_UGE;
1378+ }
1379+ vswap();
1380+ type1.t = t;
1381+ gen_cast(&type1);
1382+ vswap();
1383+ /* special case for shifts and long long: we keep the shift as
1384+ an integer */
1385+ if (op == TOK_SHR || op == TOK_SAR || op == TOK_SHL)
1386+ type1.t = VT_INT;
1387+ gen_cast(&type1);
1388+ if (is_float(t))
1389+ gen_opif(op);
1390+ else
1391+ gen_opic(op);
1392+ if (op >= TOK_ULT && op <= TOK_GT) {
1393+ /* relationnal op: the result is an int */
1394+ vtop->type.t = VT_INT;
1395+ } else {
1396+ vtop->type.t = t;
1397+ }
1398+ }
1399+}
1400+
1401+#ifndef TCC_TARGET_ARM
1402+/* generic itof for unsigned long long case */
1403+void gen_cvt_itof1(int t)
1404+{
1405+ if ((vtop->type.t & (VT_BTYPE | VT_UNSIGNED)) ==
1406+ (VT_LLONG | VT_UNSIGNED)) {
1407+
1408+ if (t == VT_FLOAT)
1409+ vpush_global_sym(&func_old_type, TOK___floatundisf);
1410+#if LDOUBLE_SIZE != 8
1411+ else if (t == VT_LDOUBLE)
1412+ vpush_global_sym(&func_old_type, TOK___floatundixf);
1413+#endif
1414+ else
1415+ vpush_global_sym(&func_old_type, TOK___floatundidf);
1416+ vrott(2);
1417+ gfunc_call(1);
1418+ vpushi(0);
1419+ vtop->r = reg_fret(t);
1420+ } else {
1421+ gen_cvt_itof(t);
1422+ }
1423+}
1424+#endif
1425+
1426+/* generic ftoi for unsigned long long case */
1427+void gen_cvt_ftoi1(int t)
1428+{
1429+ int st;
1430+
1431+ if (t == (VT_LLONG | VT_UNSIGNED)) {
1432+ /* not handled natively */
1433+ st = vtop->type.t & VT_BTYPE;
1434+ if (st == VT_FLOAT)
1435+ vpush_global_sym(&func_old_type, TOK___fixunssfdi);
1436+#if LDOUBLE_SIZE != 8
1437+ else if (st == VT_LDOUBLE)
1438+ vpush_global_sym(&func_old_type, TOK___fixunsxfdi);
1439+#endif
1440+ else
1441+ vpush_global_sym(&func_old_type, TOK___fixunsdfdi);
1442+ vrott(2);
1443+ gfunc_call(1);
1444+ vpushi(0);
1445+ vtop->r = REG_IRET;
1446+ vtop->r2 = REG_LRET;
1447+ } else {
1448+ gen_cvt_ftoi(t);
1449+ }
1450+}
1451+
1452+/* force char or short cast */
1453+void force_charshort_cast(int t)
1454+{
1455+ int bits, dbt;
1456+ dbt = t & VT_BTYPE;
1457+ /* XXX: add optimization if lvalue : just change type and offset */
1458+ if (dbt == VT_BYTE)
1459+ bits = 8;
1460+ else
1461+ bits = 16;
1462+ if (t & VT_UNSIGNED) {
1463+ vpushi((1 << bits) - 1);
1464+ gen_op('&');
1465+ } else {
1466+ bits = 32 - bits;
1467+ vpushi(bits);
1468+ gen_op(TOK_SHL);
1469+ /* result must be signed or the SAR is converted to an SHL
1470+ This was not the case when "t" was a signed short
1471+ and the last value on the stack was an unsigned int */
1472+ vtop->type.t &= ~VT_UNSIGNED;
1473+ vpushi(bits);
1474+ gen_op(TOK_SAR);
1475+ }
1476+}
1477+
1478+/* cast 'vtop' to 'type'. Casting to bitfields is forbidden. */
1479+static void gen_cast(CType *type)
1480+{
1481+ int sbt, dbt, sf, df, c, p;
1482+
1483+ /* special delayed cast for char/short */
1484+ /* XXX: in some cases (multiple cascaded casts), it may still
1485+ be incorrect */
1486+ if (vtop->r & VT_MUSTCAST) {
1487+ vtop->r &= ~VT_MUSTCAST;
1488+ force_charshort_cast(vtop->type.t);
1489+ }
1490+
1491+ /* bitfields first get cast to ints */
1492+ if (vtop->type.t & VT_BITFIELD) {
1493+ gv(RC_INT);
1494+ }
1495+
1496+ dbt = type->t & (VT_BTYPE | VT_UNSIGNED);
1497+ sbt = vtop->type.t & (VT_BTYPE | VT_UNSIGNED);
1498+
1499+ if (sbt != dbt) {
1500+ sf = is_float(sbt);
1501+ df = is_float(dbt);
1502+ c = (vtop->r & (VT_VALMASK | VT_LVAL | VT_SYM)) == VT_CONST;
1503+ p = (vtop->r & (VT_VALMASK | VT_LVAL | VT_SYM)) == (VT_CONST | VT_SYM);
1504+ if (c) {
1505+ /* constant case: we can do it now */
1506+ /* XXX: in ISOC, cannot do it if error in convert */
1507+ if (sbt == VT_FLOAT)
1508+ vtop->c.ld = vtop->c.f;
1509+ else if (sbt == VT_DOUBLE)
1510+ vtop->c.ld = vtop->c.d;
1511+
1512+ if (df) {
1513+ if ((sbt & VT_BTYPE) == VT_LLONG) {
1514+ if (sbt & VT_UNSIGNED)
1515+ vtop->c.ld = vtop->c.ull;
1516+ else
1517+ vtop->c.ld = vtop->c.ll;
1518+ } else if(!sf) {
1519+ if (sbt & VT_UNSIGNED)
1520+ vtop->c.ld = vtop->c.ui;
1521+ else
1522+ vtop->c.ld = vtop->c.i;
1523+ }
1524+
1525+ if (dbt == VT_FLOAT)
1526+ vtop->c.f = (float)vtop->c.ld;
1527+ else if (dbt == VT_DOUBLE)
1528+ vtop->c.d = (double)vtop->c.ld;
1529+ } else if (sf && dbt == (VT_LLONG|VT_UNSIGNED)) {
1530+ vtop->c.ull = (unsigned long long)vtop->c.ld;
1531+ } else if (sf && dbt == VT_BOOL) {
1532+ vtop->c.i = (vtop->c.ld != 0);
1533+ } else {
1534+ if(sf)
1535+ vtop->c.ll = (long long)vtop->c.ld;
1536+ else if (sbt == (VT_LLONG|VT_UNSIGNED))
1537+ vtop->c.ll = vtop->c.ull;
1538+ else if (sbt & VT_UNSIGNED)
1539+ vtop->c.ll = vtop->c.ui;
1540+ else if (sbt != VT_LLONG)
1541+ vtop->c.ll = vtop->c.i;
1542+
1543+ if (dbt == (VT_LLONG|VT_UNSIGNED))
1544+ vtop->c.ull = vtop->c.ll;
1545+ else if (dbt == VT_BOOL)
1546+ vtop->c.i = (vtop->c.ll != 0);
1547+ else if (dbt != VT_LLONG) {
1548+ int s = 0;
1549+ if ((dbt & VT_BTYPE) == VT_BYTE)
1550+ s = 24;
1551+ else if ((dbt & VT_BTYPE) == VT_SHORT)
1552+ s = 16;
1553+
1554+ if(dbt & VT_UNSIGNED)
1555+ vtop->c.ui = ((unsigned int)vtop->c.ll << s) >> s;
1556+ else
1557+ vtop->c.i = ((int)vtop->c.ll << s) >> s;
1558+ }
1559+ }
1560+ } else if (p && dbt == VT_BOOL) {
1561+ vtop->r = VT_CONST;
1562+ vtop->c.i = 1;
1563+ } else if (!nocode_wanted) {
1564+ /* non constant case: generate code */
1565+ if (sf && df) {
1566+ /* convert from fp to fp */
1567+ gen_cvt_ftof(dbt);
1568+ } else if (df) {
1569+ /* convert int to fp */
1570+ gen_cvt_itof1(dbt);
1571+ } else if (sf) {
1572+ /* convert fp to int */
1573+ if (dbt == VT_BOOL) {
1574+ vpushi(0);
1575+ gen_op(TOK_NE);
1576+ } else {
1577+ /* we handle char/short/etc... with generic code */
1578+ if (dbt != (VT_INT | VT_UNSIGNED) &&
1579+ dbt != (VT_LLONG | VT_UNSIGNED) &&
1580+ dbt != VT_LLONG)
1581+ dbt = VT_INT;
1582+ gen_cvt_ftoi1(dbt);
1583+ if (dbt == VT_INT && (type->t & (VT_BTYPE | VT_UNSIGNED)) != dbt) {
1584+ /* additional cast for char/short... */
1585+ vtop->type.t = dbt;
1586+ gen_cast(type);
1587+ }
1588+ }
1589+#ifndef TCC_TARGET_X86_64
1590+ } else if ((dbt & VT_BTYPE) == VT_LLONG) {
1591+ if ((sbt & VT_BTYPE) != VT_LLONG) {
1592+ /* scalar to long long */
1593+ /* machine independent conversion */
1594+ gv(RC_INT);
1595+ /* generate high word */
1596+ if (sbt == (VT_INT | VT_UNSIGNED)) {
1597+ vpushi(0);
1598+ gv(RC_INT);
1599+ } else {
1600+ if (sbt == VT_PTR) {
1601+ /* cast from pointer to int before we apply
1602+ shift operation, which pointers don't support*/
1603+ gen_cast(&int_type);
1604+ }
1605+ gv_dup();
1606+ vpushi(31);
1607+ gen_op(TOK_SAR);
1608+ }
1609+ /* patch second register */
1610+ vtop[-1].r2 = vtop->r;
1611+ vpop();
1612+ }
1613+#else
1614+ } else if ((dbt & VT_BTYPE) == VT_LLONG ||
1615+ (dbt & VT_BTYPE) == VT_PTR) {
1616+ /* XXX: not sure if this is perfect... need more tests */
1617+ if ((sbt & VT_BTYPE) != VT_LLONG) {
1618+ int r = gv(RC_INT);
1619+ if (sbt != (VT_INT | VT_UNSIGNED) &&
1620+ sbt != VT_PTR && sbt != VT_FUNC) {
1621+ /* x86_64 specific: movslq */
1622+ o(0x6348);
1623+ o(0xc0 + (REG_VALUE(r) << 3) + REG_VALUE(r));
1624+ }
1625+ }
1626+#endif
1627+ } else if (dbt == VT_BOOL) {
1628+ /* scalar to bool */
1629+ vpushi(0);
1630+ gen_op(TOK_NE);
1631+ } else if ((dbt & VT_BTYPE) == VT_BYTE ||
1632+ (dbt & VT_BTYPE) == VT_SHORT) {
1633+ if (sbt == VT_PTR) {
1634+ vtop->type.t = VT_INT;
1635+ warning("nonportable conversion from pointer to char/short");
1636+ }
1637+ force_charshort_cast(dbt);
1638+ } else if ((dbt & VT_BTYPE) == VT_INT) {
1639+ /* scalar to int */
1640+ if (sbt == VT_LLONG) {
1641+ /* from long long: just take low order word */
1642+ lexpand();
1643+ vpop();
1644+ }
1645+ /* if lvalue and single word type, nothing to do because
1646+ the lvalue already contains the real type size (see
1647+ VT_LVAL_xxx constants) */
1648+ }
1649+ }
1650+ } else if ((dbt & VT_BTYPE) == VT_PTR && !(vtop->r & VT_LVAL)) {
1651+ /* if we are casting between pointer types,
1652+ we must update the VT_LVAL_xxx size */
1653+ vtop->r = (vtop->r & ~VT_LVAL_TYPE)
1654+ | (lvalue_type(type->ref->type.t) & VT_LVAL_TYPE);
1655+ }
1656+ vtop->type = *type;
1657+}
1658+
1659+/* return type size. Put alignment at 'a' */
1660+static int type_size(CType *type, int *a)
1661+{
1662+ Sym *s;
1663+ int bt;
1664+
1665+ bt = type->t & VT_BTYPE;
1666+ if (bt == VT_STRUCT) {
1667+ /* struct/union */
1668+ s = type->ref;
1669+ *a = s->r;
1670+ return s->c;
1671+ } else if (bt == VT_PTR) {
1672+ if (type->t & VT_ARRAY) {
1673+ int ts;
1674+
1675+ s = type->ref;
1676+ ts = type_size(&s->type, a);
1677+
1678+ if (ts < 0 && s->c < 0)
1679+ ts = -ts;
1680+
1681+ return ts * s->c;
1682+ } else {
1683+ *a = PTR_SIZE;
1684+ return PTR_SIZE;
1685+ }
1686+ } else if (bt == VT_LDOUBLE) {
1687+ *a = LDOUBLE_ALIGN;
1688+ return LDOUBLE_SIZE;
1689+ } else if (bt == VT_DOUBLE || bt == VT_LLONG) {
1690+#ifdef TCC_TARGET_I386
1691+#ifdef TCC_TARGET_PE
1692+ *a = 8;
1693+#else
1694+ *a = 4;
1695+#endif
1696+#elif defined(TCC_TARGET_ARM)
1697+#ifdef TCC_ARM_EABI
1698+ *a = 8;
1699+#else
1700+ *a = 4;
1701+#endif
1702+#else
1703+ *a = 8;
1704+#endif
1705+ return 8;
1706+ } else if (bt == VT_INT || bt == VT_ENUM || bt == VT_FLOAT) {
1707+ *a = 4;
1708+ return 4;
1709+ } else if (bt == VT_SHORT) {
1710+ *a = 2;
1711+ return 2;
1712+ } else {
1713+ /* char, void, function, _Bool */
1714+ *a = 1;
1715+ return 1;
1716+ }
1717+}
1718+
1719+/* return the pointed type of t */
1720+static inline CType *pointed_type(CType *type)
1721+{
1722+ return &type->ref->type;
1723+}
1724+
1725+/* modify type so that its it is a pointer to type. */
1726+static void mk_pointer(CType *type)
1727+{
1728+ Sym *s;
1729+ s = sym_push(SYM_FIELD, type, 0, -1);
1730+ type->t = VT_PTR | (type->t & ~VT_TYPE);
1731+ type->ref = s;
1732+}
1733+
1734+/* compare function types. OLD functions match any new functions */
1735+static int is_compatible_func(CType *type1, CType *type2)
1736+{
1737+ Sym *s1, *s2;
1738+
1739+ s1 = type1->ref;
1740+ s2 = type2->ref;
1741+ if (!is_compatible_types(&s1->type, &s2->type))
1742+ return 0;
1743+ /* check func_call */
1744+ if (FUNC_CALL(s1->r) != FUNC_CALL(s2->r))
1745+ return 0;
1746+ /* XXX: not complete */
1747+ if (s1->c == FUNC_OLD || s2->c == FUNC_OLD)
1748+ return 1;
1749+ if (s1->c != s2->c)
1750+ return 0;
1751+ while (s1 != NULL) {
1752+ if (s2 == NULL)
1753+ return 0;
1754+ if (!is_compatible_parameter_types(&s1->type, &s2->type))
1755+ return 0;
1756+ s1 = s1->next;
1757+ s2 = s2->next;
1758+ }
1759+ if (s2)
1760+ return 0;
1761+ return 1;
1762+}
1763+
1764+/* return true if type1 and type2 are the same. If unqualified is
1765+ true, qualifiers on the types are ignored.
1766+
1767+ - enums are not checked as gcc __builtin_types_compatible_p ()
1768+ */
1769+static int compare_types(CType *type1, CType *type2, int unqualified)
1770+{
1771+ int bt1, t1, t2;
1772+
1773+ t1 = type1->t & VT_TYPE;
1774+ t2 = type2->t & VT_TYPE;
1775+ if (unqualified) {
1776+ /* strip qualifiers before comparing */
1777+ t1 &= ~(VT_CONSTANT | VT_VOLATILE);
1778+ t2 &= ~(VT_CONSTANT | VT_VOLATILE);
1779+ }
1780+ /* XXX: bitfields ? */
1781+ if (t1 != t2)
1782+ return 0;
1783+ /* test more complicated cases */
1784+ bt1 = t1 & VT_BTYPE;
1785+ if (bt1 == VT_PTR) {
1786+ type1 = pointed_type(type1);
1787+ type2 = pointed_type(type2);
1788+ return is_compatible_types(type1, type2);
1789+ } else if (bt1 == VT_STRUCT) {
1790+ return (type1->ref == type2->ref);
1791+ } else if (bt1 == VT_FUNC) {
1792+ return is_compatible_func(type1, type2);
1793+ } else {
1794+ return 1;
1795+ }
1796+}
1797+
1798+/* return true if type1 and type2 are exactly the same (including
1799+ qualifiers).
1800+*/
1801+static int is_compatible_types(CType *type1, CType *type2)
1802+{
1803+ return compare_types(type1,type2,0);
1804+}
1805+
1806+/* return true if type1 and type2 are the same (ignoring qualifiers).
1807+*/
1808+static int is_compatible_parameter_types(CType *type1, CType *type2)
1809+{
1810+ return compare_types(type1,type2,1);
1811+}
1812+
1813+/* print a type. If 'varstr' is not NULL, then the variable is also
1814+ printed in the type */
1815+/* XXX: union */
1816+/* XXX: add array and function pointers */
1817+void type_to_str(char *buf, int buf_size,
1818+ CType *type, const char *varstr)
1819+{
1820+ int bt, v, t;
1821+ Sym *s, *sa;
1822+ char buf1[256];
1823+ const char *tstr;
1824+
1825+ t = type->t & VT_TYPE;
1826+ bt = t & VT_BTYPE;
1827+ buf[0] = '\0';
1828+ if (t & VT_CONSTANT)
1829+ pstrcat(buf, buf_size, "const ");
1830+ if (t & VT_VOLATILE)
1831+ pstrcat(buf, buf_size, "volatile ");
1832+ if (t & VT_UNSIGNED)
1833+ pstrcat(buf, buf_size, "unsigned ");
1834+ switch(bt) {
1835+ case VT_VOID:
1836+ tstr = "void";
1837+ goto add_tstr;
1838+ case VT_BOOL:
1839+ tstr = "_Bool";
1840+ goto add_tstr;
1841+ case VT_BYTE:
1842+ tstr = "char";
1843+ goto add_tstr;
1844+ case VT_SHORT:
1845+ tstr = "short";
1846+ goto add_tstr;
1847+ case VT_INT:
1848+ tstr = "int";
1849+ goto add_tstr;
1850+ case VT_LONG:
1851+ tstr = "long";
1852+ goto add_tstr;
1853+ case VT_LLONG:
1854+ tstr = "long long";
1855+ goto add_tstr;
1856+ case VT_FLOAT:
1857+ tstr = "float";
1858+ goto add_tstr;
1859+ case VT_DOUBLE:
1860+ tstr = "double";
1861+ goto add_tstr;
1862+ case VT_LDOUBLE:
1863+ tstr = "long double";
1864+ add_tstr:
1865+ pstrcat(buf, buf_size, tstr);
1866+ break;
1867+ case VT_ENUM:
1868+ case VT_STRUCT:
1869+ if (bt == VT_STRUCT)
1870+ tstr = "struct ";
1871+ else
1872+ tstr = "enum ";
1873+ pstrcat(buf, buf_size, tstr);
1874+ v = type->ref->v & ~SYM_STRUCT;
1875+ if (v >= SYM_FIRST_ANOM)
1876+ pstrcat(buf, buf_size, "<anonymous>");
1877+ else
1878+ pstrcat(buf, buf_size, get_tok_str(v, NULL));
1879+ break;
1880+ case VT_FUNC:
1881+ s = type->ref;
1882+ type_to_str(buf, buf_size, &s->type, varstr);
1883+ pstrcat(buf, buf_size, "(");
1884+ sa = s->next;
1885+ while (sa != NULL) {
1886+ type_to_str(buf1, sizeof(buf1), &sa->type, NULL);
1887+ pstrcat(buf, buf_size, buf1);
1888+ sa = sa->next;
1889+ if (sa)
1890+ pstrcat(buf, buf_size, ", ");
1891+ }
1892+ pstrcat(buf, buf_size, ")");
1893+ goto no_var;
1894+ case VT_PTR:
1895+ s = type->ref;
1896+ pstrcpy(buf1, sizeof(buf1), "*");
1897+ if (varstr)
1898+ pstrcat(buf1, sizeof(buf1), varstr);
1899+ type_to_str(buf, buf_size, &s->type, buf1);
1900+ goto no_var;
1901+ }
1902+ if (varstr) {
1903+ pstrcat(buf, buf_size, " ");
1904+ pstrcat(buf, buf_size, varstr);
1905+ }
1906+ no_var: ;
1907+}
1908+
1909+/* verify type compatibility to store vtop in 'dt' type, and generate
1910+ casts if needed. */
1911+static void gen_assign_cast(CType *dt)
1912+{
1913+ CType *st, *type1, *type2, tmp_type1, tmp_type2;
1914+ char buf1[256], buf2[256];
1915+ int dbt, sbt;
1916+
1917+ st = &vtop->type; /* source type */
1918+ dbt = dt->t & VT_BTYPE;
1919+ sbt = st->t & VT_BTYPE;
1920+ if (dt->t & VT_CONSTANT)
1921+ warning("assignment of read-only location");
1922+ switch(dbt) {
1923+ case VT_PTR:
1924+ /* special cases for pointers */
1925+ /* '0' can also be a pointer */
1926+ if (is_null_pointer(vtop))
1927+ goto type_ok;
1928+ /* accept implicit pointer to integer cast with warning */
1929+ if (is_integer_btype(sbt)) {
1930+ warning("assignment makes pointer from integer without a cast");
1931+ goto type_ok;
1932+ }
1933+ type1 = pointed_type(dt);
1934+ /* a function is implicitely a function pointer */
1935+ if (sbt == VT_FUNC) {
1936+ if ((type1->t & VT_BTYPE) != VT_VOID &&
1937+ !is_compatible_types(pointed_type(dt), st))
1938+ goto error;
1939+ else
1940+ goto type_ok;
1941+ }
1942+ if (sbt != VT_PTR)
1943+ goto error;
1944+ type2 = pointed_type(st);
1945+ if ((type1->t & VT_BTYPE) == VT_VOID ||
1946+ (type2->t & VT_BTYPE) == VT_VOID) {
1947+ /* void * can match anything */
1948+ } else {
1949+ /* exact type match, except for unsigned */
1950+ tmp_type1 = *type1;
1951+ tmp_type2 = *type2;
1952+ tmp_type1.t &= ~(VT_UNSIGNED | VT_CONSTANT | VT_VOLATILE);
1953+ tmp_type2.t &= ~(VT_UNSIGNED | VT_CONSTANT | VT_VOLATILE);
1954+ if (!is_compatible_types(&tmp_type1, &tmp_type2))
1955+ warning("assignment from incompatible pointer type");
1956+ }
1957+ /* check const and volatile */
1958+ if ((!(type1->t & VT_CONSTANT) && (type2->t & VT_CONSTANT)) ||
1959+ (!(type1->t & VT_VOLATILE) && (type2->t & VT_VOLATILE)))
1960+ warning("assignment discards qualifiers from pointer target type");
1961+ break;
1962+ case VT_BYTE:
1963+ case VT_SHORT:
1964+ case VT_INT:
1965+ case VT_LLONG:
1966+ if (sbt == VT_PTR || sbt == VT_FUNC) {
1967+ warning("assignment makes integer from pointer without a cast");
1968+ }
1969+ /* XXX: more tests */
1970+ break;
1971+ case VT_STRUCT:
1972+ tmp_type1 = *dt;
1973+ tmp_type2 = *st;
1974+ tmp_type1.t &= ~(VT_CONSTANT | VT_VOLATILE);
1975+ tmp_type2.t &= ~(VT_CONSTANT | VT_VOLATILE);
1976+ if (!is_compatible_types(&tmp_type1, &tmp_type2)) {
1977+ error:
1978+ type_to_str(buf1, sizeof(buf1), st, NULL);
1979+ type_to_str(buf2, sizeof(buf2), dt, NULL);
1980+ error("cannot cast '%s' to '%s'", buf1, buf2);
1981+ }
1982+ break;
1983+ }
1984+ type_ok:
1985+ gen_cast(dt);
1986+}
1987+
1988+/* store vtop in lvalue pushed on stack */
1989+void vstore(void)
1990+{
1991+ int sbt, dbt, ft, r, t, size, align, bit_size, bit_pos, rc, delayed_cast;
1992+
1993+ ft = vtop[-1].type.t;
1994+ sbt = vtop->type.t & VT_BTYPE;
1995+ dbt = ft & VT_BTYPE;
1996+ if (((sbt == VT_INT || sbt == VT_SHORT) && dbt == VT_BYTE) ||
1997+ (sbt == VT_INT && dbt == VT_SHORT)) {
1998+ /* optimize char/short casts */
1999+ delayed_cast = VT_MUSTCAST;
2000+ vtop->type.t = ft & (VT_TYPE & ~(VT_BITFIELD | (-1 << VT_STRUCT_SHIFT)));
2001+ /* XXX: factorize */
2002+ if (ft & VT_CONSTANT)
2003+ warning("assignment of read-only location");
2004+ } else {
2005+ delayed_cast = 0;
2006+ if (!(ft & VT_BITFIELD))
2007+ gen_assign_cast(&vtop[-1].type);
2008+ }
2009+
2010+ if (sbt == VT_STRUCT) {
2011+ /* if structure, only generate pointer */
2012+ /* structure assignment : generate memcpy */
2013+ /* XXX: optimize if small size */
2014+ if (!nocode_wanted) {
2015+ size = type_size(&vtop->type, &align);
2016+
2017+#ifdef TCC_ARM_EABI
2018+ if(!(align & 7))
2019+ vpush_global_sym(&func_old_type, TOK_memcpy8);
2020+ else if(!(align & 3))
2021+ vpush_global_sym(&func_old_type, TOK_memcpy4);
2022+ else
2023+#endif
2024+ vpush_global_sym(&func_old_type, TOK_memcpy);
2025+
2026+ /* destination */
2027+ vpushv(vtop - 2);
2028+ vtop->type.t = VT_PTR;
2029+ gaddrof();
2030+ /* source */
2031+ vpushv(vtop - 2);
2032+ vtop->type.t = VT_PTR;
2033+ gaddrof();
2034+ /* type size */
2035+ vpushi(size);
2036+ gfunc_call(3);
2037+
2038+ vswap();
2039+ vpop();
2040+ } else {
2041+ vswap();
2042+ vpop();
2043+ }
2044+ /* leave source on stack */
2045+ } else if (ft & VT_BITFIELD) {
2046+ /* bitfield store handling */
2047+ bit_pos = (ft >> VT_STRUCT_SHIFT) & 0x3f;
2048+ bit_size = (ft >> (VT_STRUCT_SHIFT + 6)) & 0x3f;
2049+ /* remove bit field info to avoid loops */
2050+ vtop[-1].type.t = ft & ~(VT_BITFIELD | (-1 << VT_STRUCT_SHIFT));
2051+
2052+ /* duplicate source into other register */
2053+ gv_dup();
2054+ vswap();
2055+ vrott(3);
2056+
2057+ if((ft & VT_BTYPE) == VT_BOOL) {
2058+ gen_cast(&vtop[-1].type);
2059+ vtop[-1].type.t = (vtop[-1].type.t & ~VT_BTYPE) | (VT_BYTE | VT_UNSIGNED);
2060+ }
2061+
2062+ /* duplicate destination */
2063+ vdup();
2064+ vtop[-1] = vtop[-2];
2065+
2066+ /* mask and shift source */
2067+ if((ft & VT_BTYPE) != VT_BOOL) {
2068+ if((ft & VT_BTYPE) == VT_LLONG) {
2069+ vpushll((1ULL << bit_size) - 1ULL);
2070+ } else {
2071+ vpushi((1 << bit_size) - 1);
2072+ }
2073+ gen_op('&');
2074+ }
2075+ vpushi(bit_pos);
2076+ gen_op(TOK_SHL);
2077+ /* load destination, mask and or with source */
2078+ vswap();
2079+ if((ft & VT_BTYPE) == VT_LLONG) {
2080+ vpushll(~(((1ULL << bit_size) - 1ULL) << bit_pos));
2081+ } else {
2082+ vpushi(~(((1 << bit_size) - 1) << bit_pos));
2083+ }
2084+ gen_op('&');
2085+ gen_op('|');
2086+ /* store result */
2087+ vstore();
2088+
2089+ /* pop off shifted source from "duplicate source..." above */
2090+ vpop();
2091+
2092+ } else {
2093+#ifdef CONFIG_TCC_BCHECK
2094+ /* bound check case */
2095+ if (vtop[-1].r & VT_MUSTBOUND) {
2096+ vswap();
2097+ gbound();
2098+ vswap();
2099+ }
2100+#endif
2101+ if (!nocode_wanted) {
2102+ rc = RC_INT;
2103+ if (is_float(ft)) {
2104+ rc = RC_FLOAT;
2105+#ifdef TCC_TARGET_X86_64
2106+ if ((ft & VT_BTYPE) == VT_LDOUBLE) {
2107+ rc = RC_ST0;
2108+ }
2109+#endif
2110+ }
2111+ r = gv(rc); /* generate value */
2112+ /* if lvalue was saved on stack, must read it */
2113+ if ((vtop[-1].r & VT_VALMASK) == VT_LLOCAL) {
2114+ SValue sv;
2115+ t = get_reg(RC_INT);
2116+#ifdef TCC_TARGET_X86_64
2117+ sv.type.t = VT_PTR;
2118+#else
2119+ sv.type.t = VT_INT;
2120+#endif
2121+ sv.r = VT_LOCAL | VT_LVAL;
2122+ sv.c.ul = vtop[-1].c.ul;
2123+ load(t, &sv);
2124+ vtop[-1].r = t | VT_LVAL;
2125+ }
2126+ store(r, vtop - 1);
2127+#ifndef TCC_TARGET_X86_64
2128+ /* two word case handling : store second register at word + 4 */
2129+ if ((ft & VT_BTYPE) == VT_LLONG) {
2130+ vswap();
2131+ /* convert to int to increment easily */
2132+ vtop->type.t = VT_INT;
2133+ gaddrof();
2134+ vpushi(4);
2135+ gen_op('+');
2136+ vtop->r |= VT_LVAL;
2137+ vswap();
2138+ /* XXX: it works because r2 is spilled last ! */
2139+ store(vtop->r2, vtop - 1);
2140+ }
2141+#endif
2142+ }
2143+ vswap();
2144+ vtop--; /* NOT vpop() because on x86 it would flush the fp stack */
2145+ vtop->r |= delayed_cast;
2146+ }
2147+}
2148+
2149+/* post defines POST/PRE add. c is the token ++ or -- */
2150+void inc(int post, int c)
2151+{
2152+ test_lvalue();
2153+ vdup(); /* save lvalue */
2154+ if (post) {
2155+ gv_dup(); /* duplicate value */
2156+ vrotb(3);
2157+ vrotb(3);
2158+ }
2159+ /* add constant */
2160+ vpushi(c - TOK_MID);
2161+ gen_op('+');
2162+ vstore(); /* store value */
2163+ if (post)
2164+ vpop(); /* if post op, return saved value */
2165+}
2166+
2167+/* Parse GNUC __attribute__ extension. Currently, the following
2168+ extensions are recognized:
2169+ - aligned(n) : set data/function alignment.
2170+ - packed : force data alignment to 1
2171+ - section(x) : generate data/code in this section.
2172+ - unused : currently ignored, but may be used someday.
2173+ - regparm(n) : pass function parameters in registers (i386 only)
2174+ */
2175+static void parse_attribute(AttributeDef *ad)
2176+{
2177+ int t, n;
2178+
2179+ while (tok == TOK_ATTRIBUTE1 || tok == TOK_ATTRIBUTE2) {
2180+ next();
2181+ skip('(');
2182+ skip('(');
2183+ while (tok != ')') {
2184+ if (tok < TOK_IDENT)
2185+ expect("attribute name");
2186+ t = tok;
2187+ next();
2188+ switch(t) {
2189+ case TOK_SECTION1:
2190+ case TOK_SECTION2:
2191+ skip('(');
2192+ if (tok != TOK_STR)
2193+ expect("section name");
2194+ ad->section = find_section(tcc_state, (char *)tokc.cstr->data);
2195+ next();
2196+ skip(')');
2197+ break;
2198+ case TOK_ALIGNED1:
2199+ case TOK_ALIGNED2:
2200+ if (tok == '(') {
2201+ next();
2202+ n = expr_const();
2203+ if (n <= 0 || (n & (n - 1)) != 0)
2204+ error("alignment must be a positive power of two");
2205+ skip(')');
2206+ } else {
2207+ n = MAX_ALIGN;
2208+ }
2209+ ad->aligned = n;
2210+ break;
2211+ case TOK_PACKED1:
2212+ case TOK_PACKED2:
2213+ ad->packed = 1;
2214+ break;
2215+ case TOK_UNUSED1:
2216+ case TOK_UNUSED2:
2217+ /* currently, no need to handle it because tcc does not
2218+ track unused objects */
2219+ break;
2220+ case TOK_NORETURN1:
2221+ case TOK_NORETURN2:
2222+ /* currently, no need to handle it because tcc does not
2223+ track unused objects */
2224+ break;
2225+ case TOK_CDECL1:
2226+ case TOK_CDECL2:
2227+ case TOK_CDECL3:
2228+ FUNC_CALL(ad->func_attr) = FUNC_CDECL;
2229+ break;
2230+ case TOK_STDCALL1:
2231+ case TOK_STDCALL2:
2232+ case TOK_STDCALL3:
2233+ FUNC_CALL(ad->func_attr) = FUNC_STDCALL;
2234+ break;
2235+#ifdef TCC_TARGET_I386
2236+ case TOK_REGPARM1:
2237+ case TOK_REGPARM2:
2238+ skip('(');
2239+ n = expr_const();
2240+ if (n > 3)
2241+ n = 3;
2242+ else if (n < 0)
2243+ n = 0;
2244+ if (n > 0)
2245+ FUNC_CALL(ad->func_attr) = FUNC_FASTCALL1 + n - 1;
2246+ skip(')');
2247+ break;
2248+ case TOK_FASTCALL1:
2249+ case TOK_FASTCALL2:
2250+ case TOK_FASTCALL3:
2251+ FUNC_CALL(ad->func_attr) = FUNC_FASTCALLW;
2252+ break;
2253+#endif
2254+ case TOK_DLLEXPORT:
2255+ FUNC_EXPORT(ad->func_attr) = 1;
2256+ break;
2257+ default:
2258+ if (tcc_state->warn_unsupported)
2259+ warning("'%s' attribute ignored", get_tok_str(t, NULL));
2260+ /* skip parameters */
2261+ if (tok == '(') {
2262+ int parenthesis = 0;
2263+ do {
2264+ if (tok == '(')
2265+ parenthesis++;
2266+ else if (tok == ')')
2267+ parenthesis--;
2268+ next();
2269+ } while (parenthesis && tok != -1);
2270+ }
2271+ break;
2272+ }
2273+ if (tok != ',')
2274+ break;
2275+ next();
2276+ }
2277+ skip(')');
2278+ skip(')');
2279+ }
2280+}
2281+
2282+/* enum/struct/union declaration. u is either VT_ENUM or VT_STRUCT */
2283+static void struct_decl(CType *type, int u)
2284+{
2285+ int a, v, size, align, maxalign, c, offset;
2286+ int bit_size, bit_pos, bsize, bt, lbit_pos, prevbt;
2287+ Sym *s, *ss, *ass, **ps;
2288+ AttributeDef ad;
2289+ CType type1, btype;
2290+
2291+ a = tok; /* save decl type */
2292+ next();
2293+ if (tok != '{') {
2294+ v = tok;
2295+ next();
2296+ /* struct already defined ? return it */
2297+ if (v < TOK_IDENT)
2298+ expect("struct/union/enum name");
2299+ s = struct_find(v);
2300+ if (s) {
2301+ if (s->type.t != a)
2302+ error("invalid type");
2303+ goto do_decl;
2304+ }
2305+ } else {
2306+ v = anon_sym++;
2307+ }
2308+ type1.t = a;
2309+ /* we put an undefined size for struct/union */
2310+ s = sym_push(v | SYM_STRUCT, &type1, 0, -1);
2311+ s->r = 0; /* default alignment is zero as gcc */
2312+ /* put struct/union/enum name in type */
2313+ do_decl:
2314+ type->t = u;
2315+ type->ref = s;
2316+
2317+ if (tok == '{') {
2318+ next();
2319+ if (s->c != -1)
2320+ error("struct/union/enum already defined");
2321+ /* cannot be empty */
2322+ c = 0;
2323+ /* non empty enums are not allowed */
2324+ if (a == TOK_ENUM) {
2325+ for(;;) {
2326+ v = tok;
2327+ if (v < TOK_UIDENT)
2328+ expect("identifier");
2329+ next();
2330+ if (tok == '=') {
2331+ next();
2332+ c = expr_const();
2333+ }
2334+ /* enum symbols have static storage */
2335+ ss = sym_push(v, &int_type, VT_CONST, c);
2336+ ss->type.t |= VT_STATIC;
2337+ if (tok != ',')
2338+ break;
2339+ next();
2340+ c++;
2341+ /* NOTE: we accept a trailing comma */
2342+ if (tok == '}')
2343+ break;
2344+ }
2345+ skip('}');
2346+ } else {
2347+ maxalign = 1;
2348+ ps = &s->next;
2349+ prevbt = VT_INT;
2350+ bit_pos = 0;
2351+ offset = 0;
2352+ while (tok != '}') {
2353+ parse_btype(&btype, &ad);
2354+ while (1) {
2355+ bit_size = -1;
2356+ v = 0;
2357+ type1 = btype;
2358+ if (tok != ':') {
2359+ type_decl(&type1, &ad, &v, TYPE_DIRECT | TYPE_ABSTRACT);
2360+ if (v == 0 && (type1.t & VT_BTYPE) != VT_STRUCT)
2361+ expect("identifier");
2362+ if ((type1.t & VT_BTYPE) == VT_FUNC ||
2363+ (type1.t & (VT_TYPEDEF | VT_STATIC | VT_EXTERN | VT_INLINE)))
2364+ error("invalid type for '%s'",
2365+ get_tok_str(v, NULL));
2366+ }
2367+ if (tok == ':') {
2368+ next();
2369+ bit_size = expr_const();
2370+ /* XXX: handle v = 0 case for messages */
2371+ if (bit_size < 0)
2372+ error("negative width in bit-field '%s'",
2373+ get_tok_str(v, NULL));
2374+ if (v && bit_size == 0)
2375+ error("zero width for bit-field '%s'",
2376+ get_tok_str(v, NULL));
2377+ }
2378+ size = type_size(&type1, &align);
2379+ if (ad.aligned) {
2380+ if (align < ad.aligned)
2381+ align = ad.aligned;
2382+ } else if (ad.packed) {
2383+ align = 1;
2384+ } else if (*tcc_state->pack_stack_ptr) {
2385+ if (align > *tcc_state->pack_stack_ptr)
2386+ align = *tcc_state->pack_stack_ptr;
2387+ }
2388+ lbit_pos = 0;
2389+ if (bit_size >= 0) {
2390+ bt = type1.t & VT_BTYPE;
2391+ if (bt != VT_INT &&
2392+ bt != VT_BYTE &&
2393+ bt != VT_SHORT &&
2394+ bt != VT_BOOL &&
2395+ bt != VT_ENUM &&
2396+ bt != VT_LLONG)
2397+ error("bitfields must have scalar type");
2398+ bsize = size * 8;
2399+ if (bit_size > bsize) {
2400+ error("width of '%s' exceeds its type",
2401+ get_tok_str(v, NULL));
2402+ } else if (bit_size == bsize) {
2403+ /* no need for bit fields */
2404+ bit_pos = 0;
2405+ } else if (bit_size == 0) {
2406+ /* XXX: what to do if only padding in a
2407+ structure ? */
2408+ /* zero size: means to pad */
2409+ bit_pos = 0;
2410+ } else {
2411+ /* we do not have enough room ?
2412+ did the type change?
2413+ is it a union? */
2414+ if ((bit_pos + bit_size) > bsize ||
2415+ bt != prevbt || a == TOK_UNION)
2416+ bit_pos = 0;
2417+ lbit_pos = bit_pos;
2418+ /* XXX: handle LSB first */
2419+ type1.t |= VT_BITFIELD |
2420+ (bit_pos << VT_STRUCT_SHIFT) |
2421+ (bit_size << (VT_STRUCT_SHIFT + 6));
2422+ bit_pos += bit_size;
2423+ }
2424+ prevbt = bt;
2425+ } else {
2426+ bit_pos = 0;
2427+ }
2428+ if (v != 0 || (type1.t & VT_BTYPE) == VT_STRUCT) {
2429+ /* add new memory data only if starting
2430+ bit field */
2431+ if (lbit_pos == 0) {
2432+ if (a == TOK_STRUCT) {
2433+ c = (c + align - 1) & -align;
2434+ offset = c;
2435+ if (size > 0)
2436+ c += size;
2437+ } else {
2438+ offset = 0;
2439+ if (size > c)
2440+ c = size;
2441+ }
2442+ if (align > maxalign)
2443+ maxalign = align;
2444+ }
2445+#if 0
2446+ printf("add field %s offset=%d",
2447+ get_tok_str(v, NULL), offset);
2448+ if (type1.t & VT_BITFIELD) {
2449+ printf(" pos=%d size=%d",
2450+ (type1.t >> VT_STRUCT_SHIFT) & 0x3f,
2451+ (type1.t >> (VT_STRUCT_SHIFT + 6)) & 0x3f);
2452+ }
2453+ printf("\n");
2454+#endif
2455+ }
2456+ if (v == 0 && (type1.t & VT_BTYPE) == VT_STRUCT) {
2457+ ass = type1.ref;
2458+ while ((ass = ass->next) != NULL) {
2459+ ss = sym_push(ass->v, &ass->type, 0, offset + ass->c);
2460+ *ps = ss;
2461+ ps = &ss->next;
2462+ }
2463+ } else if (v) {
2464+ ss = sym_push(v | SYM_FIELD, &type1, 0, offset);
2465+ *ps = ss;
2466+ ps = &ss->next;
2467+ }
2468+ if (tok == ';' || tok == TOK_EOF)
2469+ break;
2470+ skip(',');
2471+ }
2472+ skip(';');
2473+ }
2474+ skip('}');
2475+ /* store size and alignment */
2476+ s->c = (c + maxalign - 1) & -maxalign;
2477+ s->r = maxalign;
2478+ }
2479+ }
2480+}
2481+
2482+/* return 0 if no type declaration. otherwise, return the basic type
2483+ and skip it.
2484+ */
2485+static int parse_btype(CType *type, AttributeDef *ad)
2486+{
2487+ int t, u, type_found, typespec_found, typedef_found;
2488+ Sym *s;
2489+ CType type1;
2490+
2491+ memset(ad, 0, sizeof(AttributeDef));
2492+ type_found = 0;
2493+ typespec_found = 0;
2494+ typedef_found = 0;
2495+ t = 0;
2496+ while(1) {
2497+ switch(tok) {
2498+ case TOK_EXTENSION:
2499+ /* currently, we really ignore extension */
2500+ next();
2501+ continue;
2502+
2503+ /* basic types */
2504+ case TOK_CHAR:
2505+ u = VT_BYTE;
2506+ basic_type:
2507+ next();
2508+ basic_type1:
2509+ if ((t & VT_BTYPE) != 0)
2510+ error("too many basic types");
2511+ t |= u;
2512+ typespec_found = 1;
2513+ break;
2514+ case TOK_VOID:
2515+ u = VT_VOID;
2516+ goto basic_type;
2517+ case TOK_SHORT:
2518+ u = VT_SHORT;
2519+ goto basic_type;
2520+ case TOK_INT:
2521+ next();
2522+ typespec_found = 1;
2523+ break;
2524+ case TOK_LONG:
2525+ next();
2526+ if ((t & VT_BTYPE) == VT_DOUBLE) {
2527+ t = (t & ~VT_BTYPE) | VT_LDOUBLE;
2528+ } else if ((t & VT_BTYPE) == VT_LONG) {
2529+ t = (t & ~VT_BTYPE) | VT_LLONG;
2530+ } else {
2531+ u = VT_LONG;
2532+ goto basic_type1;
2533+ }
2534+ break;
2535+ case TOK_BOOL:
2536+ u = VT_BOOL;
2537+ goto basic_type;
2538+ case TOK_FLOAT:
2539+ u = VT_FLOAT;
2540+ goto basic_type;
2541+ case TOK_DOUBLE:
2542+ next();
2543+ if ((t & VT_BTYPE) == VT_LONG) {
2544+ t = (t & ~VT_BTYPE) | VT_LDOUBLE;
2545+ } else {
2546+ u = VT_DOUBLE;
2547+ goto basic_type1;
2548+ }
2549+ break;
2550+ case TOK_ENUM:
2551+ struct_decl(&type1, VT_ENUM);
2552+ basic_type2:
2553+ u = type1.t;
2554+ type->ref = type1.ref;
2555+ goto basic_type1;
2556+ case TOK_STRUCT:
2557+ case TOK_UNION:
2558+ struct_decl(&type1, VT_STRUCT);
2559+ goto basic_type2;
2560+
2561+ /* type modifiers */
2562+ case TOK_CONST1:
2563+ case TOK_CONST2:
2564+ case TOK_CONST3:
2565+ t |= VT_CONSTANT;
2566+ next();
2567+ break;
2568+ case TOK_VOLATILE1:
2569+ case TOK_VOLATILE2:
2570+ case TOK_VOLATILE3:
2571+ t |= VT_VOLATILE;
2572+ next();
2573+ break;
2574+ case TOK_SIGNED1:
2575+ case TOK_SIGNED2:
2576+ case TOK_SIGNED3:
2577+ typespec_found = 1;
2578+ t |= VT_SIGNED;
2579+ next();
2580+ break;
2581+ case TOK_REGISTER:
2582+ case TOK_AUTO:
2583+ case TOK_RESTRICT1:
2584+ case TOK_RESTRICT2:
2585+ case TOK_RESTRICT3:
2586+ next();
2587+ break;
2588+ case TOK_UNSIGNED:
2589+ t |= VT_UNSIGNED;
2590+ next();
2591+ typespec_found = 1;
2592+ break;
2593+
2594+ /* storage */
2595+ case TOK_EXTERN:
2596+ t |= VT_EXTERN;
2597+ next();
2598+ break;
2599+ case TOK_STATIC:
2600+ t |= VT_STATIC;
2601+ next();
2602+ break;
2603+ case TOK_TYPEDEF:
2604+ t |= VT_TYPEDEF;
2605+ next();
2606+ break;
2607+ case TOK_INLINE1:
2608+ case TOK_INLINE2:
2609+ case TOK_INLINE3:
2610+ t |= VT_INLINE;
2611+ next();
2612+ break;
2613+
2614+ /* GNUC attribute */
2615+ case TOK_ATTRIBUTE1:
2616+ case TOK_ATTRIBUTE2:
2617+ parse_attribute(ad);
2618+ break;
2619+ /* GNUC typeof */
2620+ case TOK_TYPEOF1:
2621+ case TOK_TYPEOF2:
2622+ case TOK_TYPEOF3:
2623+ next();
2624+ parse_expr_type(&type1);
2625+ goto basic_type2;
2626+ default:
2627+ if (typespec_found || typedef_found)
2628+ goto the_end;
2629+ s = sym_find(tok);
2630+ if (!s || !(s->type.t & VT_TYPEDEF))
2631+ goto the_end;
2632+ typedef_found = 1;
2633+ t |= (s->type.t & ~VT_TYPEDEF);
2634+ type->ref = s->type.ref;
2635+ next();
2636+ typespec_found = 1;
2637+ break;
2638+ }
2639+ type_found = 1;
2640+ }
2641+the_end:
2642+ if ((t & (VT_SIGNED|VT_UNSIGNED)) == (VT_SIGNED|VT_UNSIGNED))
2643+ error("signed and unsigned modifier");
2644+ if (tcc_state->char_is_unsigned) {
2645+ if ((t & (VT_SIGNED|VT_UNSIGNED|VT_BTYPE)) == VT_BYTE)
2646+ t |= VT_UNSIGNED;
2647+ }
2648+ t &= ~VT_SIGNED;
2649+
2650+ /* long is never used as type */
2651+ if ((t & VT_BTYPE) == VT_LONG)
2652+#ifndef TCC_TARGET_X86_64
2653+ t = (t & ~VT_BTYPE) | VT_INT;
2654+#else
2655+ t = (t & ~VT_BTYPE) | VT_LLONG;
2656+#endif
2657+ type->t = t;
2658+ return type_found;
2659+}
2660+
2661+/* convert a function parameter type (array to pointer and function to
2662+ function pointer) */
2663+static inline void convert_parameter_type(CType *pt)
2664+{
2665+ /* remove const and volatile qualifiers (XXX: const could be used
2666+ to indicate a const function parameter */
2667+ pt->t &= ~(VT_CONSTANT | VT_VOLATILE);
2668+ /* array must be transformed to pointer according to ANSI C */
2669+ pt->t &= ~VT_ARRAY;
2670+ if ((pt->t & VT_BTYPE) == VT_FUNC) {
2671+ mk_pointer(pt);
2672+ }
2673+}
2674+
2675+static void post_type(CType *type, AttributeDef *ad)
2676+{
2677+ int n, l, t1, arg_size, align;
2678+ Sym **plast, *s, *first;
2679+ AttributeDef ad1;
2680+ CType pt;
2681+
2682+ if (tok == '(') {
2683+ /* function declaration */
2684+ next();
2685+ l = 0;
2686+ first = NULL;
2687+ plast = &first;
2688+ arg_size = 0;
2689+ if (tok != ')') {
2690+ for(;;) {
2691+ /* read param name and compute offset */
2692+ if (l != FUNC_OLD) {
2693+ if (!parse_btype(&pt, &ad1)) {
2694+ if (l) {
2695+ error("invalid type");
2696+ } else {
2697+ l = FUNC_OLD;
2698+ goto old_proto;
2699+ }
2700+ }
2701+ l = FUNC_NEW;
2702+ if ((pt.t & VT_BTYPE) == VT_VOID && tok == ')')
2703+ break;
2704+ type_decl(&pt, &ad1, &n, TYPE_DIRECT | TYPE_ABSTRACT);
2705+ if ((pt.t & VT_BTYPE) == VT_VOID)
2706+ error("parameter declared as void");
2707+ arg_size += (type_size(&pt, &align) + 3) & ~3;
2708+ } else {
2709+ old_proto:
2710+ n = tok;
2711+ if (n < TOK_UIDENT)
2712+ expect("identifier");
2713+ pt.t = VT_INT;
2714+ next();
2715+ }
2716+ convert_parameter_type(&pt);
2717+ s = sym_push(n | SYM_FIELD, &pt, 0, 0);
2718+ *plast = s;
2719+ plast = &s->next;
2720+ if (tok == ')')
2721+ break;
2722+ skip(',');
2723+ if (l == FUNC_NEW && tok == TOK_DOTS) {
2724+ l = FUNC_ELLIPSIS;
2725+ next();
2726+ break;
2727+ }
2728+ }
2729+ }
2730+ /* if no parameters, then old type prototype */
2731+ if (l == 0)
2732+ l = FUNC_OLD;
2733+ skip(')');
2734+ t1 = type->t & VT_STORAGE;
2735+ /* NOTE: const is ignored in returned type as it has a special
2736+ meaning in gcc / C++ */
2737+ type->t &= ~(VT_STORAGE | VT_CONSTANT);
2738+ post_type(type, ad);
2739+ /* we push a anonymous symbol which will contain the function prototype */
2740+ FUNC_ARGS(ad->func_attr) = arg_size;
2741+ s = sym_push(SYM_FIELD, type, ad->func_attr, l);
2742+ s->next = first;
2743+ type->t = t1 | VT_FUNC;
2744+ type->ref = s;
2745+ } else if (tok == '[') {
2746+ /* array definition */
2747+ next();
2748+ if (tok == TOK_RESTRICT1)
2749+ next();
2750+ n = -1;
2751+ if (tok != ']') {
2752+ n = expr_const();
2753+ if (n < 0)
2754+ error("invalid array size");
2755+ }
2756+ skip(']');
2757+ /* parse next post type */
2758+ t1 = type->t & VT_STORAGE;
2759+ type->t &= ~VT_STORAGE;
2760+ post_type(type, ad);
2761+
2762+ /* we push a anonymous symbol which will contain the array
2763+ element type */
2764+ s = sym_push(SYM_FIELD, type, 0, n);
2765+ type->t = t1 | VT_ARRAY | VT_PTR;
2766+ type->ref = s;
2767+ }
2768+}
2769+
2770+/* Parse a type declaration (except basic type), and return the type
2771+ in 'type'. 'td' is a bitmask indicating which kind of type decl is
2772+ expected. 'type' should contain the basic type. 'ad' is the
2773+ attribute definition of the basic type. It can be modified by
2774+ type_decl().
2775+ */
2776+static void type_decl(CType *type, AttributeDef *ad, int *v, int td)
2777+{
2778+ Sym *s;
2779+ CType type1, *type2;
2780+ int qualifiers;
2781+
2782+ while (tok == '*') {
2783+ qualifiers = 0;
2784+ redo:
2785+ next();
2786+ switch(tok) {
2787+ case TOK_CONST1:
2788+ case TOK_CONST2:
2789+ case TOK_CONST3:
2790+ qualifiers |= VT_CONSTANT;
2791+ goto redo;
2792+ case TOK_VOLATILE1:
2793+ case TOK_VOLATILE2:
2794+ case TOK_VOLATILE3:
2795+ qualifiers |= VT_VOLATILE;
2796+ goto redo;
2797+ case TOK_RESTRICT1:
2798+ case TOK_RESTRICT2:
2799+ case TOK_RESTRICT3:
2800+ goto redo;
2801+ }
2802+ mk_pointer(type);
2803+ type->t |= qualifiers;
2804+ }
2805+
2806+ /* XXX: clarify attribute handling */
2807+ if (tok == TOK_ATTRIBUTE1 || tok == TOK_ATTRIBUTE2)
2808+ parse_attribute(ad);
2809+
2810+ /* recursive type */
2811+ /* XXX: incorrect if abstract type for functions (e.g. 'int ()') */
2812+ type1.t = 0; /* XXX: same as int */
2813+ if (tok == '(') {
2814+ next();
2815+ /* XXX: this is not correct to modify 'ad' at this point, but
2816+ the syntax is not clear */
2817+ if (tok == TOK_ATTRIBUTE1 || tok == TOK_ATTRIBUTE2)
2818+ parse_attribute(ad);
2819+ type_decl(&type1, ad, v, td);
2820+ skip(')');
2821+ } else {
2822+ /* type identifier */
2823+ if (tok >= TOK_IDENT && (td & TYPE_DIRECT)) {
2824+ *v = tok;
2825+ next();
2826+ } else {
2827+ if (!(td & TYPE_ABSTRACT))
2828+ expect("identifier");
2829+ *v = 0;
2830+ }
2831+ }
2832+ post_type(type, ad);
2833+ if (tok == TOK_ATTRIBUTE1 || tok == TOK_ATTRIBUTE2)
2834+ parse_attribute(ad);
2835+ if (!type1.t)
2836+ return;
2837+ /* append type at the end of type1 */
2838+ type2 = &type1;
2839+ for(;;) {
2840+ s = type2->ref;
2841+ type2 = &s->type;
2842+ if (!type2->t) {
2843+ *type2 = *type;
2844+ break;
2845+ }
2846+ }
2847+ *type = type1;
2848+}
2849+
2850+/* compute the lvalue VT_LVAL_xxx needed to match type t. */
2851+static int lvalue_type(int t)
2852+{
2853+ int bt, r;
2854+ r = VT_LVAL;
2855+ bt = t & VT_BTYPE;
2856+ if (bt == VT_BYTE || bt == VT_BOOL)
2857+ r |= VT_LVAL_BYTE;
2858+ else if (bt == VT_SHORT)
2859+ r |= VT_LVAL_SHORT;
2860+ else
2861+ return r;
2862+ if (t & VT_UNSIGNED)
2863+ r |= VT_LVAL_UNSIGNED;
2864+ return r;
2865+}
2866+
2867+/* indirection with full error checking and bound check */
2868+static void indir(void)
2869+{
2870+ if ((vtop->type.t & VT_BTYPE) != VT_PTR) {
2871+ if ((vtop->type.t & VT_BTYPE) == VT_FUNC)
2872+ return;
2873+ expect("pointer");
2874+ }
2875+ if ((vtop->r & VT_LVAL) && !nocode_wanted)
2876+ gv(RC_INT);
2877+ vtop->type = *pointed_type(&vtop->type);
2878+ /* Arrays and functions are never lvalues */
2879+ if (!(vtop->type.t & VT_ARRAY)
2880+ && (vtop->type.t & VT_BTYPE) != VT_FUNC) {
2881+ vtop->r |= lvalue_type(vtop->type.t);
2882+ /* if bound checking, the referenced pointer must be checked */
2883+ if (do_bounds_check)
2884+ vtop->r |= VT_MUSTBOUND;
2885+ }
2886+}
2887+
2888+/* pass a parameter to a function and do type checking and casting */
2889+static void gfunc_param_typed(Sym *func, Sym *arg)
2890+{
2891+ int func_type;
2892+ CType type;
2893+
2894+ func_type = func->c;
2895+ if (func_type == FUNC_OLD ||
2896+ (func_type == FUNC_ELLIPSIS && arg == NULL)) {
2897+ /* default casting : only need to convert float to double */
2898+ if ((vtop->type.t & VT_BTYPE) == VT_FLOAT) {
2899+ type.t = VT_DOUBLE;
2900+ gen_cast(&type);
2901+ }
2902+ } else if (arg == NULL) {
2903+ error("too many arguments to function");
2904+ } else {
2905+ type = arg->type;
2906+ type.t &= ~VT_CONSTANT; /* need to do that to avoid false warning */
2907+ gen_assign_cast(&type);
2908+ }
2909+}
2910+
2911+/* parse an expression of the form '(type)' or '(expr)' and return its
2912+ type */
2913+static void parse_expr_type(CType *type)
2914+{
2915+ int n;
2916+ AttributeDef ad;
2917+
2918+ skip('(');
2919+ if (parse_btype(type, &ad)) {
2920+ type_decl(type, &ad, &n, TYPE_ABSTRACT);
2921+ } else {
2922+ expr_type(type);
2923+ }
2924+ skip(')');
2925+}
2926+
2927+static void parse_type(CType *type)
2928+{
2929+ AttributeDef ad;
2930+ int n;
2931+
2932+ if (!parse_btype(type, &ad)) {
2933+ expect("type");
2934+ }
2935+ type_decl(type, &ad, &n, TYPE_ABSTRACT);
2936+}
2937+
2938+static void vpush_tokc(int t)
2939+{
2940+ CType type;
2941+ type.t = t;
2942+ vsetc(&type, VT_CONST, &tokc);
2943+}
2944+
2945+static void unary(void)
2946+{
2947+ int n, t, align, size, r;
2948+ CType type;
2949+ Sym *s;
2950+ AttributeDef ad;
2951+
2952+ /* XXX: GCC 2.95.3 does not generate a table although it should be
2953+ better here */
2954+ tok_next:
2955+ switch(tok) {
2956+ case TOK_EXTENSION:
2957+ next();
2958+ goto tok_next;
2959+ case TOK_CINT:
2960+ case TOK_CCHAR:
2961+ case TOK_LCHAR:
2962+ vpushi(tokc.i);
2963+ next();
2964+ break;
2965+ case TOK_CUINT:
2966+ vpush_tokc(VT_INT | VT_UNSIGNED);
2967+ next();
2968+ break;
2969+ case TOK_CLLONG:
2970+ vpush_tokc(VT_LLONG);
2971+ next();
2972+ break;
2973+ case TOK_CULLONG:
2974+ vpush_tokc(VT_LLONG | VT_UNSIGNED);
2975+ next();
2976+ break;
2977+ case TOK_CFLOAT:
2978+ vpush_tokc(VT_FLOAT);
2979+ next();
2980+ break;
2981+ case TOK_CDOUBLE:
2982+ vpush_tokc(VT_DOUBLE);
2983+ next();
2984+ break;
2985+ case TOK_CLDOUBLE:
2986+ vpush_tokc(VT_LDOUBLE);
2987+ next();
2988+ break;
2989+ case TOK___FUNCTION__:
2990+ if (!gnu_ext)
2991+ goto tok_identifier;
2992+ /* fall thru */
2993+ case TOK___FUNC__:
2994+ {
2995+ void *ptr;
2996+ int len;
2997+ /* special function name identifier */
2998+ len = strlen(funcname) + 1;
2999+ /* generate char[len] type */
3000+ type.t = VT_BYTE;
3001+ mk_pointer(&type);
3002+ type.t |= VT_ARRAY;
3003+ type.ref->c = len;
3004+ vpush_ref(&type, data_section, data_section->data_offset, len);
3005+ ptr = section_ptr_add(data_section, len);
3006+ memcpy(ptr, funcname, len);
3007+ next();
3008+ }
3009+ break;
3010+ case TOK_LSTR:
3011+#ifdef TCC_TARGET_PE
3012+ t = VT_SHORT | VT_UNSIGNED;
3013+#else
3014+ t = VT_INT;
3015+#endif
3016+ goto str_init;
3017+ case TOK_STR:
3018+ /* string parsing */
3019+ t = VT_BYTE;
3020+ str_init:
3021+ if (tcc_state->warn_write_strings)
3022+ t |= VT_CONSTANT;
3023+ type.t = t;
3024+ mk_pointer(&type);
3025+ type.t |= VT_ARRAY;
3026+ memset(&ad, 0, sizeof(AttributeDef));
3027+ decl_initializer_alloc(&type, &ad, VT_CONST, 2, 0, 0);
3028+ break;
3029+ case '(':
3030+ next();
3031+ /* cast ? */
3032+ if (parse_btype(&type, &ad)) {
3033+ type_decl(&type, &ad, &n, TYPE_ABSTRACT);
3034+ skip(')');
3035+ /* check ISOC99 compound literal */
3036+ if (tok == '{') {
3037+ /* data is allocated locally by default */
3038+ if (global_expr)
3039+ r = VT_CONST;
3040+ else
3041+ r = VT_LOCAL;
3042+ /* all except arrays are lvalues */
3043+ if (!(type.t & VT_ARRAY))
3044+ r |= lvalue_type(type.t);
3045+ memset(&ad, 0, sizeof(AttributeDef));
3046+ decl_initializer_alloc(&type, &ad, r, 1, 0, 0);
3047+ } else {
3048+ unary();
3049+ gen_cast(&type);
3050+ }
3051+ } else if (tok == '{') {
3052+ /* save all registers */
3053+ save_regs(0);
3054+ /* statement expression : we do not accept break/continue
3055+ inside as GCC does */
3056+ block(NULL, NULL, NULL, NULL, 0, 1);
3057+ skip(')');
3058+ } else {
3059+ gexpr();
3060+ skip(')');
3061+ }
3062+ break;
3063+ case '*':
3064+ next();
3065+ unary();
3066+ indir();
3067+ break;
3068+ case '&':
3069+ next();
3070+ unary();
3071+ /* functions names must be treated as function pointers,
3072+ except for unary '&' and sizeof. Since we consider that
3073+ functions are not lvalues, we only have to handle it
3074+ there and in function calls. */
3075+ /* arrays can also be used although they are not lvalues */
3076+ if ((vtop->type.t & VT_BTYPE) != VT_FUNC &&
3077+ !(vtop->type.t & VT_ARRAY) && !(vtop->type.t & VT_LLOCAL))
3078+ test_lvalue();
3079+ mk_pointer(&vtop->type);
3080+ gaddrof();
3081+ break;
3082+ case '!':
3083+ next();
3084+ unary();
3085+ if ((vtop->r & (VT_VALMASK | VT_LVAL | VT_SYM)) == VT_CONST) {
3086+ CType boolean;
3087+ boolean.t = VT_BOOL;
3088+ gen_cast(&boolean);
3089+ vtop->c.i = !vtop->c.i;
3090+ } else if ((vtop->r & VT_VALMASK) == VT_CMP)
3091+ vtop->c.i = vtop->c.i ^ 1;
3092+ else {
3093+ save_regs(1);
3094+ vseti(VT_JMP, gtst(1, 0));
3095+ }
3096+ break;
3097+ case '~':
3098+ next();
3099+ unary();
3100+ vpushi(-1);
3101+ gen_op('^');
3102+ break;
3103+ case '+':
3104+ next();
3105+ /* in order to force cast, we add zero */
3106+ unary();
3107+ if ((vtop->type.t & VT_BTYPE) == VT_PTR)
3108+ error("pointer not accepted for unary plus");
3109+ vpushi(0);
3110+ gen_op('+');
3111+ break;
3112+ case TOK_SIZEOF:
3113+ case TOK_ALIGNOF1:
3114+ case TOK_ALIGNOF2:
3115+ t = tok;
3116+ next();
3117+ if (tok == '(') {
3118+ parse_expr_type(&type);
3119+ } else {
3120+ unary_type(&type);
3121+ }
3122+ size = type_size(&type, &align);
3123+ if (t == TOK_SIZEOF) {
3124+ if (size < 0)
3125+ error("sizeof applied to an incomplete type");
3126+ vpushi(size);
3127+ } else {
3128+ vpushi(align);
3129+ }
3130+ vtop->type.t |= VT_UNSIGNED;
3131+ break;
3132+
3133+ case TOK_builtin_types_compatible_p:
3134+ {
3135+ CType type1, type2;
3136+ next();
3137+ skip('(');
3138+ parse_type(&type1);
3139+ skip(',');
3140+ parse_type(&type2);
3141+ skip(')');
3142+ type1.t &= ~(VT_CONSTANT | VT_VOLATILE);
3143+ type2.t &= ~(VT_CONSTANT | VT_VOLATILE);
3144+ vpushi(is_compatible_types(&type1, &type2));
3145+ }
3146+ break;
3147+ case TOK_builtin_constant_p:
3148+ {
3149+ int saved_nocode_wanted, res;
3150+ next();
3151+ skip('(');
3152+ saved_nocode_wanted = nocode_wanted;
3153+ nocode_wanted = 1;
3154+ gexpr();
3155+ res = (vtop->r & (VT_VALMASK | VT_LVAL | VT_SYM)) == VT_CONST;
3156+ vpop();
3157+ nocode_wanted = saved_nocode_wanted;
3158+ skip(')');
3159+ vpushi(res);
3160+ }
3161+ break;
3162+ case TOK_builtin_frame_address:
3163+ {
3164+ CType type;
3165+ next();
3166+ skip('(');
3167+ if (tok != TOK_CINT) {
3168+ error("__builtin_frame_address only takes integers");
3169+ }
3170+ if (tokc.i != 0) {
3171+ error("TCC only supports __builtin_frame_address(0)");
3172+ }
3173+ next();
3174+ skip(')');
3175+ type.t = VT_VOID;
3176+ mk_pointer(&type);
3177+ vset(&type, VT_LOCAL, 0);
3178+ }
3179+ break;
3180+#ifdef TCC_TARGET_X86_64
3181+ case TOK_builtin_malloc:
3182+ tok = TOK_malloc;
3183+ goto tok_identifier;
3184+ case TOK_builtin_free:
3185+ tok = TOK_free;
3186+ goto tok_identifier;
3187+#endif
3188+ case TOK_INC:
3189+ case TOK_DEC:
3190+ t = tok;
3191+ next();
3192+ unary();
3193+ inc(0, t);
3194+ break;
3195+ case '-':
3196+ next();
3197+ vpushi(0);
3198+ unary();
3199+ gen_op('-');
3200+ break;
3201+ case TOK_LAND:
3202+ if (!gnu_ext)
3203+ goto tok_identifier;
3204+ next();
3205+ /* allow to take the address of a label */
3206+ if (tok < TOK_UIDENT)
3207+ expect("label identifier");
3208+ s = label_find(tok);
3209+ if (!s) {
3210+ s = label_push(&global_label_stack, tok, LABEL_FORWARD);
3211+ } else {
3212+ if (s->r == LABEL_DECLARED)
3213+ s->r = LABEL_FORWARD;
3214+ }
3215+ if (!s->type.t) {
3216+ s->type.t = VT_VOID;
3217+ mk_pointer(&s->type);
3218+ s->type.t |= VT_STATIC;
3219+ }
3220+ vset(&s->type, VT_CONST | VT_SYM, 0);
3221+ vtop->sym = s;
3222+ next();
3223+ break;
3224+ default:
3225+ tok_identifier:
3226+ t = tok;
3227+ next();
3228+ if (t < TOK_UIDENT)
3229+ expect("identifier");
3230+ s = sym_find(t);
3231+ if (!s) {
3232+ if (tok != '(')
3233+ error("'%s' undeclared", get_tok_str(t, NULL));
3234+ /* for simple function calls, we tolerate undeclared
3235+ external reference to int() function */
3236+ if (tcc_state->warn_implicit_function_declaration)
3237+ warning("implicit declaration of function '%s'",
3238+ get_tok_str(t, NULL));
3239+ s = external_global_sym(t, &func_old_type, 0);
3240+ }
3241+ if ((s->type.t & (VT_STATIC | VT_INLINE | VT_BTYPE)) ==
3242+ (VT_STATIC | VT_INLINE | VT_FUNC)) {
3243+ /* if referencing an inline function, then we generate a
3244+ symbol to it if not already done. It will have the
3245+ effect to generate code for it at the end of the
3246+ compilation unit. Inline function as always
3247+ generated in the text section. */
3248+ if (!s->c)
3249+ put_extern_sym(s, text_section, 0, 0);
3250+ r = VT_SYM | VT_CONST;
3251+ } else {
3252+ r = s->r;
3253+ }
3254+ vset(&s->type, r, s->c);
3255+ /* if forward reference, we must point to s */
3256+ if (vtop->r & VT_SYM) {
3257+ vtop->sym = s;
3258+ vtop->c.ul = 0;
3259+ }
3260+ break;
3261+ }
3262+
3263+ /* post operations */
3264+ while (1) {
3265+ if (tok == TOK_INC || tok == TOK_DEC) {
3266+ inc(1, tok);
3267+ next();
3268+ } else if (tok == '.' || tok == TOK_ARROW) {
3269+ /* field */
3270+ if (tok == TOK_ARROW)
3271+ indir();
3272+ test_lvalue();
3273+ gaddrof();
3274+ next();
3275+ /* expect pointer on structure */
3276+ if ((vtop->type.t & VT_BTYPE) != VT_STRUCT)
3277+ expect("struct or union");
3278+ s = vtop->type.ref;
3279+ /* find field */
3280+ tok |= SYM_FIELD;
3281+ while ((s = s->next) != NULL) {
3282+ if (s->v == tok)
3283+ break;
3284+ }
3285+ if (!s)
3286+ error("field not found: %s", get_tok_str(tok & ~SYM_FIELD, NULL));
3287+ /* add field offset to pointer */
3288+ vtop->type = char_pointer_type; /* change type to 'char *' */
3289+ vpushi(s->c);
3290+ gen_op('+');
3291+ /* change type to field type, and set to lvalue */
3292+ vtop->type = s->type;
3293+ /* an array is never an lvalue */
3294+ if (!(vtop->type.t & VT_ARRAY)) {
3295+ vtop->r |= lvalue_type(vtop->type.t);
3296+ /* if bound checking, the referenced pointer must be checked */
3297+ if (do_bounds_check)
3298+ vtop->r |= VT_MUSTBOUND;
3299+ }
3300+ next();
3301+ } else if (tok == '[') {
3302+ next();
3303+ gexpr();
3304+ gen_op('+');
3305+ indir();
3306+ skip(']');
3307+ } else if (tok == '(') {
3308+ SValue ret;
3309+ Sym *sa;
3310+ int nb_args;
3311+
3312+ /* function call */
3313+ if ((vtop->type.t & VT_BTYPE) != VT_FUNC) {
3314+ /* pointer test (no array accepted) */
3315+ if ((vtop->type.t & (VT_BTYPE | VT_ARRAY)) == VT_PTR) {
3316+ vtop->type = *pointed_type(&vtop->type);
3317+ if ((vtop->type.t & VT_BTYPE) != VT_FUNC)
3318+ goto error_func;
3319+ } else {
3320+ error_func:
3321+ expect("function pointer");
3322+ }
3323+ } else {
3324+ vtop->r &= ~VT_LVAL; /* no lvalue */
3325+ }
3326+ /* get return type */
3327+ s = vtop->type.ref;
3328+ next();
3329+ sa = s->next; /* first parameter */
3330+ nb_args = 0;
3331+ ret.r2 = VT_CONST;
3332+ /* compute first implicit argument if a structure is returned */
3333+ if ((s->type.t & VT_BTYPE) == VT_STRUCT) {
3334+ /* get some space for the returned structure */
3335+ size = type_size(&s->type, &align);
3336+ loc = (loc - size) & -align;
3337+ ret.type = s->type;
3338+ ret.r = VT_LOCAL | VT_LVAL;
3339+ /* pass it as 'int' to avoid structure arg passing
3340+ problems */
3341+ vseti(VT_LOCAL, loc);
3342+ ret.c = vtop->c;
3343+ nb_args++;
3344+ } else {
3345+ ret.type = s->type;
3346+ /* return in register */
3347+ if (is_float(ret.type.t)) {
3348+ ret.r = reg_fret(ret.type.t);
3349+ } else {
3350+ if ((ret.type.t & VT_BTYPE) == VT_LLONG)
3351+ ret.r2 = REG_LRET;
3352+ ret.r = REG_IRET;
3353+ }
3354+ ret.c.i = 0;
3355+ }
3356+ if (tok != ')') {
3357+ for(;;) {
3358+ expr_eq();
3359+ gfunc_param_typed(s, sa);
3360+ nb_args++;
3361+ if (sa)
3362+ sa = sa->next;
3363+ if (tok == ')')
3364+ break;
3365+ skip(',');
3366+ }
3367+ }
3368+ if (sa)
3369+ error("too few arguments to function");
3370+ skip(')');
3371+ if (!nocode_wanted) {
3372+ gfunc_call(nb_args);
3373+ } else {
3374+ vtop -= (nb_args + 1);
3375+ }
3376+ /* return value */
3377+ vsetc(&ret.type, ret.r, &ret.c);
3378+ vtop->r2 = ret.r2;
3379+ } else {
3380+ break;
3381+ }
3382+ }
3383+}
3384+
3385+static void uneq(void)
3386+{
3387+ int t;
3388+
3389+ unary();
3390+ if (tok == '=' ||
3391+ (tok >= TOK_A_MOD && tok <= TOK_A_DIV) ||
3392+ tok == TOK_A_XOR || tok == TOK_A_OR ||
3393+ tok == TOK_A_SHL || tok == TOK_A_SAR) {
3394+ test_lvalue();
3395+ t = tok;
3396+ next();
3397+ if (t == '=') {
3398+ expr_eq();
3399+ } else {
3400+ vdup();
3401+ expr_eq();
3402+ gen_op(t & 0x7f);
3403+ }
3404+ vstore();
3405+ }
3406+}
3407+
3408+static void expr_prod(void)
3409+{
3410+ int t;
3411+
3412+ uneq();
3413+ while (tok == '*' || tok == '/' || tok == '%') {
3414+ t = tok;
3415+ next();
3416+ uneq();
3417+ gen_op(t);
3418+ }
3419+}
3420+
3421+static void expr_sum(void)
3422+{
3423+ int t;
3424+
3425+ expr_prod();
3426+ while (tok == '+' || tok == '-') {
3427+ t = tok;
3428+ next();
3429+ expr_prod();
3430+ gen_op(t);
3431+ }
3432+}
3433+
3434+static void expr_shift(void)
3435+{
3436+ int t;
3437+
3438+ expr_sum();
3439+ while (tok == TOK_SHL || tok == TOK_SAR) {
3440+ t = tok;
3441+ next();
3442+ expr_sum();
3443+ gen_op(t);
3444+ }
3445+}
3446+
3447+static void expr_cmp(void)
3448+{
3449+ int t;
3450+
3451+ expr_shift();
3452+ while ((tok >= TOK_ULE && tok <= TOK_GT) ||
3453+ tok == TOK_ULT || tok == TOK_UGE) {
3454+ t = tok;
3455+ next();
3456+ expr_shift();
3457+ gen_op(t);
3458+ }
3459+}
3460+
3461+static void expr_cmpeq(void)
3462+{
3463+ int t;
3464+
3465+ expr_cmp();
3466+ while (tok == TOK_EQ || tok == TOK_NE) {
3467+ t = tok;
3468+ next();
3469+ expr_cmp();
3470+ gen_op(t);
3471+ }
3472+}
3473+
3474+static void expr_and(void)
3475+{
3476+ expr_cmpeq();
3477+ while (tok == '&') {
3478+ next();
3479+ expr_cmpeq();
3480+ gen_op('&');
3481+ }
3482+}
3483+
3484+static void expr_xor(void)
3485+{
3486+ expr_and();
3487+ while (tok == '^') {
3488+ next();
3489+ expr_and();
3490+ gen_op('^');
3491+ }
3492+}
3493+
3494+static void expr_or(void)
3495+{
3496+ expr_xor();
3497+ while (tok == '|') {
3498+ next();
3499+ expr_xor();
3500+ gen_op('|');
3501+ }
3502+}
3503+
3504+/* XXX: fix this mess */
3505+static void expr_land_const(void)
3506+{
3507+ expr_or();
3508+ while (tok == TOK_LAND) {
3509+ next();
3510+ expr_or();
3511+ gen_op(TOK_LAND);
3512+ }
3513+}
3514+
3515+/* XXX: fix this mess */
3516+static void expr_lor_const(void)
3517+{
3518+ expr_land_const();
3519+ while (tok == TOK_LOR) {
3520+ next();
3521+ expr_land_const();
3522+ gen_op(TOK_LOR);
3523+ }
3524+}
3525+
3526+/* only used if non constant */
3527+static void expr_land(void)
3528+{
3529+ int t;
3530+
3531+ expr_or();
3532+ if (tok == TOK_LAND) {
3533+ t = 0;
3534+ save_regs(1);
3535+ for(;;) {
3536+ t = gtst(1, t);
3537+ if (tok != TOK_LAND) {
3538+ vseti(VT_JMPI, t);
3539+ break;
3540+ }
3541+ next();
3542+ expr_or();
3543+ }
3544+ }
3545+}
3546+
3547+static void expr_lor(void)
3548+{
3549+ int t;
3550+
3551+ expr_land();
3552+ if (tok == TOK_LOR) {
3553+ t = 0;
3554+ save_regs(1);
3555+ for(;;) {
3556+ t = gtst(0, t);
3557+ if (tok != TOK_LOR) {
3558+ vseti(VT_JMP, t);
3559+ break;
3560+ }
3561+ next();
3562+ expr_land();
3563+ }
3564+ }
3565+}
3566+
3567+/* XXX: better constant handling */
3568+static void expr_eq(void)
3569+{
3570+ int tt, u, r1, r2, rc, t1, t2, bt1, bt2;
3571+ SValue sv;
3572+ CType type, type1, type2;
3573+
3574+ if (const_wanted) {
3575+ expr_lor_const();
3576+ if (tok == '?') {
3577+ CType boolean;
3578+ int c;
3579+ boolean.t = VT_BOOL;
3580+ vdup();
3581+ gen_cast(&boolean);
3582+ c = vtop->c.i;
3583+ vpop();
3584+ next();
3585+ if (tok != ':' || !gnu_ext) {
3586+ vpop();
3587+ gexpr();
3588+ }
3589+ if (!c)
3590+ vpop();
3591+ skip(':');
3592+ expr_eq();
3593+ if (c)
3594+ vpop();
3595+ }
3596+ } else {
3597+ expr_lor();
3598+ if (tok == '?') {
3599+ next();
3600+ if (vtop != vstack) {
3601+ /* needed to avoid having different registers saved in
3602+ each branch */
3603+ if (is_float(vtop->type.t)) {
3604+ rc = RC_FLOAT;
3605+#ifdef TCC_TARGET_X86_64
3606+ if ((vtop->type.t & VT_BTYPE) == VT_LDOUBLE) {
3607+ rc = RC_ST0;
3608+ }
3609+#endif
3610+ }
3611+ else
3612+ rc = RC_INT;
3613+ gv(rc);
3614+ save_regs(1);
3615+ }
3616+ if (tok == ':' && gnu_ext) {
3617+ gv_dup();
3618+ tt = gtst(1, 0);
3619+ } else {
3620+ tt = gtst(1, 0);
3621+ gexpr();
3622+ }
3623+ type1 = vtop->type;
3624+ sv = *vtop; /* save value to handle it later */
3625+ vtop--; /* no vpop so that FP stack is not flushed */
3626+ skip(':');
3627+ u = gjmp(0);
3628+ gsym(tt);
3629+ expr_eq();
3630+ type2 = vtop->type;
3631+
3632+ t1 = type1.t;
3633+ bt1 = t1 & VT_BTYPE;
3634+ t2 = type2.t;
3635+ bt2 = t2 & VT_BTYPE;
3636+ /* cast operands to correct type according to ISOC rules */
3637+ if (is_float(bt1) || is_float(bt2)) {
3638+ if (bt1 == VT_LDOUBLE || bt2 == VT_LDOUBLE) {
3639+ type.t = VT_LDOUBLE;
3640+ } else if (bt1 == VT_DOUBLE || bt2 == VT_DOUBLE) {
3641+ type.t = VT_DOUBLE;
3642+ } else {
3643+ type.t = VT_FLOAT;
3644+ }
3645+ } else if (bt1 == VT_LLONG || bt2 == VT_LLONG) {
3646+ /* cast to biggest op */
3647+ type.t = VT_LLONG;
3648+ /* convert to unsigned if it does not fit in a long long */
3649+ if ((t1 & (VT_BTYPE | VT_UNSIGNED)) == (VT_LLONG | VT_UNSIGNED) ||
3650+ (t2 & (VT_BTYPE | VT_UNSIGNED)) == (VT_LLONG | VT_UNSIGNED))
3651+ type.t |= VT_UNSIGNED;
3652+ } else if (bt1 == VT_PTR || bt2 == VT_PTR) {
3653+ /* XXX: test pointer compatibility */
3654+ type = type1;
3655+ } else if (bt1 == VT_FUNC || bt2 == VT_FUNC) {
3656+ /* XXX: test function pointer compatibility */
3657+ type = type1;
3658+ } else if (bt1 == VT_STRUCT || bt2 == VT_STRUCT) {
3659+ /* XXX: test structure compatibility */
3660+ type = type1;
3661+ } else if (bt1 == VT_VOID || bt2 == VT_VOID) {
3662+ /* NOTE: as an extension, we accept void on only one side */
3663+ type.t = VT_VOID;
3664+ } else {
3665+ /* integer operations */
3666+ type.t = VT_INT;
3667+ /* convert to unsigned if it does not fit in an integer */
3668+ if ((t1 & (VT_BTYPE | VT_UNSIGNED)) == (VT_INT | VT_UNSIGNED) ||
3669+ (t2 & (VT_BTYPE | VT_UNSIGNED)) == (VT_INT | VT_UNSIGNED))
3670+ type.t |= VT_UNSIGNED;
3671+ }
3672+
3673+ /* now we convert second operand */
3674+ gen_cast(&type);
3675+ if (VT_STRUCT == (vtop->type.t & VT_BTYPE))
3676+ gaddrof();
3677+ rc = RC_INT;
3678+ if (is_float(type.t)) {
3679+ rc = RC_FLOAT;
3680+#ifdef TCC_TARGET_X86_64
3681+ if ((type.t & VT_BTYPE) == VT_LDOUBLE) {
3682+ rc = RC_ST0;
3683+ }
3684+#endif
3685+ } else if ((type.t & VT_BTYPE) == VT_LLONG) {
3686+ /* for long longs, we use fixed registers to avoid having
3687+ to handle a complicated move */
3688+ rc = RC_IRET;
3689+ }
3690+
3691+ r2 = gv(rc);
3692+ /* this is horrible, but we must also convert first
3693+ operand */
3694+ tt = gjmp(0);
3695+ gsym(u);
3696+ /* put again first value and cast it */
3697+ *vtop = sv;
3698+ gen_cast(&type);
3699+ if (VT_STRUCT == (vtop->type.t & VT_BTYPE))
3700+ gaddrof();
3701+ r1 = gv(rc);
3702+ move_reg(r2, r1);
3703+ vtop->r = r2;
3704+ gsym(tt);
3705+ }
3706+ }
3707+}
3708+
3709+static void gexpr(void)
3710+{
3711+ while (1) {
3712+ expr_eq();
3713+ if (tok != ',')
3714+ break;
3715+ vpop();
3716+ next();
3717+ }
3718+}
3719+
3720+/* parse an expression and return its type without any side effect. */
3721+static void expr_type(CType *type)
3722+{
3723+ int saved_nocode_wanted;
3724+
3725+ saved_nocode_wanted = nocode_wanted;
3726+ nocode_wanted = 1;
3727+ gexpr();
3728+ *type = vtop->type;
3729+ vpop();
3730+ nocode_wanted = saved_nocode_wanted;
3731+}
3732+
3733+/* parse a unary expression and return its type without any side
3734+ effect. */
3735+static void unary_type(CType *type)
3736+{
3737+ int a;
3738+
3739+ a = nocode_wanted;
3740+ nocode_wanted = 1;
3741+ unary();
3742+ *type = vtop->type;
3743+ vpop();
3744+ nocode_wanted = a;
3745+}
3746+
3747+/* parse a constant expression and return value in vtop. */
3748+static void expr_const1(void)
3749+{
3750+ int a;
3751+ a = const_wanted;
3752+ const_wanted = 1;
3753+ expr_eq();
3754+ const_wanted = a;
3755+}
3756+
3757+/* parse an integer constant and return its value. */
3758+static int expr_const(void)
3759+{
3760+ int c;
3761+ expr_const1();
3762+ if ((vtop->r & (VT_VALMASK | VT_LVAL | VT_SYM)) != VT_CONST)
3763+ expect("constant expression");
3764+ c = vtop->c.i;
3765+ vpop();
3766+ return c;
3767+}
3768+
3769+/* return the label token if current token is a label, otherwise
3770+ return zero */
3771+static int is_label(void)
3772+{
3773+ int last_tok;
3774+
3775+ /* fast test first */
3776+ if (tok < TOK_UIDENT)
3777+ return 0;
3778+ /* no need to save tokc because tok is an identifier */
3779+ last_tok = tok;
3780+ next();
3781+ if (tok == ':') {
3782+ next();
3783+ return last_tok;
3784+ } else {
3785+ unget_tok(last_tok);
3786+ return 0;
3787+ }
3788+}
3789+
3790+static void block(int *bsym, int *csym, int *case_sym, int *def_sym,
3791+ int case_reg, int is_expr)
3792+{
3793+ int a, b, c, d;
3794+ Sym *s;
3795+
3796+ /* generate line number info */
3797+ if (do_debug &&
3798+ (last_line_num != file->line_num || last_ind != ind)) {
3799+ put_stabn(N_SLINE, 0, file->line_num, ind - func_ind);
3800+ last_ind = ind;
3801+ last_line_num = file->line_num;
3802+ }
3803+
3804+ if (is_expr) {
3805+ /* default return value is (void) */
3806+ vpushi(0);
3807+ vtop->type.t = VT_VOID;
3808+ }
3809+
3810+ if (tok == TOK_IF) {
3811+ /* if test */
3812+ next();
3813+ skip('(');
3814+ gexpr();
3815+ skip(')');
3816+ a = gtst(1, 0);
3817+ block(bsym, csym, case_sym, def_sym, case_reg, 0);
3818+ c = tok;
3819+ if (c == TOK_ELSE) {
3820+ next();
3821+ d = gjmp(0);
3822+ gsym(a);
3823+ block(bsym, csym, case_sym, def_sym, case_reg, 0);
3824+ gsym(d); /* patch else jmp */
3825+ } else
3826+ gsym(a);
3827+ } else if (tok == TOK_WHILE) {
3828+ next();
3829+ d = ind;
3830+ skip('(');
3831+ gexpr();
3832+ skip(')');
3833+ a = gtst(1, 0);
3834+ b = 0;
3835+ block(&a, &b, case_sym, def_sym, case_reg, 0);
3836+ gjmp_addr(d);
3837+ gsym(a);
3838+ gsym_addr(b, d);
3839+ } else if (tok == '{') {
3840+ Sym *llabel;
3841+
3842+ next();
3843+ /* record local declaration stack position */
3844+ s = local_stack;
3845+ llabel = local_label_stack;
3846+ /* handle local labels declarations */
3847+ if (tok == TOK_LABEL) {
3848+ next();
3849+ for(;;) {
3850+ if (tok < TOK_UIDENT)
3851+ expect("label identifier");
3852+ label_push(&local_label_stack, tok, LABEL_DECLARED);
3853+ next();
3854+ if (tok == ',') {
3855+ next();
3856+ } else {
3857+ skip(';');
3858+ break;
3859+ }
3860+ }
3861+ }
3862+ while (tok != '}') {
3863+ decl(VT_LOCAL);
3864+ if (tok != '}') {
3865+ if (is_expr)
3866+ vpop();
3867+ block(bsym, csym, case_sym, def_sym, case_reg, is_expr);
3868+ }
3869+ }
3870+ /* pop locally defined labels */
3871+ label_pop(&local_label_stack, llabel);
3872+ /* pop locally defined symbols */
3873+ if(is_expr) {
3874+ /* XXX: this solution makes only valgrind happy...
3875+ triggered by gcc.c-torture/execute/20000917-1.c */
3876+ Sym *p;
3877+ switch(vtop->type.t & VT_BTYPE) {
3878+ case VT_PTR:
3879+ case VT_STRUCT:
3880+ case VT_ENUM:
3881+ case VT_FUNC:
3882+ for(p=vtop->type.ref;p;p=p->prev)
3883+ if(p->prev==s)
3884+ error("unsupported expression type");
3885+ }
3886+ }
3887+ sym_pop(&local_stack, s);
3888+ next();
3889+ } else if (tok == TOK_RETURN) {
3890+ next();
3891+ if (tok != ';') {
3892+ gexpr();
3893+ gen_assign_cast(&func_vt);
3894+ if ((func_vt.t & VT_BTYPE) == VT_STRUCT) {
3895+ CType type;
3896+ /* if returning structure, must copy it to implicit
3897+ first pointer arg location */
3898+#ifdef TCC_ARM_EABI
3899+ int align, size;
3900+ size = type_size(&func_vt,&align);
3901+ if(size <= 4)
3902+ {
3903+ if((vtop->r != (VT_LOCAL | VT_LVAL) || (vtop->c.i & 3))
3904+ && (align & 3))
3905+ {
3906+ int addr;
3907+ loc = (loc - size) & -4;
3908+ addr = loc;
3909+ type = func_vt;
3910+ vset(&type, VT_LOCAL | VT_LVAL, addr);
3911+ vswap();
3912+ vstore();
3913+ vset(&int_type, VT_LOCAL | VT_LVAL, addr);
3914+ }
3915+ vtop->type = int_type;
3916+ gv(RC_IRET);
3917+ } else {
3918+#endif
3919+ type = func_vt;
3920+ mk_pointer(&type);
3921+ vset(&type, VT_LOCAL | VT_LVAL, func_vc);
3922+ indir();
3923+ vswap();
3924+ /* copy structure value to pointer */
3925+ vstore();
3926+#ifdef TCC_ARM_EABI
3927+ }
3928+#endif
3929+ } else if (is_float(func_vt.t)) {
3930+ gv(rc_fret(func_vt.t));
3931+ } else {
3932+ gv(RC_IRET);
3933+ }
3934+ vtop--; /* NOT vpop() because on x86 it would flush the fp stack */
3935+ }
3936+ skip(';');
3937+ rsym = gjmp(rsym); /* jmp */
3938+ } else if (tok == TOK_BREAK) {
3939+ /* compute jump */
3940+ if (!bsym)
3941+ error("cannot break");
3942+ *bsym = gjmp(*bsym);
3943+ next();
3944+ skip(';');
3945+ } else if (tok == TOK_CONTINUE) {
3946+ /* compute jump */
3947+ if (!csym)
3948+ error("cannot continue");
3949+ *csym = gjmp(*csym);
3950+ next();
3951+ skip(';');
3952+ } else if (tok == TOK_FOR) {
3953+ int e;
3954+ next();
3955+ skip('(');
3956+ if (tok != ';') {
3957+ gexpr();
3958+ vpop();
3959+ }
3960+ skip(';');
3961+ d = ind;
3962+ c = ind;
3963+ a = 0;
3964+ b = 0;
3965+ if (tok != ';') {
3966+ gexpr();
3967+ a = gtst(1, 0);
3968+ }
3969+ skip(';');
3970+ if (tok != ')') {
3971+ e = gjmp(0);
3972+ c = ind;
3973+ gexpr();
3974+ vpop();
3975+ gjmp_addr(d);
3976+ gsym(e);
3977+ }
3978+ skip(')');
3979+ block(&a, &b, case_sym, def_sym, case_reg, 0);
3980+ gjmp_addr(c);
3981+ gsym(a);
3982+ gsym_addr(b, c);
3983+ } else
3984+ if (tok == TOK_DO) {
3985+ next();
3986+ a = 0;
3987+ b = 0;
3988+ d = ind;
3989+ block(&a, &b, case_sym, def_sym, case_reg, 0);
3990+ skip(TOK_WHILE);
3991+ skip('(');
3992+ gsym(b);
3993+ gexpr();
3994+ c = gtst(0, 0);
3995+ gsym_addr(c, d);
3996+ skip(')');
3997+ gsym(a);
3998+ skip(';');
3999+ } else
4000+ if (tok == TOK_SWITCH) {
4001+ next();
4002+ skip('(');
4003+ gexpr();
4004+ /* XXX: other types than integer */
4005+ case_reg = gv(RC_INT);
4006+ vpop();
4007+ skip(')');
4008+ a = 0;
4009+ b = gjmp(0); /* jump to first case */
4010+ c = 0;
4011+ block(&a, csym, &b, &c, case_reg, 0);
4012+ /* if no default, jmp after switch */
4013+ if (c == 0)
4014+ c = ind;
4015+ /* default label */
4016+ gsym_addr(b, c);
4017+ /* break label */
4018+ gsym(a);
4019+ } else
4020+ if (tok == TOK_CASE) {
4021+ int v1, v2;
4022+ if (!case_sym)
4023+ expect("switch");
4024+ next();
4025+ v1 = expr_const();
4026+ v2 = v1;
4027+ if (gnu_ext && tok == TOK_DOTS) {
4028+ next();
4029+ v2 = expr_const();
4030+ if (v2 < v1)
4031+ warning("empty case range");
4032+ }
4033+ /* since a case is like a label, we must skip it with a jmp */
4034+ b = gjmp(0);
4035+ gsym(*case_sym);
4036+ vseti(case_reg, 0);
4037+ vpushi(v1);
4038+ if (v1 == v2) {
4039+ gen_op(TOK_EQ);
4040+ *case_sym = gtst(1, 0);
4041+ } else {
4042+ gen_op(TOK_GE);
4043+ *case_sym = gtst(1, 0);
4044+ vseti(case_reg, 0);
4045+ vpushi(v2);
4046+ gen_op(TOK_LE);
4047+ *case_sym = gtst(1, *case_sym);
4048+ }
4049+ gsym(b);
4050+ skip(':');
4051+ is_expr = 0;
4052+ goto block_after_label;
4053+ } else
4054+ if (tok == TOK_DEFAULT) {
4055+ next();
4056+ skip(':');
4057+ if (!def_sym)
4058+ expect("switch");
4059+ if (*def_sym)
4060+ error("too many 'default'");
4061+ *def_sym = ind;
4062+ is_expr = 0;
4063+ goto block_after_label;
4064+ } else
4065+ if (tok == TOK_GOTO) {
4066+ next();
4067+ if (tok == '*' && gnu_ext) {
4068+ /* computed goto */
4069+ next();
4070+ gexpr();
4071+ if ((vtop->type.t & VT_BTYPE) != VT_PTR)
4072+ expect("pointer");
4073+ ggoto();
4074+ } else if (tok >= TOK_UIDENT) {
4075+ s = label_find(tok);
4076+ /* put forward definition if needed */
4077+ if (!s) {
4078+ s = label_push(&global_label_stack, tok, LABEL_FORWARD);
4079+ } else {
4080+ if (s->r == LABEL_DECLARED)
4081+ s->r = LABEL_FORWARD;
4082+ }
4083+ /* label already defined */
4084+ if (s->r & LABEL_FORWARD)
4085+ s->next = (void *)gjmp((long)s->next);
4086+ else
4087+ gjmp_addr((long)s->next);
4088+ next();
4089+ } else {
4090+ expect("label identifier");
4091+ }
4092+ skip(';');
4093+ } else if (tok == TOK_ASM1 || tok == TOK_ASM2 || tok == TOK_ASM3) {
4094+ asm_instr();
4095+ } else {
4096+ b = is_label();
4097+ if (b) {
4098+ /* label case */
4099+ s = label_find(b);
4100+ if (s) {
4101+ if (s->r == LABEL_DEFINED)
4102+ error("duplicate label '%s'", get_tok_str(s->v, NULL));
4103+ gsym((long)s->next);
4104+ s->r = LABEL_DEFINED;
4105+ } else {
4106+ s = label_push(&global_label_stack, b, LABEL_DEFINED);
4107+ }
4108+ s->next = (void *)ind;
4109+ /* we accept this, but it is a mistake */
4110+ block_after_label:
4111+ if (tok == '}') {
4112+ warning("deprecated use of label at end of compound statement");
4113+ } else {
4114+ if (is_expr)
4115+ vpop();
4116+ block(bsym, csym, case_sym, def_sym, case_reg, is_expr);
4117+ }
4118+ } else {
4119+ /* expression case */
4120+ if (tok != ';') {
4121+ if (is_expr) {
4122+ vpop();
4123+ gexpr();
4124+ } else {
4125+ gexpr();
4126+ vpop();
4127+ }
4128+ }
4129+ skip(';');
4130+ }
4131+ }
4132+}
4133+
4134+/* t is the array or struct type. c is the array or struct
4135+ address. cur_index/cur_field is the pointer to the current
4136+ value. 'size_only' is true if only size info is needed (only used
4137+ in arrays) */
4138+static void decl_designator(CType *type, Section *sec, unsigned long c,
4139+ int *cur_index, Sym **cur_field,
4140+ int size_only)
4141+{
4142+ Sym *s, *f;
4143+ int notfirst, index, index_last, align, l, nb_elems, elem_size;
4144+ CType type1;
4145+
4146+ notfirst = 0;
4147+ elem_size = 0;
4148+ nb_elems = 1;
4149+ if (gnu_ext && (l = is_label()) != 0)
4150+ goto struct_field;
4151+ while (tok == '[' || tok == '.') {
4152+ if (tok == '[') {
4153+ if (!(type->t & VT_ARRAY))
4154+ expect("array type");
4155+ s = type->ref;
4156+ next();
4157+ index = expr_const();
4158+ if (index < 0 || (s->c >= 0 && index >= s->c))
4159+ expect("invalid index");
4160+ if (tok == TOK_DOTS && gnu_ext) {
4161+ next();
4162+ index_last = expr_const();
4163+ if (index_last < 0 ||
4164+ (s->c >= 0 && index_last >= s->c) ||
4165+ index_last < index)
4166+ expect("invalid index");
4167+ } else {
4168+ index_last = index;
4169+ }
4170+ skip(']');
4171+ if (!notfirst)
4172+ *cur_index = index_last;
4173+ type = pointed_type(type);
4174+ elem_size = type_size(type, &align);
4175+ c += index * elem_size;
4176+ /* NOTE: we only support ranges for last designator */
4177+ nb_elems = index_last - index + 1;
4178+ if (nb_elems != 1) {
4179+ notfirst = 1;
4180+ break;
4181+ }
4182+ } else {
4183+ next();
4184+ l = tok;
4185+ next();
4186+ struct_field:
4187+ if ((type->t & VT_BTYPE) != VT_STRUCT)
4188+ expect("struct/union type");
4189+ s = type->ref;
4190+ l |= SYM_FIELD;
4191+ f = s->next;
4192+ while (f) {
4193+ if (f->v == l)
4194+ break;
4195+ f = f->next;
4196+ }
4197+ if (!f)
4198+ expect("field");
4199+ if (!notfirst)
4200+ *cur_field = f;
4201+ /* XXX: fix this mess by using explicit storage field */
4202+ type1 = f->type;
4203+ type1.t |= (type->t & ~VT_TYPE);
4204+ type = &type1;
4205+ c += f->c;
4206+ }
4207+ notfirst = 1;
4208+ }
4209+ if (notfirst) {
4210+ if (tok == '=') {
4211+ next();
4212+ } else {
4213+ if (!gnu_ext)
4214+ expect("=");
4215+ }
4216+ } else {
4217+ if (type->t & VT_ARRAY) {
4218+ index = *cur_index;
4219+ type = pointed_type(type);
4220+ c += index * type_size(type, &align);
4221+ } else {
4222+ f = *cur_field;
4223+ if (!f)
4224+ error("too many field init");
4225+ /* XXX: fix this mess by using explicit storage field */
4226+ type1 = f->type;
4227+ type1.t |= (type->t & ~VT_TYPE);
4228+ type = &type1;
4229+ c += f->c;
4230+ }
4231+ }
4232+ decl_initializer(type, sec, c, 0, size_only);
4233+
4234+ /* XXX: make it more general */
4235+ if (!size_only && nb_elems > 1) {
4236+ unsigned long c_end;
4237+ uint8_t *src, *dst;
4238+ int i;
4239+
4240+ if (!sec)
4241+ error("range init not supported yet for dynamic storage");
4242+ c_end = c + nb_elems * elem_size;
4243+ if (c_end > sec->data_allocated)
4244+ section_realloc(sec, c_end);
4245+ src = sec->data + c;
4246+ dst = src;
4247+ for(i = 1; i < nb_elems; i++) {
4248+ dst += elem_size;
4249+ memcpy(dst, src, elem_size);
4250+ }
4251+ }
4252+}
4253+
4254+#define EXPR_VAL 0
4255+#define EXPR_CONST 1
4256+#define EXPR_ANY 2
4257+
4258+/* store a value or an expression directly in global data or in local array */
4259+static void init_putv(CType *type, Section *sec, unsigned long c,
4260+ int v, int expr_type)
4261+{
4262+ int saved_global_expr, bt, bit_pos, bit_size;
4263+ void *ptr;
4264+ unsigned long long bit_mask;
4265+ CType dtype;
4266+
4267+ switch(expr_type) {
4268+ case EXPR_VAL:
4269+ vpushi(v);
4270+ break;
4271+ case EXPR_CONST:
4272+ /* compound literals must be allocated globally in this case */
4273+ saved_global_expr = global_expr;
4274+ global_expr = 1;
4275+ expr_const1();
4276+ global_expr = saved_global_expr;
4277+ /* NOTE: symbols are accepted */
4278+ if ((vtop->r & (VT_VALMASK | VT_LVAL)) != VT_CONST)
4279+ error("initializer element is not constant");
4280+ break;
4281+ case EXPR_ANY:
4282+ expr_eq();
4283+ break;
4284+ }
4285+
4286+ dtype = *type;
4287+ dtype.t &= ~VT_CONSTANT; /* need to do that to avoid false warning */
4288+
4289+ if (sec) {
4290+ /* XXX: not portable */
4291+ /* XXX: generate error if incorrect relocation */
4292+ gen_assign_cast(&dtype);
4293+ bt = type->t & VT_BTYPE;
4294+ /* we'll write at most 12 bytes */
4295+ if (c + 12 > sec->data_allocated) {
4296+ section_realloc(sec, c + 12);
4297+ }
4298+ ptr = sec->data + c;
4299+ /* XXX: make code faster ? */
4300+ if (!(type->t & VT_BITFIELD)) {
4301+ bit_pos = 0;
4302+ bit_size = 32;
4303+ bit_mask = -1LL;
4304+ } else {
4305+ bit_pos = (vtop->type.t >> VT_STRUCT_SHIFT) & 0x3f;
4306+ bit_size = (vtop->type.t >> (VT_STRUCT_SHIFT + 6)) & 0x3f;
4307+ bit_mask = (1LL << bit_size) - 1;
4308+ }
4309+ if ((vtop->r & VT_SYM) &&
4310+ (bt == VT_BYTE ||
4311+ bt == VT_SHORT ||
4312+ bt == VT_DOUBLE ||
4313+ bt == VT_LDOUBLE ||
4314+ bt == VT_LLONG ||
4315+ (bt == VT_INT && bit_size != 32)))
4316+ error("initializer element is not computable at load time");
4317+ switch(bt) {
4318+ case VT_BOOL:
4319+ vtop->c.i = (vtop->c.i != 0);
4320+ case VT_BYTE:
4321+ *(char *)ptr |= (vtop->c.i & bit_mask) << bit_pos;
4322+ break;
4323+ case VT_SHORT:
4324+ *(short *)ptr |= (vtop->c.i & bit_mask) << bit_pos;
4325+ break;
4326+ case VT_DOUBLE:
4327+ *(double *)ptr = vtop->c.d;
4328+ break;
4329+ case VT_LDOUBLE:
4330+ *(long double *)ptr = vtop->c.ld;
4331+ break;
4332+ case VT_LLONG:
4333+ *(long long *)ptr |= (vtop->c.ll & bit_mask) << bit_pos;
4334+ break;
4335+ default:
4336+ if (vtop->r & VT_SYM) {
4337+ greloc(sec, vtop->sym, c, R_DATA_32);
4338+ }
4339+ *(int *)ptr |= (vtop->c.i & bit_mask) << bit_pos;
4340+ break;
4341+ }
4342+ vtop--;
4343+ } else {
4344+ vset(&dtype, VT_LOCAL|VT_LVAL, c);
4345+ vswap();
4346+ vstore();
4347+ vpop();
4348+ }
4349+}
4350+
4351+/* put zeros for variable based init */
4352+static void init_putz(CType *t, Section *sec, unsigned long c, int size)
4353+{
4354+ if (sec) {
4355+ /* nothing to do because globals are already set to zero */
4356+ } else {
4357+ vpush_global_sym(&func_old_type, TOK_memset);
4358+ vseti(VT_LOCAL, c);
4359+ vpushi(0);
4360+ vpushi(size);
4361+ gfunc_call(3);
4362+ }
4363+}
4364+
4365+/* 't' contains the type and storage info. 'c' is the offset of the
4366+ object in section 'sec'. If 'sec' is NULL, it means stack based
4367+ allocation. 'first' is true if array '{' must be read (multi
4368+ dimension implicit array init handling). 'size_only' is true if
4369+ size only evaluation is wanted (only for arrays). */
4370+static void decl_initializer(CType *type, Section *sec, unsigned long c,
4371+ int first, int size_only)
4372+{
4373+ int index, array_length, n, no_oblock, nb, parlevel, i;
4374+ int size1, align1, expr_type;
4375+ Sym *s, *f;
4376+ CType *t1;
4377+
4378+ if (type->t & VT_ARRAY) {
4379+ s = type->ref;
4380+ n = s->c;
4381+ array_length = 0;
4382+ t1 = pointed_type(type);
4383+ size1 = type_size(t1, &align1);
4384+
4385+ no_oblock = 1;
4386+ if ((first && tok != TOK_LSTR && tok != TOK_STR) ||
4387+ tok == '{') {
4388+ skip('{');
4389+ no_oblock = 0;
4390+ }
4391+
4392+ /* only parse strings here if correct type (otherwise: handle
4393+ them as ((w)char *) expressions */
4394+ if ((tok == TOK_LSTR &&
4395+#ifdef TCC_TARGET_PE
4396+ (t1->t & VT_BTYPE) == VT_SHORT && (t1->t & VT_UNSIGNED)
4397+#else
4398+ (t1->t & VT_BTYPE) == VT_INT
4399+#endif
4400+ ) || (tok == TOK_STR && (t1->t & VT_BTYPE) == VT_BYTE)) {
4401+ while (tok == TOK_STR || tok == TOK_LSTR) {
4402+ int cstr_len, ch;
4403+ CString *cstr;
4404+
4405+ cstr = tokc.cstr;
4406+ /* compute maximum number of chars wanted */
4407+ if (tok == TOK_STR)
4408+ cstr_len = cstr->size;
4409+ else
4410+ cstr_len = cstr->size / sizeof(nwchar_t);
4411+ cstr_len--;
4412+ nb = cstr_len;
4413+ if (n >= 0 && nb > (n - array_length))
4414+ nb = n - array_length;
4415+ if (!size_only) {
4416+ if (cstr_len > nb)
4417+ warning("initializer-string for array is too long");
4418+ /* in order to go faster for common case (char
4419+ string in global variable, we handle it
4420+ specifically */
4421+ if (sec && tok == TOK_STR && size1 == 1) {
4422+ memcpy(sec->data + c + array_length, cstr->data, nb);
4423+ } else {
4424+ for(i=0;i<nb;i++) {
4425+ if (tok == TOK_STR)
4426+ ch = ((unsigned char *)cstr->data)[i];
4427+ else
4428+ ch = ((nwchar_t *)cstr->data)[i];
4429+ init_putv(t1, sec, c + (array_length + i) * size1,
4430+ ch, EXPR_VAL);
4431+ }
4432+ }
4433+ }
4434+ array_length += nb;
4435+ next();
4436+ }
4437+ /* only add trailing zero if enough storage (no
4438+ warning in this case since it is standard) */
4439+ if (n < 0 || array_length < n) {
4440+ if (!size_only) {
4441+ init_putv(t1, sec, c + (array_length * size1), 0, EXPR_VAL);
4442+ }
4443+ array_length++;
4444+ }
4445+ } else {
4446+ index = 0;
4447+ while (tok != '}') {
4448+ decl_designator(type, sec, c, &index, NULL, size_only);
4449+ if (n >= 0 && index >= n)
4450+ error("index too large");
4451+ /* must put zero in holes (note that doing it that way
4452+ ensures that it even works with designators) */
4453+ if (!size_only && array_length < index) {
4454+ init_putz(t1, sec, c + array_length * size1,
4455+ (index - array_length) * size1);
4456+ }
4457+ index++;
4458+ if (index > array_length)
4459+ array_length = index;
4460+ /* special test for multi dimensional arrays (may not
4461+ be strictly correct if designators are used at the
4462+ same time) */
4463+ if (index >= n && no_oblock)
4464+ break;
4465+ if (tok == '}')
4466+ break;
4467+ skip(',');
4468+ }
4469+ }
4470+ if (!no_oblock)
4471+ skip('}');
4472+ /* put zeros at the end */
4473+ if (!size_only && n >= 0 && array_length < n) {
4474+ init_putz(t1, sec, c + array_length * size1,
4475+ (n - array_length) * size1);
4476+ }
4477+ /* patch type size if needed */
4478+ if (n < 0)
4479+ s->c = array_length;
4480+ } else if ((type->t & VT_BTYPE) == VT_STRUCT &&
4481+ (sec || !first || tok == '{')) {
4482+ int par_count;
4483+
4484+ /* NOTE: the previous test is a specific case for automatic
4485+ struct/union init */
4486+ /* XXX: union needs only one init */
4487+
4488+ /* XXX: this test is incorrect for local initializers
4489+ beginning with ( without {. It would be much more difficult
4490+ to do it correctly (ideally, the expression parser should
4491+ be used in all cases) */
4492+ par_count = 0;
4493+ if (tok == '(') {
4494+ AttributeDef ad1;
4495+ CType type1;
4496+ next();
4497+ while (tok == '(') {
4498+ par_count++;
4499+ next();
4500+ }
4501+ if (!parse_btype(&type1, &ad1))
4502+ expect("cast");
4503+ type_decl(&type1, &ad1, &n, TYPE_ABSTRACT);
4504+#if 0
4505+ if (!is_assignable_types(type, &type1))
4506+ error("invalid type for cast");
4507+#endif
4508+ skip(')');
4509+ }
4510+ no_oblock = 1;
4511+ if (first || tok == '{') {
4512+ skip('{');
4513+ no_oblock = 0;
4514+ }
4515+ s = type->ref;
4516+ f = s->next;
4517+ array_length = 0;
4518+ index = 0;
4519+ n = s->c;
4520+ while (tok != '}') {
4521+ decl_designator(type, sec, c, NULL, &f, size_only);
4522+ index = f->c;
4523+ if (!size_only && array_length < index) {
4524+ init_putz(type, sec, c + array_length,
4525+ index - array_length);
4526+ }
4527+ index = index + type_size(&f->type, &align1);
4528+ if (index > array_length)
4529+ array_length = index;
4530+ f = f->next;
4531+ if (no_oblock && f == NULL)
4532+ break;
4533+ if (tok == '}')
4534+ break;
4535+ skip(',');
4536+ }
4537+ /* put zeros at the end */
4538+ if (!size_only && array_length < n) {
4539+ init_putz(type, sec, c + array_length,
4540+ n - array_length);
4541+ }
4542+ if (!no_oblock)
4543+ skip('}');
4544+ while (par_count) {
4545+ skip(')');
4546+ par_count--;
4547+ }
4548+ } else if (tok == '{') {
4549+ next();
4550+ decl_initializer(type, sec, c, first, size_only);
4551+ skip('}');
4552+ } else if (size_only) {
4553+ /* just skip expression */
4554+ parlevel = 0;
4555+ while ((parlevel > 0 || (tok != '}' && tok != ',')) &&
4556+ tok != -1) {
4557+ if (tok == '(')
4558+ parlevel++;
4559+ else if (tok == ')')
4560+ parlevel--;
4561+ next();
4562+ }
4563+ } else {
4564+ /* currently, we always use constant expression for globals
4565+ (may change for scripting case) */
4566+ expr_type = EXPR_CONST;
4567+ if (!sec)
4568+ expr_type = EXPR_ANY;
4569+ init_putv(type, sec, c, 0, expr_type);
4570+ }
4571+}
4572+
4573+/* parse an initializer for type 't' if 'has_init' is non zero, and
4574+ allocate space in local or global data space ('r' is either
4575+ VT_LOCAL or VT_CONST). If 'v' is non zero, then an associated
4576+ variable 'v' of scope 'scope' is declared before initializers are
4577+ parsed. If 'v' is zero, then a reference to the new object is put
4578+ in the value stack. If 'has_init' is 2, a special parsing is done
4579+ to handle string constants. */
4580+static void decl_initializer_alloc(CType *type, AttributeDef *ad, int r,
4581+ int has_init, int v, int scope)
4582+{
4583+ int size, align, addr, data_offset;
4584+ int level;
4585+ ParseState saved_parse_state = {0};
4586+ TokenString init_str;
4587+ Section *sec;
4588+
4589+ size = type_size(type, &align);
4590+ /* If unknown size, we must evaluate it before
4591+ evaluating initializers because
4592+ initializers can generate global data too
4593+ (e.g. string pointers or ISOC99 compound
4594+ literals). It also simplifies local
4595+ initializers handling */
4596+ tok_str_new(&init_str);
4597+ if (size < 0) {
4598+ if (!has_init)
4599+ error("unknown type size");
4600+ /* get all init string */
4601+ if (has_init == 2) {
4602+ /* only get strings */
4603+ while (tok == TOK_STR || tok == TOK_LSTR) {
4604+ tok_str_add_tok(&init_str);
4605+ next();
4606+ }
4607+ } else {
4608+ level = 0;
4609+ while (level > 0 || (tok != ',' && tok != ';')) {
4610+ if (tok < 0)
4611+ error("unexpected end of file in initializer");
4612+ tok_str_add_tok(&init_str);
4613+ if (tok == '{')
4614+ level++;
4615+ else if (tok == '}') {
4616+ level--;
4617+ if (level <= 0) {
4618+ next();
4619+ break;
4620+ }
4621+ }
4622+ next();
4623+ }
4624+ }
4625+ tok_str_add(&init_str, -1);
4626+ tok_str_add(&init_str, 0);
4627+
4628+ /* compute size */
4629+ save_parse_state(&saved_parse_state);
4630+
4631+ macro_ptr = init_str.str;
4632+ next();
4633+ decl_initializer(type, NULL, 0, 1, 1);
4634+ /* prepare second initializer parsing */
4635+ macro_ptr = init_str.str;
4636+ next();
4637+
4638+ /* if still unknown size, error */
4639+ size = type_size(type, &align);
4640+ if (size < 0)
4641+ error("unknown type size");
4642+ }
4643+ /* take into account specified alignment if bigger */
4644+ if (ad->aligned) {
4645+ if (ad->aligned > align)
4646+ align = ad->aligned;
4647+ } else if (ad->packed) {
4648+ align = 1;
4649+ }
4650+ if ((r & VT_VALMASK) == VT_LOCAL) {
4651+ sec = NULL;
4652+ if (do_bounds_check && (type->t & VT_ARRAY))
4653+ loc--;
4654+ loc = (loc - size) & -align;
4655+ addr = loc;
4656+ /* handles bounds */
4657+ /* XXX: currently, since we do only one pass, we cannot track
4658+ '&' operators, so we add only arrays */
4659+ if (do_bounds_check && (type->t & VT_ARRAY)) {
4660+ unsigned long *bounds_ptr;
4661+ /* add padding between regions */
4662+ loc--;
4663+ /* then add local bound info */
4664+ bounds_ptr = section_ptr_add(lbounds_section, 2 * sizeof(unsigned long));
4665+ bounds_ptr[0] = addr;
4666+ bounds_ptr[1] = size;
4667+ }
4668+ if (v) {
4669+ /* local variable */
4670+ sym_push(v, type, r, addr);
4671+ } else {
4672+ /* push local reference */
4673+ vset(type, r, addr);
4674+ }
4675+ } else {
4676+ Sym *sym;
4677+
4678+ sym = NULL;
4679+ if (v && scope == VT_CONST) {
4680+ /* see if the symbol was already defined */
4681+ sym = sym_find(v);
4682+ if (sym) {
4683+ if (!is_compatible_types(&sym->type, type))
4684+ error("incompatible types for redefinition of '%s'",
4685+ get_tok_str(v, NULL));
4686+ if (sym->type.t & VT_EXTERN) {
4687+ /* if the variable is extern, it was not allocated */
4688+ sym->type.t &= ~VT_EXTERN;
4689+ /* set array size if it was ommited in extern
4690+ declaration */
4691+ if ((sym->type.t & VT_ARRAY) &&
4692+ sym->type.ref->c < 0 &&
4693+ type->ref->c >= 0)
4694+ sym->type.ref->c = type->ref->c;
4695+ } else {
4696+ /* we accept several definitions of the same
4697+ global variable. this is tricky, because we
4698+ must play with the SHN_COMMON type of the symbol */
4699+ /* XXX: should check if the variable was already
4700+ initialized. It is incorrect to initialized it
4701+ twice */
4702+ /* no init data, we won't add more to the symbol */
4703+ if (!has_init)
4704+ goto no_alloc;
4705+ }
4706+ }
4707+ }
4708+
4709+ /* allocate symbol in corresponding section */
4710+ sec = ad->section;
4711+ if (!sec) {
4712+ if (has_init)
4713+ sec = data_section;
4714+ else if (tcc_state->nocommon)
4715+ sec = bss_section;
4716+ }
4717+ if (sec) {
4718+ data_offset = sec->data_offset;
4719+ data_offset = (data_offset + align - 1) & -align;
4720+ addr = data_offset;
4721+ /* very important to increment global pointer at this time
4722+ because initializers themselves can create new initializers */
4723+ data_offset += size;
4724+ /* add padding if bound check */
4725+ if (do_bounds_check)
4726+ data_offset++;
4727+ sec->data_offset = data_offset;
4728+ /* allocate section space to put the data */
4729+ if (sec->sh_type != SHT_NOBITS &&
4730+ data_offset > sec->data_allocated)
4731+ section_realloc(sec, data_offset);
4732+ /* align section if needed */
4733+ if (align > sec->sh_addralign)
4734+ sec->sh_addralign = align;
4735+ } else {
4736+ addr = 0; /* avoid warning */
4737+ }
4738+
4739+ if (v) {
4740+ if (scope != VT_CONST || !sym) {
4741+ sym = sym_push(v, type, r | VT_SYM, 0);
4742+ }
4743+ /* update symbol definition */
4744+ if (sec) {
4745+ put_extern_sym(sym, sec, addr, size);
4746+ } else {
4747+ ElfW(Sym) *esym;
4748+ /* put a common area */
4749+ put_extern_sym(sym, NULL, align, size);
4750+ /* XXX: find a nicer way */
4751+ esym = &((ElfW(Sym) *)symtab_section->data)[sym->c];
4752+ esym->st_shndx = SHN_COMMON;
4753+ }
4754+ } else {
4755+ CValue cval;
4756+
4757+ /* push global reference */
4758+ sym = get_sym_ref(type, sec, addr, size);
4759+ cval.ul = 0;
4760+ vsetc(type, VT_CONST | VT_SYM, &cval);
4761+ vtop->sym = sym;
4762+ }
4763+
4764+ /* handles bounds now because the symbol must be defined
4765+ before for the relocation */
4766+ if (do_bounds_check) {
4767+ unsigned long *bounds_ptr;
4768+
4769+ greloc(bounds_section, sym, bounds_section->data_offset, R_DATA_32);
4770+ /* then add global bound info */
4771+ bounds_ptr = section_ptr_add(bounds_section, 2 * sizeof(long));
4772+ bounds_ptr[0] = 0; /* relocated */
4773+ bounds_ptr[1] = size;
4774+ }
4775+ }
4776+ if (has_init) {
4777+ decl_initializer(type, sec, addr, 1, 0);
4778+ /* restore parse state if needed */
4779+ if (init_str.str) {
4780+ tok_str_free(init_str.str);
4781+ restore_parse_state(&saved_parse_state);
4782+ }
4783+ }
4784+ no_alloc: ;
4785+}
4786+
4787+void put_func_debug(Sym *sym)
4788+{
4789+ char buf[512];
4790+
4791+ /* stabs info */
4792+ /* XXX: we put here a dummy type */
4793+ snprintf(buf, sizeof(buf), "%s:%c1",
4794+ funcname, sym->type.t & VT_STATIC ? 'f' : 'F');
4795+ put_stabs_r(buf, N_FUN, 0, file->line_num, 0,
4796+ cur_text_section, sym->c);
4797+ /* //gr gdb wants a line at the function */
4798+ put_stabn(N_SLINE, 0, file->line_num, 0);
4799+ last_ind = 0;
4800+ last_line_num = 0;
4801+}
4802+
4803+/* parse an old style function declaration list */
4804+/* XXX: check multiple parameter */
4805+static void func_decl_list(Sym *func_sym)
4806+{
4807+ AttributeDef ad;
4808+ int v;
4809+ Sym *s;
4810+ CType btype, type;
4811+
4812+ /* parse each declaration */
4813+ while (tok != '{' && tok != ';' && tok != ',' && tok != TOK_EOF) {
4814+ if (!parse_btype(&btype, &ad))
4815+ expect("declaration list");
4816+ if (((btype.t & VT_BTYPE) == VT_ENUM ||
4817+ (btype.t & VT_BTYPE) == VT_STRUCT) &&
4818+ tok == ';') {
4819+ /* we accept no variable after */
4820+ } else {
4821+ for(;;) {
4822+ type = btype;
4823+ type_decl(&type, &ad, &v, TYPE_DIRECT);
4824+ /* find parameter in function parameter list */
4825+ s = func_sym->next;
4826+ while (s != NULL) {
4827+ if ((s->v & ~SYM_FIELD) == v)
4828+ goto found;
4829+ s = s->next;
4830+ }
4831+ error("declaration for parameter '%s' but no such parameter",
4832+ get_tok_str(v, NULL));
4833+ found:
4834+ /* check that no storage specifier except 'register' was given */
4835+ if (type.t & VT_STORAGE)
4836+ error("storage class specified for '%s'", get_tok_str(v, NULL));
4837+ convert_parameter_type(&type);
4838+ /* we can add the type (NOTE: it could be local to the function) */
4839+ s->type = type;
4840+ /* accept other parameters */
4841+ if (tok == ',')
4842+ next();
4843+ else
4844+ break;
4845+ }
4846+ }
4847+ skip(';');
4848+ }
4849+}
4850+
4851+/* parse a function defined by symbol 'sym' and generate its code in
4852+ 'cur_text_section' */
4853+static void gen_function(Sym *sym)
4854+{
4855+ int saved_nocode_wanted = nocode_wanted;
4856+ nocode_wanted = 0;
4857+ ind = cur_text_section->data_offset;
4858+ /* NOTE: we patch the symbol size later */
4859+ put_extern_sym(sym, cur_text_section, ind, 0);
4860+ funcname = get_tok_str(sym->v, NULL);
4861+ func_ind = ind;
4862+ /* put debug symbol */
4863+ if (do_debug)
4864+ put_func_debug(sym);
4865+ /* push a dummy symbol to enable local sym storage */
4866+ sym_push2(&local_stack, SYM_FIELD, 0, 0);
4867+ gfunc_prolog(&sym->type);
4868+ rsym = 0;
4869+ block(NULL, NULL, NULL, NULL, 0, 0);
4870+ gsym(rsym);
4871+ gfunc_epilog();
4872+ cur_text_section->data_offset = ind;
4873+ label_pop(&global_label_stack, NULL);
4874+ sym_pop(&local_stack, NULL); /* reset local stack */
4875+ /* end of function */
4876+ /* patch symbol size */
4877+ ((ElfW(Sym) *)symtab_section->data)[sym->c].st_size =
4878+ ind - func_ind;
4879+ if (do_debug) {
4880+ put_stabn(N_FUN, 0, 0, ind - func_ind);
4881+ }
4882+ /* It's better to crash than to generate wrong code */
4883+ cur_text_section = NULL;
4884+ funcname = ""; /* for safety */
4885+ func_vt.t = VT_VOID; /* for safety */
4886+ ind = 0; /* for safety */
4887+ nocode_wanted = saved_nocode_wanted;
4888+}
4889+
4890+static void gen_inline_functions(void)
4891+{
4892+ Sym *sym;
4893+ CType *type;
4894+ int *str, inline_generated;
4895+
4896+ /* iterate while inline function are referenced */
4897+ for(;;) {
4898+ inline_generated = 0;
4899+ for(sym = global_stack; sym != NULL; sym = sym->prev) {
4900+ type = &sym->type;
4901+ if (((type->t & VT_BTYPE) == VT_FUNC) &&
4902+ (type->t & (VT_STATIC | VT_INLINE)) ==
4903+ (VT_STATIC | VT_INLINE) &&
4904+ sym->c != 0) {
4905+ /* the function was used: generate its code and
4906+ convert it to a normal function */
4907+ str = INLINE_DEF(sym->r);
4908+ sym->r = VT_SYM | VT_CONST;
4909+ sym->type.t &= ~VT_INLINE;
4910+
4911+ macro_ptr = str;
4912+ next();
4913+ cur_text_section = text_section;
4914+ gen_function(sym);
4915+ macro_ptr = NULL; /* fail safe */
4916+
4917+ tok_str_free(str);
4918+ inline_generated = 1;
4919+ }
4920+ }
4921+ if (!inline_generated)
4922+ break;
4923+ }
4924+
4925+ /* free all remaining inline function tokens */
4926+ for(sym = global_stack; sym != NULL; sym = sym->prev) {
4927+ type = &sym->type;
4928+ if (((type->t & VT_BTYPE) == VT_FUNC) &&
4929+ (type->t & (VT_STATIC | VT_INLINE)) ==
4930+ (VT_STATIC | VT_INLINE)) {
4931+ //gr printf("sym %d %s\n", sym->r, get_tok_str(sym->v, NULL));
4932+ if (sym->r == (VT_SYM | VT_CONST)) //gr beware!
4933+ continue;
4934+ str = INLINE_DEF(sym->r);
4935+ tok_str_free(str);
4936+ sym->r = 0; /* fail safe */
4937+ }
4938+ }
4939+}
4940+
4941+/* 'l' is VT_LOCAL or VT_CONST to define default storage type */
4942+static void decl(int l)
4943+{
4944+ int v, has_init, r;
4945+ CType type, btype;
4946+ Sym *sym;
4947+ AttributeDef ad;
4948+
4949+ while (1) {
4950+ if (!parse_btype(&btype, &ad)) {
4951+ /* skip redundant ';' */
4952+ /* XXX: find more elegant solution */
4953+ if (tok == ';') {
4954+ next();
4955+ continue;
4956+ }
4957+ if (l == VT_CONST &&
4958+ (tok == TOK_ASM1 || tok == TOK_ASM2 || tok == TOK_ASM3)) {
4959+ /* global asm block */
4960+ asm_global_instr();
4961+ continue;
4962+ }
4963+ /* special test for old K&R protos without explicit int
4964+ type. Only accepted when defining global data */
4965+ if (l == VT_LOCAL || tok < TOK_DEFINE)
4966+ break;
4967+ btype.t = VT_INT;
4968+ }
4969+ if (((btype.t & VT_BTYPE) == VT_ENUM ||
4970+ (btype.t & VT_BTYPE) == VT_STRUCT) &&
4971+ tok == ';') {
4972+ /* we accept no variable after */
4973+ next();
4974+ continue;
4975+ }
4976+ while (1) { /* iterate thru each declaration */
4977+ type = btype;
4978+ type_decl(&type, &ad, &v, TYPE_DIRECT);
4979+#if 0
4980+ {
4981+ char buf[500];
4982+ type_to_str(buf, sizeof(buf), t, get_tok_str(v, NULL));
4983+ printf("type = '%s'\n", buf);
4984+ }
4985+#endif
4986+ if ((type.t & VT_BTYPE) == VT_FUNC) {
4987+ /* if old style function prototype, we accept a
4988+ declaration list */
4989+ sym = type.ref;
4990+ if (sym->c == FUNC_OLD)
4991+ func_decl_list(sym);
4992+ }
4993+
4994+ if (tok == '{') {
4995+ if (l == VT_LOCAL)
4996+ error("cannot use local functions");
4997+ if ((type.t & VT_BTYPE) != VT_FUNC)
4998+ expect("function definition");
4999+
5000+ /* reject abstract declarators in function definition */
5001+ sym = type.ref;
5002+ while ((sym = sym->next) != NULL)
5003+ if (!(sym->v & ~SYM_FIELD))
5004+ expect("identifier");
5005+
5006+ /* XXX: cannot do better now: convert extern line to static inline */
5007+ if ((type.t & (VT_EXTERN | VT_INLINE)) == (VT_EXTERN | VT_INLINE))
5008+ type.t = (type.t & ~VT_EXTERN) | VT_STATIC;
5009+
5010+ sym = sym_find(v);
5011+ if (sym) {
5012+ if ((sym->type.t & VT_BTYPE) != VT_FUNC)
5013+ goto func_error1;
5014+ /* specific case: if not func_call defined, we put
5015+ the one of the prototype */
5016+ /* XXX: should have default value */

106 more lines aren’t shown here.

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t