Mercurial > hg > CbC > old > device

comparison mc-code-spu.c @ 680:f536897fa3cb

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
*** empty log message ***
author kono
date Sun, 29 Jul 2007 23:09:38 +0900
parents 7c42cf329666
children e5a498eab0f4
comparison
equal deleted inserted replaced
679:c62ba4e606ce 680:f536897fa3cb
89 89
90 90
91 91
92 static void dconst(int l,int h,double value); 92 static void dconst(int l,int h,double value);
93 static void code_assign_input_double_long(int e1,int e2) ; 93 static void code_assign_input_double_long(int e1,int e2) ;
94 static void code_assign_input_double_reg(int e1,int e2) ;
94 static void code_assign_input_float_int(int e1,int e2) ; 95 static void code_assign_input_float_int(int e1,int e2) ;
95 #endif 96 #endif
96 static void use_input_reg(int reg,int mode); 97 static void use_input_reg(int reg,int mode);
97 static void ascii(char *s); 98 static void ascii(char *s);
98 99
481 482
482 static void 483 static void
483 lvar(int l,char *cext) 484 lvar(int l,char *cext)
484 { 485 {
485 if (large_lvar) { 486 if (large_lvar) {
486 printf("[%s, 0]%s\n",register_name(large_lvar),cext); 487 //printf("[%s, 0]%s\n##lvar0\n",register_name(large_lvar),cext);
488 printf("0(%s)\n##lvar0\n",register_name(large_lvar));
487 free_register(large_lvar); 489 free_register(large_lvar);
488 return; 490 return;
489 } 491 }
490 if (is_code(fnptr)) { 492 if (is_code(fnptr)) {
491 if (l>=ARG_LVAR_OFFSET) { /* caller's arguments */ 493 if (l>=ARG_LVAR_OFFSET) { /* caller's arguments */
492 printf("[sp, %d]%s\n",CODE_CALLER_ARG(l-ARG_LVAR_OFFSET),cext); 494 //printf("[sp, %d]%s\n##lvar1\n",CODE_CALLER_ARG(l-ARG_LVAR_OFFSET),cext);
493 } else 495 printf("%d($sp)\n##lvar1\n",CODE_CALLER_ARG(l-ARG_LVAR_OFFSET));
494 printf("[fp, %d]%s\n",CODE_LVAR(l),cext); 496 //} else
495 } else if (l<0) { /* local variable */ 497 // printf("[fp, %d]%s\n",CODE_LVAR(l),cext);
496 //printf("[fp, #%d+.L%d]%s\n",FUNC_LVAR(l),lvar_offset_label,cext); 498 printf("%d($sp)\n",CODE_LVAR(l));
499 }
500 } else if (l<0) { /* local variable */
501 //printf("[fp, #%d+.L%d]%s\n##lvar2\n",FUNC_LVAR(l),lvar_offset_label,cext);
497 printf(".LC%d+%d($sp)\n",lvar_offset_label,FUNC_LVAR(l)); 502 printf(".LC%d+%d($sp)\n",lvar_offset_label,FUNC_LVAR(l));
498 } else if (l>=ARG_LVAR_OFFSET) { /* caller's arguments */ 503 } else if (l>=ARG_LVAR_OFFSET) { /* caller's arguments */
499 printf("[sp, %d]%s\n",CALLER_ARG(l-ARG_LVAR_OFFSET),cext); 504 printf("%d($sp)%s\n",CALLER_ARG(l-ARG_LVAR_OFFSET),cext);
500 } else { /* callee's arguments */ 505 } else { /* callee's arguments */
501 printf("[fp, %d]%s\n",CALLEE_ARG(l),cext); 506 printf("%d($sp)%s\n",CALLEE_ARG(l),cext);
502 } 507 }
503 } 508 }
504 509
505 static void 510 static void
506 lvar_address(int l,int creg) 511 lvar_address(int l,int creg)
507 { 512 {
516 code_add(creg,CODE_LVAR(l),REG_fp); 521 code_add(creg,CODE_LVAR(l),REG_fp);
517 } else if (l<0) { /* local variable */ 522 } else if (l<0) { /* local variable */
518 // printf("\tsfi\t%s, fp, %d\n",register_name(creg), FUNC_LVAR(l)); 523 // printf("\tsfi\t%s, fp, %d\n",register_name(creg), FUNC_LVAR(l));
519 trn = register_name(tmp = get_register()); 524 trn = register_name(tmp = get_register());
520 //disp = search_const(LVAR,glist2(lvar_offset_label,FUNC_LVAR(l)),&label); 525 //disp = search_const(LVAR,glist2(lvar_offset_label,FUNC_LVAR(l)),&label);
521 printf("\tlqd\t%s, %d($sp)\n",trn,(disp*4)); 526 //printf("\tlqdhoge\t%s, %d($sp)\n",trn,(disp*4));
522 printf("\tadd\t%s, fp, %s\n",register_name(creg),trn); 527 printf("\tlqd\t%s, 64($sp)\n",trn);
528 printf("\ta\t%s, $sp, %s\n",register_name(creg),trn);
523 } else if (l>=ARG_LVAR_OFFSET) { /* caller's arguments */ 529 } else if (l>=ARG_LVAR_OFFSET) { /* caller's arguments */
524 code_add(creg,CALLER_ARG(l-ARG_LVAR_OFFSET),REG_sp); 530 code_add(creg,CALLER_ARG(l-ARG_LVAR_OFFSET),REG_sp);
525 } else { /* callee's arguments */ 531 } else { /* callee's arguments */
526 code_add(creg,CALLEE_ARG(l),REG_fp); 532 code_add(creg,CALLEE_ARG(l),REG_fp);
527 } 533 }
1244 { 1250 {
1245 //int label,disp; 1251 //int label,disp;
1246 int disp; 1252 int disp;
1247 char *rrn = register_name(r); 1253 char *rrn = register_name(r);
1248 //disp = search_const(GVAR,(int)nptr,&label); 1254 //disp = search_const(GVAR,(int)nptr,&label);
1249 printf("\tlqd\t%s, %d($sp)\n",rrn,(disp*4)); 1255 printf("\tlqd\t%s, %d($sp)\n",rrn,(nptr->sc)*16);
1250 } 1256 }
1251 1257
1252 #define mask8(d,bit) (d & (255 << bit)) 1258 #define mask8(d,bit) (d & (255 << bit))
1253 1259
1254 /* 1260 /*
1360 1366
1361 use_int(reg); 1367 use_int(reg);
1362 crn = register_name(reg); 1368 crn = register_name(reg);
1363 if ((s=make_const(e2,&p1,&p2,&p3,CONST))) { 1369 if ((s=make_const(e2,&p1,&p2,&p3,CONST))) {
1364 add = s>0?"a":"sf"; 1370 add = s>0?"a":"sf";
1365 mov = s>0?"il":"mvn"; 1371 mov = s>0?"il":"ori";
1366 printf("\t%s\t%s, %d\n",mov,crn,p1); 1372 printf("\t%s\t%s, %s, %d\n",mov,crn,crn,p1);
1367 if (p2) printf("\t%s\t%s, %s, %d\n",add,crn,crn,p2); 1373 if (p2) printf("\t%s\t%s, %s, %d\n",add,crn,crn,p2);
1368 if (p3) printf("\t%s\t%s, %s, %d\n",add,crn,crn,p3); 1374 if (p3) printf("\t%s\t%s, %s, %d\n",add,crn,crn,p3);
1369 } else { 1375 } else {
1370 //disp = search_const(CONST,e2,&label); 1376 //disp = search_const(CONST,e2,&label);
1371 printf("\tlqd\t%s, %d($sp)\n",crn,(disp*4)); 1377 printf("\tlqd\t%s, %d($sp)\n",crn,(disp*4));
1395 ***********************************************************/ 1401 ***********************************************************/
1396 use_int(reg); 1402 use_int(reg);
1397 crn = register_name(reg); 1403 crn = register_name(reg);
1398 if (-32768<e2&&e2<32768) 1404 if (-32768<e2&&e2<32768)
1399 printf("\til %s,%d\n",crn,e2); 1405 printf("\til %s,%d\n",crn,e2);
1400 else if(32767<e2&&e2<262143) 1406 else if(32767<e2&&e2<262144)
1401 printf("\tila %s,%d\n",crn,e2); 1407 printf("\tila %s,%d\n",crn,e2);
1402 else if(262143<e2) { 1408 else if(262143<e2) {
1403 printf("\t ilhu %s,%d\n",crn,e2/16^4); 1409 printf("\t ilhu\t%s,%d\n",crn,e2/65536);
1404 printf("\t iohl %s,%d\n",crn,e2%16^4); 1410 printf("\t iohl %s,%d\n",crn,e2%65536);
1405 } else { 1411 } else {
1406 r = (~e2 >> 16) & 0xffff; 1412 r = (~e2 >> 16) & 0xffff;
1407 r += 1; 1413 r += 1;
1408 r = -r; 1414 r = -r;
1409 printf("\tilhu %s,%d\n",crn,r); 1415 printf("\tilhu\t%s,%d\n",crn,r);
1410 if(e2 > -262143) 1416 if((e2&0xffff) > -262143)
1411 printf("\tiohl %s,%d\n",crn, (e2&0xffff)); 1417 printf("\tiohl %s,%d\n",crn, (e2&0xffff));
1412 else 1418 else
1413 printf("\tori %s,%s,%d\n",crn,crn,(e2&0xffff)); 1419 printf("\tori %s,%s,%d\n",crn,crn,(e2&0xffff));
1414 } 1420 }
1415 } 1421 }
1417 static void 1423 static void
1418 code_add(int reg,int offset,int r) 1424 code_add(int reg,int offset,int r)
1419 { 1425 {
1420 char *crn = register_name(reg); 1426 char *crn = register_name(reg);
1421 char *rrn = register_name(r); 1427 char *rrn = register_name(r);
1422 char *drn; 1428 char *rn2 = register_name(r+1);
1429 char *drn;
1423 int dreg; 1430 int dreg;
1424 int s,p1,p2,p3; 1431 int s,p1,p2,p3,h;
1425 char *add; 1432 char *add;
1426 //int label,disp; 1433 //int label,disp;
1427 int disp; 1434 int disp;
1428 if (offset==0) { 1435 if (offset==0) {
1429 if(r!=reg) 1436 if(r!=reg)
1430 printf("\tori\t%s, %s, 0\n",crn,rrn); 1437 printf("\tori\t%s, %s, 0\n",crn,rrn);
1431 } else if ((s=make_const(offset,&p1,&p2,&p3,0))) { 1438 } else if ((s=make_const(offset,&p1,&p2,&p3,0))) {
1432 add = s>0?"a":"sfi"; 1439 add = s>0?"a":"sf";
1433 printf("\t%s\t%s, %s, %d\n",add,crn,rrn,p1); 1440 //printf("\t%s\t%s, %s, %d\n",add,crn,rrn,p1);
1434 if (p2) printf("\t%s\t%s, %s, %d\n",add,crn,crn,p2); 1441 if (-32768<(p1+p2+p3)&&(p1+p2+p3)<32768)
1435 if (p3) printf("\t%s\t%s, %s, %d\n",add,crn,crn,p3); 1442 printf("\til\t%s,%d\n",rn2,(p1+p2+p3));
1443 else if( (p1+p2+p3) > 32767 && (p1+p2+p3) < 262144)
1444 printf("\tila\t%s, %d\n",rn2,p1+p2+p3);
1445 else if( (p1+p2+p3) > 262143) {
1446 printf("\tilhu\t%s, %d\n",rn2,(p1+p2+p3)/65536);
1447 printf("\tiohl\t%s, %d\n",rn2,(p1+p2+p3)%65536);
1448 } else {
1449 h = (~(p1+p2+p3) >> 16) & 0xffff;
1450 h += 1;
1451 h = -h;
1452 printf("\tilhu\t%s,%d\n",crn,h);
1453 if(((p1+p2)&0xffff) > -262143)
1454 printf("\tiohl %s,%d\n",crn, ((p1+p2)&0xffff));
1455 else
1456 printf("\tori %s,%s,%d\n",crn,crn,((p1+p2)&0xffff));
1457
1458 }
1459
1460 printf("\t%s\t%s, %s, %s\n", add, crn, rrn ,rn2);
1461 //if (p2) printf("\t%s\t%s, %s, %s\n",add,crn,rrn,rrn+1);
1462 //if (p3) printf("\t%s\t%s, %s, %d\n",add,crn,crn,p3);
1436 } else { 1463 } else {
1437 //disp = search_const(CONST,offset,&label); 1464 //disp = search_const(CONST,offset,&label);
1438 drn = register_name(dreg = get_register()); 1465 drn = register_name(dreg = get_register());
1439 printf("\tlqd\t%s, %d($sp)\n",drn,(disp*4)); 1466 printf("\tlqd\t%s, %d($sp)\n",drn,(disp*4));
1440 printf("\ta\t%s, %s, %s\n",crn,drn,rrn); 1467 printf("\ta\t%s, %s, %s\n",crn,drn,rrn);
1447 code_ld(char *ld,int reg,int offset,int r,char *cext) 1474 code_ld(char *ld,int reg,int offset,int r,char *cext)
1448 { 1475 {
1449 char *crn = register_name(reg); 1476 char *crn = register_name(reg);
1450 char *rrn = register_name(r); 1477 char *rrn = register_name(r);
1451 if (-1024<offset&&offset<1024) { 1478 if (-1024<offset&&offset<1024) {
1452 printf("\t%s\t%s, [%s, %d]%s\n",ld,crn,rrn,offset,cext); 1479 printf("\t%s\t%s, %d(%s)\n",ld,crn,offset,rrn);
1453 } else { 1480 } else {
1454 code_add(reg,offset,r); 1481 code_add(reg,offset,r);
1455 printf("\t%s\t%s, [%s, 0]%s\n",ld,crn,crn,cext); 1482 printf("\t%s\t%s, 0(%s) %s\n",ld,crn,crn,cext);
1456 } 1483 }
1457 } 1484 }
1458 1485
1459 static void 1486 static void
1460 code_ldf(char *ld,char *crn,int offset,int r,char *cext) 1487 code_ldf(char *ld,char *crn,int offset,int r,char *cext)
1461 { 1488 {
1462 //char *rrn = register_name(r); 1489 char *rrn = register_name(r);
1463 char *orn; 1490 char *orn;
1464 int reg; 1491 int reg;
1465 if (-1024<offset&&offset<1024) { 1492 if (-1024<offset&&offset<1024) {
1466 printf("\t%s\t%s, %d(%s)\n",ld,crn,(offset*4),cext); 1493 printf("\t%s\t%s, %d(%s)\n",ld,crn,(offset*4),rrn);
1467 } else { 1494 } else {
1468 orn = register_name(reg=get_register()); 1495 orn = register_name(reg=get_register());
1469 code_add(reg,offset,r); 1496 code_add(reg,offset,r);
1470 //printf("\t%s\t%s, [%s, 0]%s\n",ld,crn,orn,cext); 1497 //printf("\t%s\t%s, [%s, 0]%s\n",ld,crn,orn,cext);
1471 printf("hoge\n");
1472 free_register(reg); 1498 free_register(reg);
1473 } 1499 }
1474 } 1500 }
1475 1501
1476 1502
1477 #define cload(sz,sign) \ 1503 #define cload(sz,sign) \
1478 (sz==1?(sign?"lqx":"lqa"):sz==SIZE_OF_SHORT?(sign?"lqx":"lqa"):"lqd") 1504 (sz==1?(sign?"lqd":"lqd"):sz==SIZE_OF_SHORT?(sign?"lqd":"lqd"):"lqd")
1479 1505
1480 1506
1481 #define cext(sign,sz,reg) 1507 #define cext(sign,sz,reg)
1482 1508
1483 static char * 1509 static char *
1529 code_rlvar(int e2,int reg) { 1555 code_rlvar(int e2,int reg) {
1530 use_int(reg); 1556 use_int(reg);
1531 lvar_intro(e2); 1557 lvar_intro(e2);
1532 printf("\tlqd\t%s, ",register_name(reg)); 1558 printf("\tlqd\t%s, ",register_name(reg));
1533 e2 *= 4; 1559 e2 *= 4;
1534 lvar(e2,""); 1560 lvar(e2,"");
1535 } 1561 }
1536 1562
1537 extern void 1563 extern void
1538 code_i2c(int reg) 1564 code_i2c(int reg)
1539 { 1565 {
1546 1572
1547 extern void 1573 extern void
1548 code_u2uc(int reg) 1574 code_u2uc(int reg)
1549 { 1575 {
1550 use_int(reg); 1576 use_int(reg);
1551 printf("and\t%s, %s, #255\n",register_name(reg),register_name(reg)); 1577 printf("\tandbi\t%s, %s, 255\n",register_name(reg),register_name(reg));
1552 } 1578 }
1553 1579
1554 extern void 1580 extern void
1555 code_u2us(int reg) 1581 code_u2us(int reg)
1556 { 1582 {
1583 // &! ということらしい、だけど16711680とかは使えない。よってilhuとかで16711680をレジスタに格納して
1584 // and rt,rs,ra でandを行えば良いが、!はどうすんだ？
1557 use_int(reg); 1585 use_int(reg);
1558 printf("bic\t%s, %s, #16711680\n",register_name(reg),register_name(reg)); 1586 //printf("bic\t%s, %s, #16711680\n",register_name(reg),register_name(reg));
1559 printf("bic\t%s, %s, #-16777216\n",register_name(reg),register_name(reg)); 1587 printf("\tilhu\t%s,255\n", register_name(reg+1));
1588 printf("\tand\t%s,%s,%s\n",register_name(reg),register_name(reg),register_name(reg+1));
1589 //printf("bic\t%s, %s, #-16777216\n",register_name(reg),register_name(reg));
1590 printf("\tilhu\t%s,-256\n", register_name(reg+1));
1591 printf("\tand\t%s,%s,%s\n",register_name(reg),register_name(reg),register_name(reg+1));
1560 } 1592 }
1561 1593
1562 void 1594 void
1563 code_crlvar(int e2,int reg,int sign,int sz) { 1595 code_crlvar(int e2,int reg,int sign,int sz) {
1564 use_int(reg); 1596 use_int(reg);
1589 } 1621 }
1590 1622
1591 void 1623 void
1592 code_neg(int creg) { 1624 code_neg(int creg) {
1593 use_int(creg); 1625 use_int(creg);
1594 printf("\trsb\t%s, %s, #0\n", register_name(creg), register_name(creg)); 1626 //printf("\trsb\t%s, %s, #0\n", register_name(creg), register_name(creg));
1627 printf("\tsfi\t%s, %s, 0\n", register_name(creg), register_name(creg));
1595 } 1628 }
1596 1629
1597 1630
1598 void 1631 void
1599 code_not(int creg) { 1632 code_not(int creg) {
1600 use_int(creg); 1633 use_int(creg);
1601 printf("\tmvn\t%s, %s\n", 1634 printf("\tori\t%s, %s, 0\n",
1602 register_name(creg), register_name(creg)); 1635 register_name(creg), register_name(creg));
1603 } 1636 }
1604 1637
1605 1638
1606 void 1639 void
1607 code_lnot(int creg) { 1640 code_lnot(int creg) {
1608 use_int(creg); 1641 use_int(creg);
1609 1642
1610 printf("\tcmp\t%s, #0\n", register_name(creg)); 1643 //printf("\tcmp\t%s, #0\n", register_name(creg));
1611 printf("\tmovne\t%s, #0\n", register_name(creg)); 1644 printf("\tceqbi\t%s,%s,0\n",register_name(creg),register_name(creg));
1612 printf("\tmoveq\t%s, #1\n", register_name(creg)); 1645 //printf("\tmovnehoge\t%s, #0\n", register_name(creg));
1646 //printf("\tmoveq\t%s, #1\n", register_name(creg));
1613 } 1647 }
1614 1648
1615 void 1649 void
1616 code_preinc(int e1,int e2,int dir,int sign,int sz,int reg) { 1650 code_preinc(int e1,int e2,int dir,int sign,int sz,int reg) {
1617 char *xrn,*drn; 1651 char *xrn,*drn;
1687 void 1721 void
1688 code_environment(int creg) { 1722 code_environment(int creg) {
1689 /* save frame pointer */ 1723 /* save frame pointer */
1690 if (is_code(fnptr)) { 1724 if (is_code(fnptr)) {
1691 use_int(creg); 1725 use_int(creg);
1692 printf("\tmov\t%s, fp\n",register_name(creg)); 1726 //printf("\tmov\t%s, fp\n",register_name(creg));
1693 } else { 1727 printf("\tori\t%s, fp, 0\n",register_name(creg));
1728 } else {
1694 //int disp,label; 1729 //int disp,label;
1695 int disp; 1730 int disp;
1696 char *trn = register_name(REG_ip); 1731 char *trn = register_name(REG_ip);
1697 use_int(creg); 1732 use_int(creg);
1698 //disp = search_const(LVAR,glist2(lvar_offset_label,FUNC_LVAR(0)),&label); 1733 //disp = search_const(LVAR,glist2(lvar_offset_label,FUNC_LVAR(0)),&label);
1699 printf("\tlqa\t%s, %d\n",trn,disp); 1734 printf("\tlqa\t%s, %d\n",trn,disp);
1700 printf("\ta\t%s, fp, %s\n",register_name(creg),trn); 1735 printf("\ta\t%s, $sp, %s\n",register_name(creg),trn);
1701 } 1736 }
1702 } 1737 }
1703 1738
1704 static int rexpr_bool(int e1, int reg); 1739 static int rexpr_bool(int e1, int reg);
1705 #if LONGLONG_CODE 1740 #if LONGLONG_CODE
1716 #endif 1751 #endif
1717 b_expr(e1,1,e2=fwdlabel(),1); /* including > < ... */ 1752 b_expr(e1,1,e2=fwdlabel(),1); /* including > < ... */
1718 if (use) { 1753 if (use) {
1719 use_int(reg); 1754 use_int(reg);
1720 xrn = register_name(reg); 1755 xrn = register_name(reg);
1721 printf("\tmov\t%s, #0\n",xrn); 1756 //printf("\tmov\t%s, #0\n",xrn);
1757 printf("\til\t%s, 0\n",xrn);
1722 gen_jmp(e3=fwdlabel()); 1758 gen_jmp(e3=fwdlabel());
1723 fwddef(e2); 1759 fwddef(e2);
1724 printf("\tmov\t%s, #1\n",xrn); 1760 //printf("\tmov\t%s, #1\n",xrn);
1761 printf("\til\t%s, 1\n",xrn);
1725 fwddef(e3); 1762 fwddef(e3);
1726 } else { 1763 } else {
1727 fwddef(e2); 1764 fwddef(e2);
1728 } 1765 }
1729 } 1766 }
1733 code_cmp_crgvar(int e1,int reg,int sz,int label,int cond) { 1770 code_cmp_crgvar(int e1,int reg,int sz,int label,int cond) {
1734 use_int(reg); 1771 use_int(reg);
1735 code_ld(cload(sz,0),reg,cadr(e1),get_ptr_cache((NMTBL*)caddr(e1)), 1772 code_ld(cload(sz,0),reg,cadr(e1),get_ptr_cache((NMTBL*)caddr(e1)),
1736 cext_at(sz,0)); 1773 cext_at(sz,0));
1737 cext(0,sz,r); 1774 cext(0,sz,r);
1738 printf("\tcmp\t%s, #0\n",register_name(reg)); 1775 printf("\tceqi\t%s, %s, 0\n",register_name(reg), register_name(reg));
1739 jcond(label,cond); 1776 jcond(label,cond);
1740 } 1777 }
1741 1778
1742 1779
1743 void 1780 void
1744 code_cmp_crlvar(int e2,int reg, int sz,int label,int cond) { 1781 code_cmp_crlvar(int e2,int reg, int sz,int label,int cond) {
1745 char *crn; 1782 char *crn;
1746 use_int(reg); 1783 use_int(reg);
1747 crn = register_name(reg); 1784 crn = register_name(reg);
1748 lvar_intro(e2); 1785 lvar_intro(e2);
1749 printf("\t%s\t%s, ",cload(sz,0),crn); 1786 printf("\t%s\t%s,hoge2 ",cload(sz,0),crn);
1750 lvar(e2,cext_at(sz,0)); 1787 lvar(e2,cext_at(sz,0));
1751 cext(0,sz,reg); 1788 cext(0,sz,reg);
1752 code_cmp_register(reg,label,cond); 1789 code_cmp_register(reg,label,cond);
1753 } 1790 }
1754 1791
1775 1812
1776 1813
1777 void 1814 void
1778 code_cmp_register(int e2,int label,int cond) { 1815 code_cmp_register(int e2,int label,int cond) {
1779 use_int(e2); 1816 use_int(e2);
1780 printf("\tcmp\t%s, #0\n",register_name(e2)); 1817 printf("\tceqi\t%s, %s, 0\n",register_name(e2), register_name(e2));
1781 jcond(label,cond); 1818 jcond(label,cond);
1782 } 1819 }
1783 1820
1784 1821
1785 void 1822 void
1832 case 1: case -1: 1869 case 1: case -1:
1833 printf("\tlqd\t%s, %d(%s)\n",drn,(offset*4),trn); 1870 printf("\tlqd\t%s, %d(%s)\n",drn,(offset*4),trn);
1834 printf("\tstqd\t%s,%d(%s)\n",drn,(offset*4),trn); 1871 printf("\tstqd\t%s,%d(%s)\n",drn,(offset*4),trn);
1835 break; 1872 break;
1836 case 2: case -2: 1873 case 2: case -2:
1837 printf("\tlqx\t%s, [%s,#%d]\n",drn,frn,offset); 1874 printf("\tlqd\t%s, %d(%s)\n",drn,(offset*4),trn);
1838 printf("\tstqx\t%s, [%s,#%d]\n",drn,trn,offset); 1875 printf("\tstqd\t%s,%d(%s)\n",drn,(offset*4),trn);
1839 break; 1876 break;
1840 case 4: case -4: 1877 case 4: case -4:
1841 printf("\tlqa\t%s, [%s,#%d]\n",drn,frn,offset); 1878 printf("\tlqd\t%s, %d(%s)\n",drn,(offset*4),trn);
1842 printf("\tstqa\t%s, [%s,#%d]\n",drn,trn,offset); 1879 printf("\tstqd\t%s,%d(%s)\n",drn,(offset*4),trn);
1843 break; 1880 break;
1844 default: 1881 default:
1845 if (length <0) { 1882 if (length <0) {
1846 if (length > -MAX_COPY_LEN) { 1883 if (length > -MAX_COPY_LEN) {
1847 for(;length<=-4;length+=4,offset-=4) 1884 for(;length<=-4;length+=4,offset-=4)
1865 code_save_stacks(); 1902 code_save_stacks();
1866 parallel_rassign(list3(1,list3(2,0,from),to)); 1903 parallel_rassign(list3(1,list3(2,0,from),to));
1867 code_const(length>0?length:-length,3); 1904 code_const(length>0?length:-length,3);
1868 /* overlap must be allowed */ 1905 /* overlap must be allowed */
1869 // offset have to be ignored */ 1906 // offset have to be ignored */
1870 printf("\thbra\t%s\n",memmove); 1907 //printf("\thbra\t%s\n",memmove);
1871 extern_define(memmove,0,FUNCTION,1); 1908 extern_define(memmove,0,FUNCTION,1);
1872 set_ireg(RET_REGISTER,0); 1909 set_ireg(RET_REGISTER,0);
1873 if (creg!=to) { 1910 if (creg!=to) {
1874 free_register(to); to = creg; 1911 free_register(to); to = creg;
1875 } 1912 }
1916 if (length<MAX_COPY_LEN) { 1953 if (length<MAX_COPY_LEN) {
1917 sreg = get_register(); if (!sreg) error(-1); 1954 sreg = get_register(); if (!sreg) error(-1);
1918 srn = register_name(sreg); 1955 srn = register_name(sreg);
1919 code_lvar(arg_disp,dreg); 1956 code_lvar(arg_disp,dreg);
1920 for(count=0;count<length;count+=SIZE_OF_INT) { 1957 for(count=0;count<length;count+=SIZE_OF_INT) {
1921 printf("\tlqd\t%s, [%s, #%d]\n",srn,crn,count+on_register*SIZE_OF_INT); 1958 printf("\tlqd\t%s, %d(%s)\n",srn,count+on_register*SIZE_OF_INT,crn);
1922 printf("\tstr\t%s, [%s, #%d]\n",srn,drn,count); 1959 printf("\tstqd\t%s, %d(%s)\n",srn,count,drn);
1923 } 1960 }
1924 free_register(sreg); 1961 free_register(sreg);
1925 if (on_register) { 1962 if (on_register) {
1926 if (creg<=MAX_INPUT_REGISTER_VAR) { 1963 if (creg<=MAX_INPUT_REGISTER_VAR) {
1927 code_register(creg,REG_ip); 1964 code_register(creg,REG_ip);
1945 } 1982 }
1946 if (dreg!=-1) free_register(dreg); 1983 if (dreg!=-1) free_register(dreg);
1947 } 1984 }
1948 for (count=0,arg_reg; on_register-->0; arg_reg++,count+=SIZE_OF_INT) { 1985 for (count=0,arg_reg; on_register-->0; arg_reg++,count+=SIZE_OF_INT) {
1949 // len0 = (len0>2)?0:len0; 1986 // len0 = (len0>2)?0:len0;
1950 printf("\t%s\t%s, [%s, #%d]\n", cload(0,0), 1987 printf("\t%s\t%s, %d(%s)\n", cload(0,0),
1951 register_name(arg_reg), crn,count); 1988 register_name(arg_reg), count,crn);
1952 use_input_reg(arg_reg,1); 1989 use_input_reg(arg_reg,1);
1953 } 1990 }
1954 return length/SIZE_OF_INT; 1991 return length/SIZE_OF_INT;
1955 } 1992 }
1956 1993
2240 default: 2277 default:
2241 g_expr(rvalue_t(e2,DOUBLE)); 2278 g_expr(rvalue_t(e2,DOUBLE));
2242 reg = freg; 2279 reg = freg;
2243 case DREGISTER: 2280 case DREGISTER:
2244 if (car(e2)==DREGISTER) reg = cadr(e2); 2281 if (car(e2)==DREGISTER) reg = cadr(e2);
2245 printf("\tstqd\t%s, [sp, #-8]!\n",register_name(reg)); 2282 //printf("\tstqd\t%s, #sp, #-8]!\n",register_name(reg));
2246 printf("\tldmfd\tsp!, {%s, %s}\n",lregister_name_low(r),lregister_name_high(r)); 2283 //printf("\tstqd\t%s, #sp, #-8]!\n",register_name(reg));
2284 //printf("\tldmfd\tsp!, {%s, %s}\n",lregister_name_low(r),lregister_name_high(r));
2285 printf("\tstqd\t%s, -8($sp)\n",register_name(reg));
2286 printf("\tstqd\t%s, -8($sp)\n",register_name(reg));
2287 printf("\tlqx\t$sp,%s, %s\n",lregister_name_low(r),lregister_name_high(r));
2247 } 2288 }
2248 if (tmp!=-1) free_lvar(tmp); 2289 if (tmp!=-1) free_lvar(tmp);
2290 #endif
2291 }
2292
2293 static void
2294 code_assign_input_double_reg(int e1,int e2) {
2295 #if FLOAT_CODE
2296 int r,tmp=-1,reg=0;
2297 double value;
2298 if(car(e1)!=REGISTER) { error(-1); return;}
2299 r = cadr(e1);
2300 switch(car(e2)) {
2301 case DCONST:
2302 value = dcadr(e2);
2303 dconst(r,r,value);
2304 break;
2305 case DRGVAR:
2306 code_lrgvar(e2,r);
2307 break;
2308 case DRLVAR:
2309 code_lrlvar(cadr(e2),r);
2310 break;
2311 default:
2312 g_expr(rvalue_t(e2,DOUBLE));
2313 reg = freg;
2314 }
2315 if(tmp!=-1) free_lvar(tmp);
2249 #endif 2316 #endif
2250 } 2317 }
2251 2318
2252 static int 2319 static int
2253 compute_complex_arg(int e3,int reg_arg_list,int arg) { 2320 compute_complex_arg(int e3,int reg_arg_list,int arg) {
2339 code_call(int e2,NMTBL *fn,int jmp) 2406 code_call(int e2,NMTBL *fn,int jmp)
2340 { 2407 {
2341 if (car(e2) == FNAME) { 2408 if (car(e2) == FNAME) {
2342 printf("\tbrsl\t$lr,%s\n",fn->nm); 2409 printf("\tbrsl\t$lr,%s\n",fn->nm);
2343 } else { 2410 } else {
2344 printf("\tmov\tlr, pc\n"); 2411 //printf("\tmov\tlr, pc\n");
2345 printf("\tmov\tpc, %s\n",register_name(cadr(jmp))); 2412 printf("\tori\t$sp,%s,0\n",register_name(cadr(jmp)));
2413 printf("\tori\t$sp, %s,0\n",register_name(cadr(jmp)));
2346 } 2414 }
2347 } 2415 }
2348 2416
2349 int 2417 int
2350 function(int e1) 2418 function(int e1)
2503 } 2571 }
2504 reg_arg_list = list2(arg,reg_arg_list); 2572 reg_arg_list = list2(arg,reg_arg_list);
2505 g_expr_u(assign_expr0(arg,e4,t,t)); 2573 g_expr_u(assign_expr0(arg,e4,t,t));
2506 } else if (t==DOUBLE) { 2574 } else if (t==DOUBLE) {
2507 reg_arg_list = list2(arg,reg_arg_list); 2575 reg_arg_list = list2(arg,reg_arg_list);
2508 if (car(arg)==LREGISTER) { 2576 if (car(arg)==REGISTER) {
2509 use_input_reg(cadr(arg),1); 2577 use_input_reg(cadr(arg),1);
2510 code_assign_input_double_long(arg, e4); 2578 //code_assign_input_double_long(arg, e4);
2579 code_assign_input_double_reg(arg, e4);
2511 } else { 2580 } else {
2512 g_expr_u(assign_expr0(arg,e4,t,t)); 2581 g_expr_u(assign_expr0(arg,e4,t,t));
2513 } 2582 }
2514 } else if (t==FLOAT) { 2583 } else if (t==FLOAT) {
2515 reg_arg_list = list2(arg,reg_arg_list); 2584 reg_arg_list = list2(arg,reg_arg_list);
2565 char *crn; 2634 char *crn;
2566 2635
2567 g_expr(list3(BAND,list3(ADD,e1,list2(CONST,15)),list2(CONST,~15))); 2636 g_expr(list3(BAND,list3(ADD,e1,list2(CONST,15)),list2(CONST,~15)));
2568 use_int(reg); 2637 use_int(reg);
2569 crn = register_name(reg); 2638 crn = register_name(reg);
2570 printf("\trsb\tsp, %s, sp\n",crn); 2639 //printf("\tsfi\t$sp, %s, $sp\n",crn);
2571 if (!max_func_arg_label) max_func_arg_label = fwdlabel(); 2640 if (!max_func_arg_label) max_func_arg_label = fwdlabel();
2572 code_label_value(max_func_arg_label ,REG_ip); 2641 code_label_value(max_func_arg_label ,REG_ip);
2573 printf("\ta\t%s, sp, ip\n",crn); 2642 printf("\ta\t%s, $sp, $sp\n",crn);
2574 } 2643 }
2575 2644
2576 void 2645 void
2577 code_frame_pointer(int e3) { 2646 code_frame_pointer(int e3) {
2578 use_int(e3); 2647 use_int(e3);
2579 printf("\tmov\tfp, %s\n",register_name(e3)); 2648 //printf("\tmov\tfp, %s\n",register_name(e3));
2649 printf("\tori\t$sp,%s\n",register_name(e3));
2580 } 2650 }
2581 2651
2582 int 2652 int
2583 code_frame_pointer_register() 2653 code_frame_pointer_register()
2584 { 2654 {
2593 int disp; 2663 int disp;
2594 if (is_function(fnptr) && ! env) { 2664 if (is_function(fnptr) && ! env) {
2595 trn = register_name(REG_ip); 2665 trn = register_name(REG_ip);
2596 //disp = search_const(LVAR,glist2(lvar_offset_label,FUNC_LVAR(0)),&label); 2666 //disp = search_const(LVAR,glist2(lvar_offset_label,FUNC_LVAR(0)),&label);
2597 printf("\tlqd\t%s, %d($sp)\n",trn,disp); 2667 printf("\tlqd\t%s, %d($sp)\n",trn,disp);
2598 printf("\ta\tfp, fp, %s\n",trn); 2668 printf("\ta\t$sp, $sp, %s\n",trn);
2599 } 2669 }
2600 } 2670 }
2601 2671
2602 static void 2672 static void
2603 code_unfix_frame_pointer() 2673 code_unfix_frame_pointer()
2616 void 2686 void
2617 code_jmp(char *s) { 2687 code_jmp(char *s) {
2618 // jump to continuation means use all register variable 2688 // jump to continuation means use all register variable
2619 max_reg_var = REG_VAR_MAX-REG_VAR_MIN; 2689 max_reg_var = REG_VAR_MAX-REG_VAR_MIN;
2620 max_reg_var = FREG_VAR_MAX-FREG_VAR_MIN; 2690 max_reg_var = FREG_VAR_MAX-FREG_VAR_MIN;
2621 printf("\thogebr\t%s\n",s); 2691 printf("\tbr\t%s\n",s);
2622 control=0; 2692 control=0;
2623 } 2693 }
2624 2694
2625 void 2695 void
2626 code_indirect_jmp(int e2) { 2696 code_indirect_jmp(int e2) {
2627 // jump to continuation means use all register variable 2697 // jump to continuation means use all register variable
2628 max_reg_var = REG_VAR_MAX-REG_VAR_MIN; 2698 max_reg_var = REG_VAR_MAX-REG_VAR_MIN;
2629 max_reg_var = FREG_VAR_MAX-FREG_VAR_MIN; 2699 max_reg_var = FREG_VAR_MAX-FREG_VAR_MIN;
2630 use_int(e2); 2700 use_int(e2);
2631 printf("\tmov\tpc, %s @ indirect jump\n",register_name(e2)); // ?! 2701 //printf("\tmov\tpc, %s @ indirect jump\n",register_name(e2)); // ?!
2702 printf("\tbi\t%s\n",register_name(e2)); // ?!
2632 control=0; 2703 control=0;
2633 } 2704 }
2634 2705
2635 void 2706 void
2636 code_rindirect(int e1, int reg,int offset, int sign,int sz) 2707 code_rindirect(int e1, int reg,int offset, int sign,int sz)
2651 int xreg; 2722 int xreg;
2652 g_expr(e1); 2723 g_expr(e1);
2653 if (!is_int_reg(creg)) error(-1); 2724 if (!is_int_reg(creg)) error(-1);
2654 xreg = creg; 2725 xreg = creg;
2655 use_float(d,reg); 2726 use_float(d,reg);
2656 code_ldf(d?"ldfd":"ldfs",register_name(reg),offset,xreg,""); 2727 code_ldf(d?"lqd":"lqd",register_name(reg),offset,xreg,"");
2657 return d?DOUBLE:FLOAT; 2728 return d?DOUBLE:FLOAT;
2658 } 2729 }
2659 #endif 2730 #endif
2660 2731
2661 #if LONGLONG_CODE||FLOAT_CODE 2732 #if LONGLONG_CODE||FLOAT_CODE
2664 lload(int creg,int reg,int offset) 2735 lload(int creg,int reg,int offset)
2665 { 2736 {
2666 char *crn=register_name(creg); 2737 char *crn=register_name(creg);
2667 #if ENDIAN_L==0 2738 #if ENDIAN_L==0
2668 if (creg!=reg) { 2739 if (creg!=reg) {
2669 printf("\tldr\t%s, [%s, #%d]\n",lregister_name_low(reg),crn,offset); 2740 printf("\tlqd\t%s, %d(%s)\n",lregister_name_low(reg),offset,crn);
2670 printf("\tldr\t%s, [%s, #%d]\n",lregister_name_high(reg),crn,offset+SIZE_OF_INT); 2741 //printf("\tldr\t%s, [%s, #%d]\n",lregister_name_high(reg),crn,offset+SIZE_OF_INT);
2671 } else { 2742 } else {
2672 printf("\tldr\t%s, [%s, #%d]\n",lregister_name_high(reg),crn,offset+SIZE_OF_INT); 2743 printf("\tlqd\t%s, %d(%s)\n",lregister_name_high(reg),offset+SIZE_OF_INT,crn);
2673 printf("\tldr\t%s, [%s, #%d]\n",lregister_name_low(reg),crn,offset); 2744 //printf("\tldr\t%s, [%s, #%d]\n",lregister_name_low(reg),crn,offset);
2674 } 2745 }
2675 #else 2746 #else
2676 if (creg!=reg) { 2747 if (creg!=reg) {
2677 printf("\tldr\t%s, [%s, #%d]\n",lregister_name_low(reg),crn,offset+SIZE_OF_INT); 2748 printf("\tlqd\t%s, %d(%s)\n",lregister_name_low(reg),offset+SIZE_OF_INT,crn);
2678 printf("\tldr\t%s, [%s, #%d]\n",lregister_name_high(reg),crn,offset); 2749 //printf("\tldr\t%s, [%s, #%d]\n",lregister_name_high(reg),crn,offset);
2679 } else { 2750 } else {
2680 printf("\tldr\t%s, [%s, #%d]\n",lregister_name_high(reg),crn,offset); 2751 printf("\tlqd\t%s, %d(%s)\n",lregister_name_high(reg),offset,crn);
2681 printf("\tldr\t%s, [%s, #%d]\n",lregister_name_low(reg),crn,offset+SIZE_OF_INT); 2752 //printf("\tldr\t%s, [%s, #%d]\n",lregister_name_low(reg),crn,offset+SIZE_OF_INT);
2682 } 2753 }
2683 #endif 2754 #endif
2684 } 2755 }
2685 2756
2686 2757
2712 char *crn_h; 2783 char *crn_h;
2713 char *crn_l; 2784 char *crn_l;
2714 crn_h = lregister_name_high(creg); 2785 crn_h = lregister_name_high(creg);
2715 crn_l = lregister_name_low(creg); 2786 crn_l = lregister_name_low(creg);
2716 #if ENDIAN_L==0 2787 #if ENDIAN_L==0
2717 printf("\tstr\t%s, [%s, #0]\n",crn_l,drn); 2788 printf("\tstqd\t%s, 0(%s)\n",crn_l,drn);
2718 printf("\tstr\t%s, [%s, #%d]\n",crn_h,drn,SIZE_OF_INT); 2789 printf("\tstqd\t%s, %d(%s)\n",crn_h,SIZE_OF_INT,drn);
2719 #else 2790 #else
2720 printf("\tstr\t%s, [%s, #0]\n",crn_h,drn); 2791 printf("\tstqd\t%s, 0(%s)\n",crn_h,drn);
2721 printf("\tstr\t%s, [%s, #%d]\n",crn_l,drn,SIZE_OF_INT); 2792 printf("\tstqd\t%s, %d(%s)\n",crn_l,SIZE_OF_INT,drn);
2722 #endif 2793 #endif
2723 } 2794 }
2724 2795
2725 int 2796 int
2726 code_lrindirect(int e1, int reg, int offset, int us) 2797 code_lrindirect(int e1, int reg, int offset, int us)
2738 2809
2739 static char * 2810 static char *
2740 cstore(int sz) 2811 cstore(int sz)
2741 { 2812 {
2742 switch(sz) { 2813 switch(sz) {
2743 case 1: return "stqx"; 2814 case 1: return "stqd";
2744 case SIZE_OF_SHORT: return "stqa"; 2815 case SIZE_OF_SHORT: return "stqd";
2745 default: return "stqd"; 2816 default: return "stqd";
2746 } 2817 }
2747 } 2818 }
2748 2819
2749 void 2820 void
2923 switch(op) { 2994 switch(op) {
2924 case MUL: case UMUL: 2995 case MUL: case UMUL:
2925 v=ilog(v); 2996 v=ilog(v);
2926 case LSHIFT: 2997 case LSHIFT:
2927 case ULSHIFT: 2998 case ULSHIFT:
2928 printf("\tmov\t%s, %s, asl #%d\n",crn,crn,v); 2999 printf("\troti\t%s, %s,-%d\n",crn,crn,v);
2929 break; 3000 break;
2930 case DIV: 3001 case DIV:
2931 v=ilog(v); 3002 v=ilog(v);
2932 case RSHIFT: 3003 case RSHIFT:
2933 printf("\trotmai\t%s, %s, %d\n",crn,crn,v); 3004 printf("\troti\t%s, %s, -%d\n",crn,crn,v);
2934 break; 3005 break;
2935 case UDIV: 3006 case UDIV:
2936 v=ilog(v); 3007 v=ilog(v);
2937 case URSHIFT: 3008 case URSHIFT:
2938 printf("\tshli\t%s, %s,%d\n",crn,crn,v); 3009 printf("\tshli\t%s, %s,%d\n",crn,crn,v);
2942 break; 3013 break;
2943 case SUB: 3014 case SUB:
2944 code_add(creg,-v,creg); 3015 code_add(creg,-v,creg);
2945 break; 3016 break;
2946 case CMP: printf("\tceq\t%s,%d\n",crn,v); break; 3017 case CMP: printf("\tceq\t%s,%d\n",crn,v); break;
2947 case BOR: printf("\tor\t%s, %s, #%d\n",crn,crn,v); break; 3018 case BOR: printf("\tori\t%s, %s, %d\n",crn,crn,v); break;
2948 case EOR: printf("\txor\t%s, %s, #%d\n",crn,crn,v); break; 3019 case EOR: printf("\txori\t%s, %s, %d\n",crn,crn,v); break;
2949 case BAND: printf("\tand\t%s, %s, #%d\n",crn,crn,v); break; 3020 case BAND: printf("\tandi\t%s, %s, %d\n",crn,crn,v); break;
2950 default: 3021 default:
2951 error(-1); 3022 error(-1);
2952 } 3023 }
2953 } 3024 }
2954 3025
3001 printf("\tceqi\t%s, %s, %d\n",crn,crn,-e); 3072 printf("\tceqi\t%s, %s, %d\n",crn,crn,-e);
3002 } 3073 }
3003 switch(cond) { 3074 switch(cond) {
3004 case -1: break; 3075 case -1: break;
3005 case 1: 3076 case 1:
3006 printf("\tbne\t.LC%d\n",label); break; 3077 printf("\tbr\t.LC%d\n",label); break;
3007 case 0: 3078 case 0:
3008 printf("\tbeq\t.LC%d\n",label); break; 3079 printf("\tbr\t.LC%d\n",label); break;
3009 case LT: 3080 case LT:
3010 printf("\tblt\t.LC%d\n",label); break; 3081 printf("\tbra\t.LC%d\n",label); break;
3011 case GT: 3082 case GT:
3012 printf("\tbgt\t.LC%d\n",label); break; 3083 printf("\tbgt\t.LC%d\n",label); break;
3013 default: error(-1); 3084 default: error(-1);
3014 } 3085 }
3015 if (reg!=-1) free_register(reg); 3086 if (reg!=-1) free_register(reg);
3016 } 3087 }
3054 rn2 = register_name(r2); 3125 rn2 = register_name(r2);
3055 printf("\tceq\t%s, %s, %s\n",rn1,rn1,rn2); 3126 printf("\tceq\t%s, %s, %s\n",rn1,rn1,rn2);
3056 } 3127 }
3057 3128
3058 switch(op+(!cond)*BNOT) { 3129 switch(op+(!cond)*BNOT) {
3059 case GT: case LE+BNOT: cc="cgt"; ncc="le"; break; 3130 case GT: case LE+BNOT: cc="r"; ncc="r"; break;
3060 case LE: case GT+BNOT: cc="le"; ncc="cgt"; break; 3131 case LE: case GT+BNOT: cc="r"; ncc="r"; break;
3061 case GE: case LT+BNOT: cc="ge"; ncc="lt"; break; 3132 case GE: case LT+BNOT: cc="r"; ncc="r"; break;
3062 case LT: case GE+BNOT: cc="lt"; ncc="ge"; break; 3133 case LT: case GE+BNOT: cc="r"; ncc="r"; break;
3063 case UGT: case ULE+BNOT: cc="hi"; ncc="ls"; break; 3134 case UGT: case ULE+BNOT: cc="r"; ncc="r"; break;
3064 case ULE: case UGT+BNOT: cc="ls"; ncc="hi"; break; 3135 case ULE: case UGT+BNOT: cc="r"; ncc="r"; break;
3065 case UGE: case ULT+BNOT: cc="hs"; ncc="lo"; break; 3136 case UGE: case ULT+BNOT: cc="r"; ncc="r"; break;
3066 case ULT: case UGE+BNOT: cc="lo"; ncc="hs"; break; 3137 case ULT: case UGE+BNOT: cc="r"; ncc="r"; break;
3067 case EQ: case NEQ+BNOT: cc="eq"; ncc="ne"; break; 3138 case EQ: case NEQ+BNOT: cc="r"; ncc="r"; break;
3068 case NEQ: case EQ+BNOT: cc="ne"; ncc="eq"; break; 3139 //case NEQ: case EQ+BNOT: cc="rnz"; ncc="r"; break;
3140 case NEQ: case EQ+BNOT: cc="r"; ncc="r"; break;
3069 default: error(-1); 3141 default: error(-1);
3070 } 3142 }
3071 3143
3072 if (mode==COND_BRANCH||mode==COND_BRANCH_CONST) { 3144 if (mode==COND_BRANCH||mode==COND_BRANCH_CONST) {
3073 printf("\tb%s\t.LC%d\n",cc,l1); 3145 printf("\tb%s\t.LC%d\n",cc,l1);
3146 //printf("\tb%s\t%s, .LC%d\n",cc,rn1,l1);
3074 } else if (mode==COND_VALUE||mode==COND_VALUE_CONST) { 3147 } else if (mode==COND_VALUE||mode==COND_VALUE_CONST) {
3075 rn0 = register_name(r0); 3148 rn0 = register_name(r0);
3076 printf("\tmov%s\t%s, #0\n",ncc,rn0); 3149 // ここはnccで分岐させなきゃダメだな
3077 printf("\tmov%s\t%s, #1\n",cc,rn0); 3150 printf("#####pcond##########\n");
3151 //printf("\tmovhoge%s\t%s, #0\n",ncc,rn0);
3152 //printf("\tmovfuho%s\t%s, #1\n",cc,rn0);
3078 } else error(-1); 3153 } else error(-1);
3079 } 3154 }
3080 3155
3081 int 3156 int
3082 rexpr_bool(int e1, int reg) 3157 rexpr_bool(int e1, int reg)
3129 #define CMP_C1T (-1) 3204 #define CMP_C1T (-1)
3130 3205
3131 static void 3206 static void
3132 jcond(int l, int cond) 3207 jcond(int l, int cond)
3133 { 3208 {
3134 printf("\tb%s\t.LC%d\n",cond?"ne":"eq",l); 3209 printf("\tb%s\t.LC%d\n",cond?"r":"r",l);
3135 } 3210 }
3136 3211
3137 void 3212 void
3138 jmp(int l) 3213 jmp(int l)
3139 { 3214 {
3170 { 3245 {
3171 int i; 3246 int i;
3172 if (freg_save>0) { 3247 if (freg_save>0) {
3173 i=reg_save*SIZE_OF_INT+ 3248 i=reg_save*SIZE_OF_INT+
3174 freg_save*SIZE_OF_DOUBLE + 20; 3249 freg_save*SIZE_OF_DOUBLE + 20;
3175 printf("\tlfm\tf4, %d, [fp, #%d]\n",freg_save,-i); 3250 //printf("\tlfm\tf4, %d, [fp, #%d]\n",freg_save,-i);
3176 } 3251 printf("\tlqd\t$sp,%d($sp)\n",i);
3252 }
3177 //printf("\tldmea\tfp, {"); 3253 //printf("\tldmea\tfp, {");
3178 for (i=reg_var_num(0);i<reg_var_num(reg_save);i++) { 3254 for (i=reg_var_num(0);i<reg_var_num(reg_save);i++) {
3179 printf("%s, ",register_name(i)); 3255 //printf("%s, ",register_name(i));
3180 } 3256 printf("\tlqd\t%s,-%d($sp)\n",register_name(i),-disp);
3257 disp -= SIZE_OF_FLOAT*4;
3258 }
3181 //printf("fp, sp, pc}\n"); 3259 //printf("fp, sp, pc}\n");
3182 return disp; 3260 return disp;
3183 } 3261 }
3184 3262
3185 static int entry_label; 3263 static int entry_label;
3196 printf("\t.type\t%s,function\n",name); 3274 printf("\t.type\t%s,function\n",name);
3197 r1_offset_label = fwdlabel(); 3275 r1_offset_label = fwdlabel();
3198 max_func_args = 0; 3276 max_func_args = 0;
3199 printf("%s:\n",name); 3277 printf("%s:\n",name);
3200 code_label_value(r1_offset_label,REG_ip); 3278 code_label_value(r1_offset_label,REG_ip);
3201 printf("\ta\tsp, ip, fp\n"); 3279 printf("\ta\t$sp, $sp, $fp\n");
3202 clear_ptr_cache(); 3280 clear_ptr_cache();
3203 } 3281 }
3204 3282
3205 3283
3206 void 3284 void
3233 // r1_offset_label = fwdlabel(); 3311 // r1_offset_label = fwdlabel();
3234 printf("\t.type\t%s,function\n",name); 3312 printf("\t.type\t%s,function\n",name);
3235 if (stmode!=STATIC) 3313 if (stmode!=STATIC)
3236 printf("\t.globl\t%s\n",name); 3314 printf("\t.globl\t%s\n",name);
3237 printf("%s:\n",name); 3315 printf("%s:\n",name);
3238 //printf("\tmov\tip, sp\n"); 3316 //printf("\tmov\t$sp, $lr,0\n");
3239 printf("\tstqd\t$lr,16($sp)\n"); 3317 printf("\tstqd\t$lr,16($sp)\n");
3240 printf("\tstqd\t$sp,-32($sp)\n"); 3318 printf("\tstqd\t$sp,-32($sp)\n");
3241 printf("\tai\t$sp,$sp,-32\n"); 3319 printf("\tai\t$sp,$sp,-32\n");
3242 //gen_jmp(entry_label = fwdlabel()); 3320 //gen_jmp(entry_label = fwdlabel());
3243 //register_save_return_label = backdef(); 3321 //register_save_return_label = backdef();
3254 } 3332 }
3255 3333
3256 void 3334 void
3257 code_label_call(int l) 3335 code_label_call(int l)
3258 { 3336 {
3259 printf("\tbl\tL_%d\n",l); 3337 printf("\tbr\tL_%d\n",l);
3260 } 3338 }
3261 3339
3262 void 3340 void
3263 code_ret() 3341 code_ret()
3264 { 3342 {
3265 printf("\tmov\tpc, lr\n"); 3343 //printf("\tmov\tpc, lr\n");
3266 control=0; 3344 control=0;
3267 } 3345 }
3268 3346
3269 void 3347 void
3270 leave(int control0, char *name) 3348 leave(int control0, char *name)
3293 } else if (cadr(fnptr->ty)>0&&( 3371 } else if (cadr(fnptr->ty)>0&&(
3294 car(cadr(fnptr->ty))==STRUCT || 3372 car(cadr(fnptr->ty))==STRUCT ||
3295 car(cadr(fnptr->ty))==UNION)) { 3373 car(cadr(fnptr->ty))==UNION)) {
3296 sz = size(cadr(fnptr->ty)); 3374 sz = size(cadr(fnptr->ty));
3297 code_const(sz,REGISTER_OPERAND); 3375 code_const(sz,REGISTER_OPERAND);
3298 printf("\tsf\tr1, r2, fp\n"); 3376 printf("\tsf\t$1, $2, $sp\n");
3299 printf("\tlqd\tr0, [fp, #%d]\n",(my_func_args-1)*SIZE_OF_INT); 3377 printf("\tlqd\t$1, %d($sp)\n",(my_func_args-1)*SIZE_OF_INT);
3300 emit_copy(6,3,sz,0,1,1); 3378 emit_copy(6,3,sz,0,1,1);
3301 } else if (cadr(fnptr->ty)!=VOID) { 3379 } else if (cadr(fnptr->ty)!=VOID) {
3302 creg = ireg = cadr(get_input_register_var(0,0,1)); 3380 creg = ireg = cadr(get_input_register_var(0,0,1));
3303 if (creg!=RET_REGISTER) 3381 if (creg!=RET_REGISTER)
3304 set_ireg(RET_REGISTER,1); 3382 set_ireg(RET_REGISTER,1);
3314 3392
3315 // entry part (save register) 3393 // entry part (save register)
3316 3394
3317 fwddef(entry_label); 3395 fwddef(entry_label);
3318 if (arg_on_register>0) 3396 if (arg_on_register>0)
3319 printf("\tsfi\tsp, sp, %d\n",arg_on_register); 3397 printf("\tsfi\t$sp, $sp, %d\n",arg_on_register);
3320 //code_register_save(max_reg_var,max_reg_var,0); 3398 //code_register_save(max_reg_var,max_reg_var,0);
3321 3399
3322 //printf("\tsf\tfp, ip, #%d\n",4+arg_on_register); 3400 //printf("\tsf\tfp, ip, #%d\n",4+arg_on_register);
3323 code_add(REG_sp,disp-max_func_args*SIZE_OF_INT,REG_sp); 3401 code_add(REG_sp,disp-max_func_args*SIZE_OF_INT,REG_sp);
3324 gen_jmp(register_save_return_label); 3402 gen_jmp(register_save_return_label);
3555 3633
3556 void 3634 void
3557 emit_label(int labelno) 3635 emit_label(int labelno)
3558 { 3636 {
3559 data_mode(0); 3637 data_mode(0);
3560 printf("\t.word .L%d\n",labelno); 3638 printf("\t.word .LC%d\n",labelno);
3561 } 3639 }
3562 3640
3563 void 3641 void
3564 emit_data_closing(NMTBL *n) 3642 emit_data_closing(NMTBL *n)
3565 { 3643 {
3569 if (mode==GDECL) { 3647 if (mode==GDECL) {
3570 data_mode(0); 3648 data_mode(0);
3571 #ifdef DOT_SIZE 3649 #ifdef DOT_SIZE
3572 lb=fwdlabel(); 3650 lb=fwdlabel();
3573 printf(".LC%d:\n",lb); 3651 printf(".LC%d:\n",lb);
3574 printf("\t.size\t%s,.L%d-%s\n",n->nm,lb,n->nm); 3652 printf("\t.size\t%s,.LC%d-%s\n",n->nm,lb,n->nm);
3575 #endif 3653 #endif
3576 } 3654 }
3577 } 3655 }
3578 3656
3579 3657
3580 static void 3658 static void
3581 comm(NMTBL *n) 3659 comm(NMTBL *n)
3582 { 3660 {
3583 printf(".comm %s,%d @ %d\n",n->nm,size(n->ty), 3661 //printf(".comm %s,%d @ %d\n",n->nm,size(n->ty),
3584 (n->ty==DOUBLE||n->ty==LONGLONG||n->ty==ULONGLONG)?8:4 3662 //(n->ty==DOUBLE||n->ty==LONGLONG||n->ty==ULONGLONG)?8:4
3585 ); 3663 //);
3586 } 3664 }
3587 3665
3588 void 3666 void
3589 global_table(void) 3667 global_table(void)
3590 { 3668 {
3673 extern_conv(char *conv) 3751 extern_conv(char *conv)
3674 { 3752 {
3675 code_save_stacks(); 3753 code_save_stacks();
3676 clear_ptr_cache(); 3754 clear_ptr_cache();
3677 extern_define(conv,0,FUNCTION,1); 3755 extern_define(conv,0,FUNCTION,1);
3678 printf("\tbl\t%s\n",conv); 3756 printf("\tbr\t%s\n",conv);
3679 lib_args(16); 3757 lib_args(16);
3680 } 3758 }
3681 #endif 3759 #endif
3682 3760
3683 static void 3761 static void
3688 clear_ptr_cache(); 3766 clear_ptr_cache();
3689 g = list3(REGISTER_OPERAND,0,reg); 3767 g = list3(REGISTER_OPERAND,0,reg);
3690 g = list3(REGISTER_OPERAND_1,g,oreg); 3768 g = list3(REGISTER_OPERAND_1,g,oreg);
3691 parallel_rassign(g); 3769 parallel_rassign(g);
3692 extern_define(lib,0,FUNCTION,1); 3770 extern_define(lib,0,FUNCTION,1);
3693 printf("\tbl\t%s\n",lib); 3771 printf("\tbr\t%s\n",lib);
3694 lib_args(16); 3772 lib_args(16);
3695 set_ireg(RET_REGISTER,0); 3773 set_ireg(RET_REGISTER,0);
3696 if (reg!=RET_REGISTER) { 3774 if (reg!=RET_REGISTER) {
3697 code_register(RET_REGISTER,reg); 3775 code_register(RET_REGISTER,reg);
3698 } 3776 }
3718 } 3796 }
3719 3797
3720 static char * 3798 static char *
3721 movef(int d) 3799 movef(int d)
3722 { 3800 {
3723 return d?"mvfd":"mvfs"; 3801 return d?"ori":"ori";
3724 } 3802 }
3725 3803
3726 static char * 3804 static char *
3727 fload(int d) { return d?"ldfd":"ldfs"; } 3805 fload(int d) { return d?"lqd":"lqd"; }
3728 3806
3729 static char * 3807 static char *
3730 fstore(int d) { return d?"stfd":"stfs"; } 3808 fstore(int d) { return d?"stqd":"stqd"; }
3731 3809
3732 3810
3733 void 3811 void
3734 code_dregister(int e2,int freg,int d) 3812 code_dregister(int e2,int freg,int d)
3735 { 3813 {
3736 use_float(d,freg); 3814 use_float(d,freg);
3737 if (freg!=e2) { 3815 if (freg!=e2) {
3738 if (is_int_reg(e2)) error(-1); 3816 if (is_int_reg(e2)) error(-1);
3739 printf("\t%s\t%s, %s\n",movef(d), 3817 printf("\t%s\t%s, %s, 0\n",movef(d),
3740 register_name(freg),register_name(e2)); 3818 register_name(freg),register_name(e2));
3741 } 3819 }
3742 } 3820 }
3743 3821
3744 void 3822 void
3745 code_dassign_gvar(int e2,int freg,int d) 3823 code_dassign_gvar(int e2,int freg,int d)
3746 { 3824 {
3747 use_float(d,freg); 3825 use_float(d,freg);
3748 code_ldf(fstore(d),register_name(freg),cadr(e2), 3826 code_ldf(fstore(d),register_name(freg),cadr(e2),
3749 get_ptr_cache((NMTBL*)caddr(e2))," @ float"); 3827 get_ptr_cache((NMTBL*)caddr(e2)),"");
3750 } 3828 }
3751 3829
3752 void 3830 void
3753 code_dassign_lvar(int e2,int freg,int d) 3831 code_dassign_lvar(int e2,int freg,int d)
3754 { 3832 {
3755 use_float(d,freg); 3833 use_float(d,freg);
3756 lvar_intro(e2); 3834 lvar_intro(e2);
3757 printf("\t%s\t%s, ",fstore(d),register_name(freg)); 3835 printf("\t%s\t%s, ",fstore(d),register_name(freg));
3758 lvar(e2,"@ float"); 3836 lvar(e2,"");
3759 } 3837 }
3760 3838
3761 void 3839 void
3762 code_dassign(int e2,int freg,int d) 3840 code_dassign(int e2,int freg,int d)
3763 { 3841 {
3764 use_float(d,freg); 3842 use_float(d,freg);
3765 printf("\t%s\t%s, [%s, #0] @ float\n",fstore(d), 3843 //printf("\t%s\t%s, [%s, #0] @ float\n",fstore(d),
3844 printf("\t%s\t%s, 0(%s)\n",fstore(d),
3766 register_name(freg),register_name(e2)); 3845 register_name(freg),register_name(e2));
3767 } 3846 }
3768 3847
3769 void 3848 void
3770 code_dassign_dregister(int e2,int d,int freg) { 3849 code_dassign_dregister(int e2,int d,int freg) {
3771 use_float(d,freg); 3850 use_float(d,freg);
3772 if (e2!=freg) { 3851 if (e2!=freg) {
3773 printf("\t%s\t%s, %s\n",movef(d), 3852 printf("\t%s\t%s, %s, 0\n",movef(d),
3774 register_name(e2),register_name(freg)); 3853 register_name(e2),register_name(freg));
3775 } 3854 }
3776 } 3855 }
3777 3856
3778 static double d0 = 1.0; 3857 static double d0 = 1.0;
3800 } 3879 }
3801 3880
3802 static void 3881 static void
3803 dconst(int l,int h,double value) 3882 dconst(int l,int h,double value)
3804 { 3883 {
3805 #if ENDIAN_D==0 3884 code_dconst(code_d2(value),h,1);
3806 code_const(code_d1(value),l);
3807 code_const(code_d2(value),h);
3808 #else
3809 code_const(code_d1(value),h);
3810 code_const(code_d2(value),l);
3811 #endif
3812 } 3885 }
3813 3886
3814 3887
3815 void 3888 void
3816 code_dconst(int e2,int freg,int d) 3889 code_dconst(int e2,int freg,int d)
3821 int label,disp; 3894 int label,disp;
3822 3895
3823 use_float(d,freg); 3896 use_float(d,freg);
3824 frn = register_name(freg); 3897 frn = register_name(freg);
3825 if (value==0 || value==1 || value==10) { 3898 if (value==0 || value==1 || value==10) {
3826 printf("\t%s\t%s, #%d\n",movef(d),frn,(int)value); 3899 printf("\t%s\t%s, %s, %d\n",movef(d),frn,frn,(int)value);
3827 } else if (value==-1 || value==-10) { 3900 } else if (value==-1 || value==-10) {
3828 printf("\t%s\t%s, #%d\n",d?"mnfd":"mnfs",frn,(int)-value); 3901 printf("\t%s\t%s, %d\n",d?"mnfd":"mnfs",frn,(int)-value);
3829 } else if (d) { 3902 } else if (d) {
3830 #if ENDIAN_D==0 3903 #if ENDIAN_D==0
3831 disp = search_double_const(DCONST, 3904 disp = search_double_const(DCONST,
3832 code_d1(value),code_d2(value),&label); 3905 code_d1(value),code_d2(value),&label);
3833 #else 3906 #else
3834 disp = search_double_const(DCONST, 3907 disp = search_double_const(DCONST,
3835 code_d2(value),code_d1(value),&label); 3908 code_d2(value),code_d1(value),&label);
3836 #endif 3909 #endif
3837 printf("\tldfd\t%s, .LC%d+%d\n",frn,label,disp); 3910 printf("\tlqd\t%s, .LC%d+%d($sp)\n",frn,label,disp);
3838 } else { 3911 } else {
3839 //disp = search_const(CONST,*((int*)&f),&label); 3912 //disp = search_const(CONST,*((int*)&f),&label);
3840 printf("\tldfs\t%s, .LC%d+%d\n",frn,label,disp); 3913 printf("\tlqd\t%s, .LC%d+%d($sp)\n",frn,label,disp);
3841 } 3914 }
3842 } 3915 }
3843 3916
3844 3917
3845 void 3918 void
3872 code_d2i0(int reg,int d) 3945 code_d2i0(int reg,int d)
3873 { 3946 {
3874 int lreg; 3947 int lreg;
3875 use_float(d,reg); 3948 use_float(d,reg);
3876 lreg = get_register(); 3949 lreg = get_register();
3877 printf("\tfixz\t%s, %s\n",register_name(lreg),register_name(reg)); 3950 //printf("\tfixz\t%s, %s\n",register_name(lreg),register_name(reg));
3878 set_ireg(lreg,0); 3951 set_ireg(lreg,0);
3879 return; 3952 return;
3880 } 3953 }
3881 3954
3882 void 3955 void
3897 int lreg,reg0; 3970 int lreg,reg0;
3898 char *lrn,*frn,*crn; 3971 char *lrn,*frn,*crn;
3899 // u = (d>2.1e9)?((int)(d-2.1e9)^2147483648):(int)d 3972 // u = (d>2.1e9)?((int)(d-2.1e9)^2147483648):(int)d
3900 use_float(1,reg); 3973 use_float(1,reg);
3901 frn = register_name(reg); 3974 frn = register_name(reg);
3902 if (!d) printf("\tmvfd\t%s, %s\n",frn,frn); 3975 if (!d) printf("\tori\t%s, %s, 0\n",frn,frn);
3903 emit_dpush(1); 3976 emit_dpush(1);
3904 code_dconst(dlist2(DCONST,2.147483648e9),USE_CREG,1); 3977 code_dconst(dlist2(DCONST,2.147483648e9),USE_CREG,1);
3905 lrn = register_name(lreg = emit_dpop(d)); 3978 lrn = register_name(lreg = emit_dpop(d));
3906 frn = register_name(freg); 3979 frn = register_name(freg);
3907 set_ireg(reg0=get_register(),0); 3980 set_ireg(reg0=get_register(),0);
3908 crn = register_name(reg0); 3981 crn = register_name(reg0);
3909 printf("\tcmfe\t%s, %s\n",lrn,frn); 3982 printf("\tcmfe\t%s, %s\n",lrn,frn);
3910 printf("\tbge\t1f\n"); 3983 printf("\tbr\t1f\n");
3911 printf("\tfixz\t%s, %s\n",crn,lrn); 3984 //printf("\tfixz\t%s, %s\n",crn,lrn);
3912 printf("\tb\t2f\n"); 3985 printf("\tb\t2f\n");
3913 printf("1:\n"); 3986 printf("1:\n");
3914 printf("\tsufd\t%s, %s, %s\n",lrn,lrn,frn); 3987 printf("\tsufd\t%s, %s, %s\n",lrn,lrn,frn);
3915 printf("\tfixz\t%s, %s\n",crn,lrn); 3988 //printf("\tfixz\t%s, %s\n",crn,lrn);
3916 printf("\teor\t%s, %s, #-2147483648\n",crn,crn); 3989 printf("\teor\t%s, %s, #-2147483648\n",crn,crn);
3917 printf("2:\n"); 3990 printf("2:\n");
3918 emit_dpop_free(lreg,d); 3991 emit_dpop_free(lreg,d);
3919 return; 3992 return;
3920 } 3993 }
3927 use_int(reg); 4000 use_int(reg);
3928 crn = register_name(reg); 4001 crn = register_name(reg);
3929 set_dreg(reg=get_dregister(1),0); 4002 set_dreg(reg=get_dregister(1),0);
3930 frn = register_name(reg); 4003 frn = register_name(reg);
3931 printf("\tfltd\t%s, %s\n",frn,crn); 4004 printf("\tfltd\t%s, %s\n",frn,crn);
3932 printf("\tcmp\t%s, #0\n",crn); 4005 printf("\tceqi\t%s, %s, 0\n",crn,crn);
3933 printf("\tbge\t1f\n"); 4006 printf("\tbr\t1f\n");
3934 freg1 = get_dregister(1); 4007 freg1 = get_dregister(1);
3935 code_dconst(dlist2(DCONST,4.29496729600000000000e9),freg1,1); 4008 code_dconst(dlist2(DCONST,4.29496729600000000000e9),freg1,1);
3936 frn = register_name(creg); 4009 frn = register_name(creg);
3937 lrn = register_name(freg1); 4010 lrn = register_name(freg1);
3938 printf("\tadfd\t%s, %s, %s\n",frn,frn,lrn); 4011 printf("\tadfd\t%s, %s, %s\n",frn,frn,lrn);
3953 4026
3954 void 4027 void
3955 code_f2d(int reg) { 4028 code_f2d(int reg) {
3956 char *frn; 4029 char *frn;
3957 frn = register_name(freg); 4030 frn = register_name(freg);
3958 printf("\tmvfd\t%s, %s\n",frn,frn); 4031 printf("\tori\t%s, %s, 0\n",frn,frn);
3959 return; 4032 return;
3960 } 4033 }
3961 4034
3962 void 4035 void
3963 code_d2i(int reg) { 4036 code_d2i(int reg) {
4218 case DOP+NEQ: 4291 case DOP+NEQ:
4219 op=DOP+EQ; break; 4292 op=DOP+EQ; break;
4220 } 4293 }
4221 } 4294 }
4222 switch(op) { 4295 switch(op) {
4223 case FOP+GT: op1=FOP+CMP; opn = "bgt"; break; 4296 case FOP+GT: op1=FOP+CMP; opn = "br"; break;
4224 case FOP+GE: op1=FOP+CMPGE; opn = "bge"; break; 4297 case FOP+GE: op1=FOP+CMPGE; opn = "br"; break;
4225 case FOP+EQ: op1=FOP+CMP; opn = "beq"; break; 4298 case FOP+EQ: op1=FOP+CMP; opn = "br"; break;
4226 case FOP+NEQ: op1=FOP+CMP; opn = "bne"; break; 4299 case FOP+NEQ: op1=FOP+CMP; opn = "br"; break;
4227 case DOP+GT: op1=DOP+CMP; opn = "bgt"; break; 4300 case DOP+GT: op1=DOP+CMP; opn = "br"; break;
4228 case DOP+GE: op1=DOP+CMPGE; opn = "bge"; break; 4301 case DOP+GE: op1=DOP+CMPGE; opn = "br"; break;
4229 case DOP+EQ: op1=DOP+CMP; opn = "beq"; break; 4302 case DOP+EQ: op1=DOP+CMP; opn = "br"; break;
4230 case DOP+NEQ: op1=DOP+CMP; opn = "bne"; break; 4303 case DOP+NEQ: op1=DOP+CMP; opn = "br"; break;
4231 default: error(-1); 4304 default: error(-1);
4232 } 4305 }
4233 g_expr(list3(op1,e2,e1)); 4306 g_expr(list3(op1,e2,e1));
4234 printf("\t%s\t.L%d\n",opn,l1); 4307 printf("\t%s\t.L%d\n",opn,l1);
4235 return l1; 4308 return l1;
4319 4392
4320 void 4393 void
4321 code_cmp_lregister(int reg,int label,int cond) 4394 code_cmp_lregister(int reg,int label,int cond)
4322 { 4395 {
4323 use_longlong(reg); 4396 use_longlong(reg);
4324 printf("\torr\t%s, %s, %s\n", 4397 printf("\torc\t%s, %s, %s\n",
4325 lregister_name_low(reg), 4398 lregister_name_low(reg),
4326 lregister_name_low(reg), 4399 lregister_name_low(reg),
4327 lregister_name_high(reg)); 4400 lregister_name_high(reg));
4328 code_cmp_register((reg),label,cond); 4401 code_cmp_register((reg),label,cond);
4329 } 4402 }
4402 use_longlong(creg); 4475 use_longlong(creg);
4403 crn_h = lregister_name_high(creg); 4476 crn_h = lregister_name_high(creg);
4404 crn_l = lregister_name_low(creg); 4477 crn_l = lregister_name_low(creg);
4405 lvar_intro(e2); 4478 lvar_intro(e2);
4406 #if ENDIAN_L==0 4479 #if ENDIAN_L==0
4407 printf("\tstr\t%s, ",crn_l);lvar(e2,""); 4480 printf("\tstqd\t%s, ",crn_l);lvar(e2,"");
4408 printf("\tstr\t%s, ",crn_h);lvar(e2+SIZE_OF_INT,""); 4481 printf("\tstqd\t%s, ",crn_h);lvar(e2+SIZE_OF_INT,"");
4409 #else 4482 #else
4410 printf("\tstr\t%s, ",crn_h);lvar(e2,""); 4483 printf("\tstqd\t%s, ",crn_h);lvar(e2,"");
4411 printf("\tstr\t%s, ",crn_l);lvar(e2+SIZE_OF_INT,""); 4484 printf("\tstqd\t%s, ",crn_l);lvar(e2+SIZE_OF_INT,"");
4412 #endif 4485 #endif
4413 } 4486 }
4414 4487
4415 void 4488 void
4416 code_lassign_lregister(int e2,int reg) 4489 code_lassign_lregister(int e2,int reg)
4448 use_longlong(creg); 4521 use_longlong(creg);
4449 crn_h = lregister_name_high(creg); 4522 crn_h = lregister_name_high(creg);
4450 crn_l = lregister_name_low(creg); 4523 crn_l = lregister_name_low(creg);
4451 r = get_ptr_cache((NMTBL*)caddr(e1)); 4524 r = get_ptr_cache((NMTBL*)caddr(e1));
4452 #if ENDIAN_L==0 4525 #if ENDIAN_L==0
4453 code_ldf("ldr",crn_l,cadr(e1),r,""); 4526 code_ldf("lqd",crn_l,cadr(e1),r,"");
4454 code_ldf("ldr",crn_h,cadr(e1)+SIZE_OF_INT,r,""); 4527 //code_ldf("ldr",crn_h,cadr(e1)+SIZE_OF_INT,r,"");
4455 #else 4528 #else
4456 code_ldf("ldr",crn_h,cadr(e1),r,""); 4529 code_ldf("lqd",crn_h,cadr(e1),r,"");
4457 code_ldf("ldr",crn_l,cadr(e1)+SIZE_OF_INT,r,""); 4530 //code_ldf("ldr",crn_l,cadr(e1)+SIZE_OF_INT,r,"");
4458 #endif 4531 #endif
4459 } 4532 }
4460 4533
4461 void 4534 void
4462 code_lrlvar(int e1,int creg) 4535 code_lrlvar(int e1,int creg)
4492 4565
4493 void 4566 void
4494 code_lconst(int e1,int creg) 4567 code_lconst(int e1,int creg)
4495 { 4568 {
4496 use_longlong(creg); 4569 use_longlong(creg);
4497 #if ENDIAN_L==0
4498 code_const(code_l1(lcadr(e1)),(creg));
4499 code_const(code_l2(lcadr(e1)),(creg)); 4570 code_const(code_l2(lcadr(e1)),(creg));
4500 #else
4501 code_const(code_l1(lcadr(e1)),(creg));
4502 code_const(code_l2(lcadr(e1)),(creg));
4503 #endif
4504 } 4571 }
4505 4572
4506 void 4573 void
4507 code_lneg(int creg) 4574 code_lneg(int creg)
4508 { 4575 {
4588 case LEOR: 4655 case LEOR:
4589 printf("\teor\t%s, %s, %s\n",crn_l,crn_l,orn_l); 4656 printf("\teor\t%s, %s, %s\n",crn_l,crn_l,orn_l);
4590 printf("\teor\t%s, %s, %s\n",crn_h,crn_h,orn_h); 4657 printf("\teor\t%s, %s, %s\n",crn_h,crn_h,orn_h);
4591 break; 4658 break;
4592 case LBOR: 4659 case LBOR:
4593 printf("\torr\t%s, %s, %s\n",crn_l,crn_l,orn_l); 4660 printf("\tor\t%s, %s, %s\n",crn_l,crn_l,orn_l);
4594 printf("\torr\t%s, %s, %s\n",crn_h,crn_h,orn_h); 4661 printf("\tor\t%s, %s, %s\n",crn_h,crn_h,orn_h);
4595 break; 4662 break;
4596 case LMUL: 4663 case LMUL:
4597 case LUMUL: 4664 case LUMUL:
4598 code_longlong_lib("__muldi3",reg,oreg); 4665 code_longlong_lib("__muldi3",reg,oreg);
4599 check_lreg(reg); 4666 check_lreg(reg);
4676 if (v==32) { 4743 if (v==32) {
4677 code_register((creg),(creg)); 4744 code_register((creg),(creg));
4678 code_const(0,(creg)); 4745 code_const(0,(creg));
4679 return; 4746 return;
4680 } else if (v>31) { 4747 } else if (v>31) {
4681 printf("\tmov\t%s, %s, lsl #%d\n",crn_h,crn_l,v-32); 4748 //printf("\tmov\t%s, %s, lsl #%d\n",crn_h,crn_l,v-32);
4682 code_const(0,(creg)); 4749 // 右シフト
4750 printf("\troti\t%s,%s,%d\n",crn_h,crn_h,96-v);
4751 code_const(0,(creg));
4683 return; 4752 return;
4684 } 4753 }
4685 greg = get_register(); 4754 greg = get_register();
4686 grn = register_name(greg); 4755 grn = register_name(greg);
4687 printf("\tmov\t%s, %s, lsl #%d\n",crn_h,crn_h,v); 4756 printf("\tshli\t%s, %s, %d\n",crn_h,crn_h,v);
4688 printf("\tmov\t%s, %s, lsr #%d\n",grn,crn_l,32-v); 4757 printf("\troti\t%s, %s, -%d\n",grn,crn_l,32-v);
4689 printf("\torr\t%s, %s,%s\n",crn_h,crn_h,grn); 4758 printf("\torc\t%s, %s,%s\n",crn_h,crn_h,grn);
4690 printf("\tmov\t%s, %s, lsl #%d\n",crn_l,crn_l,v); 4759 printf("\tshli\t%s, %s,%d\n",crn_l,crn_l,v);
4691 free_register(greg); 4760 free_register(greg);
4692 return; 4761 return;
4693 case LDIV: 4762 case LDIV:
4694 v=ilog(v); 4763 v=ilog(v);
4695 case LRSHIFT: 4764 case LRSHIFT:
4696 if (v==0) return; 4765 if (v==0) return;
4697 if (v==32) { 4766 if (v==32) {
4698 code_register((creg),(creg)); 4767 code_register((creg),(creg));
4699 printf("\tmov\t%s, %s, asr #31\n",crn_h,crn_l); 4768 printf("\tshli\t%s, %s, 31\n",crn_h,crn_l);
4700 return; 4769 return;
4701 } else if (v>31) { 4770 } else if (v>31) {
4702 printf("\tmov\t%s, %s, asr #%d\n",crn_l,crn_h,v-32); 4771 printf("\t\t%s, %s, asr #%d\n",crn_l,crn_h,v-32);
4703 printf("\tmov\t%s, %s, asr #31\n",crn_h,crn_l); 4772 printf("\tshl\t%s, %s, 31\n",crn_h,crn_l);
4704 return; 4773 return;
4705 } 4774 }
4706 greg = get_register(); 4775 greg = get_register();
4707 grn = register_name(greg); 4776 grn = register_name(greg);
4708 printf("\tmov\t%s, %s, lsr #%d\n",crn_l,crn_l,v); 4777 printf("\troti \t%s, %s, %d\n",crn_l,crn_l,v);
4709 printf("\tmov\t%s, %s, lsl #%d\n",grn,crn_h,32-v); 4778 printf("\troti\t%s, %s, %d\n",grn,crn_h,160-v);
4710 printf("\torr\t%s, %s,%s\n",crn_l,crn_l,grn); 4779 printf("\tor\t%s, %s,%s\n",crn_l,crn_l,grn);
4711 printf("\tmov\t%s, %s, asr #%d\n",crn_h,crn_h,v); 4780 printf("\tshli\t%s, %s, %d\n",crn_h,crn_h,v);
4712 free_register(greg); 4781 free_register(greg);
4713 return; 4782 return;
4714 case LUDIV: 4783 case LUDIV:
4715 v=ilog(v); 4784 v=ilog(v);
4716 case LURSHIFT: 4785 case LURSHIFT:
4724 code_const(0,(creg)); 4793 code_const(0,(creg));
4725 return; 4794 return;
4726 } 4795 }
4727 greg = get_register(); 4796 greg = get_register();
4728 grn = register_name(greg); 4797 grn = register_name(greg);
4729 printf("\tmov\t%s, %s, lsl #%d\n",grn,crn_h,32-v); 4798 printf("\troti\t%s, %s, %d\n",grn,crn_h,96-v);
4730 printf("\tmov\t%s, %s, lsr #%d\n",crn_l,crn_l,v); 4799 printf("\troti\t%s, %s, %d\n",crn_l,crn_l,v);
4731 printf("\torr\t%s, %s,%s\n",crn_l,grn,crn_l); 4800 printf("\tor\t%s, %s,%s\n",crn_l,grn,crn_l);
4732 printf("\tmov\t%s, %s, lsr #%d\n",crn_h,crn_h,v); 4801 printf("\troti\t%s, %s, %d\n",crn_h,crn_h,v);
4733 free_register(greg); 4802 free_register(greg);
4734 return; 4803 return;
4735 case LADD: 4804 case LADD:
4736 printf("\tadds\t%s, %s, #%d\n",crn_l,crn_l,v); 4805 printf("\tadds\t%s, %s, #%d\n",crn_l,crn_l,v);
4737 printf("\tadc\t%s, %s, #%d\n",crn_h,crn_h,vh); 4806 printf("\tadc\t%s, %s, #%d\n",crn_h,crn_h,vh);
4739 case LSUB: 4808 case LSUB:
4740 printf("\tsubs\t%s, %s, #%d\n",crn_l,crn_l,v); 4809 printf("\tsubs\t%s, %s, #%d\n",crn_l,crn_l,v);
4741 printf("\tsbc\t%s, %s, #%d\n",crn_h,crn_h,vh); 4810 printf("\tsbc\t%s, %s, #%d\n",crn_h,crn_h,vh);
4742 break; 4811 break;
4743 case LBAND: 4812 case LBAND:
4744 printf("\tand\t%s, %s, #%d\n",crn_l,crn_l,v); 4813 printf("\tandi\t%s, %s, %d\n",crn_l,crn_l,v);
4745 printf("\tand\t%s, %s, #%d\n",crn_h,crn_h,vh); 4814 printf("\tandi\t%s, %s, %d\n",crn_h,crn_h,vh);
4746 break; 4815 break;
4747 case LEOR: 4816 case LEOR:
4748 printf("\teor\t%s, %s, #%d\n",crn_l,crn_l,v); 4817 printf("\teor\t%s, %s, #%d\n",crn_l,crn_l,v);
4749 printf("\teor\t%s, %s, #%d\n",crn_h,crn_h,vh); 4818 printf("\teor\t%s, %s, #%d\n",crn_h,crn_h,vh);
4750 break; 4819 break;
4751 case LBOR: 4820 case LBOR:
4752 printf("\torr\t%s, %s, #%d\n",crn_l,crn_l,v); 4821 printf("\tori\t%s, %s, %d\n",crn_l,crn_l,v);
4753 printf("\torr\t%s, %s, #%d\n",crn_h,crn_h,vh); 4822 printf("\tori\t%s, %s, %d\n",crn_h,crn_h,vh);
4754 break; 4823 break;
4755 default: 4824 default:
4756 error(-1); 4825 error(-1);
4757 } 4826 }
4758 if (dx!=-1) free_register(dx); 4827 if (dx!=-1) free_register(dx);
4768 use_longlong(reg); 4837 use_longlong(reg);
4769 crn_h = lregister_name_high(lreg); 4838 crn_h = lregister_name_high(lreg);
4770 crn_l = lregister_name_low(lreg); 4839 crn_l = lregister_name_low(lreg);
4771 if (reg0!=(lreg)) 4840 if (reg0!=(lreg))
4772 printf("\tori\t%s, %s, 0\n",crn_l,crn); 4841 printf("\tori\t%s, %s, 0\n",crn_l,crn);
4773 printf("\tmov\t%s, %s, asr #31\n",crn_h,crn_l); 4842 printf("\tshli\t%s, %s, 31\n",crn_h,crn_l);
4774 } 4843 }
4775 4844
4776 void 4845 void
4777 code_i2ull(int reg) 4846 code_i2ull(int reg)
4778 { 4847 {
5102 code_cmpdimm(max-min,t,dlabel,-1); 5171 code_cmpdimm(max-min,t,dlabel,-1);
5103 printf("\tldrls\tpc, [pc, %s, asl #2]\n",trn); 5172 printf("\tldrls\tpc, [pc, %s, asl #2]\n",trn);
5104 break; 5173 break;
5105 case 2: 5174 case 2:
5106 printf("\ttst\t%s, #1\n",trn); 5175 printf("\ttst\t%s, #1\n",trn);
5107 printf("\tbne\t.L%d\n",dlabel); 5176 printf("\tbr\t.L%d\n",dlabel);
5108 code_cmpdimm(max-min,t,dlabel,-1); 5177 code_cmpdimm(max-min,t,dlabel,-1);
5109 printf("\tldrls\tpc, [pc, %s, asl #1]\n",trn); break; 5178 printf("\tldrls\tpc, [pc, %s, asl #1]\n",trn); break;
5110 break; 5179 break;
5111 case 4: 5180 case 4:
5112 printf("\ttst\t%s, #3\n",trn); 5181 printf("\ttst\t%s, #3\n",trn);
5113 printf("\tbne\t.L%d\n",dlabel); 5182 printf("\tbr\t.L%d\n",dlabel);
5114 code_cmpdimm(max-min,t,dlabel,-1); 5183 code_cmpdimm(max-min,t,dlabel,-1);
5115 printf("\tldrls\tpc, [pc, %s]\n",trn); break; 5184 printf("\tldrls\tpc, [pc, %s]\n",trn); break;
5116 break; 5185 break;
5117 default: 5186 default:
5118 error(-1); 5187 error(-1);
5515 static void 5584 static void
5516 make_mask_and_or(int mask,int tmp,char *trn,char *crn,char *lrn) 5585 make_mask_and_or(int mask,int tmp,char *trn,char *crn,char *lrn)
5517 { 5586 {
5518 // printf("## mask 0x%08x ~0x%08x\n",mask,~mask); 5587 // printf("## mask 0x%08x ~0x%08x\n",mask,~mask);
5519 code_const(~mask,tmp); 5588 code_const(~mask,tmp);
5520 printf("\torr\t%s, %s, %s\n",trn,crn,trn); 5589 printf("\tor\t%s, %s, %s\n",trn,crn,trn);
5521 /* do conjunction */ 5590 /* do conjunction */
5522 printf("\tand\t%s, %s, %s\n",lrn,trn,lrn); 5591 printf("\tand\t%s, %s, %s\n",lrn,trn,lrn);
5523 /* make or-mask */ 5592 /* make or-mask */
5524 code_const(mask,tmp); 5593 code_const(mask,tmp);
5525 printf("\tand\t%s, %s, %s\n",trn,crn,trn); 5594 printf("\tand\t%s, %s, %s\n",trn,crn,trn);
5526 /* do disjunction */ 5595 /* do disjunction */
5527 printf("\torr\t%s, %s, %s\n",crn,trn,lrn); 5596 printf("\tor\t%s, %s, %s\n",crn,trn,lrn);
5528 } 5597 }
5529 5598
5530 extern void 5599 extern void
5531 code_bit_replace(int adr,int value,int type) 5600 code_bit_replace(int adr,int value,int type)
5532 { 5601 {
5647 int tmp = -1; 5716 int tmp = -1;
5648 int m; 5717 int m;
5649 // printf("## mask 0x%08x ~0x%08x\n",mask,~mask); 5718 // printf("## mask 0x%08x ~0x%08x\n",mask,~mask);
5650 if ((m=(~mask|c))!=-1) { 5719 if ((m=(~mask|c))!=-1) {
5651 if (is_stage1_const(m,0)>0) { 5720 if (is_stage1_const(m,0)>0) {
5652 printf("\tand\t%s, %s, #%d\n",crn,crn,m); 5721 printf("\tandi\t%s, %s, %d\n",crn,crn,m);
5653 } else { 5722 } else {
5654 trn = register_name(tmp=get_register()); 5723 trn = register_name(tmp=get_register());
5655 code_const((~mask|c),tmp); 5724 code_const((~mask|c),tmp);
5656 /* do conjunction */ 5725 /* do conjunction */
5657 printf("\tand\t%s, %s, %s\n",crn,trn,crn); 5726 printf("\tand\t%s, %s, %s\n",crn,trn,crn);
5661 /* make or-mask */ 5730 /* make or-mask */
5662 c = mask&c; 5731 c = mask&c;
5663 if (c!=0) { 5732 if (c!=0) {
5664 /* do disjunction */ 5733 /* do disjunction */
5665 if (is_stage1_const(c,0)>0) { 5734 if (is_stage1_const(c,0)>0) {
5666 printf("\torr\t%s, %s, #%d\n",crn,crn,c); 5735 printf("\tori\t%s, %s, %d\n",crn,crn,c);
5667 } else { 5736 } else {
5668 trn = register_name(tmp=get_register()); 5737 trn = register_name(tmp=get_register());
5669 code_const(c,tmp); 5738 code_const(c,tmp);
5670 printf("\torr\t%s, %s, %s\n",crn,trn,crn); 5739 printf("\tor\t%s, %s, %s\n",crn,trn,crn);
5671 } 5740 }
5672 } 5741 }
5673 if (tmp!=-1) free_register(tmp); 5742 if (tmp!=-1) free_register(tmp);
5674 } 5743 }
5675 5744