CbC/old/device: mc-code-mips.c comparison

comparison mc-code-mips.c @ 205:a50f90d0b63a

*** empty log message ***

author	kono
date	Thu, 15 Apr 2004 01:01:51 +0900
parents	4c614334f3d0
children	32f54ab63b35

comparison

equal deleted inserted replaced

-:4c614334f3d0
+:a50f90d0b63a
 #define CREG_REGISTER  MAX_TMP_REG
 #define FREG_FREGISTER (MAX_TMP_FREG+FREG_OFFSET)
 #define DREG_DREGISTER (2+DREG_OFFSET)
-int powerpc_regs[REAL_MAX_REGISTER+REAL_MAX_FREGISTER+REAL_MAX_DREGISTER];
+static int powerpc_regs[REAL_MAX_REGISTER+REAL_MAX_FREGISTER+REAL_MAX_DREGISTER];
-int powerpc_regv[REAL_MAX_REGISTER+REAL_MAX_FREGISTER+REAL_MAX_DREGISTER];
+static int dreg_pair0[REAL_MAX_DREGISTER] = {
-int dreg_pair0[REAL_MAX_DREGISTER] = {
 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30
 };
-int dreg_pair1[REAL_MAX_DREGISTER] = {
+static int dreg_pair1[REAL_MAX_DREGISTER] = {
 1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31
 };
-int *regv  = powerpc_regv;
+static int *regs  = powerpc_regs;
-int *regs  = powerpc_regs;
 static int max_reg_var, max_freg_var;
-static int cond_reg=-1,cond_freg=-1,cond_dreg=-1;
 static char *reg_name[] = {
 "$0","$1","$2","$3","$4","$5","$6","$7","$8","$9",
 "$10","$11","$12","$13","$14","$15","$16","$17","$18","$19",
 "$20","$21","$22","$23","$24","$25","$26","$27","$28","$29",
 }
 void
 code_lvar(int e2,int creg) {
 lvar_address(e2,creg);
-regv[creg]=1;
 }
 void
 code_init(void)
 {
 /* this is called once program call */
 }
 void
 gexpr_code_init(void){
-regv[creg]=0;
-regv[freg]=0;
 }
 void
 code_gexpr(int e){
 if (is_int_reg(creg) && creg!=ireg) error(-1);
 type = n->ty;
 if (scalar(type)) {
 if ((reg = get_input_register_var(reg_var,n,is_code0))) {
 n->sc = REGISTER;
 n->dsp = cadr(reg);
-regv[n->dsp]= 1;
 regs[n->dsp]= INPUT_REG;
 reg_var++;
 cadddr(args)=size_of_int; /* why we need this? */
 }
 } else if (type==FLOAT) {
 if ((reg = get_input_dregister_var(freg_var,n,is_code0,0))) {
 n->sc = FREGISTER;
 n->dsp = cadr(reg);
-regv[n->dsp]= 1;
 regs[n->dsp]= INPUT_REG;
 freg_var++;
 cadddr(args)=size(type); /* why we need this? */
 }
 } else if (type==DOUBLE) {
 if ((reg = get_input_dregister_var(reg_var,n,is_code0,1))) {
 n->sc = DREGISTER;
 n->dsp = cadr(reg);
-regv[n->dsp]= 1;
 regs[n->dsp]= INPUT_REG;
 reg_var+=2;
 cadddr(args)=size(type); /* why we need this? */
 }
 }
 #endif
 for(i=0;i<REG_VAR_BASE-REG_VAR_MIN;i++) {
 reg =REG_VAR_BASE-i;
 if (! regs[reg]) {       /* �Ȥ��Ƥ��ʤ��ʤ� */
 regs[reg]=USING_REG; /* ���Υ쥸������Ȥ����Ȥ������ */
-regv[reg]=0;
 	    if (i>max_reg_var) max_reg_var=i;
 	    return reg;
 }
 }
 /* �����Ƥ����꤬�ʤ��ʤ顢���顼 (���ä���ï���ȤäƤ��?) */
 }
 for(i=0;i<FREG_VAR_BASE-REG_VAR_MIN;i++) {
 reg =FREG_VAR_BASE-i+FREG_OFFSET;
 if (! regs[reg]) {       /* �Ȥ��Ƥ��ʤ��ʤ� */
 regs[reg]=USING_REG; /* ���Υ쥸������Ȥ����Ȥ������ */
-regv[reg]=0;
 	    if (i>max_freg_var) max_freg_var=i;
 	    return reg;
 }
 }
 /* �����Ƥ����꤬�ʤ��ʤ顢���顼 (���ä���ï���ȤäƤ��?) */
 return dreg_stack[--dreg_sp];
 }
 #endif
 #if LONGLONG_CODE
+int
+get_lregister() {
+return -1;
+}
 int
 get_lregister_var(NMTBL *n)
 {
 return list2(LVAR,new_lvar(size_of_double));
 }
 free_register(int i) {    /* ����ʤ��ʤä��쥸�������� */
 int i0,i1;
 if (i<0||MAX_FREGISTER+FREG_OFFSET+REAL_MAX_DREGISTER<i) error(-1);
 if (is_double_reg(i)) {
 	i0 = dreg_pair0[i-DREG_OFFSET];
-	regv[i0]=regs[i0]=0;
+	regs[i0]=0;
 	i1 = dreg_pair1[i-DREG_OFFSET];
-	regv[i1]=regs[i1]=0;
+	regs[i1]=0;
 }
-regv[i]=regs[i]=0;
+regs[i]=0;
 }
 int
 get_input_dregister_var(int i,NMTBL *n,int is_code,int d)
 {
 free_register_count(int d)
 {
 int i,count,fcount;
 fcount = count = 0;
 for(i=0;i<MAX_REGISTER;i++) {
-if (! regs[i] && ! regv[i]) count++;
+if (! regs[i]) count++;
 }
 for(i=0;i<MAX_FREGISTER;i++) {
-if (! regs[i+FREG_OFFSET] && ! regv[i+FREG_OFFSET]) fcount++;
+if (! regs[i+FREG_OFFSET]) fcount++;
 }
 printf("# free reg %d freg %d\n",count,fcount);
 return d?fcount:count;
 }
 void
 free_all_register(void)
 {
 int i;
-for(i=0;i<MAX_REGISTER;i++) { regs[i]=0; regv[i]=0; }
+for(i=0;i<MAX_REGISTER;i++) { regs[i]=0; }
-for(i=0;i<MAX_FREGISTER;i++) { regs[i+FREG_OFFSET]=0; regv[i+FREG_OFFSET]=0; }
+for(i=0;i<MAX_FREGISTER;i++) { regs[i+FREG_OFFSET]=0; }
-for(i=0;i<MAX_DREGISTER;i++) { regs[i+DREG_OFFSET]=0; regv[i+DREG_OFFSET]=0; }
+for(i=0;i<MAX_DREGISTER;i++) { regs[i+DREG_OFFSET]=0; }
 creg = get_register();
 #if FLOAT_CODE
 freg = get_dregister(0);
 dreg = DREG_DREGISTER;
 #endif
 is_float_reg(creg)?fregister_name(creg):
 is_double_reg(creg)?dregister_name0(creg):"bad",
 register_name(ireg),fregister_name(freg),dregister_name0(dreg));
 #if 0
 printf("\n# regs:");
-for(i=0;i<MAX_REGISTER;i++) { printf("%d",regv[i]); }
 printf(":");
 for(i=0;i<MAX_REGISTER;i++) { printf("%d",regs[i]); }
 printf("\n# freg:");
 for(i=0;i<MAX_FREGISTER;i++) { printf("%d",regs[i+FREG_OFFSET]); }
 for(i=reg_sp;i>=0;i--) {
 	free_register(freg_stack[--freg_sp]);
 }
 while(dreg_sp > 0) {
 	free_register(dreg_stack[--dreg_sp]);
 }
-if (cond_freg!=-1) {
-	if(car(cond_freg)==FREGISTER) free_register(cadr(cond_freg));
-	cond_freg=-1;
-}
-if (cond_dreg!=-1) {
-	if(car(cond_dreg)==DREGISTER) free_register(cadr(cond_dreg));
-	cond_dreg=-1;
-}
-if (cond_reg!=-1)  {
-	if(car(cond_reg)==REGISTER) free_register(cadr(cond_reg));
-	cond_reg=-1;
-}
 cmpreg = -1;
 text_mode();
 gexpr_code_init();
 register_usage("gexpr_init");
 }
 dreg_sp = 0;
 text_mode();
 }
 int
-register_var(int r) {
-return r;
-}
-int
 get_register_var(NMTBL *n)
 {
 int i;
 for(i=0;i<REG_VAR_BASE-REG_VAR_MIN;i++) {
 	if (! regs[REG_VAR_BASE-i]) {       /* �Ȥ��Ƥ��ʤ��ʤ� */
 	    /* ���Υ쥸������Ȥ����Ȥ������ */
 	    regs[REG_VAR_BASE-i]=USING_REG;
-	    regv[REG_VAR_BASE-i]=0;
 	    if (i>max_reg_var) max_reg_var=i;
 	    /* ���ξ���ɽ���ֹ���֤� */
 	    return list3(REGISTER,REG_VAR_BASE-i,(int)n);
 	}
 }
 if (d) {
 	for(i=0;i<DREG_VAR_BASE-DREG_VAR_MIN;i++) {
 	    if (! regs[j=(DREG_VAR_BASE-i+DREG_OFFSET)]) {       /* �Ȥ��Ƥ��ʤ��ʤ� */
 		if (regs[dreg_pair0[j]] || regs[dreg_pair1[j]]) continue;
 		regs[DREG_VAR_BASE-i+DREG_OFFSET]=USING_REG; /*���Υ쥸������Ȥ����Ȥ������*/
-		regv[DREG_VAR_BASE-i+DREG_OFFSET]=0;
 		regs[dreg_pair0[j]] = regs[dreg_pair1[j]] = USING_REG;
-		regv[dreg_pair0[j]] = regv[dreg_pair1[j]] = 0;
 		if (dreg_pair1[j]>max_reg_var) max_reg_var=dreg_pair1[j];
 		/* ���ξ���ɽ���ֹ���֤� */
 		return list3(DREGISTER,DREG_VAR_BASE-i+DREG_OFFSET,(int)n);
 	    }
 	}
 	return list2(LVAR,new_lvar(size_of_double));
 } else {
 	for(i=0;i<FREG_VAR_BASE-FREG_VAR_MIN;i++) {
 	    if (! regs[FREG_VAR_BASE-i+FREG_OFFSET]) {       /* �Ȥ��Ƥ��ʤ��ʤ� */
 		regs[FREG_VAR_BASE-i+FREG_OFFSET]=USING_REG; /*���Υ쥸������Ȥ����Ȥ������*/
-		regv[FREG_VAR_BASE-i+FREG_OFFSET]=0;
 		if (i>max_freg_var) max_freg_var=i;
 		/* ���ξ���ɽ���ֹ���֤� */
 		return list3(FREGISTER,FREG_VAR_BASE-i+FREG_OFFSET,(int)n);
 	    }
 	}
 int new_reg;
 if (reg_sp>MAX_MAX) error(-1);
 new_reg = get_register();
 reg_stack[reg_sp++] = creg;     /* push ���뤫���˥쥸������Ȥ� */
 ireg = creg = new_reg;
-regv[creg]=1;
 }
 int
 emit_pop(int type)
 {
 if (xreg<= -REG_LVAR_OFFSET) {
 	reg = get_register();
 code_rlvar(REG_LVAR_OFFSET+xreg,reg);
 	free_lvar(REG_LVAR_OFFSET+xreg);
 	xreg = reg;
-	regv[creg]=1;
 }
 return xreg;
 }
 void
 }
 void
 code_gvar(int e1,int creg) {
 printf("\tla %s,%s\n",register_name(creg),((NMTBL*)cadr(e1))->nm);
-regv[creg]=1;
 }
 void
 code_rgvar(int e1,int creg) {
 printf("\tlw %s,%s\n",register_name(creg),((NMTBL*)cadr(e1))->nm);
-regv[creg]=1;
 }
 char *cload(int sign,int sz) { return sz==1?(sign?"lbu":"lb"):(sz==size_of_short?(sign?"lhu":"lh"):"lw");}
 char *cstore(int sz) { return sz==1?"sb":(sz==size_of_short)?"sh":"sw";}
 void
 code_crgvar(int e1,int creg,int sign,int sz){
 printf("\t%s %s,%s\n",cload(sign,sz),register_name(creg),((NMTBL*)cadr(e1))->nm);
-regv[creg]=1;
 }
 void
 code_register(int e2,int creg) {
 if (creg!=e2)
 printf("\tmove %s,%s\n",register_name(creg),register_name(e2));
-regv[creg]=1;
 }
 void
 code_rlvar(int e2,int reg) {
 printf("\tlw %s,",register_name(reg));
 lvar(e2);
-regv[creg]=1;
 }
 void
 code_crlvar(int e2,int reg,int sign,int sz) {
 printf("\t%s %s,",cload(sign,sz),register_name(reg));
 lvar(e2);
-regv[reg]=1;
 }
 void
 code_fname(NMTBL *n,int creg) {
 printf("\tla %s,%s\n",register_name(creg),n->nm);
-regv[creg]=1;
 }
 void
 code_const(int e2,int creg) {
 printf("\tli %s,%d\n",register_name(creg),e2);
-regv[creg]=1;
 }
 void
 code_neg(int creg) {
 if (car(e2)==REGISTER) {
 printf("\taddu %s,%s,%d\n",
 register_name(cadr(e2)),register_name(cadr(e2)), dir);
 if (cadr(reg)!=e2)
 printf("\tmove %s,%s\n",register_name(cadr(reg)),register_name(e2));
-regv[reg]=1;
 return;
 }
 g_expr(e2);
 xrn = register_name(creg);
 dreg=get_register(); if (!dreg) error(-1);
 drn = register_name(dreg);
 printf("\t%s %s,0(%s)\n",cload(sign,sz),drn,xrn);
 printf("\taddu %s,%s,%d\n",drn,drn,dir);
 printf("\t%s %s,0(%s)\n",cstore(sz),drn,xrn);
 i=creg;creg=dreg;dreg=i;
-regv[creg]=1; ireg=creg;
+ireg=creg;
 free_register(dreg);
 }
 void
 int dreg,nreg,i;
 if (car(e2)==REGISTER) {
 printf("\tmove %s,%s\n",register_name(reg),register_name(cadr(e2)));
 printf("\taddu %s,%s,%d\n",
 register_name(cadr(e2)),register_name(cadr(e2)),dir);
-regv[reg]=1;
 return;
 }
 g_expr(e2);
 crn = register_name(creg);
 dreg=get_register(); if (!dreg) error(-1);
 printf("\taddu %s,%s,%d\n",nrn,xrn,dir);
 printf("\t%s %s,0(%s)\n",cstore(sz),nrn,crn);
 i=creg;creg=dreg;dreg=i;
 free_register(nreg);
 free_register(dreg);
-regv[creg]=1; ireg=creg;
+ireg=creg;
 }
 void
 void
 code_cmp_crgvar(int e1,int sz) {
 if (cmpreg==-1) cmpreg = get_register();
 code_crgvar(cadr(e1),cmpreg,1,sz);
-regv[cmpreg]=1;
 }
 void
 code_cmp_crlvar(int e2,int sz) {
 if (cmpreg==-1) cmpreg = get_register();
 code_crlvar(e2,cmpreg,1,sz);
-regv[cmpreg]=1;
 }
 void
 code_cmp_rgvar(int e1) {
 if (cmpreg==-1) cmpreg = get_register();
 code_rgvar(e1,cmpreg);
-regv[cmpreg]=1;
 }
 void
 code_cmp_rlvar(int e2) {
 if (cmpreg==-1) cmpreg = get_register();
 code_rlvar(e2,cmpreg);
-regv[cmpreg]=1;
 }
 void
 code_cmp_register(int e2) {
 cmpreg = e2;
 /* prevent cmpreg freeing */
-regv[cmpreg]=2;
 }
 void
 ascii(char *s)
 if(creg!=to) {
 free_register(creg); creg=to;
 }
 }
 free_register(dreg);
-regv[from]=regv[to]=regv[dreg]=0;
-regv[creg]=1;
 }
 int
 struct_push(int e4,int t,int arg)
 {
 	    free_register(cadr(arg));
 	else if (car(arg)==LVAR&&cadr(arg)<0) free_lvar(cadr(arg));
 }
 if (ret_type==DOUBLE) {
 	set_dreg(RET_DREGISTER,0);
-regv[dreg]=1; regv[creg]=0;
 } else if (ret_type==FLOAT) {
 	set_freg(RET_FREGISTER,0);
-regv[freg]=1; regv[creg]=0;
 } else if (ret_type==VOID) {
-regv[freg]=0; regv[creg]=0;
 } else {
 	set_creg(RET_REGISTER,0);
-regv[freg]=0; regv[creg]=1;
 }
 return ret_type;
 }
 void
 if (d) {
 printf("\tlw %s,%d(%s)\n",
 dregister_name0(dreg),offset,crn);
 printf("\tlw %s,%d(%s)\n",
 dregister_name1(dreg),offset+size_of_int,crn);
-regv[creg]=0; regv[dreg]=1;
 	creg = dreg;
 return DOUBLE;
 } else {
 printf("\tl.s %s,%d(%s)\n", fregister_name(freg),offset,crn);
-regv[creg]=0; regv[freg]=1;
 	creg = freg;
 return FLOAT;
 }
 }
 #endif
 } else if (byte==size_of_short) {
 printf("\tsh %s,0(%s)\n",crn,drn);
 } else {
 printf("\tsw %s,0(%s)\n",crn,drn);
 }
-regv[creg]=1;
 }
 void
 code_register_assop(int e2,int op,int byte) {
 creg = reg = e2;
 tosop(op,xreg);
 creg = xreg;
 if (creg!=reg)
 printf("\tmove %s,%s\n",register_name(creg),register_name(reg));
-regv[creg]=1;
 }
 void
 code_assop(int op,int byte,int sign) {
 char *xrn,*crn,*drn;
 int xreg;
 int edx = get_register(); if(!edx) error(-1);
 xrn = register_name(xreg = emit_pop(0));       /* pop e3 value */
-regv[xreg]=regs[xreg]=1;
+regs[xreg]=1;
 printf("# assop\n\tmr %s,%s\n",register_name(edx),register_name(creg));
-regv[edx]=1;
 ld_indexx(byte,0,edx,sign);
 tosop(op,xreg);
 crn = register_name(creg);
 drn = register_name(edx);
 printf("\t%s %s,0(%s)\n",cstore(byte),crn,drn);
 free_register(edx);
 emit_pop_free(xreg);
-regv[creg]=1;
 }
 void
 tosop(int op,int oreg)
 	error(-1);
 } else if (oreg<= -REG_LVAR_OFFSET) {
 	dx = get_register(); if (dx<0) error(-1);
 code_rlvar(oreg+REG_LVAR_OFFSET,dx);
 	oreg = dx;
-regv[oreg]=1;
 }
 switch(op) {
 case LSHIFT:
 case ULSHIFT:
 	shift("sll",oreg);
-	regv[creg]=1;
 	return;
 case RSHIFT:
 	shift("srl",oreg);
-	regv[creg]=1;
 	return;
 case URSHIFT:
 	shift("sra",oreg);
-	regv[creg]=1;
 	return;
 }
 orn = register_name(oreg);
 crn = register_name(creg);
 switch(op) {
 break;
 default:
 	error(-1);
 }
 if(oreg!=creg) free_register(oreg);
-regv[creg]=1;
 }
 void
 shift(char *op, int reg)
 /* used in dosiwtch() */
 if(chk) return;
 creg = use_int(creg);
 printf("\tli %s,%d\n",register_name(creg),e);
 cmpreg = csreg;
-regv[cmpreg]=2; /* prevent from freeing */
 }
 void
 code_opening(char *s)
 {
 if (cmpreg==-1) error(-1);
 printf("\tb%s %s,%s,L_%d\n",
 cond?"ne":"eq",
 	register_name(creg),register_name(cmpreg),
 	l);
-if (regv[cmpreg]==1) {
+free_register(cmpreg); cmpreg = -1;
-free_register(cmpreg); cmpreg = -1;
-}
-regv[creg]=0;
 }
 void
 jmp(int l)
 {
 	} else {
 	    if (!is_float_reg(e2)) error(-1);
 	    printf("\tfmr %s,%s\n",fregister_name(freg),fregister_name(e2));
 	}
 }
-regv[freg]=1;
 }
 void code_dassign_gvar(int e2,int freg,int d)
 {
 NMTBL *n = (NMTBL*)cadr(e2);
 printf("\tsw %s,0(%s)\n",dregister_name0(freg),n->nm);
 printf("\tsw %s,0(%s)\n",dregister_name1(freg),n->nm);
 } else {
 printf("\ts.s %s,0(%s)\n",fregister_name(freg),n->nm);
 }
-regv[freg]=1;
 }
 void code_dassign_lvar(int e2,int freg,int d)
 {
 if (d) {
 e2 += size_of_double/2;
 } else {
 printf("\ts.s %s,",fregister_name(freg));
 }
 lvar(e2);
-regv[freg]=1;
 }
 void code_dassign(int e2,int freg,int d)
 {
 if (d) {
 printf("\tsw %s,0(%s)\n",dregister_name0(freg),register_name(e2));
 printf("\tsw %s,4(%s)\n",dregister_name1(freg),register_name(e2));
 } else {
 printf("\ts.s %s,0(%s)\n",fregister_name(freg),register_name(e2));
 }
-regv[freg]=1;
 }
 void
 code_dassign_dregister(int e2,int d,int freg) {
 /* ����äƤ���code_dregister ��Ʊ��? */
 printf("\tli.d %s,%g\n",dregister_name0(freg),value);
 } else {
 frn = fregister_name(freg);
 printf("\tli.s %s,%g\n",frn,value);
 }
-regv[freg]=1;
 }
 void code_dneg(int freg,int d)
 {
 {
 code_save_stacks();
 set_dreg(RET_DREGISTER,1);
 code_dpfunc("dptoli");
 set_creg(RET_REGISTER,0);
-regv[freg]=0;
-regv[creg]=1;
 }
 void code_i2d(int creg0)
 {
 code_save_stacks();
 set_creg(RET_REGISTER,1);
 code_dpfunc("litodp");
 set_dreg(RET_DREGISTER,0);
-regv[freg]=1;
-regv[creg]=0;
 }
 void code_d2u(int freg0)
 {
 code_save_stacks();
 set_dreg(RET_DREGISTER,1);
 code_dpfunc("dptoul");
 set_creg(RET_REGISTER,0);
-regv[freg]=1;
 }
 void code_u2d(int creg0)
 {
 code_save_stacks();
 set_creg(RET_REGISTER,1);
 code_dpfunc("ultodp");
 set_dreg(RET_DREGISTER,0);
-regv[freg]=1;
 }
 void code_d2f(int freg) {
 code_save_stacks();
 set_dreg(RET_DREGISTER,1);
 printf("\tlw %s,%s\n",dregister_name0(freg),name);
 printf("\tlw %s,%s\n",dregister_name1(freg),name);
 } else {
 printf("\tl.s %s,%s\n",fregister_name(freg),name);
 }
-regv[freg]=1;
 }
 void code_drlvar(int e2,int d,int freg)
 {
 printf("\tlw %s,",dregister_name0(freg)); lvar(e2);
 printf("\tlw %s,",dregister_name1(freg)); lvar(e2+size_of_double/2);
 } else {
 printf("\tl.s %s,",fregister_name(freg)); lvar(e2);
 }
-regv[freg]=1;
 }
 void code_cmp_drgvar(int e2,int d)
 {
 char *frn;
 if (d) {
 	code_save_stacks();
 	set_dreg(RET_DREGISTER,1);
 code_drgvar(e2,d,RET_DREGISTER+2);
 	code_dpfunc("dcmp");
-	regv[dreg]=0;
 } else {
 	frn=fregister_name(freg);
 g=get_dregister(d);
 code_drgvar(e2,d,g);
 printf("\tfc.eq.s %s,%s\n",frn,fregister_name(g));
 	free_register(g);
-	regv[freg]=0;
 }
 }
 void code_cmp_drlvar(int e2,int d)
 {
 if (d) {
 	code_save_stacks();
 	set_dreg(RET_DREGISTER,1);
 code_drgvar(e2,d,RET_DREGISTER+2);
 	code_dpfunc("dcmp");
-	regv[dreg]=0;
 } else {
 g=get_dregister(d);
 code_drlvar(e2,d,g);
 printf("\tc.eq.s %s,%s\n",frn,fregister_name(g));
 	free_register(g);
-	regv[freg]=0;
 }
 }
 static void
 dtosop0(char *opn,int e1,int d,int cmp)
 }
 void dtosop(int op,int e1)
 {
-regv[freg]=1;
 switch(op) {
 case FADD: dtosop0("fadd",e1,0,0); return;
 case DADD: dtosop0("dpadd",e1,1,0); return;
 case FSUB: dtosop0("fadd",e1,0,0); return;
 case DSUB: dtosop0("dpsub",e1,1,0); return;
 dtosop(op,xreg);
 printf("\ts.s %s,0(%s)\n",frn,crn);
 emit_dpop_free(xreg,d);
 	creg = freg;
 }
-regv[creg]=1;
 }
 void
 code_dpreinc(int e1,int e2,int d,int reg) {
 printf("\tfsub %s,%s,%s\n",frn,frn,grn);
 printf("\ts.s %s,0(%s)\n",frn,crn);
 free_register(g);
 	creg = freg;
 }
-regv[creg]=1;
 }
 void
 code_dpostinc(int e1,int e2,int d,int reg) {
 char *frn;
 printf("\tfsub %s,%s,%s\n",frn,frn,grn);
 printf("\ts.s %s,0(%s)\n",grn,crn);
 free_register(g);
 	creg = freg;
 }
-regv[creg]=1;
 }
 void
 drexpr(int e1, int e2,int l1, int op)
 	xreg=pop_fregister();
 if (xreg<= -REG_LVAR_OFFSET) {
 	reg = get_dregister(d);
 code_drlvar(REG_LVAR_OFFSET+xreg,d,reg);
 	free_lvar(REG_LVAR_OFFSET+xreg);
-	regv[reg]=1; xreg=reg;
+	xreg=reg;
 }
 return xreg;
 }
 void emit_dpop_free(int e1,int d)
 if (freg_sp>MAX_MAX) error(-1);
 new_reg = get_dregister(d);
 if (d) {
 	dreg_stack[dreg_sp++] = dreg;     /* push ���뤫���˥쥸������Ȥ� */
 	creg = dreg = new_reg;
-	regv[dreg]=1;
 } else {
 	freg_stack[freg_sp++] = freg;     /* push ���뤫���˥쥸������Ȥ� */
 	creg = freg = new_reg;
-	regv[freg]=1;
 }
 }
 #endif

Mercurial > hg > CbC > old > device

comparison mc-code-mips.c @ 205:a50f90d0b63a