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

comparison mc-code-powerpc.c @ 206:4170cefb48f6

*** empty log message ***

author	kono
date	Thu, 15 Apr 2004 07:25:38 +0900
parents	a50f90d0b63a
children	8a3516f6eb66

comparison

equal deleted inserted replaced

-:a50f90d0b63a
+:4170cefb48f6
 /* floating point registers */
 static int  freg_sp;  /* floating point REGister Stack-Pointer */
 static int freg_stack[MAX_MAX]; /* 実際のレジスタの領域 */
+static int  lreg_sp;  /* longlong  REGister Stack-Pointer */
+static int lreg_stack[MAX_MAX]; /* 実際のレジスタの領域 */
 #define REG_fp   1
 #define REG_sp   30
 #define REG_VAR_BASE 29
 #define REG_VAR_MIN  18
 #define MIN_TMP_REG 3
 #define FREG_VAR_BASE 31
 #define FREG_VAR_MIN  20
 #define MIN_TMP_FREG 1
 #define MAX_TMP_FREG 14
-#define RET_REGISTER 3
+#define RET_REGISTER regv[3]
-#define RET_FREGISTER (1+FREG_OFFSET)
+#define RET_FREGISTER regv[(1+FREG_OFFSET)]
 #define RET_LREGISTER_L 4    /* low word */
 #define RET_LREGISTER_H 3    /* high word */
+static int lreg_ret;
+#define RET_LREGISTER lreg_ret
 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_INPUT_DREGISTER_VAR = 14-MIN_TMP_FREG;
 int MAX_INPUT_FREGISTER_VAR = 14-MIN_TMP_FREG;
 int MAX_CODE_INPUT_DREGISTER_VAR = 14-MIN_TMP_FREG;
 int MAX_CODE_INPUT_FREGISTER_VAR = 14-MIN_TMP_FREG;
-#define CREG_REGISTER  MAX_TMP_REG
-#define FREG_FREGISTER (MAX_TMP_FREG+FREG_OFFSET)
 static int powerpc_regs[REAL_MAX_REGISTER+REAL_MAX_FREGISTER];
+static int regv[REAL_MAX_REGISTER+REAL_MAX_FREGISTER];
 static int *regs  = powerpc_regs;
+#define CREG_REGISTER  regv[MAX_TMP_REG]
+#define FREG_FREGISTER regv[MAX_TMP_FREG+FREG_OFFSET]
 static int max_reg_var, max_freg_var;
 static char *reg_name[] = {
 "r0","r1","r2","r3","r4","r5","r6","r7","r8","r9",
 if (lreg) {
 	free_register(lreg); lreg = 0;
 }
 if (!is_int_reg(i)) {
 	if (!ireg) ireg = get_register();
-	i = lreg;
+	i = ireg;
 }
 return i;
 }
 int use_float(int i) {
 if (!is_float_reg(i)) i = freg;
-if (!regs[i]) regs[i]=1;
+if (!regs[cadr(i)]) regs[cadr(i)]=1;
 return i;
 }
 int use_double(int i) {
 if (!is_float_reg(i)) i = freg;
-if (!regs[i]) regs[i]=1;
+if (!regs[cadr(i)]) regs[cadr(i)]=1;
 return i;
 }
 int use_longlong(int i) {
 if (ireg) {
 static char * fload(int d);
 static int code_d1(double d);
 static int code_d2(double d);
+#endif
+#if LONGLONG_CODE
+static int code_l1(long long ll);
+static int code_l2(long long ll);
 #endif
 static void code_save_stacks();
 static void code_save_input_registers();
 static void clear_ptr_cache_reg(int r);
 }
 void
 code_init(void)
 {
+int i;
 macro_define("__ppc__ 1\n");
 macro_define("__BIG_ENDIAN__ 1\n");
 //    macro_define("_BSD_CT_RUNE_T_ int\n");
 macro_define("__STDC__ 1\n");
 init_ptr_cache();
+lreg_ret = glist3(LREGISTER, RET_LREGISTER_L,RET_LREGISTER_H);
+for(i=0;i<MAX_REGISTER;i++) { regv[i]=glist2(REGISTER,i); }
+for(i=0;i<MAX_FREGISTER;i++) { regv[i+FREG_OFFSET]=glist2(DREGISTER,i+FREG_OFFSET); }
 }
 void
 gexpr_code_init(void){
 #if 0
 {    /* 使われていないレジスタを調べる */
 int i,reg;
 for(i=MAX_TMP_REG;i>MIN_TMP_REG;i--) {
 	if (regs[i]) continue;  /* 使われている */
 	regs[i]=USING_REG;      /* そのレジスタを使うことを宣言し */
-	return glist2(REGISTER,i);   /* その場所を表す番号を返す */
+	return regv[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 glist2(REGISTER,i);   /* その場所を表す番号を返す */
+	return regv[i];   /* その場所を表す番号を返す */
 }
 /* search register stack */
 for(i=0;i<reg_sp;i++) {
 	if ((reg=reg_stack[i])>=0) {
 code_assign_lvar(
 (reg_stack[i]=new_lvar(size_of_int)),reg,0);
 reg_stack[i]= reg_stack[i]-REG_LVAR_OFFSET;
 	    return reg;
 	}
 }
+#if LONGLONG_CODE
+/* search register stack */
+for(i=0;i<lreg_sp;i++) {
+	if ((reg=lreg_stack[i])>=0) {
+code_assign_lvar(
+(lreg_stack[i]=new_lvar(size_of_longlong)),reg,0);
+lreg_stack[i]= lreg_stack[i]-REG_LVAR_OFFSET;
+	    free_register(reg);
+	    return get_register();
+	}
+}
+#endif
 for(i=0;i<REG_VAR_BASE-REG_VAR_MIN;i++) {
 reg =REG_VAR_BASE-i;
 if (! regs[reg]) {       /* 使われていないなら */
 regs[reg]=USING_REG; /* そのレジスタを使うことを宣言し */
 	    if (i>max_reg_var) max_reg_var=i;
-	    return glist2(REGISTER,reg);   /* その場所を表す番号を返す */
+	    return regv[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 glist2(DREGISTER,i);   /* その場所を表す番号を返す */
+	return regv[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; /* そのレジスタを使うことを宣言し */
 	    if (i>max_freg_var) max_freg_var=i;
-	    return glist2(DREGISTER,reg);   /* その場所を表す番号を返す */
+	    return regv[reg];   /* その場所を表す番号を返す */
 }
 }
 /* 空いている場所がないなら、エラー (いったい誰が使ってるの?) */
 error(REG_ERR); return freg;
 }
 {     /* レジスタから値を取り出す */
 return freg_stack[--freg_sp];
 }
 #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)
 {
+int i,j;
+int max_reg_var_save=max_reg_var;
+for(i=0;i<REG_VAR_BASE-REG_VAR_MIN;i++) {
+	if (! regs[REG_VAR_BASE-i]) {       /* 使われていないなら */
+	    /* そのレジスタを使うことを宣言し */
+	    regs[REG_VAR_BASE-i]=USING_REG;
+	    if (i>max_reg_var) max_reg_var=i;
+	    for(j=0;j<REG_VAR_BASE-REG_VAR_MIN;j++) {
+		if (! regs[REG_VAR_BASE-j]) {       /* 使われていないなら */
+		    /* そのレジスタを使うことを宣言し */
+		    regs[REG_VAR_BASE-j]=USING_REG;
+		    if (j>max_reg_var) max_reg_var=j;
+		    /* その場所を表す番号を返す */
+		    return list3(LREGISTER,
+			glist3(LREGISTER,REG_VAR_BASE-j,REG_VAR_BASE-i),
+			(int)n);
+		}
+	    }
+	    /* ひとつしかなかった */
+	    regs[REG_VAR_BASE-i]=0;
+	    max_reg_var=max_reg_var_save;
+	}
+}
 return list2(LVAR,new_lvar(size_of_longlong));
 }
-#endif
 void
 emit_pop_free(int xreg)
 {
 if (xreg>=0)
 	free_register(xreg);
 }
 void
 free_register(int i) {    /* いらなくなったレジスタを開放 */
-if (i<0||MAX_FREGISTER+FREG_OFFSET<i) error(-1);
+int j;
-regs[i]=0;
+if (i==0) return;
+j = cadr(i); regs[j]=0;
+if (car(i)==LREGISTER) {
+	j = caddr(i); regs[j]=0;
+	free_glist3(i);
+}
 }
 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,glist2(DREGISTER,i),(int)n);
+return list3(DREGISTER,regv[i],(int)n);
 }
 int
 get_input_lregister_var(int i,NMTBL *n,int is_code)
+{
+if (is_code) {
+	if(!(i+1<REG_VAR_BASE-REG_VAR_MIN)) return 0;
+	i = REG_VAR_BASE-i;
+} else {
+	if (i<0||i+1>=MAX_INPUT_REGISTER_VAR) return 0;
+	i = i+MIN_TMP_REG;
+}
+return list3(LREGISTER,list3(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(LREGISTER,glist3(LREGISTER,i+1,i),(int)n);
+return list3(REGISTER,regv[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,glist2(REGISTER,i),(int)n);
+return list3(REGISTER,regv[i],(int)n);
 }
 int
 free_register_count(int d)
 {
 void
 free_all_register(void)
 {
 int i;
+#if LONGLONG_CODE
+if (lreg) free_register(lreg);
+lreg = 0;
+#endif
 for(i=0;i<MAX_REGISTER;i++) { regs[i]=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);
 int i;
 #endif
 if (chk) return;
 if (!lsrc) return;
 printf("# %d: %s:",lineno,s);
-printf(" creg=%s fgreg=%s",register_name(creg),fregister_name(freg));
+if (ireg) printf(" creg=%s",register_name(ireg));
+if (freg) printf(" freg=%s",fregister_name(freg));
+if (lreg) printf(" lreg=%s,%s",lregister_name_high(lreg),
+	lregister_name_low(lreg));
 #if 0
 printf("\n# regs:");
 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]); }
 	free_register(reg_stack[--reg_sp]);
 }
 while(freg_sp > 0) {
 	free_register(freg_stack[--freg_sp]);
 }
+while(lreg_sp > 0) {
+	free_register(lreg_stack[--lreg_sp]);
+}
 text_mode();
 gexpr_code_init();
 register_usage("gexpr_init");
 }
 	if (! regs[REG_VAR_BASE-i]) {       /* 使われていないなら */
 	    /* そのレジスタを使うことを宣言し */
 	    regs[REG_VAR_BASE-i]=USING_REG;
 	    if (i>max_reg_var) max_reg_var=i;
 	    /* その場所を表す番号を返す */
-	    return list3(REGISTER,REG_VAR_BASE-i,(int)n);
+	    return list3(REGISTER,glist2(REGISTER,REG_VAR_BASE-i),(int)n);
 	}
 }
 return list2(LVAR,new_lvar(size_of_int));
-}
-int
-fregister_var(int r) {
-return r;
 }
 int
 get_dregister_var(NMTBL *n,int d)
 {
 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; /*そのレジスタを使うことを宣言し*/
 	    if (i>max_freg_var) max_freg_var=i;
 	    /* その場所を表す番号を返す */
-	    return list3(DREGISTER,FREG_VAR_BASE-i+FREG_OFFSET,(int)n);
+	    return list3(DREGISTER,
+		glist2(DREGISTER,FREG_VAR_BASE-i+FREG_OFFSET),(int)n);
 }
 }
 return list2(LVAR,new_lvar(size_of_double));
 }
 if (type==INT) {
 	xreg = reg_stack[reg_sp];
 	if (xreg<= -REG_LVAR_OFFSET) {
 	    return list2(LVAR,REG_LVAR_OFFSET+xreg);
 	} else {
-	    return list2(REGISTER,xreg);
+	    return xreg;
 	}
 } else {
 	xreg = freg_stack[freg_sp];
 	if (xreg<= -REG_LVAR_OFFSET) {
 	    return list2(LVAR,REG_LVAR_OFFSET+xreg);
 	} else {
-	    return list2(DREGISTER,xreg);
+	    return xreg;
 	}
 }
 return xreg;
 }
 cadr(p1)=0;            /* remove the last one */
 cadr(p) = ptr_cache;   /* connect current queue to the last one */
 ptr_cache = p;         /* now the last one is the top */
 if (!caddr(p)) {
 	if((r=get_register())) {
-	    caddr(p)=r; regs[r]=PTRC_REG;
+	    caddr(p)=r; regs[cadr(r)]=PTRC_REG;
 	} else {
 	    error(-1);
 	    r=creg; /* this can't happen */
 	}
 	car(p)=g;
 void
 set_creg(int reg,int mode)
 {
 if (reg!=creg) {
 	clear_ptr_cache_reg(reg);
-	if (reg!=ireg && mode)
+	if (ireg && reg!=ireg && mode) {
 	    printf("\tmr %s,%s\n",register_name(reg),register_name(ireg));
+	}
 	free_register(creg);
-	creg = ireg = reg;
+	regs[cadr(creg)]=USING_REG;
-	regs[creg]=1;
+}
-}
+creg = ireg = reg;
-if (ireg!=creg) error(-1);
-ireg = reg;
 }
 void
 set_freg(int reg,int mode)
 {
 if (reg!=creg) {
 	if (reg!=freg && mode) {
 	    printf("\tfmr %s,%s\n",fregister_name(reg),fregister_name(freg));
 	}
 	free_register(creg);
-	creg = freg = reg;
+	regs[cadr(freg)]=USING_REG;
-	regs[freg]=1;
+}
-}
+creg = freg = reg;
-if (freg!=creg) error(-1);
-freg = reg;
 }
 void
 set_lreg(int reg,int mode)
 {
+if (reg!=creg) {
+	if (reg!=lreg && mode) {
+	    printf("\tmr %s,%s\n",
+		lregister_name_low(reg),lregister_name_low(lreg));
+	    printf("\tmr %s,%s\n",
+		lregister_name_high(reg),lregister_name_high(lreg));
+	}
+	regs[cadr(lreg)]=USING_REG;
+	regs[caddr(lreg)]=USING_REG;
+	free_register(creg);
+}
+creg = lreg = reg;
 }
 void
 use_var(int arg)
 {
 if (car(arg)==REGISTER)
 	regs[cadr(arg)]=USING_REG;
 else if (car(arg)==DREGISTER)
 	regs[cadr(arg)]=USING_REG;
+else if (car(arg)==LREGISTER) {
+	regs[cadr(arg)]=USING_REG;
+	regs[caddr(arg)]=USING_REG;
+}
 }
 void
 code_save_input_registers()
 {
 	    n->dsp = offset;
 	    t = n->ty;
 	    if(t==FLOAT) { offset+=size_of_float; reg_offset+=1; }
 	    else if(t==DOUBLE) { offset+=size_of_double; reg_offset+=2; }
 	    else error(-1);
+	} else if (tag==LREGISTER) {
+	    /* regs[reg]==INPUT_REG case should be considered */
+	    n->dsp = offset;
+	    t = n->ty;
+	    offset+=size_of_longlong; reg_offset+=2;
 	} else {
 	    offset += size(n->ty);
 	    continue;
 	}
 	n->sc  = LVAR;
 	lvar = list2(LVAR,n->dsp);
 	g_expr_u(assign_expr0(list2(LVAR,n->dsp),list3(tag,reg,(int)n),n->ty,t));
-	if (tag==REGISTER||tag==DREGISTER||tag==FREGISTER) {
+	if (tag==REGISTER||tag==DREGISTER||tag==FREGISTER||tag==LREGISTER) {
 	    free_register(reg);
 	}
 }
 my_func_args = offset;
 }
 	    reg_arg_list = list2(arg,reg_arg_list);
 	    g_expr_u(assign_expr0(arg,e4,t,t));
 	    nargs ++ ; reg_arg++;
 	    continue;
 	} else if (t==LONGLONG||t==ULONGLONG) {
+	    if (reg_arg>=MAX_INPUT_REGISTER_VAR) {
+		arg = list2(LVAR,caller_arg_offset_v(nargs));
+	    } else if (!simple_args(e3) && cadr(e3)) {
+		arg = get_register_var(0);
+		arg_assign = list2(
+		    assign_expr0(get_input_lregister_var(reg_arg,0,0),
+			arg,t,t),
+		    arg_assign);
+	    } else {
+		arg = get_input_lregister_var(reg_arg,0,0);
+	    }
+	    use_var(arg); /* protect from input register free */
+	    reg_arg_list = list2(arg,reg_arg_list);
+	    g_expr_u(assign_expr0(arg,e4,t,t));
+	    nargs ++ ; reg_arg++;
+	    nargs ++ ; reg_arg++;
 	    continue;
 	} else if (t==DOUBLE||t==FLOAT) {
 	    if (reg_arg<MAX_INPUT_REGISTER_VAR) {
 		/* sigh...
 printf requies floating value in integer registers
 			e4 = list2(DREGISTER,freg);
 			/* freg should not change until XXX */
 		    }
 		    r0=get_input_register_var(reg_arg,0,0);
 		    r1 = reg_arg+1+MIN_TMP_REG;
-		    if (regs[r1]==PTRC_REG) clear_ptr_cache_reg(r1);
+		    if (regs[r1]==PTRC_REG)
+			clear_ptr_cache_reg(list2(REGISTER,r1));
 		    /* else if (regs[r1]) error(-1); */
 		    r1=get_input_register_var_1(reg_arg+1,0,0);
 		    use_var(r0); /* protect from input register free */
 		    use_var(r1); /* protect from input register free */
 printf("\tmtctr %s\n",jrn);
 printf("\tbctrl\n");
 }
 for(;reg_arg_list;reg_arg_list=cadr(reg_arg_list)) {
 	arg = car(reg_arg_list);
-	if (car(arg)==REGISTER||car(arg)==DREGISTER||car(arg)==FREGISTER)
+	if (car(arg)==REGISTER||car(arg)==DREGISTER||car(arg)==FREGISTER
+		||car(arg)==LREGISTER)
 	    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);
+} else if (ret_type==ULONGLONG||ret_type==LONGLONG) {
+	set_lreg(RET_LREGISTER,0);
 } else if (ret_type==VOID) {
 } else {
 	set_creg(RET_REGISTER,0);
 }
 return ret_type;
 {
 char *crn;
 g_expr(e1);
 crn=register_name(creg);
 printf("\tlwz %s,%d(%s)\n",crn,offset,crn);
-return INT;
+return us?UNSIGNED:INT;
 }
 int
 code_crindirect(int e1, int offset, int us)
 {
 g_expr(e1);
 crn=register_name(creg);
 printf("\t%s %s,%d(%s)\n",fload(d),
 	fregister_name(freg),offset,crn);
 creg = freg;
-return DOUBLE;
+return d?DOUBLE:FLOAT;
 }
 #endif
 #if LONGLONG_CODE
 int
 code_lrindirect(int e1, int offset, int us)
 {
 char *crn;
 g_expr(e1);
 crn=register_name(creg);
-return LONGLONG;
+if (!lreg) lreg = get_lregister();
+printf("\tlwz %s,%d(%s)\n",crn,offset,lregister_name_low(lreg));
+printf("\tlwz %s,%d(%s)\n",crn,offset+size_of_int,lregister_name_high(lreg));
+creg = lreg;
+return us?ULONGLONG:LONGLONG;
 }
 #endif
 void
 void
 code_set_return_register(int mode) {
 if (cadr(fnptr->ty)==DOUBLE||cadr(fnptr->ty)==FLOAT) {
 	set_freg(RET_FREGISTER,mode);
+} else if (cadr(fnptr->ty)==LONGLONG||cadr(fnptr->ty)==ULONGLONG) {
+	set_lreg(RET_LREGISTER,mode);
 } else if (cadr(fnptr->ty)==VOID) {
 } else {
 	set_creg(RET_REGISTER,mode);
 }
 }
 void
 code_set_fixed_creg(int reg,int mode,int type) {
 if (type==FLOAT||type==DOUBLE) {
 	set_freg(reg,mode);
-} else if (type==LONGLONG) {
+} else if (type==LONGLONG||type==ULONGLONG) {
 	set_lreg(reg,mode);
 } else {
 	set_creg(reg,mode);
 }
 }
 {
 int l;
 #if FLOAT_CODE
 double d;
 float f;
+#endif
+#if LONGLONG_CODE
+long long ll;
 #endif
 char *name;
 name = n->nm;
 if(mode!=GDECL && mode!=STADECL)  {
 	error(-1); return;
 	} else {
 	    printf("\t.long %d\n",cadr(e));
 	    gpc += size_of_int;
 	}
 #if LONGLONG_CODE
+} else if(t==LONGLONG||t==ULONGLONG) {
+	ll = lcadr(e);
+	printf("\t.long\t0x%x,0x%x\n",code_l2(ll),code_l1(ll));
 #endif
 #if FLOAT_CODE
 } else if(t==DOUBLE) {
 	d = dcadr(e);
 	printf("\t.long\t0x%x,0x%x\n",code_d2(d),code_d1(d));
 void code_lassign_lregister(int e2,int reg)
 {
 }
+static long long ll = 1LL;
+static int
+code_l1(long long d)
+{
+int *i = (int *)&ll; int *j = (int *)&d;
+return (i[1] == 1)?j[1]:j[0];
+}
+static int
+code_l2(long long d)
+{
+int *i = (int *)&ll; int *j = (int *)&d;
+return (i[1] == 1)?j[0]:j[1];
+}
 void code_lconst(int e1,int e2)
 {
 }

Mercurial > hg > CbC > old > device

comparison mc-code-powerpc.c @ 206:4170cefb48f6