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

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

*** empty log message ***

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

comparison

equal deleted inserted replaced

-:4c614334f3d0
+:a50f90d0b63a
 static int lvar_offset_label;
 static int reg_save;
 static int freg_save;
-static int freg,ireg;
+static int freg,ireg,lreg;
 int size_of_int = 4;
 int size_of_short = 2;
 int size_of_float = 4;
 int size_of_double = 8;
 int size_of_longlong = 8;
 int endian = 1;
-int  reg_sp;   /* REGister Stack-Pointer */
+static int  reg_sp;   /* REGister Stack-Pointer */
-int reg_stack[MAX_MAX];  /* 実際のレジスタの領域 */
+static int reg_stack[MAX_MAX];  /* 実際のレジスタの領域 */
 /* floating point registers */
-int  freg_sp;  /* floating point REGister Stack-Pointer */
+static int  freg_sp;  /* floating point REGister Stack-Pointer */
-int freg_stack[MAX_MAX]; /* 実際のレジスタの領域 */
+static int freg_stack[MAX_MAX]; /* 実際のレジスタの領域 */
 #define REG_fp   1
 #define REG_sp   30
 #define REG_VAR_BASE 29
 #define REG_VAR_MIN  18
 #define MIN_TMP_FREG 1
 #define MAX_TMP_FREG 14
 #define RET_REGISTER 3
 #define RET_FREGISTER (1+FREG_OFFSET)
+#define RET_LREGISTER_L 4    /* low word */
+#define RET_LREGISTER_H 3    /* high word */
 int MAX_REGISTER=30;             /* PowerPCのレジスタを10個まで使う*/
 int MAX_FREGISTER=31;
 #define  REAL_MAX_REGISTER 32    /* PowerPCのレジスタが32ということ*/
 #define  REAL_MAX_FREGISTER 32    /* PowerPCのレジスタが32ということ*/
 int MAX_CODE_INPUT_FREGISTER_VAR = 14-MIN_TMP_FREG;
 #define CREG_REGISTER  MAX_TMP_REG
 #define FREG_FREGISTER (MAX_TMP_FREG+FREG_OFFSET)
-int powerpc_regs[REAL_MAX_REGISTER+REAL_MAX_FREGISTER];
+static int powerpc_regs[REAL_MAX_REGISTER+REAL_MAX_FREGISTER];
-int powerpc_regv[REAL_MAX_REGISTER+REAL_MAX_FREGISTER];
+static int *regs  = powerpc_regs;
-int *regv  = powerpc_regv;
-int *regs  = powerpc_regs;
 static int max_reg_var, max_freg_var;
-static int cond_reg=-1,cond_freg=-1;
 static char *reg_name[] = {
 "r0","r1","r2","r3","r4","r5","r6","r7","r8","r9",
 "r10","r11","r12","r13","r14","r15","r16","r17","r18","r19",
 "r20","r21","r22","r23","r24","r25","r26","r27","r28","r29",
 "f10","f11","f12","f13","f14","f15","f16","f17","f18","f19",
 "f20","f21","f22","f23","f24","f25","f26","f27","f28","f29",
 "f30","f31"
 };
-#define register_name(i)  reg_name[i]
+#define register_name(i)  reg_name[cadr(i)]
-#define fregister_name(i) reg_name[i]
+#define fregister_name(i) reg_name[cadr(i)]
+#define lregister_name_low(i) reg_name[cadr(i)]
-#define is_int_reg(i)  (0<=i&&i<REAL_MAX_REGISTER)
+#define lregister_name_high(i) reg_name[caddr(i)]
-#define is_float_reg(i)  (REAL_MAX_REGISTER<=i&&i<REAL_MAX_FREGISTER+REAL_MAX_REGISTER)
+#define is_int_reg_0(i)  (0<=i&&i<REAL_MAX_REGISTER)
+#define is_float_reg_0(i)  (REAL_MAX_REGISTER<=i&&i<REAL_MAX_FREGISTER+REAL_MAX_REGISTER)
+#define is_int_reg(i)  (car(i)==REGISTER)
+#define is_float_reg(i)  (car(i)==DREGISTER)
+#define is_longlong_reg(i)  (car(i)==LREGISTER)
 int use_int(int i) {
-if (!is_int_reg(i)) i = ireg;
+if (lreg) {
-if (!regs[i]) regs[i]=1;
+	free_register(lreg); lreg = 0;
+}
+if (!is_int_reg(i)) {
+	if (!ireg) ireg = get_register();
+	i = lreg;
+}
 return i;
 }
 int use_float(int i) {
 if (!is_float_reg(i)) i = freg;
 if (!regs[i]) regs[i]=1;
 return i;
 }
 int use_longlong(int i) {
+if (ireg) {
+	free_register(ireg); ireg = 0;
+}
+if (!is_longlong_reg(i)) {
+	if (!lreg) lreg = get_lregister();
+	i = lreg;
+}
 return i;
 }
 #if FLOAT_CODE
 void
 code_lvar(int e2,int creg) {
 lvar_intro(e2);
 printf("\tla %s,",register_name(creg));
 lvar(e2);
-regv[creg]=1;
 }
 void
 code_init(void)
 {
 if (is_int_reg(creg)) {
 	dm = get_register();
 	new_reg = get_register();
 	old_reg = creg;
 	ireg = creg = new_reg;
+	free_register(old_reg);
+	free_register(dm);
 } else if (is_float_reg(creg)) {
 	dm = get_dregister(1);
 	new_reg = get_dregister(1);
 	old_reg = creg;
 	freg = creg = new_reg;
-}
+	free_register(old_reg);
-free_register(old_reg);
+	free_register(dm);
-free_register(dm);
+}
 #endif
-regv[creg]=0;
-regv[freg]=0;
 }
 void
 code_gexpr(int e){
 if (is_int_reg(creg) && creg!=ireg) error(-1);
 n = (NMTBL*)caddr(args);
 type = n->ty;
 if (scalar(type)) {
 if ((reg = get_input_register_var(reg_var,n,is_code0))) {
 n->sc = REGISTER;
-n->dsp = cadr(reg);
+n->dsp = reg;
-regv[n->dsp]= 1;
+regs[cadr(n->dsp)]= INPUT_REG;
-regs[n->dsp]= INPUT_REG;
 reg_var++;
-cadddr(args)=size_of_int; /* why we need this? */
+cadddr(args)=size_of_int;
 }
 } else if (type==FLOAT) {
 if ((reg = get_input_dregister_var(freg_var,n,is_code0,0))) {
 n->sc = DREGISTER;
-n->dsp = cadr(reg);
+n->dsp = reg;
-regv[n->dsp]= 1;
+regs[cadr(n->dsp)]= INPUT_REG;
-regs[n->dsp]= INPUT_REG;
 freg_var++;
-cadddr(args)=size(type); /* why we need this? */
+cadddr(args)=size(type);
 }
 } else if (type==DOUBLE) {
 if ((reg = get_input_dregister_var(freg_var,n,is_code0,1))) {
 n->sc = DREGISTER;
-n->dsp = cadr(reg);
+n->dsp = reg;
-regv[n->dsp]= 1;
+regs[cadr(n->dsp)]= INPUT_REG;
-regs[n->dsp]= INPUT_REG;
 freg_var++;
-cadddr(args)=size(type); /* why we need this? */
+cadddr(args)=size(type);
+}
+} else if (type==LONGLONG||type==ULONGLONG) {
+if ((reg = get_input_lregister_var(reg_var,n,is_code0))) {
+n->sc = LREGISTER;
+n->dsp = reg;
+regs[cadr(n->dsp)]= INPUT_REG;
+regs[caddr(n->dsp)]= INPUT_REG;
+reg_var+=2;
+cadddr(args)=size(type);
 }
 }
 args = cadr(args);
 }
 if (is_function(fnptr))
 {    /* 使われていないレジスタを調べる */
 int i,reg;
 for(i=MAX_TMP_REG;i>MIN_TMP_REG;i--) {
 	if (regs[i]) continue;  /* 使われている */
 	regs[i]=USING_REG;      /* そのレジスタを使うことを宣言し */
-	return i;               /* その場所を表す番号を返す */
+	return glist2(REGISTER,i);   /* その場所を表す番号を返す */
 }
 /* PTR_CACHE をつぶす */
 for(i=MAX_TMP_REG;i>MIN_TMP_REG;i--) {
 	if (regs[i]==PTRC_REG) {
 	    clear_ptr_cache_reg(i);
 	} else
 	    continue;
 	regs[i]=USING_REG;      /* そのレジスタを使うことを宣言し */
-	return i;               /* その場所を表す番号を返す */
+	return glist2(REGISTER,i);   /* その場所を表す番号を返す */
 }
 /* search register stack */
 for(i=0;i<reg_sp;i++) {
 	if ((reg=reg_stack[i])>=0) {
 code_assign_lvar(
 }
 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;
+	    return glist2(REGISTER,reg);   /* その場所を表す番号を返す */
 }
 }
 /* 空いている場所がないなら、エラー (いったい誰が使ってるの?) */
 error(HPERR); return creg;
 }
 {    /* 使われていないレジスタを調べる */
 int i,reg;
 for(i=MAX_TMP_FREG+FREG_OFFSET;i>MIN_TMP_FREG+FREG_OFFSET;i--) {
 	if (regs[i]) continue;    /* 使われている */
 	regs[i]=USING_REG;      /* そのレジスタを使うことを宣言し */
-	return i;               /* その場所を表す番号を返す */
+	return glist2(DREGISTER,i);   /* その場所を表す番号を返す */
 }
 /* search register stack */
 for(i=0;i<freg_sp;i++) {
 	if ((reg=freg_stack[i])>=0) {
 code_dassign_lvar(
 }
 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 glist2(DREGISTER,reg);   /* その場所を表す番号を返す */
 }
 }
 /* 空いている場所がないなら、エラー (いったい誰が使ってるの?) */
 error(REG_ERR); return freg;
 }
 }
 #endif
 #if LONGLONG_CODE
 int
+get_lregister()
+{
+int h,l,h0,l0;
+h = get_register(); h0 = cadr(h);
+l = get_register(); l0 = cadr(l);
+free_glist2(h); free_glist2(l);
+return glist3(LREGISTER,l0,h0);
+}
+int
 get_lregister_var(NMTBL *n)
 {
 return list2(LVAR,new_lvar(size_of_longlong));
 }
 #endif
 }
 void
 free_register(int i) {    /* いらなくなったレジスタを開放 */
 if (i<0||MAX_FREGISTER+FREG_OFFSET<i) error(-1);
-regv[i]=regs[i]=0;
+regs[i]=0;
 }
 int
 get_input_dregister_var(int i,NMTBL *n,int is_code,int d)
 {
 	i = FREG_VAR_BASE-i+FREG_OFFSET;
 } else {
 	if (i<0||i>=MAX_INPUT_DREGISTER_VAR) return 0;
 	i = i+MIN_TMP_FREG+FREG_OFFSET;
 }
-return list3(DREGISTER,i,(int)n);
+return list3(DREGISTER,glist2(DREGISTER,i),(int)n);
 }
 int
-get_input_register_var(int i,NMTBL *n,int is_code)
+get_input_lregister_var(int i,NMTBL *n,int is_code)
 {
 if (is_code) {
 	if(!(i<REG_VAR_BASE-REG_VAR_MIN)) return 0;
 	i = REG_VAR_BASE-i;
 } else {
 	if (i<0||i>=MAX_INPUT_REGISTER_VAR) return 0;
 	i = i+MIN_TMP_REG;
 }
-return list3(REGISTER,i,(int)n);
+return list3(LREGISTER,glist3(LREGISTER,i+1,i),(int)n);
+}
+int
+get_input_register_var(int i,NMTBL *n,int is_code)
+{
+if (is_code) {
+	if(!(i<REG_VAR_BASE-REG_VAR_MIN)) return 0;
+	i = REG_VAR_BASE-i;
+} else {
+	if (i<0||i>=MAX_INPUT_REGISTER_VAR) return 0;
+	i = i+MIN_TMP_REG;
+}
+return list3(REGISTER,glist2(REGISTER,i),(int)n);
 }
 /* double register case? */
 int
 	i = REG_VAR_BASE-i;
 } else {
 	if (i<0||i>=MAX_INPUT_REGISTER_VAR+1) return 0;
 	i = i+MIN_TMP_REG;
 }
-return list3(REGISTER,i,(int)n);
+return list3(REGISTER,glist2(REGISTER,i),(int)n);
 }
 int
 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;
 }
-int
+#if 0
+static int
 register_full(void)
 {
 int i;
 for(i=0;i<MAX_REGISTER;i++) {
 	if (! regs[i]) {
 	    return 0;
 	}
 }
 return 1;
 }
+#endif
 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; }
 #if FLOAT_CODE
 freg = get_dregister(1);
 set_freg(FREG_FREGISTER,0);
 #endif
 ireg = creg = get_register();
 if (!lsrc) return;
 printf("# %d: %s:",lineno,s);
 printf(" creg=%s fgreg=%s",register_name(creg),fregister_name(freg));
 #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--) {
 	if(reg_stack[i]>=0)
 	free_register(reg_stack[--reg_sp]);
 }
 while(freg_sp > 0) {
 	free_register(freg_stack[--freg_sp]);
 }
-if (cond_freg!=-1) {
-	if(car(cond_freg)==DREGISTER) free_register(cadr(cond_freg));
-	else if(car(cond_freg)==FREGISTER) free_register(cadr(cond_freg));
-	cond_freg=-1;
-}
-if (cond_reg!=-1)  {
-	if(car(cond_reg)==REGISTER) free_register(cadr(cond_reg));
-	cond_reg=-1;
-}
 text_mode();
 gexpr_code_init();
 register_usage("gexpr_init");
 }
 reg_sp = 0;
 freg_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);
 	}
 }
 {
 int i;
 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(DREGISTER,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;
 }
 int
 code_gvar(int e1,int creg) {
 int r;
 r = get_ptr_cache((NMTBL*)cadr(e1));
 if(r!=creg)
 	printf("\tmr %s,%s\n",register_name(creg),register_name(r));
-regv[creg]=1;
 return;
 }
 void
 code_rgvar(int e1,int creg) {
 if (!is_int_reg(creg)) error(-1);
 printf("\tlwz %s,0(%s)\n",register_name(creg),
 register_name(get_ptr_cache((NMTBL*)cadr(e1))));
-regv[creg]=1;
 }
 void
 code_crgvar(int e1,int creg,int sign,int sz){
 char *crn = register_name(creg);
 printf("\t%s %s,0(%s)\n",cload(sz),crn,
 register_name(get_ptr_cache((NMTBL*)cadr(e1))));
 if (sign)
 	printf("\t%s %s,%s\n",cext(sz),crn,crn);
-regv[creg]=1;
 }
 void
 code_register(int e2,int creg) {
 if (creg!=e2)
 	printf("\tmr %s,%s\n",register_name(creg),register_name(e2));
-regv[creg]=1;
 }
 void
 code_rlvar(int e2,int reg) {
 lvar_intro(e2);
 if (!is_int_reg(reg)) error(-1);
 printf("\tlwz %s,",register_name(reg));
 lvar(e2);
-regv[creg]=1;
 }
 void
 code_crlvar(int e2,int reg,int sign,int sz) {
 lvar_intro(e2);
 printf("\t%s %s,",cload(sz),register_name(reg));
 lvar(e2);
 if (sign)
 	printf("\t%s %s,%s\n",cext(sz),register_name(reg),register_name(reg));
-regv[creg]=1;
 }
 code_fname(NMTBL *n,int creg) {
 int r;
 r = get_ptr_cache(n);
 if(r!=creg)
 	printf("\tmr %s,%s\n",register_name(creg),register_name(r));
-regv[creg]=1;
 return;
 }
 void
 	printf("\tli %s,%d\n",crn,e2);
 else {
 	printf("\tlis %s,ha16(%d)\n",crn,e2);
 	printf("\taddi %s,%s,lo16(%d)\n",crn,crn,e2);
 }
-regv[creg]=1;
 }
 void
 code_neg(int creg) {
 if (car(e2)==REGISTER) {
 	printf("\taddi %s,%s,%d\n",
 		register_name(cadr(e2)),register_name(cadr(e2)), dir);
 	if (cadr(reg)!=e2)
 	    printf("\tmr %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);
 if (use && sign && sz!=size_of_int)
 	printf("\t%s %s,%s\n",cext(sz),drn,drn);
 printf("\taddi %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("\tmr %s,%s\n",register_name(reg),register_name(cadr(e2)));
 	printf("\taddi %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("\taddi %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
 code_return(int creg) {
 int r;
 char *crn = register_name(creg);
 r = get_ptr_cache((NMTBL*)cadr(e1));
 printf("\t%s %s,0(%s)\n",cload(sz),crn,register_name(r));
 printf("\tcmpwi cr0,%s,0\n",crn);
-regv[creg]=0;
 }
 void
 code_cmp_crlvar(int e2,int sz) {
 char *crn = register_name(creg);
 lvar_intro(e2);
 printf("\t%s %s,",cload(sz),crn);
 lvar(e2);
 code_cmp_register(creg);
-regv[creg]=0;
 }
 void
 code_cmp_rgvar(int e1) {
 char *crn = register_name(creg);
 if (!is_int_reg(creg)) error(-1);
 r = get_ptr_cache((NMTBL*)cadr(e1));
 printf("\tlwz %s,0(%s)\n",crn,register_name(r));
 code_cmp_register(creg);
-regv[creg]=0;
 }
 void
 code_cmp_rlvar(int e2) {
 char *crn = register_name(creg);
 lvar_intro(e2);
 printf("\tlwz %s,",crn);
 lvar(e2);
 code_cmp_register(creg);
-regv[creg]=0;
 }
 void
 code_cmp_register(int e2) {
 	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||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
 char *crn;
 g_expr(e1);
 crn=register_name(creg);
 printf("\t%s %s,%d(%s)\n",fload(d),
 	fregister_name(freg),offset,crn);
-regv[creg]=0; regv[freg]=1;
 creg = freg;
 return DOUBLE;
 }
 #endif
 } else if (byte==size_of_short) {
 	printf("\tsth %s,0(%s)\n",crn,drn);
 } else {
 	printf("\tstw %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("\tmr %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;
 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);
 if (byte==1) {
 } else {
 	printf("\tstw %s,0(%s)\n",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("slw",oreg);
-	regv[creg]=1;
 	return;
 case RSHIFT:
 	shift("sraw",oreg);
-	regv[creg]=1;
 	return;
 case URSHIFT:
 	shift("srw",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;
 }
 int
 code_const_op_p(int op,int v)
 {
 {
 if (freg!=e2) {
 	if (is_int_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)
 {
 int r;
 r = get_ptr_cache((NMTBL*)cadr(e2));
 if (!is_float_reg(freg)) error(-1);
 printf("\t%s %s,0(%s)\n",fstore(d),fregister_name(freg),register_name(r));
-regv[freg]=1;
 }
 void code_dassign_lvar(int e2,int freg,int d)
 {
 lvar_intro(e2);
 if (!is_float_reg(freg)) error(-1);
 printf("\t%s %s,",fstore(d),fregister_name(freg));
 lvar(e2);
-regv[freg]=1;
 }
 void code_dassign(int e2,int freg,int d)
 {
 if (!is_float_reg(freg)) error(-1);
 printf("\t%s %s,0(%s)\n",fstore(d),fregister_name(freg),register_name(e2));
-regv[freg]=1;
 }
 void
 code_dassign_dregister(int e2,int d,int freg) {
 if (e2!=freg) {
 	printf("\tlfd %s,0(%s)\n",frn,rrn);
 } else {
 	printf("\tlfs %s,0(%s)\n",frn,rrn);
 }
 free_register(r);
-regv[freg]=1;
 }
 void code_dneg(int freg,int d)
 {
 printf("\tfctiwz  %s,%s\n",frn,frn);
 lvar_intro(e2);
 printf("\tstfd  %s,",frn); lvar(e2);
 lvar_intro(e2+size_of_double-size_of_int);
 printf("\tlwz %s,",crn); lvar(e2+size_of_double-size_of_int);
-regv[creg]=1;
 }
 static int i2d_lib_used=0;
 static char *i2d_lib[] = {
 ".data",
 clear_ptr_cache();
 code_save_stacks();
 set_creg(RET_REGISTER,1);
 printf("\tbl i2d_\n");
 set_freg(RET_FREGISTER,0);
-regv[freg]=1;
 }
 static int d2u_lib_used=0;
 static char *d2u_lib[] = {
 /* ".literal8", */
 clear_ptr_cache();
 d2u_lib_used=1;
 set_freg(RET_FREGISTER,1);
 printf("\tbl d2u_\n");
 set_creg(RET_REGISTER,0);
-regv[freg]=1;
 }
 static int u2d_lib_used=0;
 static char *u2d_lib[] = {
 ".data",
 clear_ptr_cache();
 u2d_lib_used = 1;
 set_creg(RET_REGISTER,1);
 printf("\tbl u2d_\n");
 set_freg(FREG_FREGISTER,0);
-regv[freg]=1;
 }
 void code_d2f(int freg) { }
 void code_f2d(int freg) { }
 void code_f2i(int freg) { code_d2i(freg); }
 void code_drgvar(int e2,int d,int freg)
 {
 int r;
 r = get_ptr_cache((NMTBL*)cadr(e2));
 printf("\t%s %s,0(%s)\n",fload(d),fregister_name(freg),register_name(r));
-regv[freg]=1;
 }
 void code_drlvar(int e2,int d,int freg)
 {
 lvar_intro(e2);
 printf("\t%s %s,",fload(d),fregister_name(freg)); lvar(e2);
-regv[freg]=1;
 }
 void code_cmp_drgvar(int e2,int d)
 {
 int r;
 char *grn=fregister_name(g);
 r = get_ptr_cache((NMTBL*)cadr(e2));
 printf("\t%s %s,0(%s)\n",fload(1),grn,register_name(r));
 printf("\tfcmpu cr0,%s,%s\n",frn,grn);
 free_register(g);
-regv[freg]=0;
 }
 void code_cmp_drlvar(int e2,int d)
 {
 char *frn=fregister_name(freg);
 lvar_intro(e2);
 printf("\t%s %s,",fload(1),grn); lvar(e2);
 printf("\tfcmpu cr0,%s,%s\n",frn,grn);
 free_register(g);
-regv[freg]=0;
 }
 void dtosop(int op,int e1)
 {
 char *opn="";
 char *frn=fregister_name(freg);
 char *grn=fregister_name(e1);
-regv[freg]=1;
 switch(op) {
 case FADD:
 case DADD: opn="fadd"; break;
 case FSUB:
 case DSUB: opn="fsub"; break;
 	return;
 default:
 	error(-1); return;
 }
 printf("\t%s %s,%s,%s\n",opn,frn,frn,grn);
-regv[freg]=1;
 free_register(e1);
 }
 void
 code_dassop(int op,int d) {
 if (!is_float_reg(freg)) error(-1);
 printf("\t%s %s,0(%s)\n",fload(d),frn,crn);
 dtosop(op,xreg);
 printf("\t%s %s,0(%s)\n",fstore(d),frn,crn);
 emit_dpop_free(xreg,d);
-regv[freg]=1;
 }
 void
 code_dpreinc(int e1,int e2,int d,int reg) {
 else
 	printf("\tfsub %s,%s,%s\n",frn,frn,grn);
 if (!is_float_reg(freg)) error(-1);
 printf("\t%s %s,0(%s)\n",fstore(d),frn,crn);
 free_register(g);
-regv[freg]=1;
-regv[ireg]=0;
 creg = freg;
 }
 void
 code_dpostinc(int e1,int e2,int d,int reg) {
 else
 	printf("\tfsub %s,%s,%s\n",grn,frn,grn);
 if (!is_float_reg(freg)) error(-1);
 printf("\t%s %s,0(%s)\n",fstore(d),grn,crn);
 free_register(g);
-regv[freg]=1;
-regv[ireg]=0;
 creg = freg;
 }
 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,1,reg);
 	free_lvar(REG_LVAR_OFFSET+xreg);
-	regv[reg]=1; xreg=reg;
+	xreg=reg;
 }
 return xreg;
 }
 void emit_dpop_free(int e1,int d)
 int new_reg;
 if (freg_sp>MAX_MAX) error(-1);
 new_reg = get_dregister(1);
 freg_stack[freg_sp++] = freg;     /* push するかわりにレジスタを使う */
 creg = freg = new_reg;
-regv[freg]=1;
 }
 #endif
 #if LONGLONG_CODE

Mercurial > hg > CbC > old > device

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