Mercurial > hg > CbC > old > device

comparison mc-codegen.c @ 81:f94ca1168520

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
float first try...
author kono
date Mon, 03 Mar 2003 20:59:51 +0900
parents 83d901658ce9
children 25654dc29ecc
comparison
equal deleted inserted replaced
80:83d901658ce9 81:f94ca1168520
7 #include "mc-code.h" 7 #include "mc-code.h"
8 8
9 int creg; /* current register */ 9 int creg; /* current register */
10 int dreg; /* temporary register */ 10 int dreg; /* temporary register */
11 int reg_sp; /* REGister Stack-Pointer */ 11 int reg_sp; /* REGister Stack-Pointer */
12
13 int freg; /* current floating point register */
12 14
13 /* 15 /*
14 creg currrent virtual register 16 creg currrent virtual register
15 dreg spare virtual register 17 dreg spare virtual register
16 18
273 return; 275 return;
274 case CRLVAR: 276 case CRLVAR:
275 code_crlvar(lvar(e2)); 277 code_crlvar(lvar(e2));
276 regv[creg]=1; 278 regv[creg]=1;
277 return; 279 return;
280 case FRLVAR:
281 code_frlvar(lvar(e2));
282 regv[creg]=1;
283 return;
284 case FRGVAR:
285 code_frgvar(lvar(e2));
286 regv[creg]=1;
287 return;
288 case DRLVAR:
289 code_drlvar(lvar(e2));
290 regv[creg]=1;
291 return;
292 case DRGVAR:
293 code_drgvar(lvar(e2));
294 regv[creg]=1;
295 return;
278 case FNAME: 296 case FNAME:
279 code_fname(((NMTBL *)(e2))->nm); 297 code_fname(((NMTBL *)(e2))->nm);
280 regv[creg]=1; 298 regv[creg]=1;
281 return; 299 return;
282 case CONST: /* 代入する値が0でも特別な処理はしない */ 300 case CONST: /* 代入する値が0でも特別な処理はしない */
283 code_const(e2); 301 code_const(e2);
284 regv[creg]=1; 302 regv[creg]=1;
285 return; 303 return;
304 case DCONST:
305 code_dconst(e2);
306 regv[creg]=1;
307 return;
286 case STRING: 308 case STRING:
287 string(e1); 309 string(e1);
288 regv[creg]=1; 310 regv[creg]=1;
289 return; 311 return;
290 case FUNCTION: 312 case FUNCTION:
295 jump(e2,caddr(e1)); 317 jump(e2,caddr(e1));
296 return; 318 return;
297 case INDIRECT: 319 case INDIRECT:
298 g_expr(e2); 320 g_expr(e2);
299 return; 321 return;
300 case RINDIRECT: case CRINDIRECT: 322 case RINDIRECT: case CRINDIRECT:
323 case DRINDIRECT: case FRINDIRECT:
301 rindirect(e1); 324 rindirect(e1);
302 return; 325 return;
303 case ADDRESS: 326 case ADDRESS:
304 g_expr(e2); 327 g_expr(e2);
305 return; 328 return;
306 case MINUS: /* レジスタに対し、neglを実行すれば実現可能 */ 329 case MINUS: /* レジスタに対し、neglを実行すれば実現可能 */
307 g_expr(e2); 330 g_expr(e2);
308 code_neg(); 331 code_neg();
332 return;
333 case DMINUS:
334 g_expr(e2);
335 code_dneg();
309 return; 336 return;
310 case BNOT: /* ~ */ 337 case BNOT: /* ~ */
311 g_expr(e2); 338 g_expr(e2);
312 code_not(); 339 code_not();
313 return; 340 return;
338 case DIV: case UDIV: 365 case DIV: case UDIV:
339 case MOD: case UMOD: 366 case MOD: case UMOD:
340 case LSHIFT: case ULSHIFT: case RSHIFT: case URSHIFT: 367 case LSHIFT: case ULSHIFT: case RSHIFT: case URSHIFT:
341 case ADD: case SUB: case BAND: case EOR: case BOR: 368 case ADD: case SUB: case BAND: case EOR: case BOR:
342 machinop(e1); 369 machinop(e1);
370 return;
371 case DMUL: case DDIV:
372 case DADD: case DSUB:
373 dmachinop(e1);
343 return; 374 return;
344 case COND: 375 case COND:
345 e2=fwdlabel(); 376 e2=fwdlabel();
346 b_expr(cadr(e1),0,e2,0); 377 b_expr(cadr(e1),0,e2,0);
347 code_set_fixed_creg(0); 378 code_set_fixed_creg(0);
356 fwddef(e3); 387 fwddef(e3);
357 return; 388 return;
358 case SASS: 389 case SASS:
359 sassign(e1); 390 sassign(e1);
360 return; 391 return;
361 case ASS: case CASS: 392 case ASS: case CASS: case FASS:
362 assign(e1); 393 assign(e1);
394 return;
395 case DASS: case LASS:
396 dassign(e1);
363 return; 397 return;
364 case ASSOP: case CASSOP: 398 case ASSOP: case CASSOP:
365 assop(e1); 399 assop(e1);
400 return;
401 case DASSOP: case FASSOP:
402 dassop(e1);
366 return; 403 return;
367 case RSTRUCT: 404 case RSTRUCT:
368 g_expr(e2); 405 g_expr(e2);
369 return; 406 return;
370 case COMMA: 407 case COMMA:
459 return; 496 return;
460 case RLVAR: 497 case RLVAR:
461 code_cmp_rlvar(lvar(e2)); 498 code_cmp_rlvar(lvar(e2));
462 jcond(l1,cond); 499 jcond(l1,cond);
463 return; 500 return;
501 case DRLVAR:
502 code_cmp_drlvar(lvar(e2));
503 jcond(l1,cond);
504 return;
505 case DRGVAR:
506 code_cmp_drgvar(lvar(e2));
507 jcond(l1,cond);
508 return;
464 case REGISTER: 509 case REGISTER:
465 code_cmp_register(e2); 510 code_cmp_register(e2);
466 jcond(l1,cond); 511 jcond(l1,cond);
467 return; 512 return;
468 case CONST: 513 case CONST:
469 if((cond&&e2)||(!cond&&!e2)) jmp(l1); 514 if((cond&&e2)||(!cond&&!e2)) jmp(l1);
470 return; 515 return;
516 case DCONST:
517 if((dcadr(e2)!=0.0)^cond) jmp(l1);
518 return;
471 default: 519 default:
520 /* type ? */
472 if(err) { 521 if(err) {
473 error(-1); return; /* recursice g_expr/b_expr */ 522 error(-1); return; /* recursive g_expr/b_expr */
474 } 523 }
475 g_expr(e1); 524 g_expr(e1);
476 code_cmp_register(creg); 525 code_cmp_register(creg);
477 jcond(l1,cond); 526 jcond(l1,cond);
478 return; 527 return;
634 int 683 int
635 is_simple(int e1) 684 is_simple(int e1)
636 { 685 {
637 return ( 686 return (
638 e1==CONST || e1==FNAME || e1==LVAR || e1==REGISTER || 687 e1==CONST || e1==FNAME || e1==LVAR || e1==REGISTER ||
639 e1==GVAR || e1==RGVAR || e1==RLVAR || e1==CRLVAR || e1==CRGVAR 688 e1==GVAR || e1==RGVAR || e1==RLVAR || e1==CRLVAR || e1==CRGVAR ||
689 e1==DRLVAR || e1==FRLVAR
640 ); 690 );
641 } 691 }
642 692
643 int 693 int
644 is_same_type(int e1,int e2) 694 is_same_type(int e1,int e2)
645 { 695 {
646 int ce1=car(e1); 696 int ce1=car(e1);
647 int ce2=car(e2); 697 int ce2=car(e2);
648 return ( 698 return (
649 (ce1==LVAR && (ce2==RLVAR||ce2==CRLVAR)) 699 (ce1==LVAR && (ce2==RLVAR||ce2==CRLVAR||ce2==FRLVAR||ce2==DRLVAR))
650 || (ce2==LVAR && (ce1==RLVAR||ce1==CRLVAR)) 700 || (ce2==LVAR && (ce1==RLVAR||ce1==CRLVAR||ce1==FRLVAR||ce1==DRLVAR))
651 || (ce1==GVAR && (ce2==RGVAR||ce2==CRGVAR)) 701 || (ce1==GVAR && (ce2==RGVAR||ce2==CRGVAR||ce2==FRGVAR||ce2==DRGVAR))
652 || (ce2==GVAR && (ce1==RGVAR||ce1==CRGVAR)) 702 || (ce2==GVAR && (ce1==RGVAR||ce1==CRGVAR||ce1==FRGVAR||ce1==DRGVAR))
653 ); 703 );
654 } 704 }
655 705
656 int 706 int
657 is_memory(int e1) 707 is_memory(int e1)
658 { 708 {
659 int ce1=car(e1); 709 int ce1=car(e1);
660 return ( 710 return (
661 ce1==LVAR ||ce1==RLVAR||ce1==CRLVAR || 711 ce1==LVAR ||ce1==RLVAR||ce1==CRLVAR || ce1==DRLVAR ||
662 ce1==GVAR ||ce1==RGVAR||ce1==CRGVAR || 712 ce1==GVAR ||ce1==RGVAR||ce1==CRGVAR || ce1==DRGVAR ||
663 ce1==REGISTER 713 ce1==REGISTER
664 ); 714 );
665 } 715 }
666 716
667 void 717 void
790 emit_pop_free(e2); 840 emit_pop_free(e2);
791 regv[creg]=1; 841 regv[creg]=1;
792 return; 842 return;
793 } 843 }
794 844
845 void
846 dmachinop(int e1)
847 {
848 int e2,e3,op;
849
850 e2 = cadr(e1);
851 op = car(e1);
852 e3 = caddr(e1);
853 g_expr(e3);
854 emit_dpush();
855 g_expr(e2);
856 dtosop(car(e1),(e2=dpop_register()));
857 emit_dpop_free(e2);
858 regv[freg]=1;
859 return;
860 }
861
795 862
796 void 863 void
797 sassign(int e1) 864 sassign(int e1)
798 { 865 {
799 int e2,e3,e4,sz,xreg,det; 866 int e2,e3,e4,sz,xreg,det;
825 assign(int e1) 892 assign(int e1)
826 { 893 {
827 int e2,e3,e4,byte; 894 int e2,e3,e4,byte;
828 895
829 byte=(car(e1) == CASS); 896 byte=(car(e1) == CASS);
897 if(car(e1) == FASS) {
898 /* move float to creg */
899 }
830 /* e2=e4 */ 900 /* e2=e4 */
831 e2 = cadr(e1); 901 e2 = cadr(e1);
832 e3 = cadr(e2); 902 e3 = cadr(e2);
833 e4 = caddr(e1); 903 e4 = caddr(e1);
834 switch(car(e2)) { 904 switch(car(e2)) {
857 regv[creg]=1; 927 regv[creg]=1;
858 return; 928 return;
859 } 929 }
860 930
861 void 931 void
932 dassign(int e1)
933 {
934 int e2,e3,e4,byte;
935
936 /* e2=e4 */
937 e2 = cadr(e1);
938 e3 = cadr(e2);
939 e4 = caddr(e1);
940 switch(car(e2)) {
941 case GVAR: /* i=3 */
942 g_expr(e4);
943 code_dassign_gvar(e2,byte);
944 return;
945 case LVAR:
946 g_expr(e4);
947 code_dassign_lvar(lvar(cadr(e2)),byte);
948 return;
949 }
950 g_expr(e2);
951 emit_dpush();
952 g_expr(e4);
953 e2 = emit_dpop(0);
954 code_dassign(e2,byte);
955 emit_dpop_free(e2);
956 return;
957 }
958
959 void
862 assop(int e1) 960 assop(int e1)
863 { 961 {
864 int e2,e3,byte,op; 962 int e2,e3,byte,op;
865 963
866 /* e2 op= e3 */ 964 /* e2 op= e3 */
881 code_assop(op,byte); 979 code_assop(op,byte);
882 regv[creg]=1; 980 regv[creg]=1;
883 return; 981 return;
884 } 982 }
885 983
984 void
985 dassop(int e1)
986 {
987 }
988
989 void
990 fassop(int e1)
991 {
992 }
886 993
887 int 994 int
888 fwdlabel(void) 995 fwdlabel(void)
889 { 996 {
890 return labelno++; 997 return labelno++;