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

comparison mc-code-spu.c @ 661:f566ac85f2e0

*** empty log message ***

author	kono
date	Wed, 21 Feb 2007 20:11:23 +0900
parents
children	c9df4e08da9b

comparison

equal deleted inserted replaced

-:3e1dba5758d8
+:f566ac85f2e0
+/* Micro-C Code Generation Part for Cell SPU */
+/* ************************************************************************
+** Copyright (C) 2007 Shinji Kono
+** 連絡先： 琉球大学情報工学科 河野 真治
+** （E-Mail Address: kono@ie.u-ryukyu.ac.jp）
+**
+**    このソースのいかなる複写，改変，修正も許諾します。ただし、
+**    その際には、誰が貢献したを示すこの部分を残すこと。
+**    再配布や雑誌の付録などの問い合わせも必要ありません。
+**    営利利用も上記に反しない範囲で許可します。
+**    バイナリの配布の際にはversion messageを保存することを条件とします。
+**    このプログラムについては特に何の保証もしない、悪しからず。
+**
+**    Everyone is permitted to do anything on this program
+**    including copying, modifying, improving,
+**    as long as you don't try to pretend that you wrote it.
+**    i.e., the above copyright notice has to appear in all copies.
+**    Binary distribution requires original version messages.
+**    You don't have to ask before copying, redistribution or publishing.
+**    THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE.
+***********************************************************************/
+#include <stdio.h>
+#include "mc.h"
+#include "mc-parse.h"
+#include "mc-code.h"
+#include "mc-codegen.h"
+char *l_include_path[]={
+"/usr/lib/gcc/spu/4.0.2/include",
+	"/usr/spu/include",
+	0};
+// va_start, va_arg is wrong, use va_arm.h
+static char *init_src0 = "\
+#define __SPU__ 1\n\
+#define __STDC_HOSTED__ 1\n\
+#define __GNUC__ 4\n\
+#define __FLT_MIN_EXP__ (-125)\n\
+#define __DBL_MIN__ 2.2250738585072014e-308\n\
+#define __NO_INLINE__ 1\n\
+#define __ELF__ 1\n\
+#define __FLT_RADIX__ 2\n\
+#define __LDBL_EPSILON__ 2.2204460492503131e-16L\n\
+#define __vector __attribute__((spu_vector))\n\
+#define __WCHAR_TYPE__ int\n\
+#define __DBL_EPSILON__ 2.2204460492503131e-16\n\
+#define __INTMAX_MAX__ 9223372036854775807LL\n\
+#define __FLT_DENORM_MIN__ 1.40129846e-45F\n\
+#define __FLT_MAX__ 6.80564693e+38F\n\
+#define __FLT_MIN_10_EXP__ (-37)\n\
+#define __INTMAX_TYPE__ long long int\n\
+#define __GNUC_MINOR__ 0\n\
+#define __DBL_MAX_10_EXP__ 308\n\
+#define __LDBL_DENORM_MIN__ 4.9406564584124654e-324L\n\
+#define __PTRDIFF_TYPE__ long int\n\
+#define __LDBL_MIN_10_EXP__ (-307)\n\
+#define __LDBL_DIG__ 15\n\
+#define __WINT_TYPE__ unsigned int\n\
+";
+int data_alignment = 0;
+#define TEXT_EMIT_MODE 0
+#define DATA_EMIT_MODE 1
+#define RODATA_EMIT_MODE 2
+#define DOT_SIZE 1
+// static void data_mode(char *name);
+// static void text_mode(int alignment);
+static void ld_indexx(int byte, int n, int xreg,int reg,int sign);
+static void local_table(void);
+static void shift(char *op, int creg,int reg);
+static int push_struct(int e4,int t,int arg);
+static void register_usage(char *s);
+static void code_add(int reg,int offset,int r);
+static void const_list_table();
+//static int search_const(int tag,int value,int *label);
+static char * cstore(int sz);
+static void code_int_lib(char *lib,int reg,int oreg);
+static int caller_arg_offset_v(int arg);
+static void pcond(int op, int r2,int r1,int r0,int cond,int l1,int mode);
+#if FLOAT_CODE
+static int code_d1(double d);
+static int code_d2(double d);
+static void code_float_lib(char *opc,int oreg,int in_reg,int e1);
+static void code_float_lib_c(char *lib,int from,int to,double value);
+static void code_double_lib(char *lib,int to,int reg,int oreg);
+static void code_double_lib_c(char *lib,int from,int to,double value);
+static void dconst(int l,int h,double value);
+static void code_assign_input_double_long(int e1,int e2) ;
+static void code_assign_input_float_int(int e1,int e2) ;
+#endif
+static void use_input_reg(int reg,int mode);
+static void ascii(char *s);
+static int creg;
+static int output_mode = TEXT_EMIT_MODE;
+static int register_save_return_label;
+static int r1_offset_label;
+static int lvar_offset_label;
+static int    max_func_args = 0;
+static int arg_on_register = 0;
+static int max_func_arg_label = 0;
+static int freg,ireg,lreg;
+int code_lassop_p = 4;
+#define SIZE_OF_INT  4
+#define SIZE_OF_SHORT  2
+#define SIZE_OF_FLOAT  4
+#define SIZE_OF_DOUBLE  8
+#define SIZE_OF_LONGLONG  8
+#define ENDIAN  0
+#define ENDIAN_L  0
+#define ENDIAN_D  1
+int eval_order = NORMAL;
+static int  reg_sp;   /* REGister Stack-Pointer */
+static int reg_stack[MAX_MAX];  /* 実際のレジスタの領域 */
+#define REG_ip   13
+#define REG_fp   0
+#define REG_sp   1
+#define REG_VAR_BASE 3
+#define REG_VAR_MIN  3
+#define REG_VAR_USER_MAX  127     /* at leat 6 tmp var */
+#define REG_VAR_MAX 127
+#define MIN_TMP_REG 4
+#define MAX_TMP_REG 127
+#define FREG_VAR_BASE 3
+#define FREG_VAR_MIN  3
+#define FREG_VAR_MAX  127
+#define MIN_TMP_FREG 3
+#define MAX_TMP_FREG 127
+int MAX_REGISTER=127;             /* ARMのレジスタを10個まで使う*/
+#define  REAL_MAX_REGISTER 127    /* ARMのレジスタが32ということ*/
+#define FREG_OFFSET 3
+#define LREG_OFFSET 3
+int MAX_INPUT_REGISTER_VAR = 80;
+int MAX_INPUT_DREGISTER_VAR = 80;
+int MAX_INPUT_FREGISTER_VAR = 80;
+int MAX_CODE_INPUT_REGISTER_VAR = 80;
+int MAX_CODE_INPUT_DREGISTER_VAR = 80;
+int MAX_CODE_INPUT_FREGISTER_VAR = 80;
+#define LREG_V 3    /* mark for virtual long long/double register */
+#define REGS_MAX (REAL_MAX_REGISTER)
+static int spu_regs[REGS_MAX];
+///   #define (i)  (i)
+// #define (i)  (i)
+#define RET_REGISTER 3
+#define REGISTER_OPERAND  3     //this is first register for input
+#define REGISTER_OPERAND_1  4
+#define RET_FREGISTER FREG_OFFSET
+#define FREGISTER_OPERAND  (FREG_OFFSET)
+#define FREGISTER_OPERAND_1  (FREG_OFFSET+1)
+#define RET_LREGISTER 3
+#define LREGISTER_OPERAND 3
+#define LREGISTER_OPERAND_1 4
+#define RET_LREGISTER_L 1    /* low word */
+#define RET_LREGISTER_H 2    /* high word */
+#define LREGISTER_OPERAND_L  1    /* low word */
+#define LREGISTER_OPERAND_H  2    /* high word */
+#define LREGISTER_OPERAND_1_L  3    /* low word */
+#define LREGISTER_OPERAND_1_H  4    /* high word */
+#define RET_DREGISTER RET_LREGISTER
+#define DREGISTER_OPERAND LREGISTER_OPERAND
+#define DREGISTER_OPERAND_1 LREGISTER_OPERAND_1
+#define RET_DREGISTER_L RET_LREGISTER_L
+#define RET_DREGISTER_H RET_LREGISTER_H
+#define DREGISTER_OPERAND_H  LREGISTER_OPERAND_H
+#define DREGISTER_OPERAND_L  LREGISTER_OPERAND_L
+#define DREGISTER_OPERAND_1_L  LREGISTER_OPERAND_1_L
+#define DREGISTER_OPERAND_1_H  LREGISTER_OPERAND_1_H
+static int *regs  = spu_regs;
+// #define CREG_REGISTER  (MAX_TMP_REG)
+#define CREG_REGISTER  REGISTER_OPERAND
+// #define FREG_FREGISTER (MAX_TMP_FREG+FREG_OFFSET)
+#define FREG_FREGISTER FREGISTER_OPERAND
+// #define LREG_LREGISTER (MAX_TMP_REG+LREG_OFFSET)
+#define LREG_LREGISTER LREGISTER_OPERAND
+#define DREG_DREGISTER LREG_LREGISTER
+#define CMP_C1T (-1)
+static int max_reg_var;
+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", "$30", "$31",
+	"$32", "$33", "$34", "$35", "$36", "$37", "$38", "$39",
+	"$40", "$41", "$42", "$43", "$44", "$45", "$46", "$47",
+	"$48", "$49", "$50", "$51", "$52", "$53", "$54", "$55",
+	"$56", "$57", "$58", "$59", "$60", "$61", "$62", "$63",
+	"$64", "$65", "$66", "$67", "$68", "$69", "$70", "$71",
+	"$72", "$73", "$74", "$75", "$76", "$77", "$78", "$79",
+	"$80", "$81", "$82", "$83", "$84", "$85", "$86", "$87",
+	"$88", "$89", "$90", "$91", "$92", "$93", "$94", "$95",
+	"$96", "$97", "$98", "$99", "$100", "$101", "$102", "$103",
+	"$104", "$105", "$106", "$107", "$108", "$109", "$110", "$111",
+	"$112", "$113", "$114", "$115", "$116", "$117", "$118", "$119",
+	"$120", "$121", "$122", "$123", "$124", "$125", "$126", "$127"
+};
+#define register_name(i)  reg_name[i]
+#define lregister_name_low(i) reg_name[i]
+#define lregister_name_high(i) reg_name[i]
+char *rn(int i) { return register_name(i); }
+char *lln(int i) { return lregister_name_low(i); }
+char *lhn(int i) { return lregister_name_high(i); }
+int ll(int i) { return i; }
+int lh(int i) { return i; }
+#define is_int_reg(i)  (0<=i&&i<REAL_MAX_REGISTER)
+#define is_float_reg(i)  (is_int_reg(i))
+#define is_longlong_reg(i) (is_int_reg(i))
+#define is_double_reg(i) (is_int_reg(i))
+#define  use_int(reg) if (reg==USE_CREG) reg=use_int0()
+static
+int use_int0() {
+int i = creg;
+if (!i||!ireg||!is_int_reg(i)) {
+	if (lreg) { if (regs[lreg]) free_register(lreg); lreg = 0; }
+	if (!ireg) ireg = get_register();
+	// else if (ireg!=i) free_register(i);
+	i = ireg;
+}
+if (!regs[i]) regs[i]=USING_REG;
+creg = i;
+return i;
+}
+#if LONGLONG_CODE||FLOAT_CODE
+#define  use_longlong(reg) if (reg==USE_CREG) reg=use_int0()
+/*
+static
+int use_longlong0() {
+int i = creg;
+if (!is_longlong_reg(i)) {
+	if (ireg) { free_register(ireg); ireg=0; }
+	if (!lreg||!regs[lreg]) lreg = get_lregister();
+	 else if (lreg!=i) free_register(i);
+	i = lreg;
+}
+if (!(i)) (i) = get_register();
+if (!(i)) (i) = get_register();
+if (!regs[i]) regs[i]=USING_REG;
+if (!regs[(i)]) regs[(i)]=USING_REG;
+if (!regs[(i)]) regs[(i)]=USING_REG;
+creg = i;
+return i;
+}
+*/
+static void lmove(int to,int from);
+#endif
+#define USING_DREG 5
+#define INPUT_DREG 6
+#if FLOAT_CODE
+#define dsuffix(d) (d?'d':'s')
+#define  use_float(d,reg) if (reg==USE_CREG) { reg=use_int0();}
+/*
+static
+int use_double0() {
+int i;
+use_longlong0();
+use_int0();
+	i = lreg;
+if (!regs[i]) regs[i]=USING_DREG;
+if (!regs[(i)]) regs[(i)]=USING_REG;
+if (!regs[(i)]) regs[(i)]=USING_REG;
+creg = i;
+return i;
+}
+*/
+void code_lassign_lvar(int e2,int creg);
+int code_lrindirect(int e1, int reg, int offset, int us);
+void code_lregister(int e2,int reg);
+void code_lassign_gvar(int e2,int creg);
+void code_lassign(int e2,int creg);
+void code_lassign_lregister(int e2,int reg);
+void code_lrgvar(int e1,int creg);
+void code_lrlvar(int e1,int creg);
+void emit_lpop_free(int xreg);
+void emit_lpush();
+int emit_lpop();
+#endif
+#if LONGLONG_CODE
+static int code_l1(long long ll);
+static int code_l2(long long ll);
+#endif
+static void code_save_input_registers(int dots);
+static void    set_ireg(int,int);
+#if FLOAT_CODE
+static void    set_dreg(int,int);
+static void    set_freg(int,int);
+#endif
+#if LONGLONG_CODE
+static void    set_lreg(int,int);
+#endif
+static int max_func_args;
+static int my_func_args;
+static void jcond(int l, int cond);
+#define ARG_LVAR_OFFSET 0x10000000
+#define round16(i)   ((i+0xf)&~0xf)
+#define round4(i)   ((i+3)&~3)
+/*
+r0    return value etc.
+r0,r1 return value. (dpcmp return value on $2)
+00  special register
+r0-r3  input register
+r7-r9 saved register variable (input register for code segment)
+jump register
+sp    stack pointer
+fp    frame pointer
+f0       return value etc.
+r0-r3    input register
+f20-f31 saved register variable
+code segment stack frame
+register_save is done by callee
+(prev $sp)
+<---lvar_offset-->
+#                       $fp <--------------------r1_offset---------> $sp
+r+ +----------+-------------+--------+-------+-----------+---------------+
+cousin arg!  callee arg !reg_save!reg_arg!local       caller arg
+(arg4..)lvar>0         (arg0.3) lvar<0      lvar>0x1000 000
+<--------------my_func_args--><--disp-----><-max_func_arg->
+*SIZE_OF_INT                  *SIZE_OF_INT
+prev $sp=$fp                 $fp                        $sp
+(prev $sp)
+<------r1_offset----------------> $sp
+(prev $fp)           $fp
+r+  +-----------+--------------------+----------+-----------------------+
+callee arg      register save   local      caller arg
+disp          max_func_args*SIZE_OF_INT
+lvar<0          lvar>0x1000 0000
+prev $sp=$fp                                   $sp=$fp
+*/
+#define arg_offset (16)
+#define arg_offset1 (-64)
+int disp_offset=0;    // fore mc-codegen.c
+#define disp_offset  0
+#define code_disp_offset 0
+#define CODE_LVAR(l) ((l)+code_disp_offset)
+#define CODE_CALLER_ARG(l) ((l)+arg_offset1)
+#define FUNC_LVAR(l) (l+disp_offset)
+#define CALLER_ARG(l) ((l)+arg_offset1)
+#define CALLEE_ARG(l) ((l)+arg_offset)
+static int
+code_offset_set(NMTBL *fnptr)
+{
+int lvar_offsetv;
+int r1_offsetv;
+int code_f = is_code(fnptr);
+disp &= -SIZE_OF_INT;
+if (code_f) {
+	r1_offsetv = disp-max_func_args*SIZE_OF_INT+code_disp_offset;
+	printf("\t.set .LC%d, %d\n",r1_offset_label,r1_offsetv);
+} else {
+	lvar_offsetv =
+	    -12 - max_reg_var*SIZE_OF_INT-max_reg_var*SIZE_OF_DOUBLE;
+	printf("\t.set .LC%d, %d\n",lvar_offset_label,lvar_offsetv);
+}
+if (max_func_arg_label) {
+	printf("\t.set .LC%d, %d\n",max_func_arg_label,max_func_args*SIZE_OF_INT);
+max_func_arg_label = 0;
+}
+// printf("        @ args = %d, pretend = %d, frame = %d\n",
+// 	max_func_args,0,round16(-disp));
+// printf("        @ frame_needed = 1, current_function_anonymous_args = 0\n");
+#if 0
+printf("## vars= %d, regs= %d/%d, args= %d, extra= %d\n",
+	round16(-disp),
+	max_reg_var+2,
+	max_reg_var,
+	round16(max_func_args*SIZE_OF_INT),
+	0
+);
+printf("## callee arg top=\t%d\n",CALLEE_ARG(0));
+printf("## reg_save_top=\t\t%d\n",r1_offsetv);
+printf("## reg_save_end=\t\t%d\n",
+	-max_reg_var*SIZE_OF_INT-max_reg_var*SIZE_OF_FLOAT-2*SIZE_OF_INT+
+	r1_offsetv);
+printf("## lvar_offset=\t\t%d %d\n",lvar_offsetv,lvar_offsetv%16);
+printf("## min local var=\t%d\n",FUNC_LVAR(0)+lvar_offsetv);
+printf("## max local var=\t%d\n",FUNC_LVAR(disp)+lvar_offsetv);
+printf("## min caller arg var=\t%d\n",
+	CALLER_ARG(round16(max_func_args*SIZE_OF_INT)));
+printf("## max caller arg var=\t%d\n",CALLER_ARG(0));
+printf("##\n");
+#endif
+return 0;
+}
+#define LARGE_OFFSET(l) (l<-511||l>511)
+static void lvar_address(int l,int creg);
+static int large_lvar;
+static void
+lvar_intro(int l)
+{
+int large;
+if (is_code(fnptr)) {
+if (l>=ARG_LVAR_OFFSET) {
+	    large = LARGE_OFFSET(CODE_CALLER_ARG(l-ARG_LVAR_OFFSET));
+} else
+	    large = LARGE_OFFSET(CODE_LVAR(l));
+} else if (l<0) {  /* local variable */
+	    large = LARGE_OFFSET(FUNC_LVAR(l));
+} else if (l>=ARG_LVAR_OFFSET) {  /* caller's arguments */
+	    large = LARGE_OFFSET(CALLER_ARG(l-ARG_LVAR_OFFSET));
+} else { /* callee's arguments */
+	    large = LARGE_OFFSET(CALLEE_ARG(l));
+}
+if (large) {
+	large_lvar = get_register();
+	lvar_address(l,large_lvar);
+} else {
+	large_lvar = 0;
+}
+}
+static void
+lvar(int l,char *cext)
+{
+if (large_lvar) {
+	printf("[%s, 0]%s\n",register_name(large_lvar),cext);
+	free_register(large_lvar);
+	return;
+}
+if (is_code(fnptr)) {
+if (l>=ARG_LVAR_OFFSET) {  /* caller's arguments */
+printf("[sp, %d]%s\n",CODE_CALLER_ARG(l-ARG_LVAR_OFFSET),cext);
+} else
+printf("[fp, %d]%s\n",CODE_LVAR(l),cext);
+} else if (l<0) {  /* local variable */
+//printf("[fp, #%d+.L%d]%s\n",FUNC_LVAR(l),lvar_offset_label,cext);
+printf("%d($sp)\n",FUNC_LVAR(l));
+} else if (l>=ARG_LVAR_OFFSET) {  /* caller's arguments */
+printf("[sp, %d]%s\n",CALLER_ARG(l-ARG_LVAR_OFFSET),cext);
+} else { /* callee's arguments */
+printf("[fp, %d]%s\n",CALLEE_ARG(l),cext);
+}
+}
+static void
+lvar_address(int l,int creg)
+{
+//int label,disp;
+int disp;
+int tmp = -1;
+char *trn;
+if (is_code(fnptr)) {
+if (l>=ARG_LVAR_OFFSET) {  /* caller's arguments */
+	    code_add(creg,CODE_CALLER_ARG(l-ARG_LVAR_OFFSET),REG_sp);
+} else
+	    code_add(creg,CODE_LVAR(l),REG_fp);
+} else if (l<0) {  /* local variable */
+//        printf("\tsf\t%s, fp, %d\n",register_name(creg), FUNC_LVAR(l));
+	trn = register_name(tmp = get_register());
+	//disp = search_const(LVAR,glist2(lvar_offset_label,FUNC_LVAR(l)),&label);
+printf("\tlqd\t%s, %d($sp)\n",trn,(disp*4));
+	printf("\tadd\t%s, fp, %s\n",register_name(creg),trn);
+} else if (l>=ARG_LVAR_OFFSET) {  /* caller's arguments */
+	code_add(creg,CALLER_ARG(l-ARG_LVAR_OFFSET),REG_sp);
+} else { /* callee's arguments */
+	code_add(creg,CALLEE_ARG(l),REG_fp);
+}
+if (tmp!=-1) free_register(tmp);
+}
+void
+code_lvar(int e2,int reg) {
+use_int(reg);
+lvar_address(e2,reg);
+}
+void
+code_init(void)
+{
+/* called only once */
+size_of_int = SIZE_OF_INT;
+size_of_short = SIZE_OF_SHORT;
+size_of_float = SIZE_OF_FLOAT;
+size_of_double = SIZE_OF_DOUBLE;
+size_of_longlong = SIZE_OF_LONGLONG;
+endian = ENDIAN;
+init_src = init_src0;
+}
+extern void
+emit_reinit()
+{
+/* called for each file */
+init_ptr_cache();
+output_mode = -1;
+}
+void
+gexpr_code_init(void){
+}
+void
+code_gexpr(int e){
+if (is_int_reg(creg) && creg!=ireg) error(-1);
+//  register_usage("code_gexpr");
+}
+void
+code_arg_register(NMTBL *fnptr)
+{
+int args = fnptr->dsp;
+NMTBL *n;
+int reg_var = 0;
+int freg_var = 0;
+int type;
+int reg;
+int i;
+int is_code0 = is_code(fnptr);
+int dots;
+function_type(fnptr->ty,&dots);
+while (args) {
+/* process in reverse order */
+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);
+regs[n->dsp]= INPUT_REG;
+reg_var++;
+cadddr(args)=SIZE_OF_INT;
+}
+} else if (type==FLOAT) {
+	    if (is_function(fnptr)) {
+		if ((reg = get_input_dregister_var(reg_var,n,is_code0,0))) {
+		    n->sc = REGISTER;
+		    n->dsp = cadr(reg);
+		    regs[n->dsp]= INPUT_REG;
+		    reg_var++;
+		    cadddr(args)=size(type);
+		}
+	    } else {
+		if ((reg = get_input_dregister_var(freg_var,n,is_code0,0))) {
+		    n->sc = FREGISTER;
+		    n->dsp = cadr(reg);
+		    regs[n->dsp]= INPUT_REG;
+		    freg_var++;
+		    cadddr(args)=size(type);
+		}
+	    }
+} else if (type==DOUBLE) {
+if ((reg = get_input_dregister_var(reg_var,n,is_code0,1))) {
+n->sc = LREGISTER;
+n->dsp = cadr(reg);
+regs[i=n->dsp]= INPUT_DREG;
+regs[i]= INPUT_REG;
+//regs[i]= INPUT_REG;
+reg_var+=2;
+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 = cadr(reg);
+regs[i=n->dsp]= INPUT_REG;
+regs[i]= INPUT_REG;
+//regs[(i)]= INPUT_REG;
+reg_var+=2;
+cadddr(args)=size(type);
+}
+}
+args = cadr(args);
+}
+if (is_function(fnptr))
+	code_save_input_registers(dots);
+}
+int
+get_register(void)
+{    /* 使われていないレジスタを調べる */
+int i,j,reg;
+for(i=MAX_TMP_REG;i>=MIN_TMP_REG;i--) {
+	if (regs[i]) continue;  /* 使われている */
+	regs[i]=USING_REG;      /* そのレジスタを使うことを宣言し */
+	return i;   /* その場所を表す番号を返す */
+}
+for(i=0;i<REG_VAR_MAX-REG_VAR_MIN;i++) {
+reg =REG_VAR_BASE+i;
+if (! regs[reg]) {       /* 使われていないなら */
+regs[reg]=USING_REG; /* そのレジスタを使うことを宣言し */
+	    if (i+1>max_reg_var) max_reg_var=i+1;
+		return reg;   /* その場所を表す番号を返す */
+}
+}
+/* search register stack */
+for(i=0;i<reg_sp;i++) {
+	if ((reg=reg_stack[i])>0) {
+code_assign_lvar(
+(j=new_lvar(SIZE_OF_INT)*4),reg,0);
+reg_stack[i]= j-REG_LVAR_OFFSET;
+		return reg;
+	}
+}
+#if LONGLONG_CODE||FLOAT_CODE
+/* search register stack */
+for(i=0;i<reg_sp;i++) {
+	if ((reg=reg_stack[i])>0) {
+code_lassign_lvar(
+(j=new_lvar(SIZE_OF_LONGLONG)),reg);
+reg_stack[i]= j-REG_LVAR_OFFSET;
+	    free_register(reg);
+	    return get_register();
+	}
+}
+#endif
+/* 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;   /* その場所を表す番号を返す */
+}
+for(i=0;i<REG_VAR_MAX-REG_VAR_MIN;i++) {
+reg =REG_VAR_BASE+i;
+	/* PTR_CACHE をつぶす */
+	if (regs[reg]==PTRC_REG) {
+	    clear_ptr_cache_reg(reg);
+	    regs[reg]=0;
+	    return reg;   /* その場所を表す番号を返す */
+}
+}
+/* あいている場所がないなら、エラー（いったい誰が使ってるの？) */
+error(RGERR); return creg;
+}
+#if 0
+int
+get_register(void)
+{
+int i = get_register0();
+printf("## get_register %d\n",i);
+//printf("hoge:%d\n",i);
+	return i;
+}
+#endif
+int
+pop_register(void)
+{    /* レジスタから値を取り出す */
+	return reg_stack[--reg_sp];
+}
+#if FLOAT_CODE
+int
+get_dregister(int d)
+{    /* 使われていないレジスタを調べる */
+return get_register();
+}
+#if 0
+int
+get_dregister(int d)
+{
+int i = get_dregister0(d);
+printf("## get_dregister %d\n",i);
+return i;
+}
+#endif
+int
+pop_fregister(void)
+{   /* レジスタから値を取り出す */
+	return reg_stack[--reg_sp];
+}
+#endif
+// static int lreg_count;
+int
+get_lregister0()
+{
+	return get_register();
+}
+int
+get_lregister()
+{
+	return get_register();
+}
+int
+get_lregister_var(NMTBL *n)
+{
+	return get_register_var(n);
+}
+void
+emit_pop_free(int xreg)
+{
+if (xreg>=0 && xreg!=creg)
+	free_register(xreg);
+}
+void
+free_register(int i) {    /* いらなくなったレジスタを解放 */
+// printf("## free_register %d\n",i);
+regs[i]=0;
+//   if (is_longlong_reg(i)) {
+// printf("## free lregister %d (%d)\n",i,lreg_count++);
+//	regs[(i)]=0;
+//	regs[(i)]=0;
+	//(i)=0;
+	//(i)=0;
+//  }
+}
+extern void
+use_ptr_cache(int r)
+{
+regs[r]=PTRC_REG;
+}
+int
+get_input_dregister_var(int i,NMTBL *n,int is_code,int d)
+{
+int j;
+if (is_code) {
+	if(i>MAX_CODE_INPUT_DREGISTER_VAR) return 0;
+	i = FREG_VAR_BASE+i+FREG_OFFSET;
+	use_input_reg(i,1);
+	return list3(FREGISTER,i,(int)n);
+}
+if (d) {
+	j = get_input_lregister_var(i,n,is_code);
+	return j;
+} else {
+	if (i==0) return list3(REGISTER,1,(int)n);
+	else if (i==1) return list3(REGISTER,2,(int)n);
+	else if (i==2) return list3(REGISTER,3,(int)n);
+	else if (i==3) return list3(REGISTER,4,(int)n);
+	else return 0;
+}
+}
+int
+get_input_lregister_var(int i,NMTBL *n,int is_code)
+{
+	return get_input_register_var(i,n,is_code);
+}
+int
+get_input_register_var(int i,NMTBL *n,int is_code)
+{
+if (is_code) {
+	if(!(i<REG_VAR_MAX-REG_VAR_MIN)) return 0;
+	i = REG_VAR_BASE+i;
+	use_input_reg(i,1);
+} else {
+	if (i<0||i>=MAX_INPUT_REGISTER_VAR) return 0;
+	i = i+1;
+}
+return list3(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]) count++;
+}
+for(i=0;i<MAX_REGISTER;i++) {
+if (! regs[i+FREG_OFFSET]) fcount++;
+}
+printf("## free reg %d freg %d\n",count,fcount);
+return d?fcount:count;
+}
+#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;
+// printf("## free_all register\n");
+#if LONGLONG_CODE||FLOAT_CODE
+for(i=0;i<REAL_MAX_REGISTER;i++) {
+	regs[i+LREG_OFFSET]=0;
+}
+lreg = 0;
+// set_lreg(LREG_LREGISTER,0);
+#endif
+for(i=0;i<MAX_REGISTER;i++) { regs[i]=0; }
+#if FLOAT_CODE
+for(i=0;i<MAX_REGISTER;i++) { regs[i+FREG_OFFSET]=0; }
+freg = get_dregister(1);
+set_freg(FREG_FREGISTER,0);
+#endif
+ireg = creg = get_register();
+set_ireg(CREG_REGISTER,0);
+return;
+}
+extern int
+code_register_overlap(int s,int t)
+{
+switch(car(s)) {
+case REGISTER:
+	switch(car(t)) {
+	case FREGISTER: break;
+	case REGISTER:
+	    return cadr(s)==cadr(t);
+	    break;
+	case LREGISTER: case DREGISTER:
+	    if(cadr(s)==(cadr(t))) return 1;
+	    if(cadr(s)==(cadr(t))) return 1;
+	    break;
+	}
+	break;
+case FREGISTER:
+	switch(car(t)) {
+	case REGISTER: case LREGISTER: case DREGISTER: break;
+	case FREGISTER:
+	    return cadr(s)==cadr(t);
+	    break;
+	}
+	break;
+case DREGISTER:
+case LREGISTER:
+	switch(car(t)) {
+	case FREGISTER: break;
+	case REGISTER:
+	    if(cadr(t)==(cadr(s))) return 1;
+	    if(cadr(t)==(cadr(s))) return 1;
+	    break;
+	case LREGISTER: case DREGISTER:
+	    if((cadr(t))==(cadr(s))) return 1;
+	    if((cadr(t))==(cadr(s))) return 1;
+	    if((cadr(t))==(cadr(s))) return 1;
+	    if((cadr(t))==(cadr(s))) return 1;
+	    break;
+	}
+	break;
+}
+return 0;
+}
+void
+register_usage(char *s)
+{
+#if 1
+int i,j;
+#endif
+#define USAGE_MAX 4
+if (!lsrc) return;
+printf("## %d: %s:",lineno,s);
+if (ireg) printf(" creg=%s",register_name(ireg));
+if (freg) printf(" freg=%s",register_name(freg));
+if (lreg) printf(" lreg=%s,%s",lregister_name_high(lreg),
+	lregister_name_low(lreg));
+#if 1
+for(j=0,i=1;i<MAX_REGISTER;i++) if (regs[i]) j++;
+if (j>USAGE_MAX) {
+	// printf("\n# regs:01234567890123456789012");
+	printf("\n# regs:");
+	for(i=1;i<MAX_REGISTER;i++) {  printf("%d",regs[i]); }
+}
+if (reg_sp>0) {
+	printf(" stack ");
+	for(i=reg_sp;i>0;i--) {
+	    if(reg_stack[i-1]>=0) {
+		printf(" %s",register_name(reg_stack[i-1]));
+} else
+		printf(",%d",reg_stack[i-1]);
+	}
+}
+for(j=0,i=0;i<MAX_REGISTER;i++) if (regs[i+FREG_OFFSET]) j++;
+if (j>USAGE_MAX) {
+	printf("\n# freg:");
+	for(i=0;i<MAX_REGISTER;i++) {  printf("%d",regs[i+FREG_OFFSET]); }
+}
+if (reg_sp>0) {
+	printf(" fstack ");
+	for(i=reg_sp;i>0;i--) {
+	    if(reg_stack[i-1]>=0) {
+		printf(" %s",register_name(reg_stack[i-1]));
+} else
+		printf(",%d",reg_stack[i-1]);
+	}
+}
+for(j=0,i=0;i<REAL_MAX_REGISTER;i++) if (regs[i+LREG_OFFSET]) j++;
+if (j>USAGE_MAX) {
+	printf("\n# lreg:");
+	for(i=0;i<REAL_MAX_REGISTER;i++) {  printf("%d",regs[i+LREG_OFFSET]); }
+}
+if (reg_sp>0) {
+	printf(" lstack ");
+	for(i=reg_sp;i>0;i--) {
+	    if(reg_stack[i-1]>=0) {
+		printf(" %s",lregister_name_high(reg_stack[i-1]));
+		printf(",%s",lregister_name_low(reg_stack[i-1]));
+} else
+		printf(",%d",reg_stack[i-1]);
+	}
+}
+#endif
+printf("\n");
+}
+void
+gexpr_init(void)
+{
+while(reg_sp > 0) {
+	error(-1);
+	free_register(reg_stack[--reg_sp]);
+}
+while(reg_sp > 0) {
+	error(-1);
+	free_register(reg_stack[--reg_sp]);
+}
+while(reg_sp > 0) {
+	error(-1);
+	free_register(reg_stack[--reg_sp]);
+}
+use_int0();
+text_mode(2);
+gexpr_code_init();
+register_usage("");
+}
+void
+emit_init(void)
+{
+/* called before each declaration */
+free_all_register();
+max_reg_var=0; max_reg_var=0;
+reg_sp = 0;
+reg_sp = 0;
+}
+#define reg_var_num(i) (REG_VAR_BASE+i)
+int
+get_register_var(NMTBL *n)
+{
+int i,j;
+int max = n?REG_VAR_USER_MAX-REG_VAR_BASE:REG_VAR_MAX-REG_VAR_BASE;
+for(i=0;i<max;i++) {
+	j = reg_var_num(i);
+	if (! regs[j]) {       /* ??͡??????ˡ????ϡ????ϡ?? */
+	    /* ????ۡ???????????͡??????͡?????????? */
+	    regs[j]=USING_REG;
+	    if (i+1>=max_reg_var) max_reg_var=i+1;
+	    /* ????ۥ???????Υ?????襱?????衢? */
+	    return list3(REGISTER,j,(int)n);
+	}
+}
+return list3(LVAR,new_lvar(SIZE_OF_INT),0);
+}
+#define freg_var_num(i) (FREG_VAR_BASE+i+FREG_OFFSET)
+int
+get_dregister_var(NMTBL *n,int d)
+{
+int i,j;
+for(i=0;i<FREG_VAR_MAX-FREG_VAR_BASE;i++) {
+	j = freg_var_num(i);
+	if (! regs[j]) {       /* 使われていないなら */
+	    regs[j]=USING_REG; /* そのレジスタを使うことを宣言し */
+	    if (i+1>max_reg_var) max_reg_var=i+1;
+	    /* その場所を表す番号を返す */
+	    return list3(FREGISTER,j,(int)n);
+	}
+}
+}
+int
+emit_push()
+{
+int new_reg,old=creg;
+if (!is_int_reg(creg)) error(-1);
+if (reg_sp>MAX_MAX) error(-1);
+new_reg = get_register();       /* 絶対にとれる */
+if (new_reg==creg) error(-1);   /* who freed creg? */
+reg_stack[reg_sp++] = creg;     /* push するかわりにレジスタを使う */
+ireg = creg = new_reg;
+if (!regs[creg]) regs[creg]=USING_REG;
+return old;
+}
+int
+emit_pop(int type)
+{
+int xreg,reg;
+xreg=pop_register();
+if (xreg<= -REG_LVAR_OFFSET) {
+	reg = get_register();
+code_rlvar(REG_LVAR_OFFSET+xreg,reg);
+	free_lvar(REG_LVAR_OFFSET+xreg);
+	xreg = reg;
+}
+return xreg;
+}
+static int const_list;
+static int const_list_label;
+static int prev_const_list;
+static int prev_const_list_label;
+/*
+constant table
+glist3( tag, next, value )
+		LVAR       	glist2(label,offset)
+		GVAR       	nptr
+		CONST		value
+		LABEL		value
+nth element has offset n * SIZE_OF_INT
+*/
+#define CONST_TBL_COUNT 100
+/*
+static int
+search_const(int tag,int value,int *label)
+{
+int p,i,j,list,prev;
+for(j=0;j<2;j++) {
+	i = 0;
+	if(j==1) {
+	    if (!const_list_label) const_list_label = fwdlabel();
+	    *label = const_list_label;
+	    if (const_list==0) {
+		const_list = glist3(tag,0,value);
+		return 0;
+	    } else {
+		prev = list = const_list;
+	    }
+	} else {
+	    prev = list = prev_const_list; *label = prev_const_list_label;
+	}
+	for(p = list; p ;prev=p,p=cadr(p),i+=SIZE_OF_INT) {
+	    if (car(p)!=tag) continue;
+	    switch(tag) {
+	    case GVAR: case CONST: case LABEL:
+		if (caddr(p)!=value) continue;
+		return i;
+	    case LVAR:
+		if (car(caddr(p))!=car(value)) continue;
+		if (cadr(caddr(p))!=cadr(value)) continue;
+		return i;
+	    }
+	}
+}
+cadr(prev) = glist3(tag,0,value);
+if (i>CONST_TBL_COUNT) {
+	const_list_table();
+}
+return i;
+}
+*/
+#if FLOAT_CODE
+static int
+search_double_const(int tag,int value1,int value2,int *label)
+{
+int p,i,j,list,prev;
+for(j=0;j<2;j++) {
+	i = 0;
+	if(j==1) {
+	    if (!const_list_label) const_list_label = fwdlabel();
+	    *label = const_list_label;
+	    if (const_list==0) {
+		const_list = glist3(tag,glist3(tag,0,value2),value1);
+		return 0;
+	    } else {
+		prev = list = const_list;
+	    }
+	} else {
+	    prev =list = prev_const_list; *label = prev_const_list_label;
+	}
+	for(p = list; p ;prev=p,p=cadr(p),i+=SIZE_OF_INT) {
+	    if (car(p)!=tag) continue;
+	    switch(tag) {
+	    case DCONST: case LCONST:
+		if (caddr(p)!=value1) continue;
+		p = cadr(p);
+		if (!p||car(p)!=tag) error(-1);
+		if (caddr(p)!=value2) continue;
+		return i;
+	    }
+	    prev = p;
+	}
+}
+cadr(prev) = glist3(tag,glist3(tag,0,value2),value1);
+if (i>CONST_TBL_COUNT) {
+	const_list_table();
+}
+return i;
+}
+#endif
+static int inst_count;
+static void
+const_list_table()
+{
+int p,lb=0;
+inst_count = 0;
+if (const_list) {
+	if (control) {
+	    lb = fwdlabel();
+	    gen_jmp(lb);
+	    // printf("\t.align\t2\n");
+	}
+	fwddef(const_list_label);
+	control=0;
+	for(p = const_list; p ; p = cadr(p)) {
+	    switch(car(p)) {
+	    case GVAR:	printf("\t.word\t%s\n",((NMTBL *)caddr(p))->nm); break;
+	    case DCONST: case LCONST:
+	    case CONST:	printf("\t.word\t%d\n",caddr(p)); break;
+	    case LABEL:	printf("\t.word\t.LC%d\n",caddr(p)); break;
+	    case LVAR:	printf("\t.word\t.LC%d+%d\n",
+		car(caddr(p)),cadr(caddr(p))); break;
+	    default: error(-1);
+	    }
+	}
+	if (lb) {
+	    fwddef(lb);  // control==1 now
+	}
+	prev_const_list_label=const_list_label;
+	const_list_label = 0;
+}
+for(p = prev_const_list; p ; p = cadr(p)) {
+	if (car(p)==LVAR) {
+	    free_glist2(caddr(p));
+	}
+}
+free_glist3_a(prev_const_list);
+prev_const_list=const_list;
+const_list = 0;
+}
+extern void
+code_ptr_cache_def(int r, NMTBL *nptr)
+{
+//int label,disp;
+int disp;
+char *rrn = register_name(r);
+//disp = search_const(GVAR,(int)nptr,&label);
+printf("\tlqd\t%s, %d($sp)\n",rrn,(disp*4));
+}
+#define mask8(d,bit)   (d & (255 << bit))
+/*
+mode   CONST or other (CMP is Ok only in stage 1 result)
+*p1    stage 1 const
+*p2    stage 2 const
+*p3    stage 3 const
+return 0 ... require 4 stage
+1 ... positive result
+-1 ... negative result
+*/
+static int
+make_const(int c,int *p1,int *p2,int *p3,int mode)
+{
+int sign,im,jm,km;
+int min_stage = 4;
+int msign=0,mim=0,mjm,mkm;
+int id,jd,kd;
+int i,j,k;
+int d;
+if (c == (d = mask8(c,0))) {
+	min_stage=1; min_stage=1; msign = 1;
+	    mim = d;mjm = 0;mkm = 0;
+} else if (mode!=CONST) {
+	if (-c == (d = mask8(-c,0))) {
+	    min_stage=1; min_stage=1; msign = -1;
+		mim = d;mjm = 0;mkm = 0;
+	}
+} else {
+	if (~c== (d = mask8(~c,0))) {
+	    min_stage=1; min_stage=1; msign = -1;
+		mim = d;mjm = 0;mkm = 0;
+	}
+}
+for(sign=1;sign>=-1;sign-=2) {
+	if (min_stage==1) break;
+for(i=24;i>=0;i-=2) {
+	    jm = km = 0;
+	    if (sign>0) {
+		if (c == (d = mask8(c,i))) {
+		    min_stage=1; min_stage=1; msign = 1;
+			mim = d;mjm = 0;mkm = 0;
+		    break;
+		}
+		id = c - d;
+	    } else if (mode!=CONST) {
+		if (-c == (d = mask8(-c,i))) {
+		    min_stage=1; min_stage=1; msign = -1;
+			mim = d;mjm = 0;mkm = 0;
+		    break;
+		}
+		id = -c - d;
+	    } else {
+		if (~c== (d = mask8(~c,i))) {
+		    min_stage=1; min_stage=1; msign = -1;
+			mim = d;mjm = 0;mkm = 0;
+		    break;
+		}
+		id = ~c - d;
+	    }
+	    if (d==0) continue;
+	    im = d;
+	    if (min_stage<=2) continue;
+for(j=i-8;j>=0;j-=2) {
+		km = 0;
+if (!(jm=mask8(id,j))) continue;
+jd = id - jm;
+		if (jd==0) {
+		    min_stage=2; msign = sign;
+		    mim = im;mjm = jm;mkm = km;
+		    break;
+		}
+		if (min_stage<=3) continue;
+for(k=j-8;k>=0;k-=2) {
+if (!(km=mask8(jd,k))) continue;
+kd = jd - km;
+		    if (kd==0) {
+			min_stage=3; msign = sign;
+			mim = im;mjm = jm;mkm = km;
+			break;
+		    }
+}
+}
+}
+}
+if (min_stage<=3) {
+	*p1 = mim; *p2= mjm; *p3 = mkm;
+	return msign;
+} else return 0;
+}
+static int
+is_stage1_const(int c,int mode)
+{
+int sign,p1=0,p2=0,p3=0;
+sign = make_const(c,&p1,&p2,&p3,mode);
+return (c==0||(p1&&!p2&&!p3))?sign:0;
+}
+static void
+code_const0(int e2,int reg,char *opt)
+{
+char *crn,*add,*mov;
+int s,p1,p2,p3;
+//int label,disp;
+int disp;
+use_int(reg);
+crn = register_name(reg);
+if ((s=make_const(e2,&p1,&p2,&p3,CONST))) {
+	add = s>0?"a":"sfi";
+	/************************************************************
+	 * ここでp1の値によって、命令が異なる......                 *
+	 * il命令は-32768~32767                                     *
+	 * ila命令は262143まで                                      *
+	 * それ以上はilhuとiohlを混合して使う。                     *
+	 * example:15728639                                         *
+	 *     15728639/16^4 = 239             ilhu  $4,239         *
+	 *     15728639%16^4 = 65535           iohl  $4,65535       *
+	 ***********************************************************/
+	mov = s>0?"il":"mvn";
+	printf("\t%s\t%s, %d\n",mov,crn,p1);
+	if (p2) printf("\t%s\t%s, %s, %d\n",add,crn,crn,p2);
+	if (p3) printf("\t%s\t%s, %s, %d\n",add,crn,crn,p3);
+} else {
+	//disp = search_const(CONST,e2,&label);
+	printf("\tlqd\t%s, %d($sp)\n",crn,(disp*4));
+}
+}
+extern void
+code_const(int e2,int reg) {
+code_const0(e2,reg,"");
+}
+static void
+code_add(int reg,int offset,int r)
+{
+char *crn = register_name(reg);
+char *rrn = register_name(r);
+char *drn;
+int dreg;
+int s,p1,p2,p3;
+char *add;
+//int label,disp;
+int disp;
+if (offset==0) {
+if(r!=reg)
+printf("\tori\t%s, %s, 0\n",crn,rrn);
+} else if ((s=make_const(offset,&p1,&p2,&p3,0))) {
+	add = s>0?"a":"sfi";
+	printf("\t%s\t%s, %s, %d\n",add,crn,rrn,p1);
+	if (p2) printf("\t%s\t%s, %s, %d\n",add,crn,crn,p2);
+	if (p3) printf("\t%s\t%s, %s, %d\n",add,crn,crn,p3);
+} else {
+	//disp = search_const(CONST,offset,&label);
+	drn = register_name(dreg = get_register());
+	printf("\tlqd\t%s, %d($sp)\n",drn,(disp*4));
+	printf("\ta\t%s, %s, %s\n",crn,drn,rrn);
+	free_register(dreg);
+}
+}
+static void
+code_ld(char *ld,int reg,int offset,int r,char *cext)
+{
+char *crn = register_name(reg);
+char *rrn = register_name(r);
+if (-1024<offset&&offset<1024) {
+	printf("\t%s\t%s, [%s, %d]%s\n",ld,crn,rrn,offset,cext);
+} else {
+	code_add(reg,offset,r);
+	printf("\t%s\t%s, [%s, 0]%s\n",ld,crn,crn,cext);
+}
+}
+static void
+code_ldf(char *ld,char *crn,int offset,int r,char *cext)
+{
+//char *rrn = register_name(r);
+char *orn;
+int reg;
+if (-1024<offset&&offset<1024) {
+	printf("\t%s\t%s, %d(%s)\n",ld,crn,(offset*4),cext);
+} else {
+	orn = register_name(reg=get_register());
+	code_add(reg,offset,r);
+	//printf("\t%s\t%s, [%s, 0]%s\n",ld,crn,orn,cext);
+	printf("hoge\n");
+	free_register(reg);
+}
+}
+#define cload(sz,sign) \
+(sz==1?(sign?"lqx":"lqa"):sz==SIZE_OF_SHORT?(sign?"lqx":"lqa"):"lqd")
+#define cext(sign,sz,reg)
+static char *
+cext_at(int sz,int sign)
+{
+return ((sz==1&&!sign)?"  @ zero_extendqisi2":"");
+}
+void
+code_label(int labelno)
+{
+clear_ptr_cache();
+printf(".LC%d:\n",labelno);
+}
+void
+code_gvar(int e1,int reg) {
+use_int(reg);
+code_add(reg,cadr(e1),get_ptr_cache((NMTBL*)caddr(e1)));
+return;
+}
+void
+code_rgvar(int e1,int reg) {
+use_int(reg);
+code_ld("lqd",reg,cadr(e1),get_ptr_cache((NMTBL*)caddr(e1)),"");
+}
+void
+code_crgvar(int e1,int reg,int sign,int sz){
+use_int(reg);
+code_ld(cload(sz,sign),reg,cadr(e1),get_ptr_cache((NMTBL*)caddr(e1)),
+	cext_at(sz,sign));
+cext(sign,sz,reg);
+}
+void
+code_register(int e2,int reg) {
+use_int(reg);
+// reg = e2
+if (reg!=e2) {
+	printf("\tori\t%s, %s, 0\n",register_name(reg),register_name(e2));
+}
+}
+void
+code_rlvar(int e2,int reg) {
+use_int(reg);
+lvar_intro(e2);
+printf("\tlqd\t%s, ",register_name(reg));
+e2 *= 4;
+	lvar(e2,"");
+}
+extern void
+code_i2c(int reg)
+{
+}
+extern void
+code_i2s(int reg)
+{
+}
+extern void
+code_u2uc(int reg)
+{
+use_int(reg);
+printf("and\t%s, %s, #255\n",register_name(reg),register_name(reg));
+}
+extern void
+code_u2us(int reg)
+{
+use_int(reg);
+printf("bic\t%s, %s, #16711680\n",register_name(reg),register_name(reg));
+printf("bic\t%s, %s, #-16777216\n",register_name(reg),register_name(reg));
+}
+void
+code_crlvar(int e2,int reg,int sign,int sz) {
+use_int(reg);
+lvar_intro(e2);
+printf("\t%s\t%s, ",cload(sz,sign),register_name(reg));
+lvar(e2,cext_at(sz,sign));
+cext(sign,sz,reg);
+}
+void
+code_fname(NMTBL *n,int reg) {
+int r;
+use_int(reg);
+r = get_ptr_cache(n);
+if(r!=reg) {
+	printf("\tori\t%s, %s, 0\n",register_name(reg),register_name(r));
+}
+return;
+}
+void
+code_label_value(int label,int reg) {
+//int lb,disp;
+use_int(reg);
+//disp = search_const(LABEL,label,&lb);
+printf("\tila\t%s,.LC%d\n",register_name(reg),label);
+return;
+}
+void
+code_neg(int creg) {
+use_int(creg);
+printf("\trsb\t%s, %s, #0\n", register_name(creg), register_name(creg));
+}
+void
+code_not(int creg) {
+use_int(creg);
+printf("\tmvn\t%s, %s\n",
+	register_name(creg), register_name(creg));
+}
+void
+code_lnot(int creg) {
+use_int(creg);
+printf("\tcmp\t%s, #0\n", register_name(creg));
+printf("\tmovne\t%s, #0\n", register_name(creg));
+printf("\tmoveq\t%s, #1\n", register_name(creg));
+}
+void
+code_preinc(int e1,int e2,int dir,int sign,int sz,int reg) {
+char *xrn,*drn;
+int xreg;
+if (car(e2)==REGISTER) {
+	use_int(reg);
+	code_add(cadr(e2),dir,cadr(e2));
+	if (reg!=cadr(e2))
+	    code_register(cadr(e2),reg);
+	return;
+}
+g_expr(e2);
+if (!is_int_reg(creg)) error(-1);
+xrn = register_name(xreg = creg);
+if (reg==USE_CREG) {
+	reg=get_register(); if (!reg) error(-1);
+	drn = register_name(reg);
+	set_ireg(reg,0);
+} else {
+	drn = register_name(reg);
+}
+//        ldrb    r2, [ip, #-1]!  @ zero_extendqisi2
+//        ??????offset???????????12bit!
+code_ld(cload(sz,sign),reg,0,xreg,cext_at(sz,sign));
+code_add(reg,dir,reg);
+code_ldf(cstore(sz),drn,0,xreg,sz==SIZE_OF_SHORT?"  @ movhi":"");
+}
+void
+code_postinc(int e1,int e2,int dir,int sign,int sz,int reg) {
+char *xrn,*crn,*nrn;
+int nreg,xreg;
+if (car(e2)==REGISTER) {
+	use_int(reg);
+	code_register(cadr(e2),reg);
+	code_add(cadr(e2),dir,cadr(e2));
+	return;
+}
+g_expr(e2);
+if (!is_int_reg(creg)) error(-1);
+crn = register_name(xreg=creg);
+nreg=get_register(); if (!nreg) error(-1);
+nrn = register_name(nreg);
+if (reg==USE_CREG) {
+	reg=get_register(); if (!reg) error(-1);
+	xrn = register_name(reg);
+	set_ireg(reg,0);
+} else {
+	xrn = register_name(reg);
+}
+//_1:     ldrb    r4, [r0], #1            @ zero_extendqisi2 *buffer++
+code_ld(cload(sz,sign),reg,0,xreg,cext_at(sz,sign));
+code_add(nreg,dir,reg);
+code_ldf(cstore(sz),nrn,0,xreg,sz==SIZE_OF_SHORT?"  @ movhi":"");
+free_register(nreg);
+}
+void
+code_return(int creg) {
+//int label,disp;
+int disp;
+char *crn;
+use_int(creg);
+crn = register_name(creg);
+//disp = search_const(LABEL,retcont,&label);
+printf("\tlqd\t%s, %d($sp)\n",crn,(disp*4));
+}
+void
+code_environment(int creg) {
+/* save frame pointer */
+if (is_code(fnptr)) {
+	use_int(creg);
+	printf("\tmov\t%s, fp\n",register_name(creg));
+} else {
+	//int disp,label;
+	int disp;
+	char *trn = register_name(REG_ip);
+	use_int(creg);
+	//disp = search_const(LVAR,glist2(lvar_offset_label,FUNC_LVAR(0)),&label);
+	printf("\tlqa\t%s, %d\n",trn,disp);
+	printf("\ta\t%s, fp, %s\n",register_name(creg),trn);
+}
+}
+static int rexpr_bool(int e1, int reg);
+#if LONGLONG_CODE
+static int lrexpr_bool(int e1, int reg);
+#endif
+void
+code_bool(int e1,int reg) {
+int e2,e3;
+char *xrn;
+if (rexpr_bool(e1, reg)) return;
+#if LONGLONG_CODE
+if (lrexpr_bool(e1, reg)) return;
+#endif
+b_expr(e1,1,e2=fwdlabel(),1);  /* including > < ... */
+if (use) {
+use_int(reg);
+xrn = register_name(reg);
+printf("\tmov\t%s, #0\n",xrn);
+gen_jmp(e3=fwdlabel());
+fwddef(e2);
+printf("\tmov\t%s, #1\n",xrn);
+fwddef(e3);
+} else {
+fwddef(e2);
+}
+}
+void
+code_cmp_crgvar(int e1,int reg,int sz,int label,int cond) {
+use_int(reg);
+code_ld(cload(sz,0),reg,cadr(e1),get_ptr_cache((NMTBL*)caddr(e1)),
+	cext_at(sz,0));
+cext(0,sz,r);
+printf("\tcmp\t%s, #0\n",register_name(reg));
+jcond(label,cond);
+}
+void
+code_cmp_crlvar(int e2,int reg, int sz,int label,int cond) {
+char *crn;
+use_int(reg);
+crn = register_name(reg);
+lvar_intro(e2);
+printf("\t%s\t%s, ",cload(sz,0),crn);
+lvar(e2,cext_at(sz,0));
+cext(0,sz,reg);
+code_cmp_register(reg,label,cond);
+}
+void
+code_cmp_rgvar(int e1,int reg,int label,int cond) {
+use_int(reg);
+code_ld("lqd",reg,cadr(e1),get_ptr_cache((NMTBL*)caddr(e1)),"");
+code_cmp_register(reg,label,cond);
+}
+void
+code_cmp_rlvar(int e2,int reg,int label,int cond) {
+char *crn;
+use_int(reg);
+crn = register_name(reg);
+lvar_intro(e2);
+printf("\tlqd\t%s, ",crn);
+e2 *= 4;
+	lvar(e2,"");
+code_cmp_register(reg,label,cond);
+}
+void
+code_cmp_register(int e2,int label,int cond) {
+use_int(e2);
+printf("\tcmp\t%s, #0\n",register_name(e2));
+jcond(label,cond);
+}
+void
+code_string(int e1,int creg)
+{
+char *s,*crn;
+//int lb,label;
+int lb;
+	printf("creg:%d\n",creg);
+	NMTBL *n = (NMTBL *)cadr(e1);
+if ((lb=attr_value(n,LABEL))) {
+	// already defined
+	return code_label_value(lb,creg) ;
+	//return code_label_value(lb,35) ;
+}
+use_int(creg);
+crn = register_name(creg);
+s=n->nm;
+lb = emit_string_label();
+ascii(s);
+text_mode(2);
+//disp = search_const(LABEL,lb,&label);
+printf("\tila\t%s, .LC%d\n",crn,lb);
+set_attr(n,LABEL,lb);
+}
+#define MAX_COPY_LEN 20
+void
+emit_copy(int from,int  to,int length,int offset,int value,int det)
+{
+char *frn;
+char *trn;
+char *drn;
+char *memmove = "memmove";
+int dreg = REG_ip;
+drn	 = register_name(dreg);
+use_int(from);
+use_int(to);
+frn =	register_name(from);
+trn =	register_name(to);
+/* length <0 means upward direction copy */
+switch (length) {
+case 0:	break;
+case 1: case -1:
+	printf("\tlqd\t%s, %d(%s)\n",drn,(offset*4),trn);
+	printf("\tstqd\t%s,%d(%s)\n",drn,(offset*4),trn);
+	break;
+case 2: case -2:
+	printf("\tlqx\t%s, [%s,#%d]\n",drn,frn,offset);
+	printf("\tstqx\t%s, [%s,#%d]\n",drn,trn,offset);
+	break;
+case 4: case -4:
+	printf("\tlqa\t%s, [%s,#%d]\n",drn,frn,offset);
+	printf("\tstqa\t%s, [%s,#%d]\n",drn,trn,offset);
+	break;
+default:
+if (length <0) {
+if (length > -MAX_COPY_LEN) {
+for(;length<=-4;length+=4,offset-=4)
+emit_copy(from,to,-4,offset-4,0,det);
+for(;length<=-2;length+=2,offset-=2)
+emit_copy(from,to,-2,offset-2,0,det);
+if(length<0)
+emit_copy(from,to,length,offset-1,0,det);
+break;
+}
+	} else if (length <=MAX_COPY_LEN) {
+	    for(;length>=4;length-=4,offset+=4)
+		emit_copy(from,to,4,offset,0,det);
+	    for(;length>=2;length-=2,offset+=2)
+		emit_copy(from,to,2,offset,0,det);
+	    if(length>0)
+		emit_copy(from,to,length,offset,0,det);
+	    break;
+	}
+	clear_ptr_cache();
+	code_save_stacks();
+	parallel_rassign(list3(1,list3(2,0,from),to));
+	code_const(length>0?length:-length,3);
+/* overlap must be allowed */
+	// offset have to be ignored */
+	printf("\thbra\t%s\n",memmove);
+	extern_define(memmove,0,FUNCTION,1);
+	set_ireg(RET_REGISTER,0);
+	if (creg!=to) {
+	    free_register(to); to = creg;
+	}
+	break;
+}
+if (value) {
+/* creg must point top of the destination data */
+/* this code is necessary for the value of assignment or function call */
+/* otherwise we don't need this */
+	if(creg!=to) {
+	    free_register(creg); creg=to; ireg=to;
+	}
+}
+// free_register(dreg);
+}
+int
+push_struct(int e4,int t,int arg)
+{
+int length,len0,count;
+int dreg = -1,sreg; char *drn,*crn,*srn;
+int arg_disp = cadr(arg);
+int on_register,arg_reg;
+g_expr(e4);
+if (!is_int_reg(creg)) error(-1);
+len0=length=size(t);
+if(length%SIZE_OF_INT) {
+length += SIZE_OF_INT - (length%SIZE_OF_INT);
+}
+crn = register_name(creg);
+on_register = 0;
+// arg_reg = 1-CALLER_ARG(arg_disp-ARG_LVAR_OFFSET)/SIZE_OF_INT;
+arg_reg = (arg_disp-ARG_LVAR_OFFSET)/SIZE_OF_INT + 1;
+while (length>0 &&
+arg_disp>=ARG_LVAR_OFFSET &&
+CALLER_ARG(arg_disp-ARG_LVAR_OFFSET)<0) {
+	/* some part will be on registers */
+	on_register ++;
+	length-=SIZE_OF_INT; arg_disp+= SIZE_OF_INT;
+}
+if (length>0) {
+	dreg = get_register(); if (!dreg) error(-1);
+	drn = register_name(dreg);
+	if (length<MAX_COPY_LEN) {
+	    sreg = get_register(); if (!sreg) error(-1);
+	    srn = register_name(sreg);
+	    code_lvar(arg_disp,dreg);
+	    for(count=0;count<length;count+=SIZE_OF_INT) {
+		printf("\tlqd\t%s, [%s, #%d]\n",srn,crn,count+on_register*SIZE_OF_INT);
+		printf("\tstr\t%s, [%s, #%d]\n",srn,drn,count);
+	    }
+	    free_register(sreg);
+	    if (on_register) {
+		if (creg<=MAX_INPUT_REGISTER_VAR) {
+		    code_register(creg,REG_ip);
+		    crn = register_name(REG_ip);
+		}
+	    }
+	} else {
+	    code_lvar(arg_disp,dreg);
+	    /* downward direction copy */
+	    if (on_register) {
+		sreg = new_lvar(SIZE_OF_INT);
+		code_assign_lvar(sreg*4,creg,0);
+		code_add(creg,on_register*SIZE_OF_INT,creg);
+		emit_copy(creg,dreg,length,0,0,1);
+		code_rlvar(sreg,REG_ip);
+		crn = register_name(REG_ip);
+		free_lvar(sreg);
+	    } else {
+		emit_copy(creg,dreg,length,0,0,1);
+	    }
+	}
+	if (dreg!=-1) free_register(dreg);
+}
+for (count=0,arg_reg; on_register-->0; arg_reg++,count+=SIZE_OF_INT) {
+	// len0 = (len0>2)?0:len0;
+	printf("\t%s\t%s, [%s, #%d]\n", cload(0,0),
+		register_name(arg_reg), crn,count);
+	use_input_reg(arg_reg,1);
+}
+return length/SIZE_OF_INT;
+}
+static void
+set_ireg(int reg,int mode)
+{
+if (!is_int_reg(reg)) error(-1);
+if (reg!=creg) {
+	clear_ptr_cache_reg(reg);
+	if (ireg && reg!=ireg ) {
+	    free_register(ireg);
+	    if (mode) {
+		printf("\tori\t%s, %s, 0\n",register_name(reg),register_name(ireg));
+	    }
+	}
+	free_register(creg);
+	if (creg==lreg) lreg=0;
+	regs[reg]=USING_REG;
+}
+creg = ireg = reg;
+}
+static void
+set_freg(int reg,int mode)
+{
+if (!is_float_reg(reg)) error(-1);
+if (reg!=creg) {
+	if (freg && reg!=freg) {
+	    free_register(freg);
+	    if (mode) {
+		printf("\t%s\t%s, %s\n",
+		    "mvfs"
+		    register_name(reg),register_name(freg));
+	    }
+	}
+	// if (creg!=ireg) free_register(creg);
+	regs[reg]=USING_REG;
+}
+creg = freg = reg;
+}
+#if LONGLONG_CODE||FLOAT_CODE
+static void
+set_lreg0(int reg,int mode)
+{
+if (reg!=creg) {
+	if (lreg && reg!=lreg) {
+	    if (mode) {
+		lmove(reg,lreg);
+	    }
+	    free_register(lreg);
+	}
+	if (creg!=lreg) {
+	    free_register(creg);
+	    if (creg==ireg) ireg = 0;
+	}
+	regs[reg]=USING_REG;
+	clear_ptr_cache_reg(reg);
+	regs[reg]=USING_REG;
+	clear_ptr_cache_reg(reg);
+	regs[reg]=USING_REG;
+}
+creg = lreg = reg;
+}
+#endif
+#if LONGLONG_CODE
+static void
+set_lreg(int reg,int mode)
+{
+if (!is_longlong_reg(reg)) error(-1);
+set_lreg0(reg,mode);
+}
+#endif
+#if FLOAT_CODE
+static void
+set_dreg(int reg,int mode)
+{
+	return set_ireg(reg,mode);
+}
+static void
+set_lreg_operand(int reg,int mode)
+{
+// save_stack,clear_ptr_cache is assumed
+if (!is_longlong_reg(reg)) { error(-1); return; }
+if (mode) {
+	lmove(LREGISTER_OPERAND,reg);
+}
+}
+static void
+set_dreg_operand(int reg,int mode)
+{
+set_lreg_operand(reg,mode);
+}
+#endif
+void
+use_reg(int arg)
+{
+// printf("## use reg %d\n",arg);
+if (arg<0||arg> REGS_MAX)
+	error(-1);
+clear_ptr_cache_reg(arg);
+regs[arg]=USING_REG;
+if (is_longlong_reg(arg)) {
+	clear_ptr_cache_reg(arg);
+	regs[arg]=USING_REG;
+	clear_ptr_cache_reg(arg);
+	regs[arg]=USING_REG;
+} else if (is_double_reg(arg)) {
+	clear_ptr_cache_reg(arg);
+	regs[arg]=USING_REG;
+	clear_ptr_cache_reg(arg);
+	regs[arg]=USING_REG;
+}
+}
+void
+code_save_input_registers(int dots)
+{
+int args;
+NMTBL *n;
+int reg;
+int tag;
+/* fnptr->dsp=list4(type,fnptr->dsp,(int)n,0); */
+int offset = 0;
+int reg_var = 0;
+int len;
+arg_on_register = 0;
+for(args = fnptr->dsp;args;args = cadr(args)) {
+	n = (NMTBL *)caddr(args);
+	tag = n->sc;
+	reg = n->dsp;
+	if (!n||n==&null_nptr) error(REG_ERR);
+	if (reg_var<MAX_INPUT_REGISTER_VAR) {
+	    n->dsp = offset;
+	    n->sc  = LVAR;
+	    len = size(n->ty); len = round4(len);
+	    for(;len>0 && reg_var<MAX_INPUT_REGISTER_VAR;len-=SIZE_OF_INT) {
+		reg_var++;
+		g_expr_u(assign_expr0(list3(LVAR,offset,0),
+			list3(REGISTER,reg_var,0),INT,INT));
+		arg_on_register += SIZE_OF_INT;
+		free_register(reg);
+		offset += SIZE_OF_INT;
+	    }
+	}
+}
+if (dots) {
+while ((reg = get_input_register_var(reg_var,0,0))) {
+g_expr_u(assign_expr0(
+list3(LVAR,offset,0),reg,INT,INT));
+offset+=SIZE_OF_INT;
+reg_var++;
+	    arg_on_register += SIZE_OF_INT;
+}
+}
+my_func_args = offset;
+}
+int
+not_simple_p(int e3)
+{
+switch(e3) {
+	case FUNCTION: case CONV: case STASS: case ALLOCA:
+	case DIV : case UDIV : case MOD : case UMOD :
+	case LDIV: case LUDIV: case LMOD: case LUMOD:
+	case LMUL: case LUMUL:
+	case LLSHIFT: case LULSHIFT: case LRSHIFT: case LURSHIFT:
+	case DDIV: case DADD: case DSUB: case DMUL: case DMINUS:
+	case DPOSTINC : case DPREINC : case DASSOP :
+	case DOP+LT : case DOP+LE : case DOP+GT : case DOP+GE :
+	case DOP+EQ : case DOP+NEQ:
+	case RBIT_FIELD: case BASS: case BASSOP: case LCALL:
+	case INLINE:
+	return 1;
+}
+return 0;
+}
+int
+simple_arg(int e3)
+{
+return !contains_p(e3,not_simple_p);
+}
+static int
+caller_arg_offset_v(int arg)
+{
+return ARG_LVAR_OFFSET+arg*SIZE_OF_INT;
+}
+/*
+Mark argument register is used. This is too complex.
+There must be an easy way.
+*/
+static void
+use_input_reg(int reg,int mode)
+{
+if (is_int_reg(reg)) {
+	if (ireg&&reg == ireg) {
+	    if (creg==ireg) creg = 0;
+	    ireg = 0;
+	}
+	if (lreg) {
+	    if (lreg==reg) {
+		regs[lreg]=0;
+		if (lreg>reg&&
+		    (regs[lreg]==USING_REG||
+		     regs[lreg]==USING_DREG))
+		  {
+		    free_register(lreg);
+		}
+		if (creg==lreg) creg = ireg;
+		free_register(lreg);
+		lreg = 0;
+	    } else if (lreg==reg) {
+		regs[lreg]=0;
+		if (lreg>reg && (
+		    (regs[lreg]==USING_REG) ||
+		    (regs[lreg]==USING_DREG) ))
+		  {
+		    free_register(lreg);
+		}
+		if (creg==lreg) creg = ireg;
+		free_register(lreg);
+		lreg = 0;
+	    }
+	}
+} else if (is_longlong_reg(reg)) {
+	use_input_reg(reg,0);
+	use_input_reg(reg,0);
+} else if (is_double_reg(reg)) {
+	use_input_reg(reg,0);
+	use_input_reg(reg,0);
+} else if (is_float_reg(reg)) {
+	if (freg&&reg == freg) {
+	    if (creg==freg) creg = ireg;
+	    freg = 0;
+	}
+}
+if (mode) use_reg(reg);
+}
+static void
+code_assign_input_float_int(int e1,int e2) {
+#if FLOAT_CODE
+int r,tmp=-1;
+float f;
+char *frn;
+//  e1 = e2;
+if (car(e1)!=REGISTER) { error(-1); return; }
+frn = register_name(r=cadr(e1));
+switch(car(e2)) {
+case FCONST:
+f = dcadr(e2);
+	code_const(*((int*)&f),r);
+break;
+case FRGVAR:
+	code_rgvar(e2,r);
+break;
+case FRLVAR:
+	code_rlvar(cadr(e2),r);
+	break;
+default:
+g_expr(rvalue_t(e2,FLOAT));
+case FREGISTER:
+	tmp = new_lvar(SIZE_OF_INT);
+	code_dassign_lvar(tmp, (car(e2)==FREGISTER)?cadr(e2):freg,0);
+	code_rlvar(tmp,r);
+	if (tmp!=-1) free_lvar(tmp);
+}
+#endif
+}
+static void
+code_assign_input_double_long(int e1,int e2) {
+#if FLOAT_CODE
+int r,tmp=-1,reg=0;
+double value;
+//  e1 = e2;
+if (car(e1)!=LREGISTER) { error(-1); return; }
+r=cadr(e1);
+switch(car(e2)) {
+case DCONST:
+value = dcadr(e2);
+	dconst(r,r,value);
+break;
+case DRGVAR:
+	code_lrgvar(e2,r);
+break;
+case DRLVAR:
+	code_lrlvar(cadr(e2),r);
+	break;
+default:
+g_expr(rvalue_t(e2,DOUBLE));
+	reg = freg;
+case DREGISTER:
+	if (car(e2)==DREGISTER) reg = cadr(e2);
+printf("\tstfd\t%s, [sp, #-8]!\n",register_name(reg));
+printf("\tldmfd\tsp!, {%s, %s}\n",lregister_name_low(r),lregister_name_high(r));
+}
+if (tmp!=-1) free_lvar(tmp);
+#endif
+}
+static int
+compute_complex_arg(int e3,int reg_arg_list,int arg) {
+int t=caddr(e3);
+int e4 = car(e3);
+reg_arg_list = list2(arg,reg_arg_list);
+if (car(arg)==REGISTER||car(arg)==DREGISTER||
+	car(arg)==FREGISTER||car(arg)==LREGISTER)
+	use_input_reg(cadr(arg),1);
+if (t==FLOAT&&car(arg)==REGISTER)
+	code_assign_input_float_int(arg, e4);
+else if (t==DOUBLE&&car(arg)==LREGISTER)
+	code_assign_input_double_long(arg, e4);
+else
+	g_expr_u(assign_expr0(arg,e4,t,t));
+car(e3) = arg;
+return reg_arg_list;
+}
+static void
+increment_function_arg(int e3,int *pnargs,int *preg_arg,int *pfreg_arg) {
+int nargs=0,reg_arg=0,freg_arg=0;
+int t=caddr(e3);
+if(scalar(t)) {
+	nargs ++ ; reg_arg++; freg_arg++;
+} else if (t==LONGLONG||t==ULONGLONG||t==DOUBLE) {
+	nargs ++ ; reg_arg++;
+	nargs ++ ; reg_arg++;
+} else if (t==FLOAT) {
+	reg_arg ++ ; freg_arg++;
+	nargs += size(t)/SIZE_OF_INT;
+} else if (t>=0&&(car(t)==STRUCT||car(t)==UNION)) {
+	nargs += round4(size(t))/SIZE_OF_INT;
+} else {
+	error(TYERR);
+	nargs ++ ;
+}
+*pnargs += nargs;
+*preg_arg += reg_arg;
+*pfreg_arg += freg_arg;
+}
+#define AS_SAVE 1
+#define AS_ARG  0
+static int
+get_input_arg(int t,int mode,int nargs,int reg_arg,int freg_arg)
+{
+if(scalar(t)) {
+	if (mode==AS_SAVE) {
+	    return get_register_var(0);
+	} else if (reg_arg+1>MAX_INPUT_REGISTER_VAR) {
+	    return list3(LVAR,caller_arg_offset_v(nargs),0);
+	} else
+	    return get_input_register_var(reg_arg,0,0);
+} else if (t==LONGLONG||t==ULONGLONG) {
+	if (mode==AS_SAVE) {
+	    return get_lregister_var(0);
+	} else if (reg_arg+1>=MAX_INPUT_REGISTER_VAR)  {
+	    return list3(LVAR,caller_arg_offset_v(nargs),0);
+	} else
+	    return get_input_lregister_var(reg_arg,0,0);
+} else if (t==FLOAT) {
+	if (mode==AS_SAVE) {
+	    return get_dregister_var(0,0);
+	} else if (freg_arg>=MAX_INPUT_DREGISTER_VAR) {
+	    return list3(LVAR,caller_arg_offset_v(nargs),0);
+	} else
+	    return get_input_dregister_var(freg_arg,0,0,0);
+} else if (t==DOUBLE) {
+	if (mode==AS_SAVE) {
+	    return get_dregister_var(0,1);
+	} else if (reg_arg+1>=MAX_INPUT_DREGISTER_VAR) {
+	    return list3(LVAR,caller_arg_offset_v(nargs),0);
+	} else
+	    return get_input_dregister_var(reg_arg,0,0,1);
+} else if (t>=0&&(car(t)==STRUCT||car(t)==UNION)) {
+	if (mode==AS_SAVE) {
+	    return get_register_var(0);
+	} else
+	    return list3(LVAR,caller_arg_offset_v(nargs),0);
+} else {
+	error(-1);
+	return get_register_var(0);
+}
+}
+static void
+code_call(int e2,NMTBL *fn,int jmp)
+{
+if (car(e2) == FNAME) {
+	printf("\tbrsl\t$lr,%s\n",fn->nm);
+} else {
+	printf("\tmov\tlr, pc\n");
+	printf("\tmov\tpc, %s\n",register_name(cadr(jmp)));
+}
+}
+int
+function(int e1)
+{
+int e2,e3,e4,e5,nargs,t;
+int arg,reg_arg,freg_arg,arg_assign;
+int dots;
+int reg_arg_list=0,ret_type,special_lvar;
+NMTBL *fn = 0;
+int jmp = 0;
+int complex_;
+int pnargs,preg_arg,pfreg_arg;
+int stargs,i;
+int half_register = 0;
+special_lvar = -1;
+ret_type = function_type(cadddr(e1),&dots);
+if (caddr(cadddr(e1))==0) dots=1;
+arg_assign = 0;
+e2 = cadr(e1);
+if (car(e2) == FNAME) {
+	fn=(NMTBL *)cadr(e2);
+} else {
+	if (car(e2)==INDIRECT) e2=cadr(e2); // (*func)(i) case
+	// jmp = get_register_var(0);
+	jmp = list2(REGISTER,REG_ip);
+	if (!simple_arg(e2)) {
+	    e3=get_register_var(0);
+	    reg_arg_list = list2(e3,reg_arg_list);
+	    g_expr_u(assign_expr0(e3,e2,INT,INT));
+	    e2=e3;
+	}
+	reg_arg_list = list2(jmp,reg_arg_list);
+	arg_assign = list2(assign_expr0(jmp,e2,INT,INT),arg_assign);
+}
+/* First we execute complex argument to avoid interaction with
+input variables. Remain the last complex argument in complex_. */
+stargs = 0;
+complex_ = 0;
+nargs = reg_arg = freg_arg = 0;
+pnargs = preg_arg = pfreg_arg = 0;
+for (e3 = e1 = reverse0(caddr(e1)); e3; e3 = cadr(e3)) {
+	t=caddr(e3);
+	if (reg_arg==3 && (t==DOUBLE||t==LONGLONG||t==ULONGLONG)) {
+	    half_register=1;
+	}
+	if ((e5= !simple_arg(car(e3)))) {
+	    if (complex_) {
+		arg = get_input_arg(caddr(complex_),AS_SAVE,
+					pnargs,preg_arg,pfreg_arg);
+		reg_arg_list = compute_complex_arg(complex_,reg_arg_list,arg);
+	    }
+	    // memorise last complex arg parameter
+	    pnargs=nargs;preg_arg=reg_arg;pfreg_arg=freg_arg;
+	    complex_ = e3;
+	}
+	if (t>=0&&(car(t)==STRUCT||car(t)==UNION)) {
+	    // The struct should be pushed after complex arguments.
+	    if (e5) { // compute address only, complex_ is me now. Clear it.
+		complex_ = 0;
+		e4 = car(e3);
+		if (car(e4)!=RSTRUCT) error(-1);
+		if (!simple_arg(cadr(e4))) {
+		    // Calculate complex struct address here.
+		    // If simple, leave it.
+		    arg = get_register_var(0);
+		    g_expr_u(assign_expr0(arg,list2(ADDRESS,car(e3)),INT,INT));
+		    car(e3)=arg;
+		    reg_arg_list = list2(arg,reg_arg_list);
+		    if (car(arg)==REGISTER) use_input_reg(cadr(arg),1);
+		    else car(e3) = rvalue_t(arg,INT);
+		}
+	    }
+	    stargs = list4(e3,stargs,nargs,reg_arg);
+	}
+	increment_function_arg(e3,&nargs,&reg_arg,&freg_arg);
+}
+/* now all input register vars are free */
+code_save_stacks();
+// set_lreg(LREG_LREGISTER,0);
+set_freg(FREG_FREGISTER,0);
+set_ireg(CREG_REGISTER,0);
+//  Struct arguments need emit_copy. it destructs 3 input registers.
+//  But it returns no value on a register. So calculate it here.
+//  We cannot do this in the previous loop, because the copied struct may be
+//  override by other complex arguments. But before this we have to check
+//  complex_.
+if (stargs) {
+	if (complex_) {
+	    arg = get_input_arg(caddr(complex_),AS_SAVE,
+				    pnargs,preg_arg,pfreg_arg);
+	    reg_arg_list = compute_complex_arg(complex_,reg_arg_list,arg);
+	}
+	for(stargs=reverse0(stargs);stargs;stargs = cadr(stargs)) {
+	    e3 = car(stargs);
+	    e4 = car(e3);
+	    t  = caddr(e3);
+	    arg = get_input_arg(t,AS_ARG,caddr(stargs),cadddr(stargs),0);
+	    push_struct(e4,t,arg);
+	    car(e3)=0;  // done
+	    if (car(arg)==REGISTER)   // wrong?
+		use_input_reg(cadr(arg),1);
+	}
+} else {
+	//  last complex argument can use input register
+	if (complex_) {
+	    arg = get_input_arg(caddr(complex_),AS_ARG,pnargs,preg_arg,pfreg_arg);
+	    reg_arg_list = compute_complex_arg(complex_,reg_arg_list,arg);
+	    if (car(arg)!=LVAR) use_input_reg(cadr(arg),1);
+	    car(complex_) = 0; // done.
+	    if (car(arg)==REGISTER)
+		use_input_reg(cadr(arg),1);
+	}
+}
+nargs = reg_arg = freg_arg = 0;
+// calc stack arguments first, it may requires extra registers,
+// and we can still use input registers now.
+for (e3 = e1; e3;
+		increment_function_arg(e3,&nargs,&reg_arg,&freg_arg),
+		e3 = cadr(e3)) {
+	if (!(e4=car(e3))) continue;
+	t=caddr(e3);
+	arg = get_input_arg(t,AS_ARG,nargs,reg_arg,freg_arg);
+	if (car(arg)!=LVAR) continue;
+	g_expr_u(assign_expr0(arg,e4,t,t));
+	car(e3)=0;  // done
+}
+if (half_register) {
+	//  half register case writes *(sp-1) but it will be Ok.
+	if (max_func_args<4) max_func_args=4;
+	g_expr_u(assign_expr0(list3(REGISTER,4,0),
+		list3(LVAR,caller_arg_offset_v(3),0),INT,INT));
+	use_input_reg(4,1);
+}
+nargs = reg_arg = freg_arg = 0;
+for (e3 = e1; e3;
+		increment_function_arg(e3,&nargs,&reg_arg,&freg_arg),
+		e3 = cadr(e3)) {
+	if (!(e4=car(e3))) continue;
+	t=caddr(e3);
+	arg = get_input_arg(t,AS_ARG,nargs,reg_arg,freg_arg);
+	if(scalar(t)) {
+	    reg_arg_list = list2(arg,reg_arg_list);
+	    /* protect from input register free */
+	    if (car(arg)==REGISTER)
+		use_input_reg(cadr(arg),1);
+	    g_expr_u(assign_expr0(arg,e4,t,t));
+	} else if (t==LONGLONG||t==ULONGLONG) {
+	    if (car(arg)==LREGISTER) {
+		use_input_reg(cadr(arg),1);
+	    }
+	    reg_arg_list = list2(arg,reg_arg_list);
+	    g_expr_u(assign_expr0(arg,e4,t,t));
+	} else if (t==DOUBLE) {
+	    reg_arg_list = list2(arg,reg_arg_list);
+	    if (car(arg)==LREGISTER) {
+		use_input_reg(cadr(arg),1);
+code_assign_input_double_long(arg, e4);
+	    } else {
+		g_expr_u(assign_expr0(arg,e4,t,t));
+	    }
+	} else if (t==FLOAT) {
+	    reg_arg_list = list2(arg,reg_arg_list);
+if (car(arg)==REGISTER) {
+use_input_reg(cadr(arg),1);/* protect from input register free */
+code_assign_input_float_int(arg, e4);
+} else {
+g_expr_u(assign_expr0(arg,e4,t,t)); /* XXX */
+}
+	}
+	// structs are finished
+}
+if (max_func_args<nargs) max_func_args=nargs;
+for(;arg_assign;arg_assign=cadr(arg_assign)) {
+	g_expr_u(car(arg_assign));
+}
+clear_ptr_cache();
+code_call(e2,fn,jmp);
+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
+		||car(arg)==LREGISTER)
+	    free_register(cadr(arg));
+	else if (car(arg)==LVAR&&cadr(arg)<0) free_lvar(cadr(arg));
+}
+for(i=1;i<MAX_INPUT_REGISTER_VAR;i++) {
+	free_register(i);
+}
+if (ret_type==DOUBLE) {
+#if FLOAT_CODE
+set_dreg(RET_DREGISTER,0);
+use_reg(RET_DREGISTER);
+#endif
+} else if (ret_type==FLOAT) {
+#if FLOAT_CODE
+set_freg(RET_FREGISTER,0);
+#endif
+} else if (ret_type==ULONGLONG||ret_type==LONGLONG) {
+#if LONGLONG_CODE
+set_lreg(RET_LREGISTER,0);
+use_reg(RET_LREGISTER);
+#endif
+} else if (ret_type==VOID) {
+} else {
+set_ireg(RET_REGISTER,0);
+}
+return ret_type;
+}
+void
+code_alloca(int e1,int reg)
+{
+char *crn;
+g_expr(list3(BAND,list3(ADD,e1,list2(CONST,15)),list2(CONST,~15)));
+use_int(reg);
+crn = register_name(reg);
+printf("\trsb\tsp, %s, sp\n",crn);
+if (!max_func_arg_label) max_func_arg_label = fwdlabel();
+code_label_value(max_func_arg_label ,REG_ip);
+printf("\ta\t%s, sp, ip\n",crn);
+}
+void
+code_frame_pointer(int e3) {
+use_int(e3);
+printf("\tmov\tfp, %s\n",register_name(e3));
+}
+int
+code_frame_pointer_register()
+{
+return list2(REGISTER,REG_fp);
+}
+void
+code_fix_frame_pointer(int env) {
+char *trn;
+//int disp,label;
+//int label;
+	int disp;
+if (is_function(fnptr) && ! env) {
+	trn = register_name(REG_ip);
+	//disp = search_const(LVAR,glist2(lvar_offset_label,FUNC_LVAR(0)),&label);
+	printf("\tlqd\t%s, %d($sp)\n",trn,disp);
+	printf("\ta\tfp, fp, %s\n",trn);
+}
+}
+static void
+code_unfix_frame_pointer()
+{
+char *trn;
+//int disp,label;
+int disp;
+trn = register_name(REG_ip);
+//disp = search_const(LVAR,glist2(lvar_offset_label,FUNC_LVAR(0)),&label);
+printf("\tlqd\t%s, %d($sp)\n",trn,disp);
+printf("\tsf\tfp, fp, %s\n",trn);
+}
+void
+code_jmp(char *s) {
+// jump to continuation means use all register variable
+max_reg_var = REG_VAR_MAX-REG_VAR_MIN;
+max_reg_var = FREG_VAR_MAX-FREG_VAR_MIN;
+printf("\tbr\t%s\n",s);
+control=0;
+}
+void
+code_indirect_jmp(int e2) {
+// jump to continuation means use all register variable
+max_reg_var = REG_VAR_MAX-REG_VAR_MIN;
+max_reg_var = FREG_VAR_MAX-FREG_VAR_MIN;
+use_int(e2);
+printf("\tmov\tpc, %s @ indirect jump\n",register_name(e2)); // ?!
+control=0;
+}
+void
+code_rindirect(int e1, int reg,int offset, int sign,int sz)
+{
+int lreg;
+g_expr(e1);
+if (!is_int_reg(creg)) error(-1);
+lreg = creg;
+use_int(reg);
+code_ld(cload(sz,sign),reg,offset,lreg,cext_at(sz,sign));
+cext(sign,sz,reg);
+}
+#if FLOAT_CODE
+int
+code_drindirect(int e1, int reg,int offset, int d)
+{
+int xreg;
+g_expr(e1);
+if (!is_int_reg(creg)) error(-1);
+xreg = creg;
+use_float(d,reg);
+code_ldf(d?"ldfd":"ldfs",register_name(reg),offset,xreg,"");
+return d?DOUBLE:FLOAT;
+}
+#endif
+#if LONGLONG_CODE||FLOAT_CODE
+static void
+lload(int creg,int reg,int offset)
+{
+char *crn=register_name(creg);
+#if ENDIAN_L==0
+if (creg!=reg) {
+	printf("\tldr\t%s, [%s, #%d]\n",lregister_name_low(reg),crn,offset);
+	printf("\tldr\t%s, [%s, #%d]\n",lregister_name_high(reg),crn,offset+SIZE_OF_INT);
+} else {
+	printf("\tldr\t%s, [%s, #%d]\n",lregister_name_high(reg),crn,offset+SIZE_OF_INT);
+	printf("\tldr\t%s, [%s, #%d]\n",lregister_name_low(reg),crn,offset);
+}
+#else
+if (creg!=reg) {
+	printf("\tldr\t%s, [%s, #%d]\n",lregister_name_low(reg),crn,offset+SIZE_OF_INT);
+	printf("\tldr\t%s, [%s, #%d]\n",lregister_name_high(reg),crn,offset);
+} else {
+	printf("\tldr\t%s, [%s, #%d]\n",lregister_name_high(reg),crn,offset);
+	printf("\tldr\t%s, [%s, #%d]\n",lregister_name_low(reg),crn,offset+SIZE_OF_INT);
+}
+#endif
+}
+static void
+lmove(int to,int from)
+{
+int l;
+l = list3(to,0,from);
+l = list3(to,l,from);
+parallel_rassign(l);
+}
+static void
+set_operands(int r0,int r1,int r2,int r3)
+{
+int l;
+l = list3(DREGISTER_OPERAND_L,0,r0);
+l = list3(DREGISTER_OPERAND_H,l,r1);
+l = list3(DREGISTER_OPERAND_1_L,l,r2);
+l = list3(DREGISTER_OPERAND_1_H,l,r3);
+parallel_rassign(l);
+}
+static void
+lstore(int e2,int creg)
+{
+char *drn = register_name(e2);
+char *crn_h;
+char *crn_l;
+crn_h = lregister_name_high(creg);
+crn_l = lregister_name_low(creg);
+#if ENDIAN_L==0
+printf("\tstr\t%s, [%s, #0]\n",crn_l,drn);
+printf("\tstr\t%s, [%s, #%d]\n",crn_h,drn,SIZE_OF_INT);
+#else
+printf("\tstr\t%s, [%s, #0]\n",crn_h,drn);
+printf("\tstr\t%s, [%s, #%d]\n",crn_l,drn,SIZE_OF_INT);
+#endif
+}
+int
+code_lrindirect(int e1, int reg, int offset, int us)
+{
+int creg0;
+g_expr(e1);
+if (!is_int_reg(creg)) error(-1);
+creg0=creg;
+use_longlong(reg);
+lload(creg0,reg,offset);
+return us?ULONGLONG:LONGLONG;
+}
+#endif
+static char *
+cstore(int sz)
+{
+switch(sz) {
+case 1: return "stqx";
+case SIZE_OF_SHORT: return "stqa";
+default: return "stqd";
+}
+}
+void
+code_assign_gvar(int e2,int creg,int byte) {
+use_int(creg);
+code_ldf(cstore(byte),register_name(creg),cadr(e2),
+get_ptr_cache((NMTBL*)caddr(e2)),byte==SIZE_OF_SHORT?" @ movhi":"");
+}
+void
+code_assign_lvar(int e2,int creg,int byte) {
+char *crn;
+use_int(creg);
+crn=register_name(creg);
+lvar_intro(e2);
+printf("\t%s\t%s,",cstore(byte),crn);
+e2 *= 4;
+	lvar(e2,"");
+}
+void
+code_assign_register(int e2,int byte,int creg) {
+use_int(creg);
+if (e2!=creg) {
+	printf("\tori\t%s, %s, 0\n",register_name(e2),register_name(creg));
+}
+}
+void
+code_assign(int e2,int byte,int creg) {
+char *drn;
+char *crn;
+use_int(e2);
+drn=register_name(e2);
+use_int(creg);
+crn=register_name(creg);
+printf("\t%s\t%s, 0(%s)\n",cstore(byte),crn,drn);
+}
+void
+code_register_assop(int e2,int reg, int op,int byte) {
+//  reg <= reg(e2) op=reg
+use_int(reg);
+tosop(op,e2,reg);
+}
+void
+code_assop(int op,int creg, int byte,int sign) {
+char *xrn,*crn,*drn;
+int xreg;
+int edx = get_register_var(0);
+if (car(edx)!=REGISTER) error(-1);
+//  (*creg) op = pop()
+drn = register_name(edx=cadr(edx));
+use_int(creg);
+xrn = register_name(xreg = emit_pop(0));       /* pop e3 value */
+code_register(creg,edx);
+ld_indexx(byte,0,edx,creg,sign);
+tosop(op,creg,xreg);
+crn = register_name(creg);
+printf("\t%s\t%s, 0(%s)\n",cstore(byte),crn,drn);
+free_register(edx);
+free_register(creg);
+emit_pop_free(xreg);
+}
+int
+tosop_operand_safe_p(int op)
+{
+return 1;
+}
+void
+tosop(int op,int creg,int oreg)
+{
+int ox = -1;
+char *orn,*crn;
+// creg = creg op oreg
+use_int(creg);
+if(oreg==-1) {
+	error(-1);
+} else if (oreg<= -REG_LVAR_OFFSET) {
+	ox = get_register(); if (ox<0) error(-1);
+code_rlvar(oreg+REG_LVAR_OFFSET,ox);
+	free_lvar(oreg+REG_LVAR_OFFSET);
+	oreg = ox;
+}
+switch(op) {
+case LSHIFT:
+case ULSHIFT:
+	shift("asl",creg,oreg);
+	if(ox!=-1) free_register(ox);
+	return;
+case RSHIFT:
+	shift("asr",creg,oreg);
+	if(ox!=-1) free_register(ox);
+	return;
+case URSHIFT:
+	shift("lsr",creg,oreg);
+	if(ox!=-1) free_register(ox);
+	return;
+}
+orn = register_name(oreg);
+crn = register_name(creg);
+switch(op) {
+case ADD:
+	printf("\ta\t%s, %s, %s\n",crn,crn,orn);
+	break;
+case SUB:
+	printf("\tsf\t%s, %s, %s\n",crn,crn,orn);
+	break;
+case CMP:
+printf("\tcmp\t%s, %s\n",crn,orn);
+	break;
+case BAND:
+	printf("\tand\t%s, %s, %s\n",crn,crn,orn);
+	break;
+case EOR:
+	printf("\teor\t%s, %s, %s\n",crn,crn,orn);
+	break;
+case BOR:
+	printf("\torr\t%s, %s, %s\n",crn,crn,orn);
+	break;
+case MUL:
+case UMUL:
+	/* target!=source */
+	printf("\tmul\t%s, %s, %s\n",crn,orn,crn);
+	break;
+case DIV:
+	code_int_lib("__divsi3",creg,oreg); break;
+case UDIV:
+	code_int_lib("__udivsi3",creg,oreg); break;
+case MOD:
+	code_int_lib("__modsi3",creg,oreg); break;
+case UMOD:
+	code_int_lib("__umodsi3",creg,oreg); break;
+default:
+	error(-1);
+}
+if(ox!=-1) free_register(ox);
+}
+int
+code_const_op_p(int op,int v)
+{
+if (car(v)!=CONST) return 0;
+v = cadr(v);
+switch(op) {
+case MUL: case UMUL: case DIV: case UDIV:
+	return ilog(v);
+case ADD: case SUB:
+	return 1;
+case LSHIFT: case ULSHIFT: case RSHIFT: case URSHIFT:
+	return 0<v&&v<=32;
+case CMP:
+	return is_stage1_const(v,CMP);
+case EOR: case BOR: case BAND:
+	return (is_stage1_const(v,0)>0);
+default:
+	return 0;
+}
+}
+void
+oprtc(int op,int creg, int v)
+{
+char *crn;
+use_int(creg);
+crn = register_name(creg);
+v = cadr(v);
+switch(op) {
+case MUL: case UMUL:
+	v=ilog(v);
+case LSHIFT:
+case ULSHIFT:
+	printf("\tmov\t%s, %s, asl #%d\n",crn,crn,v);
+	break;
+case DIV:
+	v=ilog(v);
+case RSHIFT:
+	printf("\tmov\t%s, %s, asr #%d\n",crn,crn,v);
+	break;
+case UDIV:
+	v=ilog(v);
+case URSHIFT:
+	printf("\tmov\t%s, %s, lsr #%d\n",crn,crn,v);
+	break;
+case ADD:
+	code_add(creg,v,creg);
+	break;
+case SUB:
+	code_add(creg,-v,creg);
+	break;
+case CMP: printf("\tcmp\t%s,%d\n",crn,v); break;
+case BOR: printf("\torr\t%s, %s, #%d\n",crn,crn,v); break;
+case EOR: printf("\teor\t%s, %s, #%d\n",crn,crn,v); break;
+case BAND: printf("\tand\t%s, %s, #%d\n",crn,crn,v); break;
+default:
+	error(-1);
+}
+}
+void
+shift(char *op, int creg, int reg)
+{
+char *crn;
+char *rrn = register_name(reg);
+use_int(creg);
+crn = register_name(creg);
+printf("\tmov\t%s, %s, %s  %s\n",crn,crn,op,rrn);
+}
+void
+ld_indexx(int byte, int n, int xreg,int creg, int sign)
+{
+use_int(creg);
+code_ld(cload(byte,sign),creg,n,xreg,cext_at(byte,sign));
+}
+int
+code_csvalue()
+{
+return glist2(REGISTER,creg);
+}
+void
+code_cmpdimm(int e, int csreg,int label,int cond)
+{
+/* used in dosiwtch() */
+int sign,reg=-1;
+int regsv;
+char *rn,*crn;
+crn = register_name(csreg);
+if (!(sign=is_stage1_const(e,CMP))) {
+	regsv = regs[csreg]; regs[csreg]=1;
+	rn = register_name(reg= get_register());
+	regs[csreg] = regsv;
+	code_const(e,reg);
+	printf("\tcmp\t%s, %s\n",crn,rn);
+} else {
+	if (sign>0)
+	    printf("\tcmp\t%s, #%d\n",crn,e);
+	else
+	    printf("\tcmn\t%s, #%d\n",crn,-e);
+}
+switch(cond) {
+case -1: break;
+case 1:
+	printf("\tbne\t.LC%d\n",label); break;
+case 0:
+	printf("\tbeq\t.LC%d\n",label); break;
+case LT:
+	printf("\tblt\t.LC%d\n",label); break;
+case GT:
+	printf("\tbgt\t.LC%d\n",label); break;
+default: error(-1);
+}
+if (reg!=-1) free_register(reg);
+}
+void
+code_opening(char *filename)
+{
+/* this is called once per file */
+//printf("@ Generated by mc for ARM/elf\n");
+printf("\t.file \"%s\"\n",filename);
+// printf(".text\n");
+}
+// should have pcond_const
+#define COND_BRANCH 1
+#define COND_VALUE  2
+#define COND_BRANCH_CONST 3
+#define COND_VALUE_CONST  4
+/*
+if (r1 cmp r2) goto l1   COND_BRANCH
+r0 = (r1 cmp r2)         COND_VALUE
+*/
+static void
+pcond(int op, int r2,int r1,int r0,int cond,int l1,int mode)
+{
+char *rn2;
+char *rn1;
+char *rn0;
+char *cc=0,*ncc=0;
+if (mode==COND_BRANCH_CONST||mode==COND_VALUE_CONST) {
+	rn1 =		register_name(r1);
+	if (r2>=0)
+	    printf("\tcmp\t%s, #%d\n",rn1,r2);
+	else
+	    printf("\tcmn\t%s, #%d\n",rn1,-r2);
+} else {
+	rn1 =		register_name(r1);
+	rn2 =		register_name(r2);
+	printf("\tcmp\t%s, %s\n",rn1,rn2);
+}
+switch(op+(!cond)*BNOT) {
+case GT:  case LE+BNOT:	cc="gt"; ncc="le"; break;
+case LE:  case GT+BNOT:	cc="le"; ncc="gt"; break;
+case GE:  case LT+BNOT:	cc="ge"; ncc="lt"; break;
+case LT:  case GE+BNOT:	cc="lt"; ncc="ge"; break;
+case UGT: case ULE+BNOT:	cc="hi"; ncc="ls"; break;
+case ULE: case UGT+BNOT:	cc="ls"; ncc="hi"; break;
+case UGE: case ULT+BNOT:	cc="hs"; ncc="lo"; break;
+case ULT: case UGE+BNOT:	cc="lo"; ncc="hs"; break;
+case EQ:  case NEQ+BNOT:	cc="eq"; ncc="ne"; break;
+case NEQ: case EQ+BNOT:   	cc="ne"; ncc="eq"; break;
+default:        error(-1);
+}
+if (mode==COND_BRANCH||mode==COND_BRANCH_CONST) {
+	printf("\tb%s\t.LC%d\n",cc,l1);
+} else if (mode==COND_VALUE||mode==COND_VALUE_CONST) {
+	rn0 =		register_name(r0);
+	printf("\tmov%s\t%s, #0\n",ncc,rn0);
+	printf("\tmov%s\t%s, #1\n",cc,rn0);
+} else error(-1);
+}
+int
+rexpr_bool(int e1, int reg)
+{
+int e2,reg0;
+int op = car(e1);
+if (!(
+	op== GT || op== LT || op== UGT || op== ULT ||
+	op== ULE || op== UGE || op== LE || op== GE ||
+	op== EQ || op== NEQ
+)) return 0;
+if (car(caddr(e1))==CONST  && is_stage1_const(cadr(caddr(e1)),CMP)) {
+	g_expr(cadr(e1));
+	reg0 = ireg;
+	use_int(reg);
+	pcond(op, cadr(caddr(e1)),reg0,reg,1,0,COND_VALUE_CONST);
+} else {
+	g_expr(cadr(e1));
+	emit_push();
+	g_expr(caddr(e1));
+	e2 = emit_pop(1);
+	reg0 = ireg;
+	use_int(reg);
+	pcond(op, reg0,e2,reg,1,0,COND_VALUE);
+	emit_pop_free(e2);
+}
+return 1;
+}
+int
+rexpr(int e1, int l1, int cond,int t)
+{
+int e2;
+int op = car(e1);
+if (car(caddr(e1))==CONST  && is_stage1_const(cadr(caddr(e1)),CMP)) {
+	g_expr(cadr(e1));
+	pcond(op, cadr(caddr(e1)),ireg,0,cond,l1,COND_BRANCH_CONST);
+} else {
+	g_expr(cadr(e1));
+	emit_push();
+	g_expr(caddr(e1));
+	e2 = emit_pop(1);
+	pcond(op, ireg,e2,0,cond,l1,COND_BRANCH);
+	emit_pop_free(e2);
+}
+return l1;
+}
+#define CMP_C1T (-1)
+static void
+jcond(int l, int cond)
+{
+printf("\tb%s\t.LC%d\n",cond?"ne":"eq",l);
+}
+void
+jmp(int l)
+{
+printf("\tbr\t.LC%d\n",l);
+if (inst_count>CONST_TBL_COUNT/2) {
+	const_list_table();
+}
+}
+void
+code_comment(char *s)
+{
+printf("## %s",s);
+}
+/*
+static int
+code_register_save(int reg_save,int freg_save,int disp)
+{
+int i;
+printf("\tstmfd\tsp!, {");
+for (i=reg_var_num(0);i<reg_var_num(reg_save);i++) {
+	    printf("%s, ",register_name(i));
+}
+printf("fp, ip, lr, pc}\n");
+if (freg_save>0) {
+	printf("\tsfmfd\tf4, %d, [sp]!\n",freg_save);
+}
+return disp;
+}
+*/
+static int
+code_register_restore(int reg_save,int freg_save,int disp)
+{
+int i;
+if (freg_save>0) {
+	i=reg_save*SIZE_OF_INT+
+		freg_save*SIZE_OF_DOUBLE + 20;
+	printf("\tlfm\tf4, %d, [fp, #%d]\n",freg_save,-i);
+}
+//printf("\tldmea\tfp, {");
+for (i=reg_var_num(0);i<reg_var_num(reg_save);i++) {
+	    printf("%s, ",register_name(i));
+}
+//printf("fp, sp, pc}\n");
+return disp;
+}
+static int entry_label;
+void
+code_enter(char *name)
+{
+if (output_mode!=TEXT_EMIT_MODE)
+	text_mode(3);
+else
+	printf("\t.align 3\n");
+if (stmode!=STATIC)
+	printf("\t.globl\t%s\n",name);
+printf("\t.type\t%s,function\n",name);
+r1_offset_label = fwdlabel();
+max_func_args = 0;
+printf("%s:\n",name);
+code_label_value(r1_offset_label,REG_ip);
+printf("\ta\tsp, ip, fp\n");
+clear_ptr_cache();
+}
+void
+code_enter1(int args)
+{
+// set_lreg(LREG_LREGISTER,0);
+set_ireg(CREG_REGISTER,0);
+set_freg(FREG_FREGISTER,0);
+}
+void
+code_leave(char *name)
+{
+code_offset_set(fnptr);
+local_table();
+printf("\t.size\t%s,.LC%d-%s\n",name, backdef(),name);
+}
+void
+enter(char *name)
+{
+if (output_mode!=TEXT_EMIT_MODE)
+	text_mode(2);
+else
+	printf("\t.align 2\n");
+max_func_args = 0;
+lvar_offset_label = fwdlabel();
+// r1_offset_label = fwdlabel();
+printf("\t.type\t%s,function\n",name);
+if (stmode!=STATIC)
+	printf("\t.globl\t%s\n",name);
+printf("%s:\n",name);
+//printf("\tmov\tip, sp\n");
+printf("\tstqd\t$lr,16($sp)\n");
+printf("\tstqd\t$sp,-32($sp)\n");
+printf("\tai\t$sp,$sp,-32\n");
+gen_jmp(entry_label = fwdlabel());
+register_save_return_label = backdef();
+clear_ptr_cache();
+}
+void
+enter1()
+{
+text_mode(0);
+// set_lreg(LREG_LREGISTER,0);
+set_ireg(CREG_REGISTER,0);
+set_freg(FREG_FREGISTER,0);
+}
+void
+code_label_call(int l)
+{
+printf("\tbl\tL_%d\n",l);
+}
+void
+code_ret()
+{
+	printf("\tmov\tpc, lr\n");
+	control=0;
+}
+void
+leave(int control0, char *name)
+{
+int retcont1=0,sz;
+if (control0) {
+	code_set_return_register(1);
+} else
+	text_mode(2);
+if (retcont) {
+	/* return from CbC segement */
+	if (control0) gen_jmp(retlabel);
+	retcont1 = fwdlabel();
+	fwddef(retcont);
+	if (cadr(fnptr->ty)==FLOAT) {
+#if FLOAT_CODE
+	    creg = freg = cadr(get_input_dregister_var(0,0,1,0));
+	    set_freg(RET_FREGISTER,1);
+#endif
+	} else if (cadr(fnptr->ty)==DOUBLE) {
+#if FLOAT_CODE
+	    creg = lreg = cadr(get_input_dregister_var(0,0,1,1));
+	    set_dreg(RET_DREGISTER,1);
+#endif
+	} else if (cadr(fnptr->ty)>0&&(
+	    car(cadr(fnptr->ty))==STRUCT ||
+	    car(cadr(fnptr->ty))==UNION)) {
+	    sz = size(cadr(fnptr->ty));
+	    code_const(sz,REGISTER_OPERAND);
+	    printf("\tsf\tr1, r2, fp\n");
+	    printf("\tlqd\tr0, [fp, #%d]\n",(my_func_args-1)*SIZE_OF_INT);
+	    emit_copy(6,3,sz,0,1,1);
+	} else if (cadr(fnptr->ty)!=VOID) {
+	    creg = ireg = cadr(get_input_register_var(0,0,1));
+	    if (creg!=RET_REGISTER)
+		set_ireg(RET_REGISTER,1);
+	}
+	code_unfix_frame_pointer();
+}
+fwddef(retlabel);
+code_offset_set(fnptr);
+code_register_restore(max_reg_var,max_reg_var,0);
+//  leave part end
+//  entry part  (save register)
+fwddef(entry_label);
+if (arg_on_register>0)
+	printf("\tsfi\tsp, sp, %d\n",arg_on_register);
+//code_register_save(max_reg_var,max_reg_var,0);
+//printf("\tsf\tfp, ip, #%d\n",4+arg_on_register);
+code_add(REG_sp,disp-max_func_args*SIZE_OF_INT,REG_sp);
+gen_jmp(register_save_return_label);
+local_table();
+printf("\t.size\t%s,.LC%d-%s\n",name, backdef(),name);
+free_all_register();
+}
+void
+code_set_return_register(int mode) {
+if (cadr(fnptr->ty)==FLOAT) {
+	set_freg(RET_FREGISTER,mode);
+} else if (cadr(fnptr->ty)==DOUBLE) {
+#if FLOAT_CODE
+	set_dreg(RET_DREGISTER,mode);
+#endif
+} else if (cadr(fnptr->ty)==LONGLONG||cadr(fnptr->ty)==ULONGLONG) {
+#if LONGLONG_CODE
+	set_lreg(RET_LREGISTER,mode);
+#endif
+} else if (cadr(fnptr->ty)==VOID) {
+} else {
+	set_ireg(RET_REGISTER,mode);
+}
+}
+int
+code_get_fixed_creg(int reg,int type) {
+switch(type) {
+#if FLOAT_CODE
+case DOUBLE: use_float(1,reg); break;
+case FLOAT:  use_float(0,reg); break;
+#endif
+#if LONGLONG_CODE
+case LONGLONG:  case ULONGLONG:  use_longlong(reg); break;
+#endif
+default:
+if (reg==USE_CREG) {
+if (regs[CREG_REGISTER]==0||regs[CREG_REGISTER]==PTRC_REG) {
+		set_ireg(CREG_REGISTER,is_int_reg(creg)&&regs[creg]==USING_REG);
+return CREG_REGISTER;
+}
+}
+use_int(reg);
+break;
+}
+return reg;
+}
+void
+code_set_fixed_creg(int reg,int mode,int type) {
+if (type==FLOAT) {
+#if FLOAT_CODE
+	set_freg(reg,mode);
+#endif
+} else if (type==DOUBLE) {
+#if FLOAT_CODE
+	set_dreg(reg,mode);
+#endif
+} else if (type==LONGLONG||type==ULONGLONG) {
+#if LONGLONG_CODE
+	set_lreg(reg,mode);
+	// use_reg(reg);
+#endif
+} else {
+	set_ireg(reg,mode);
+}
+}
+void
+gen_gdecl(char *n, int gpc)
+{
+/*
+if (stmode!=STATIC)
+	printf(".globl %s\n",n);
+*/
+}
+void
+align(int t)
+{
+int d;
+switch(t) {
+case CHAR: case UCHAR: return;
+case SHORT: case USHORT: d = data_alignment & 1; break;
+default: d = data_alignment & 3;
+}
+if (d) {
+printf("\t.align 2\n");
+	data_alignment = 0;
+}
+}
+static void
+ascii(char *s)
+{
+printf("\t.string \"");
+while(*s) {
+	if (*s=='\n')
+	    printf("%cn",92);
+	else if (*s<' ')
+	    printf("%c%03o",92,*s);
+	else if (*s=='\\')
+	    printf("\\\\");
+	else if (*s==34)
+	    printf("%c%c",92,34);
+	else
+	    printf("%c",*s);
+	s++;
+}
+printf("\\0%c\n",34);
+}
+int
+emit_string_label() {
+int lb;
+lb=fwdlabel();
+// should put on different segement
+cstring_mode();
+printf(".LC%d:\n",lb);
+return lb;
+}
+extern void
+emit_string(char *s,int t)
+{
+t = type_value(t);
+if (car(t)==ARRAY &&
+(type_value(cadr(t))==CHAR||type_value(cadr(t))==UCHAR)) {
+ascii(s);
+} else {
+int l = emit_string_label();
+ascii(s);
+emit_label(l);
+}
+return;
+}
+void
+emit_global(NMTBL *n,int a,int e)
+{
+int t = type_value(n->ty);
+if (e>0 && car(e)==STRING && t>0 && car(t)==ARRAY &&
+(type_value(cadr(t))==CHAR||type_value(cadr(t))==UCHAR)) {
+cstring_mode();
+} else
+	data_mode(n->nm);
+align(a);
+if (n && n->sc!=STATIC)
+	printf("\t.globl\t%s\n",n->nm);
+printf("%s:\n",n->nm);
+}
+void
+emit_space(int sp)
+{
+data_mode(0);
+printf("\t.space\t%d\n",sp);
+}
+void
+emit_char(int d)
+{
+data_mode(0);
+printf("\t.byte %d\n",d);
+}
+void
+emit_short(int d)
+{
+data_mode(0);
+printf("\t.short %d\n",d);
+}
+void
+emit_int(int d)
+{
+data_mode(0);
+align(0);
+printf("\t.word %d\n",d);
+}
+void
+emit_longlong(int e)
+{
+#if LONGLONG_CODE
+long long ll = lcadr(e);
+data_mode(0);
+#if (ENDIAN_L==0)
+	printf("\t.long\t0x%x,0x%x\n",code_l1(ll),code_l2(ll));
+#else
+	printf("\t.long\t0x%x,0x%x\n",code_l2(ll),code_l1(ll));
+#endif
+#endif
+}
+void
+emit_double(int e)
+{
+#if FLOAT_CODE
+double d = dcadr(e);
+data_mode(0);
+#if (ENDIAN_D==0)
+	printf("\t.long\t0x%x,0x%x\n",code_d1(d),code_d2(d));
+#else
+	printf("\t.long\t0x%x,0x%x\n",code_d2(d),code_d1(d));
+#endif
+#endif
+}
+void
+emit_float(int e)
+{
+#if FLOAT_CODE
+float f = dcadr(e);
+data_mode(0);
+printf("\t.long\t0x%x\n",*(int *)&f);
+#endif
+}
+void
+emit_address(char *s,int offset)
+{
+data_mode(0);
+if (offset)
+	printf("\t.word %s+%d\n",s,offset);
+else
+	printf("\t.word %s\n",s);
+}
+void
+emit_label(int labelno)
+{
+data_mode(0);
+printf("\t.word .L%d\n",labelno);
+}
+void
+emit_data_closing(NMTBL *n)
+{
+#ifdef DOT_SIZE
+int lb;
+#endif
+if (mode==GDECL) {
+	data_mode(0);
+#ifdef DOT_SIZE
+	lb=fwdlabel();
+	printf(".LC%d:\n",lb);
+	printf("\t.size\t%s,.L%d-%s\n",n->nm,lb,n->nm);
+#endif
+}
+}
+static void
+comm(NMTBL *n)
+{
+printf(".comm %s,%d @ %d\n",n->nm,size(n->ty),
+	(n->ty==DOUBLE||n->ty==LONGLONG||n->ty==ULONGLONG)?8:4
+);
+}
+void
+global_table(void)
+{
+NMTBL *n;
+int init;
+init=0;
+for(n=global_list;n;n=n->next) {
+	if ((n->sc == GVAR) && n->dsp != -1) {
+	    /* n->dsp = -1 means initialized global */
+	    if (init==0) {
+		data_mode(0);
+		init=1;
+	    }
+	    comm(n);
+	} else if ((n->sc==STATIC) && n->dsp != -1) {
+	    /* n->dsp = -1 means initialized global */
+	    if (is_code(n)||is_function(n)) continue;
+	    if (init==0) {
+		data_mode(0);
+		init=1;
+	    }
+	    // printf(".local %s\n",n->nm);
+	    comm(n);
+	}
+}
+}
+void
+local_table(void)
+{
+NMTBL *n;
+int init;
+free_glist3_a(prev_const_list); prev_const_list = 0;
+const_list_table();
+init=0;
+/* static local variables */
+for(n=local_static_list;n;n=n->next) {
+	if (n->sc == STATIC) {
+	    if (n->dsp != -1) { /* initialized static */
+		if (init==0) {
+		    data_mode(0);
+		    init=1;
+		}
+		comm(n);
+	    }
+	}
+}
+text_mode(2);
+}
+void
+cstring_mode(int align)
+{
+if (output_mode!=RODATA_EMIT_MODE) {
+	printf(".section\t.rodata\n\t.align 2\n");
+	output_mode = RODATA_EMIT_MODE;
+}
+}
+void
+text_mode(int align)
+{
+if (output_mode!=TEXT_EMIT_MODE) {
+	printf(".text\n");
+	if (align) printf("\t.align %d\n",align);
+	output_mode = TEXT_EMIT_MODE;
+}
+}
+void
+data_mode(char *name)
+{
+if (output_mode!=DATA_EMIT_MODE) {
+	printf(".data\n");
+	output_mode = DATA_EMIT_MODE;
+}
+if (name)
+	printf("\t.type\t%s,object\n",name);
+}
+#define lib_args(max) if (max_func_args<max) max_func_args=max
+#if LONGLONG_CODE||FLOAT_CODE
+static void
+extern_conv(char *conv)
+{
+code_save_stacks();
+clear_ptr_cache();
+extern_define(conv,0,FUNCTION,1);
+printf("\tbl\t%s\n",conv);
+lib_args(16);
+}
+#endif
+static void
+code_int_lib(char *lib,int reg,int oreg)
+{
+int g;
+code_save_stacks();
+clear_ptr_cache();
+g = list3(REGISTER_OPERAND,0,reg);
+g = list3(REGISTER_OPERAND_1,g,oreg);
+parallel_rassign(g);
+extern_define(lib,0,FUNCTION,1);
+printf("\tbl\t%s\n",lib);
+lib_args(16);
+set_ireg(RET_REGISTER,0);
+if (reg!=RET_REGISTER) {
+	code_register(RET_REGISTER,reg);
+}
+}
+#if FLOAT_CODE
+/* floating point */
+#define  set_double(freg) if (regs[freg]) {regs[freg]=USING_DREG;}
+#define  set_float(freg) if (regs[freg]) {regs[freg]=USING_DREG;}
+void
+code_cmp_dregister(int e2,int d,int label,int cond)
+{
+char *frn;
+use_float(d,e2);
+frn = register_name(e2);
+printf("\tcmf\t%s, #0\n",frn);
+jcond(label,cond);
+return;
+}
+static char *
+movef(int d)
+{
+return d?"mvfd":"mvfs";
+}
+static char *
+fload(int d)  { return d?"ldfd":"ldfs"; }
+static char *
+fstore(int d) { return d?"stfd":"stfs"; }
+void
+code_dregister(int e2,int freg,int d)
+{
+use_float(d,freg);
+	if (freg!=e2) {
+	    if (is_int_reg(e2)) error(-1);
+	    printf("\t%s\t%s, %s\n",movef(d),
+		register_name(freg),register_name(e2));
+	}
+}
+void
+code_dassign_gvar(int e2,int freg,int d)
+{
+	use_float(d,freg);
+	code_ldf(fstore(d),register_name(freg),cadr(e2),
+	    get_ptr_cache((NMTBL*)caddr(e2))," @ float");
+}
+void
+code_dassign_lvar(int e2,int freg,int d)
+{
+	use_float(d,freg);
+	lvar_intro(e2);
+	printf("\t%s\t%s, ",fstore(d),register_name(freg));
+	lvar(e2,"@ float");
+}
+void
+code_dassign(int e2,int freg,int d)
+{
+use_float(d,freg);
+printf("\t%s\t%s, [%s, #0] @ float\n",fstore(d),
+	register_name(freg),register_name(e2));
+}
+void
+code_dassign_dregister(int e2,int d,int freg) {
+use_float(d,freg);
+if (e2!=freg) {
+	printf("\t%s\t%s, %s\n",movef(d),
+		register_name(e2),register_name(freg));
+}
+}
+static double d0 = 1.0;
+int
+code_d1(double d)
+{
+int *i = (int *)&d0; int *j = (int *)&d;
+return (i[1] == 0x3ff00000)?j[0]:j[1];
+}
+int
+code_d2(double d)
+{
+int *i = (int *)&d0; int *j = (int *)&d;
+return (i[1] == 0x3ff00000)?j[1]:j[0];
+}
+int
+code_f(double d)
+{
+float f = d;
+int *j = (int *)&f;
+return *j;
+}
+static void
+dconst(int l,int h,double value)
+{
+#if ENDIAN_D==0
+code_const(code_d1(value),l);
+code_const(code_d2(value),h);
+#else
+code_const(code_d1(value),h);
+code_const(code_d2(value),l);
+#endif
+}
+static void
+fconst(int reg,double value)
+{
+float f = value;
+code_const(*((int*)&f),reg);
+}
+void
+code_dconst(int e2,int freg,int d)
+{
+double value = dcadr(e2);
+float f = value;
+char *frn;
+int label,disp;
+use_float(d,freg);
+	frn = register_name(freg);
+	if (value==0 || value==1 || value==10) {
+	    printf("\t%s\t%s, #%d\n",movef(d),frn,(int)value);
+	} else if (value==-1 || value==-10) {
+	    printf("\t%s\t%s, #%d\n",d?"mnfd":"mnfs",frn,(int)-value);
+	} else if (d) {
+#if ENDIAN_D==0
+	    disp = search_double_const(DCONST,
+		code_d1(value),code_d2(value),&label);
+#else
+	    disp = search_double_const(DCONST,
+		code_d2(value),code_d1(value),&label);
+#endif
+	    printf("\tldfd\t%s, .LC%d+%d\n",frn,label,disp);
+	} else {
+	    //disp = search_const(CONST,*((int*)&f),&label);
+	    printf("\tldfs\t%s, .LC%d+%d\n",frn,label,disp);
+	}
+}
+void
+code_builtin_fabsf(int e)
+{
+}
+void
+code_builtin_fabs(int e)
+{
+}
+void
+code_builtin_inff()
+{
+}
+void
+code_builtin_inf(int op)
+{
+}
+void
+code_dneg(int freg,int d)
+{
+char *frn;
+use_float(d,freg);
+	frn = register_name(freg);
+	printf("\t%s\t%s, %s\n",d?"mnfd":"mnfs",frn,frn);
+}
+void
+code_d2i0(int reg,int d)
+{
+int lreg;
+	use_float(d,reg);
+	lreg = get_register();
+	printf("\tfixz\t%s, %s\n",register_name(lreg),register_name(reg));
+	set_ireg(lreg,0);
+return;
+}
+void
+code_i2d0(int reg,int d)
+{
+int lreg;
+	use_int(reg);
+	lreg = get_dregister(1);
+	printf("\tflt%c\t%s, %s\n",dsuffix(d),
+		register_name(lreg),register_name(reg));
+	set_dreg(lreg,0);
+return;
+}
+void
+code_d2u0(int reg,int d)
+{
+int lreg,reg0;
+char *lrn,*frn,*crn;
+	//   u = (d>2.1e9)?((int)(d-2.1e9)^2147483648):(int)d
+	use_float(1,reg);
+	frn = register_name(reg);
+if (!d) printf("\tmvfd\t%s, %s\n",frn,frn);
+	emit_dpush(1);
+	code_dconst(dlist2(DCONST,2.147483648e9),USE_CREG,1);
+	lrn = register_name(lreg = emit_dpop(d));
+	frn = register_name(freg);
+	set_ireg(reg0=get_register(),0);
+	crn = register_name(reg0);
+printf("\tcmfe\t%s, %s\n",lrn,frn);
+printf("\tbge\t1f\n");
+printf("\tfixz\t%s, %s\n",crn,lrn);
+printf("\tb\t2f\n");
+	printf("1:\n");
+printf("\tsufd\t%s, %s, %s\n",lrn,lrn,frn);
+printf("\tfixz\t%s, %s\n",crn,lrn);
+printf("\teor\t%s, %s, #-2147483648\n",crn,crn);
+	printf("2:\n");
+	emit_dpop_free(lreg,d);
+return;
+}
+void
+code_u2d0(int reg,int d)
+{
+int tmp,freg1;
+char *crn,*frn,*lrn;
+	use_int(reg);
+	crn = register_name(reg);
+	set_dreg(reg=get_dregister(1),0);
+	frn = register_name(reg);
+	printf("\tfltd\t%s, %s\n",frn,crn);
+	printf("\tcmp\t%s, #0\n",crn);
+printf("\tbge\t1f\n");
+	freg1 = get_dregister(1);
+	code_dconst(dlist2(DCONST,4.29496729600000000000e9),freg1,1);
+	frn = register_name(creg);
+	lrn = register_name(freg1);
+	printf("\tadfd\t%s, %s, %s\n",frn,frn,lrn);
+	printf("1:\n");
+	if (!d)
+	    printf("\tmvfs\t%s, %s\n",frn,frn);
+	free_register(freg1);
+return;
+}
+void
+code_d2f(int reg) {
+char *frn;
+	frn = register_name(freg);
+	printf("\tmvfs\t%s,%s\n",frn,frn);
+return;
+}
+void
+code_f2d(int reg) {
+char *frn;
+	frn = register_name(freg);
+	printf("\tmvfd\t%s, %s\n",frn,frn);
+return;
+}
+void
+code_d2i(int reg) {
+code_d2i0(reg,1);
+}
+void
+code_d2u(int reg) {
+code_d2u0(reg,1);
+}
+void
+code_f2i(int reg) {
+code_d2i0(reg,0);
+}
+void
+code_f2u(int reg) {
+code_d2u0(reg,0);
+}
+void
+code_i2d(int reg) {
+code_i2d0(reg,1);
+}
+void
+code_i2f(int reg) {
+code_i2d0(reg,0);
+}
+void
+code_u2d(int reg) {
+code_u2d0(reg,1);
+}
+void
+code_u2f(int reg) {
+code_u2d0(reg,0);
+}
+void
+code_drgvar(int e2,int d,int freg)
+{
+	use_float(d,freg);
+	code_ldf(fload(d),register_name(freg),cadr(e2),
+	    get_ptr_cache((NMTBL*)caddr(e2)),"");
+}
+void
+code_drlvar(int e2,int d,int freg)
+{
+	use_float(d,freg);
+	lvar_intro(e2);
+	printf("\t%s\t%s, ",fload(d),register_name(freg));
+	lvar(e2,d?"@ double":"@ float");
+}
+void
+code_cmp_drgvar(int e2,int reg,int d,int label,int cond)
+{
+use_float(d,reg);
+code_drgvar(e2,d,reg);
+code_cmp_dregister(reg,d,label,cond);
+}
+void
+code_cmp_drlvar(int e2,int reg,int d,int label,int cond)
+{
+use_float(d,reg);
+code_drlvar(e2,d,reg);
+code_cmp_dregister(reg,d,label,cond);
+}
+static void
+code_double_lib(char *lib,int to,int reg,int oreg)
+{
+code_save_stacks();
+clear_ptr_cache();
+set_operands(reg,reg,oreg,oreg);
+extern_conv(lib);
+set_dreg(RET_DREGISTER,0);
+if (to!=RET_DREGISTER) {
+	lmove(to,RET_DREGISTER);
+}
+}
+static void
+code_double_lib_c(char *lib,int from,int to,double value)
+{
+code_save_stacks();
+clear_ptr_cache();
+set_dreg_operand(from,1);
+dconst(DREGISTER_OPERAND_1_L,DREGISTER_OPERAND_1_H,value);
+extern_conv(lib);
+set_dreg(RET_DREGISTER,0);
+if (to!=RET_DREGISTER) {
+	lmove(to,RET_DREGISTER);
+}
+}
+static void
+code_float_lib(char *lib,int to,int reg,int oreg)
+{
+code_save_stacks();
+clear_ptr_cache();
+if (reg!=FREGISTER_OPERAND) code_dregister(FREGISTER_OPERAND,reg,0);
+if (to!=FREGISTER_OPERAND_1) code_dregister(FREGISTER_OPERAND_1,to,0);
+extern_conv(lib);
+set_freg(RET_FREGISTER,0);
+if (to!=RET_FREGISTER) {
+	code_dregister(to,RET_FREGISTER,0);
+}
+}
+static void
+code_float_lib_c(char *lib,int from,int to,double value)
+{
+code_save_stacks();
+clear_ptr_cache();
+set_dreg_operand(from,1);
+fconst(FREGISTER_OPERAND_1,value);
+extern_conv(lib);
+set_freg(RET_FREGISTER,0);
+if (to!=RET_FREGISTER) {
+	code_dregister(to,RET_FREGISTER,0);
+}
+}
+void
+dtosop(int op,int reg,int e1)
+{
+char *opn="";
+char *grn,*frn;
+int d;
+int cmp=0;
+d=(op<FOP);
+use_float(d,reg);
+switch(op) {
+case DADD: opn="adfd"; break;
+case DSUB: opn="sufd"; break;
+case DDIV: opn="fdvd"; break;
+case DMUL: opn="fmld"; break;
+case DCMPGE:
+case DCMP:  opn="cmfe"; cmp=1; break;
+case FADD: opn="adfs"; break;
+case FSUB: opn="sufs"; break;
+case FDIV: opn="fdvs"; break;
+case FMUL: opn="fmls"; break;
+case FCMPGE:
+case FCMP:  opn="cmfe"; cmp=1; break;
+default:
+	error(-1); return;
+}
+grn = register_name(e1);
+frn = register_name(reg);
+if (cmp) {
+printf("\t%s\t%s, %s\n",opn,grn,frn);
+} else {
+printf("\t%s\t%s, %s, %s\n",opn,frn,frn,grn);
+}
+}
+void
+code_dassop(int op,int reg,int d) {
+/* we have lvalue in creg, applied floating value is in freg */
+//  (*creg) op = pop()
+int  xreg;
+char *crn;
+char *frn;
+xreg=emit_dpop(d);
+crn=register_name(ireg);
+use_float(d,reg);
+frn  =register_name(reg);
+code_ldf(fload(d),register_name(freg),0,ireg,"");
+dtosop(op,reg,xreg);
+code_ldf(fstore(d),register_name(freg),0,ireg,"");
+emit_dpop_free(xreg,d);
+}
+void
+code_register_dassop(int reg,int op,int d) {
+// reg op= dpop()
+int  xreg;
+	xreg=emit_dpop(d);
+	dtosop(op,reg,xreg);
+	emit_dpop_free(xreg,d);
+}
+static int
+code_dload_1(int d)
+{
+int g = get_dregister(d);
+printf("\tmvf%c\t%s,#1\n",dsuffix(d),register_name(g));
+return g;
+}
+void
+code_dpreinc(int e1,int e2,int d,int reg) {
+char *frn;
+char *crn;
+int  g,reg0;
+char *grn;
+int dir=caddr(e1);
+if (car(e2)==DREGISTER||car(e2)==FREGISTER) {
+	crn=register_name(cadr(e2));
+	grn=register_name(g=code_dload_1(d));
+	if (reg==USE_CREG) {
+	    reg=get_dregister(d); if (!reg) error(-1);
+	    if (d) set_dreg(reg,0); else set_freg(reg,0);
+	}
+	frn=register_name(reg);
+	printf("\t%s%c\t%s, %s, %s\n",
+	    dir>0?"adf":"suf",dsuffix(d),
+	    crn,crn,grn);
+	if (use && reg!=cadr(e2)) {
+	    printf("\tmvf%c\t%s, %s\n",dsuffix(d),frn,crn);
+	}
+} else {
+	g_expr(e2);
+	if (!is_int_reg(creg)) error(-1);
+	reg0 = ireg;
+	if (reg==USE_CREG) {
+	    reg=get_dregister(d); if (!reg) error(-1);
+	    if (d) set_dreg(reg,0); else set_freg(reg,0);
+	}
+	grn = register_name(g = code_dload_1(d));
+	frn=register_name(reg);
+	code_ldf(fload(d),frn,0,reg0,"");
+	printf("\t%s%c\t%s, %s, %s\n",
+	    dir>0?"adf":"suf",dsuffix(d),
+	    frn,frn,grn);
+	code_ldf(fstore(d),frn,0,reg0,"");
+}
+free_register(g);
+}
+void
+code_dpostinc(int e1,int e2,int d,int reg) {
+char *frn;
+char *crn;
+int  g,reg0;
+char *grn;
+int dir=caddr(e1);
+if (car(e2)==DREGISTER||car(e2)==FREGISTER) {
+	crn=register_name(cadr(e2));
+	grn=register_name(g=code_dload_1(d));
+	if (reg==USE_CREG) {
+	    reg=get_dregister(d); if (!reg) error(-1);
+	    set_freg(reg,0);
+	}
+	frn=register_name(reg);
+	if (use && reg!=cadr(e2)) {
+	    printf("\tmvf%c\t%s, %s\n",dsuffix(d),frn,crn);
+	}
+	printf("\t%s%c\t%s,%s,%s\n",dir>0?"adf":"suf",
+	    dsuffix(d),crn,crn,grn);
+} else {
+	g_expr(e2);
+	if (!is_int_reg(creg)) error(-1);
+	crn=register_name(reg0=ireg);
+	if (reg==USE_CREG) {
+	    reg=get_dregister(d); if (!reg) error(-1);
+	    set_freg(reg,0);
+	}
+	frn=register_name(reg);
+	grn = register_name(g = code_dload_1(d));
+	code_ldf(fload(d),frn,0,reg0,"");
+	printf("\t%s%c\t%s, %s, %s\n",
+	    dir>0?"adf":"suf",dsuffix(d),
+	    grn,frn,grn);
+	code_ldf(fstore(d),grn,0,reg0,"");
+}
+free_register(g);
+}
+int
+drexpr(int e1, int e2,int l1, int op,int cond)
+{
+int op1=0;
+char *opn=0;
+if (!cond) {
+	switch(op) {
+	    case FOP+GT:
+		return drexpr(e2,e1,l1,FOP+GE,1);
+	    case FOP+GE:
+		return drexpr(e2,e1,l1,FOP+GT,1);
+	    case FOP+EQ:
+		op=FOP+NEQ; break;
+	    case FOP+NEQ:
+		op=FOP+EQ; break;
+	    case DOP+GT:
+		return drexpr(e2,e1,l1,DOP+GE,1);
+	    case DOP+GE:
+		return drexpr(e2,e1,l1,DOP+GT,1);
+	    case DOP+EQ:
+		op=DOP+NEQ; break;
+	    case DOP+NEQ:
+		op=DOP+EQ; break;
+	}
+}
+switch(op) {
+case FOP+GT:  op1=FOP+CMP;   opn = "bgt"; break;
+case FOP+GE:  op1=FOP+CMPGE; opn = "bge"; break;
+case FOP+EQ:  op1=FOP+CMP;   opn = "beq"; break;
+case FOP+NEQ: op1=FOP+CMP;   opn = "bne"; break;
+case DOP+GT:  op1=DOP+CMP;   opn = "bgt"; break;
+case DOP+GE:  op1=DOP+CMPGE; opn = "bge"; break;
+case DOP+EQ:  op1=DOP+CMP;   opn = "beq"; break;
+case DOP+NEQ: op1=DOP+CMP;   opn = "bne"; break;
+default: error(-1);
+}
+g_expr(list3(op1,e2,e1));
+printf("\t%s\t.L%d\n",opn,l1);
+return l1;
+}
+int emit_dpop(int d)
+{
+int xreg,reg;
+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);
+	xreg=reg;
+}
+return xreg;
+}
+void
+emit_dpop_free(int e1,int d)
+{
+free_register(e1);
+}
+void
+emit_dpush(int d)
+{
+int new_reg;
+if (!is_float_reg(creg)) error(-1);
+if (reg_sp>MAX_MAX) error(-1);
+new_reg = get_dregister(d);       /* ?????????? */
+reg_stack[reg_sp++] = freg;     /* push ???????????????? */
+creg = freg = new_reg;
+}
+#endif
+#if LONGLONG_CODE
+/* 64bit int part */
+int
+lrexpr_bool(int e1, int reg)
+{
+return 0;
+}
+int
+lrexpr(int e1, int e2,int l1, int op,int cond)
+{
+int reg,regh,regl,e3h,e3l;
+int e3,l2;
+g_expr(e1);
+emit_lpush();
+g_expr(e2);
+e3 = emit_lpop();
+if (!is_longlong_reg(creg)) error(-1);
+reg = lreg;
+l2 = fwdlabel();
+regh = reg; regl = reg;
+e3h =  e3;  e3l = e3;
+switch(op) {
+case LOP+GT: case LOP+GE:
+	pcond(GT,  regh,e3h,0,1,cond?l1:l2,COND_BRANCH);
+	pcond(NEQ, regh,e3h,0,1,cond?l2:l1,COND_BRANCH);
+break;
+case LOP+UGT: case LOP+UGE:
+	pcond(UGT, regh,e3h,0,1,cond?l1:l2,COND_BRANCH);
+	pcond(NEQ, regh,e3h,0,1,cond?l2:l1,COND_BRANCH);
+break;
+case LOP+EQ:
+	pcond(EQ, regh,e3h,0,0,cond?l2:l1,COND_BRANCH);
+break;
+case LOP+NEQ:
+	pcond(EQ, regh,e3h,0,0,cond?l1:l2,COND_BRANCH);
+break;
+default:
+error(-1);
+}
+pcond(op%LOP,regl,e3l,0,cond,l1,COND_BRANCH);
+fwddef(l2);
+emit_lpop_free(e3);
+return l1;
+}
+void
+code_cmp_lregister(int reg,int label,int cond)
+{
+use_longlong(reg);
+printf("\torr\t%s, %s, %s\n",
+		lregister_name_low(reg),
+		lregister_name_low(reg),
+		lregister_name_high(reg));
+code_cmp_register((reg),label,cond);
+}
+void
+code_cmp_lrgvar(int e1,int creg,int label,int cond)
+{
+use_longlong(creg);
+code_lrgvar(e1,creg);
+code_cmp_lregister(creg,label,cond);
+}
+void
+code_cmp_lrlvar(int e1,int creg,int label,int cond)
+{
+use_longlong(creg);
+code_lrlvar(e1,creg);
+code_cmp_lregister(creg,label,cond);
+}
+#endif
+#if LONGLONG_CODE||FLOAT_CODE
+int
+emit_lpop()
+{
+int xreg,reg;
+xreg=reg_stack[--reg_sp];
+if (xreg<= -REG_LVAR_OFFSET) {
+reg = get_lregister();
+code_lrlvar(REG_LVAR_OFFSET+xreg,reg);
+free_lvar(REG_LVAR_OFFSET+xreg);
+xreg = reg;
+}
+return xreg;
+}
+void
+code_lregister(int e2,int reg)
+{
+use_longlong(reg);
+if (reg!=e2) {
+	lmove(reg,e2);
+}
+}
+void
+code_lassign(int e2,int creg)
+{
+use_longlong(creg);
+lstore(e2,creg);
+}
+void
+code_lassign_gvar(int e2,int creg)
+{
+int r;
+use_longlong(creg);
+r = get_ptr_cache((NMTBL*)caddr(e2));
+#if ENDIAN_L==0
+code_ldf(cstore(0),lregister_name_low(creg),cadr(e2),r,"");
+code_ldf(cstore(0),lregister_name_high(creg),cadr(e2)+SIZE_OF_INT,r,"");
+#else
+code_ldf(cstore(0),lregister_name_high(creg),cadr(e2),r,"");
+code_ldf(cstore(0),lregister_name_low(creg),cadr(e2)+SIZE_OF_INT,r,"");
+#endif
+}
+void
+code_lassign_lvar(int e2,int creg)
+{
+char *crn_h;
+char *crn_l;
+use_longlong(creg);
+crn_h = lregister_name_high(creg);
+crn_l = lregister_name_low(creg);
+lvar_intro(e2);
+#if ENDIAN_L==0
+printf("\tstr\t%s, ",crn_l);lvar(e2,"");
+printf("\tstr\t%s, ",crn_h);lvar(e2+SIZE_OF_INT,"");
+#else
+printf("\tstr\t%s, ",crn_h);lvar(e2,"");
+printf("\tstr\t%s, ",crn_l);lvar(e2+SIZE_OF_INT,"");
+#endif
+}
+void
+code_lassign_lregister(int e2,int reg)
+{
+use_longlong(reg);
+if (e2!=reg) {
+	lmove(e2,reg);
+}
+}
+void
+emit_lpop_free(int xreg)
+{
+if (xreg>=0)
+free_register(xreg);
+}
+void
+emit_lpush()
+{
+int new_reg;
+if (!is_longlong_reg(creg)) error(-1);
+if (reg_sp>MAX_MAX) error(-1);
+new_reg = get_lregister();        /* ??????????(?) */
+reg_stack[reg_sp++] = creg;     /* push ???????????????? */
+lreg = creg = new_reg;
+}
+void
+code_lrgvar(int e1,int creg)
+{
+int r;
+char *crn_h;
+char *crn_l;
+use_longlong(creg);
+crn_h = lregister_name_high(creg);
+crn_l = lregister_name_low(creg);
+r = get_ptr_cache((NMTBL*)caddr(e1));
+#if ENDIAN_L==0
+code_ldf("ldr",crn_l,cadr(e1),r,"");
+code_ldf("ldr",crn_h,cadr(e1)+SIZE_OF_INT,r,"");
+#else
+code_ldf("ldr",crn_h,cadr(e1),r,"");
+code_ldf("ldr",crn_l,cadr(e1)+SIZE_OF_INT,r,"");
+#endif
+}
+void
+code_lrlvar(int e1,int creg)
+{
+char *crn_h;
+char *crn_l;
+use_longlong(creg);
+crn_h = lregister_name_high(creg);
+crn_l = lregister_name_low(creg);
+lvar_intro(e1);
+printf("\tlqd\t%s, ",crn_l); lvar(e1,"");
+printf("\tlqd\t%s, ",crn_h); lvar(e1+SIZE_OF_INT,"");
+}
+#endif
+#if LONGLONG_CODE
+static long long ll0 = 1LL;
+static int
+code_l1(long long d)
+{
+int *i = (int *)&ll0; int *j = (int *)&d;
+return (i[1] == 1)?j[1]:j[0];
+}
+static int
+code_l2(long long d)
+{
+int *i = (int *)&ll0; int *j = (int *)&d;
+return (i[1] == 1)?j[0]:j[1];
+}
+void
+code_lconst(int e1,int creg)
+{
+use_longlong(creg);
+#if ENDIAN_L==0
+code_const(code_l1(lcadr(e1)),(creg));
+code_const(code_l2(lcadr(e1)),(creg));
+#else
+code_const(code_l1(lcadr(e1)),(creg));
+code_const(code_l2(lcadr(e1)),(creg));
+#endif
+}
+void
+code_lneg(int creg)
+{
+char *rh,*rl;
+use_longlong(creg);
+rl=lregister_name_low(creg);
+rh=lregister_name_high(creg);
+printf("\trsbs\t%s, %s, #0\n",rl,rl);
+printf("\trsc\t%s, %s, #0\n",rh,rh);
+}
+static void
+code_longlong_lib(char *lib,int reg,int oreg)
+{
+code_save_stacks();
+clear_ptr_cache();
+set_operands((reg),(reg),(oreg),(oreg));
+extern_conv(lib);
+// set_lreg(RET_LREGISTER,0);
+}
+#define check_lreg(reg) lmove(reg,RET_LREGISTER)
+void
+ltosop(int op,int reg,int oreg)
+{
+int dx = -1;
+int ox = -1;
+char *orn_h,*crn_h;
+char *orn_l,*crn_l;
+// reg = reg op oreg
+use_longlong(reg);
+if(oreg==-1) {
+	error(-1);
+} else if (oreg<= -REG_LVAR_OFFSET) {
+	ox = get_lregister(); if (ox<0) error(-1);
+	use_reg(ox);
+code_rlvar(oreg+REG_LVAR_OFFSET,ox);
+	oreg = ox;
+}
+switch(op) {
+case LLSHIFT:
+case LULSHIFT:
+	code_longlong_lib("__ashldi3",reg,oreg);
+	check_lreg(reg);
+	if(ox!=-1) free_register(ox);
+	return;
+case LRSHIFT:
+	code_longlong_lib("__ashrdi3",reg,oreg);
+	check_lreg(reg);
+	if(ox!=-1) free_register(ox);
+	return;
+case LURSHIFT:
+	code_longlong_lib("__lshrdi3",reg,oreg);
+	check_lreg(reg);
+	if(ox!=-1) free_register(ox);
+	return;
+}
+orn_h = lregister_name_high(oreg);
+orn_l = lregister_name_low(oreg);
+crn_h = lregister_name_high(reg);
+crn_l = lregister_name_low(reg);
+switch(op) {
+case LADD:
+printf("\tadds\t%s, %s, %s\n",crn_l,crn_l,orn_l);
+printf("\tadc\t%s, %s, %s\n",crn_h,crn_h,orn_h);
+	break;
+case LSUB:
+printf("\tsubs\t%s, %s, %s\n",crn_l,crn_l,orn_l);
+printf("\tsbc\t%s, %s, %s\n",crn_h,crn_h,orn_h);
+	break;
+case LCMP:
+	error(-1);
+	break;
+case LBAND:
+	printf("\tand\t%s, %s, %s\n",crn_l,crn_l,orn_l);
+	printf("\tand\t%s, %s, %s\n",crn_h,crn_h,orn_h);
+	break;
+case LEOR:
+	printf("\teor\t%s, %s, %s\n",crn_l,crn_l,orn_l);
+	printf("\teor\t%s, %s, %s\n",crn_h,crn_h,orn_h);
+	break;
+case LBOR:
+	printf("\torr\t%s, %s, %s\n",crn_l,crn_l,orn_l);
+	printf("\torr\t%s, %s, %s\n",crn_h,crn_h,orn_h);
+	break;
+case LMUL:
+case LUMUL:
+	code_longlong_lib("__muldi3",reg,oreg);
+	check_lreg(reg);
+	break;
+case LDIV:
+	code_longlong_lib("__divdi3",reg,oreg);
+	check_lreg(reg);
+	break;
+case LUDIV:
+	code_longlong_lib("__udivdi3",reg,oreg);
+	check_lreg(reg);
+	break;
+case LMOD:
+	code_longlong_lib("__moddi3",reg,oreg);
+	check_lreg(reg);
+	break;
+case LUMOD:
+	code_longlong_lib("__umoddi3",reg,oreg);
+	check_lreg(reg);
+	break;
+default:
+	error(-1);
+}
+if(ox!=-1) free_register(ox);
+if(dx!=-1) free_register(dx);
+}
+int
+code_lconst_op_p(int op,int e)
+{
+long long v;
+if (car(e)==LCONST) {
+	v = lcadr(e);
+} else if (car(e)==CONST) {
+	v = cadr(e);
+} else return 0;
+switch(op) {
+case LMUL: case LUMUL: /* case LDIV: */ case LUDIV:
+	return ilog(v);
+case LLSHIFT: case LULSHIFT: case LRSHIFT: case LURSHIFT:
+	return 0<v&&v<=64;
+case LADD:
+case LSUB:
+case LBOR:
+case LEOR: case LBAND:
+	return (is_stage1_const(v,0)>0)
+	    && (is_stage1_const(v>>32,0)>0);
+default:
+	return 0;
+}
+}
+void
+loprtc(int op,int creg,int e)
+{
+char *crn_h;
+char *crn_l;
+char *grn;
+int v=0;
+int vh=0;
+int greg,dx=-1;
+use_longlong(creg);
+crn_h = lregister_name_high(creg);
+crn_l = lregister_name_low(creg);
+if (car(e)==LCONST) { v = lcadr(e); vh = lcadr(e)>>32; }
+else if (car(e)==CONST) {
+	v = cadr(e);
+	vh = (v<0)?-1:0;
+}
+switch(op) {
+case LMUL: case LUMUL:
+v=ilog(v);
+case LLSHIFT:
+case LULSHIFT:
+if (v==0) return;
+if (v==32) {
+code_register((creg),(creg));
+code_const(0,(creg));
+return;
+} else if (v>31) {
+printf("\tmov\t%s, %s, lsl #%d\n",crn_h,crn_l,v-32);
+code_const(0,(creg));
+return;
+}
+	greg = get_register();
+	grn = register_name(greg);
+	printf("\tmov\t%s, %s, lsl #%d\n",crn_h,crn_h,v);
+	printf("\tmov\t%s, %s, lsr #%d\n",grn,crn_l,32-v);
+	printf("\torr\t%s, %s,%s\n",crn_h,crn_h,grn);
+	printf("\tmov\t%s, %s, lsl #%d\n",crn_l,crn_l,v);
+	free_register(greg);
+	return;
+case LDIV:
+v=ilog(v);
+case LRSHIFT:
+if (v==0) return;
+if (v==32) {
+code_register((creg),(creg));
+printf("\tmov\t%s, %s, asr #31\n",crn_h,crn_l);
+return;
+} else if (v>31) {
+printf("\tmov\t%s, %s, asr #%d\n",crn_l,crn_h,v-32);
+printf("\tmov\t%s, %s, asr #31\n",crn_h,crn_l);
+return;
+}
+	greg = get_register();
+	grn = register_name(greg);
+	printf("\tmov\t%s, %s, lsr #%d\n",crn_l,crn_l,v);
+	printf("\tmov\t%s, %s, lsl #%d\n",grn,crn_h,32-v);
+	printf("\torr\t%s, %s,%s\n",crn_l,crn_l,grn);
+	printf("\tmov\t%s, %s, asr #%d\n",crn_h,crn_h,v);
+	free_register(greg);
+	return;
+case LUDIV:
+v=ilog(v);
+case LURSHIFT:
+if (v==0) return;
+if (v==32) {
+code_register((creg),(creg));
+code_const(0,(creg));
+return;
+} else if (v>31) {
+printf("\tmov\t%s, %s, lsr #%d\n",crn_l,crn_h,v-32);
+code_const(0,(creg));
+return;
+}
+	greg = get_register();
+	grn = register_name(greg);
+	printf("\tmov\t%s, %s, lsl #%d\n",grn,crn_h,32-v);
+	printf("\tmov\t%s, %s, lsr #%d\n",crn_l,crn_l,v);
+	printf("\torr\t%s, %s,%s\n",crn_l,grn,crn_l);
+	printf("\tmov\t%s, %s, lsr #%d\n",crn_h,crn_h,v);
+	free_register(greg);
+	return;
+case LADD:
+printf("\tadds\t%s, %s, #%d\n",crn_l,crn_l,v);
+printf("\tadc\t%s, %s, #%d\n",crn_h,crn_h,vh);
+	break;
+case LSUB:
+printf("\tsubs\t%s, %s, #%d\n",crn_l,crn_l,v);
+printf("\tsbc\t%s, %s, #%d\n",crn_h,crn_h,vh);
+	break;
+case LBAND:
+	printf("\tand\t%s, %s, #%d\n",crn_l,crn_l,v);
+	printf("\tand\t%s, %s, #%d\n",crn_h,crn_h,vh);
+	break;
+case LEOR:
+	printf("\teor\t%s, %s, #%d\n",crn_l,crn_l,v);
+	printf("\teor\t%s, %s, #%d\n",crn_h,crn_h,vh);
+	break;
+case LBOR:
+	printf("\torr\t%s, %s, #%d\n",crn_l,crn_l,v);
+	printf("\torr\t%s, %s, #%d\n",crn_h,crn_h,vh);
+	break;
+default:
+	error(-1);
+}
+if (dx!=-1) free_register(dx);
+}
+void
+code_i2ll(int reg)
+{
+char *crn,*crn_h,*crn_l;
+int reg0;
+crn = register_name(reg0 = ireg);
+use_longlong(reg);
+crn_h = lregister_name_high(lreg);
+crn_l = lregister_name_low(lreg);
+if (reg0!=(lreg))
+	printf("\tori\t%s, %s, 0\n",crn_l,crn);
+printf("\tmov\t%s, %s, asr #31\n",crn_h,crn_l);
+}
+void
+code_i2ull(int reg)
+{
+code_i2ll(reg);
+}
+void
+code_u2ll(int reg)
+{
+char *crn,*crn_h,*crn_l;
+int reg0;
+crn = register_name(reg0 = ireg);
+use_longlong(reg);
+crn_h = lregister_name_high(lreg);
+crn_l = lregister_name_low(lreg);
+if (reg0!=(lreg))
+	printf("\tori\t%s, %s, 0\n",crn_l,crn);
+printf("\tmov\t%s, #0\n",crn_h);
+}
+void
+code_u2ull(int creg)
+{
+code_u2ll(creg);
+}
+void
+code_ll2i(int reg)
+{
+char *crn_l;
+int reg0;
+crn_l = lregister_name_low(reg0=lreg);
+use_int(reg);
+if (ireg!=(reg0)) {
+	printf("\tori\t%s, %s, 0\n",register_name(ireg),crn_l);
+}
+}
+void
+code_ll2u(int creg)
+{
+code_ll2i(creg);
+}
+void
+code_ull2i(int creg)
+{
+code_ll2i(creg);
+}
+void
+code_ull2u(int creg)
+{
+code_ll2i(creg);
+}
+#if FLOAT_CODE
+void
+code_d2ll(int reg)
+{
+// fixdfdi$stub
+code_assign_input_double_long(
+	list2(LREGISTER,LREGISTER_OPERAND),list2(FREGISTER,freg)) ;
+extern_conv("__fixdfdi");
+set_lreg(RET_LREGISTER,0);
+if (reg!=USE_CREG&&reg!=RET_LREGISTER) {
+	use_longlong(reg);
+}
+}
+void
+code_d2ull(int reg)
+{
+code_assign_input_double_long(
+	list2(LREGISTER,LREGISTER_OPERAND),list2(FREGISTER,freg)) ;
+extern_conv("__fixunsdfdi");
+set_lreg(RET_LREGISTER,0);
+if (reg!=USE_CREG&&reg!=RET_LREGISTER) {
+	use_longlong(reg);
+}
+}
+void
+code_f2ll(int reg)
+{
+code_assign_input_float_int(list2(REGISTER,REGISTER_OPERAND),list2(FREGISTER,freg));
+extern_conv("__fixsfdi");
+set_lreg(RET_LREGISTER,0);
+if (reg!=USE_CREG&&reg!=RET_LREGISTER) {
+	use_longlong(reg);
+}
+}
+void
+code_f2ull(int reg)
+{
+code_assign_input_float_int(list2(REGISTER,REGISTER_OPERAND),list2(FREGISTER,freg));
+extern_conv("__fixunssfdi");
+set_lreg(RET_LREGISTER,0);
+if (reg!=USE_CREG&&reg!=RET_LREGISTER) {
+	use_longlong(reg);
+}
+}
+void
+code_ll2d(int reg)
+{
+set_lreg(LREGISTER_OPERAND,1);
+extern_conv("__floatdidf");
+set_dreg(RET_DREGISTER,0);
+if (reg!=USE_CREG&&reg!=RET_FREGISTER)
+	use_float(1,reg);
+}
+void
+code_ll2f(int reg)
+{
+set_lreg(LREGISTER_OPERAND,1);
+extern_conv("__floatdisf");
+set_freg(RET_FREGISTER,0);
+if (reg!=USE_CREG&&reg!=RET_FREGISTER)
+	use_float(0,reg);
+}
+void
+code_ull2d(int creg)
+{
+code_ll2d(creg);
+}
+void
+code_ull2f(int creg)
+{
+code_ll2f(creg);
+}
+#endif
+static void
+ladd(int dreg,int rreg,int v)   //   rreg = dreg + v
+{
+// v should be 8bit const with 2's shift
+if (v>0) {
+	printf("\tadds\t%s, %s, #%d\n",
+		lregister_name_low(rreg),lregister_name_low(dreg), v);
+	printf("\tadc\t%s, %s, #0\n",
+		lregister_name_high(rreg),lregister_name_high(dreg));
+} else {
+	printf("\tsubs\t%s, %s, #%d\n",
+		lregister_name_low(rreg),lregister_name_low(dreg), -v);
+	printf("\tsbc\t%s, %s, #0\n",
+		lregister_name_high(rreg),lregister_name_high(dreg));
+}
+}
+void
+code_lpreinc(int e1,int e2,int reg)
+{
+int dreg=-1,xreg=-1;
+int dir=caddr(e1);
+if (car(e2)==LREGISTER) {
+use_longlong(reg);
+	ladd(cadr(e2),cadr(e2),dir);
+if (reg!=cadr(e2)) {
+	    lmove(reg,cadr(e2));
+	}
+return;
+}
+g_expr(e2);
+if(!is_int_reg(creg)) error(-1);
+emit_push();
+if (reg==USE_CREG) {
+	dreg=get_lregister(); if (!dreg) error(-1);
+	set_lreg(dreg,0);  // free old lreg==creg
+} else {
+dreg = reg;
+}
+xreg = emit_pop(0);
+lload(xreg,dreg,0);
+ladd(dreg,dreg,dir);
+code_lassign(xreg,dreg);
+emit_pop_free(xreg);
+if (dreg!=-1) free_register(dreg);
+}
+void
+code_lpostinc(int e1,int e2,int reg)
+{
+int dreg,nreg,xreg;
+int dir=caddr(e1);
+if (car(e2)==LREGISTER) {
+	use_longlong(reg);
+	lmove(reg,cadr(e2));
+	ladd(cadr(e2),cadr(e2),dir);
+return;
+}
+g_expr(e2);
+if(!is_int_reg(creg)) error(-1);
+emit_push();
+nreg=get_lregister(); if (!nreg) error(-1);
+if (reg==USE_CREG) {
+	dreg=get_lregister(); if (!dreg) error(-1);
+	set_lreg(dreg,0);  // free old lreg==creg
+} else {
+	dreg = reg;
+}
+xreg = emit_pop(0);
+lload(xreg,dreg,0);
+ladd(dreg,nreg,dir);
+lstore(xreg,nreg);
+emit_pop_free(xreg);
+free_register(nreg);
+}
+void
+code_lassop(int op,int reg)
+{
+int xreg;
+int edx,edx0=-1;
+// (*creg) op = pop()
+xreg = emit_lpop(0);       /* pop e3 value */
+if (!is_int_reg(creg)) error(-1);
+edx = ireg;
+emit_push();
+use_longlong(reg);
+if ((lreg)==edx || (lreg)==edx) {
+	edx0 = get_register(); if(!edx0) error(-1);
+	printf("## lassop\n\tori\t%s, %s, 0\n",register_name(edx0),
+	       register_name(edx));
+	edx = edx0;
+}
+lload(edx,reg,0);
+// free_register(edx); don't do this, it will free pushed register
+ltosop(op,reg,xreg);    // loprtc?
+emit_lpop_free(xreg);
+use_reg(reg);
+edx = emit_pop(0);
+code_lassign(edx,reg);
+emit_pop_free(edx);
+if (edx0!=-1)
+	free_register(edx0);
+if (reg!=lreg)
+	free_register(reg);
+}
+void
+code_register_lassop(int reg,int op) {
+// reg op = pop()
+int  xreg=emit_lpop();
+ltosop(op,reg,xreg);
+emit_lpop_free(xreg);
+}
+#endif
+void
+code_save_stacks()
+{
+int i,reg;
+for(i=0;i<reg_sp;i++) {
+if ((reg=reg_stack[i])>=0) {
+code_assign_lvar(
+(reg_stack[i]=new_lvar(SIZE_OF_INT)*4),reg,0);
+reg_stack[i]= reg_stack[i]-REG_LVAR_OFFSET;
+	    free_register(reg);
+}
+}
+#if FLOAT_CODE
+for(i=0;i<reg_sp;i++) {
+if ((reg=reg_stack[i])>=0) {
+code_dassign_lvar(
+(reg_stack[i]=new_lvar(SIZE_OF_DOUBLE)),reg,1);
+reg_stack[i]= reg_stack[i]-REG_LVAR_OFFSET;
+	    free_register(reg);
+}
+}
+#endif
+#if LONGLONG_CODE
+for(i=0;i<reg_sp;i++) {
+if ((reg=reg_stack[i])>=0) {
+code_lassign_lvar(
+(reg_stack[i]=new_lvar(SIZE_OF_LONGLONG)),reg);
+reg_stack[i]= reg_stack[i]-REG_LVAR_OFFSET;
+	    free_register(reg);
+}
+}
+#endif
+}
+void
+emit_lib(char *p[])
+{
+while(*p) {
+	printf("%s\n",*p++);
+}
+}
+void
+code_closing()
+{
+global_table();
+/* printf("\t.ident \"Micro-C compiled\"\n"); */
+}
+#if CASE_CODE
+int
+code_table_jump_p(int delta) { return delta==1||delta==2||delta==4; }
+void
+code_table_jump(int l,int csvalue,int delta,int max,int min,int dlabel)
+{
+int t,regsv;
+char *trn;
+regsv = regs[csvalue]; regs[csvalue] = 1;
+trn = register_name(t=get_register());
+regs[csvalue] = regsv;
+code_add(t,-min,csvalue);
+switch(delta) {
+case 1:
+	code_cmpdimm(max-min,t,dlabel,-1);
+	printf("\tldrls\tpc, [pc, %s, asl #2]\n",trn);
+	break;
+case 2:
+	printf("\ttst\t%s, #1\n",trn);
+	printf("\tbne\t.L%d\n",dlabel);
+	code_cmpdimm(max-min,t,dlabel,-1);
+	printf("\tldrls\tpc, [pc, %s, asl #1]\n",trn); break;
+	break;
+case 4:
+	printf("\ttst\t%s, #3\n",trn);
+	printf("\tbne\t.L%d\n",dlabel);
+	code_cmpdimm(max-min,t,dlabel,-1);
+	printf("\tldrls\tpc, [pc, %s]\n",trn); break;
+	break;
+default:
+	error(-1);
+}
+printf("\tbr\t.L%d\n",dlabel);
+free_register(t);
+}
+void
+code_table_open(int l)
+{
+output_mode = DATA_EMIT_MODE;
+printf("\t.align 2\n");
+fwddef(l);
+}
+void
+code_table_value(int label,int table_top)
+{
+printf("\t.word .L%d\n",label);
+}
+void
+code_table_close()
+{
+}
+#endif
+#if ASM_CODE
+/*
+print an operand
+*/
+static void
+emit_asm_operand(int rstr)
+{
+if (car(rstr)==REGISTER) {
+	printf("%s",register_name(cadr(rstr)));
+} else if (car(rstr)==CONST) {
+	printf("%d",cadr(rstr));
+} else if (car(rstr)==FNAME) {
+	printf("%s",(char*)cadr(rstr));
+} else if (car(rstr)==STRING) {
+	printf(".L%d",cadr(rstr));
+} else {
+	error(-1);
+}
+}
+/*
+prepare asm operands
+char *constraints string
+int  operand expr
+int  mode          (ASM_INPUT,ASM_OUTPUT)
+int  replacement list
+int  output operands count
+int  output operands replacement list
+retrun replacement list
+list3( operands, next, clobber )
+0    can be shared in input/output
+1    can't be used in input
+*/
+int
+code_asm_operand(char *p,int e1,int mode,int repl,int n,int repl0)
+{
+int r;
+int c;
+int val;
+int clobber = 0;
+printf("## constraint %s\n",p);
+if (*p=='=') {
+	// output register
+	p++;
+}
+if (*p=='&') {
+	// earlyclobber
+	p++;
+	clobber = 1;
+}
+c = *p;
+if (c=='r') {
+	if (mode==ASM_INPUT) {
+	    for(;repl0;repl0 = cadr(repl0)) {
+		if (car(car(repl0))==REGISTER && caddr(repl0)==0) {
+		    r = cadr(car(repl0));
+		    caddr(repl0) = ASM_USED;
+		    break;
+		}
+}
+	    r = get_register();
+	} else {
+	    r = get_register();
+	}
+	repl = list3(list2(REGISTER,r),repl,clobber);
+} else if (c=='m') {
+	repl = list3(list2(0,0),repl,clobber);
+} else if (c=='i') {
+	if (car(e1)==GVAR) {
+	    e1=list3(FNAME,(int)(((NMTBL *)caddr(e1))->nm),0);
+	} else if (car(e1)==FNAME) {
+	    e1=list3(FNAME,(int)(((NMTBL *)cadr(e1))->nm),0);
+	} else if (car(e1)==STRING) {
+	    val = emit_string_label();
+	    ascii((char*)cadr(e1));
+	    e1=list3(STRING,val,0);
+	} else if (car(e1)==CONST) {
+	} else error(-1);
+	repl = list3(e1,repl,clobber);
+} else if (digit(c)) {
+	val = 0;
+	do { val = val*10 + c-'0'; } while (digit(c=*p++));
+	if (val>MAX_ASM_REG) error(-1); // too large register
+	if (n-val<0) error(-1);
+	repl = list3(car(nth(n-val-1,repl0)),repl,clobber);
+} else error(-1);
+return repl;
+}
+void
+code_free_asm_operand(int repl)
+{
+for(;repl;repl=cadr(repl)) {
+	if (car(car(repl))==REGISTER)
+	    free_register(cadr(car(repl)));
+}
+}
+extern void
+code_asm(char *asm_str,int repl)
+{
+int c,i,rstr,val;
+char *p;
+int reg[MAX_ASM_REG];
+text_mode(2);
+c = *asm_str;
+if (c!='\t'&&c!=' ') printf("\t");
+for(i=0;repl && i<MAX_ASM_REG;i++) {
+	reg[i] = car(repl);
+	repl = cadr(repl);
+}
+p = asm_str;
+while((c = *p++)) {
+	if (c=='%') {
+	    c = *p++;
+	    if (!c) { break;
+	    } else if (c=='%') {
+		printf("%%"); continue;
+	    } else if (!digit(c)) {
+		printf("%%%c",c); continue;
+	    }
+	    val = 0;
+	    do { val = val*10 + c-'0'; } while (digit(c=*p++)) ;
+	    p--;
+	    if (val>MAX_ASM_REG) error(-1); // too large register
+	    rstr = reg[val];
+	    emit_asm_operand(rstr);
+	} else {
+	    printf("%c",c);
+	}
+}
+printf("\n");
+}
+#endif
+#if BIT_FIELD_CODE
+/* bit field alignment calcuration */
+static void
+set_bitsz(int type,int *pbitpos, int *pbitsize,
+	int *psign,int *pbitsz,int *palign,int *pl)
+{
+int sign=0,bitsz=0;
+int align=0,l=0;
+switch(cadr(type)) {   /* value type */
+case INT:	        sign=1; break;
+case UNSIGNED:	break;
+case CHAR:          sign=1; break;
+case UCHAR: 	break;
+case SHORT:         sign=1; break;
+case USHORT:        sign=1; break;
+case LONGLONG:      sign=1; l=1; break;
+case ULONGLONG:     l=1; break;
+default: error(-1);
+}
+if (car(caddr(type))>0) { /* store type */
+	if (car(car(caddr(type)))==STRUCT) {
+	    bitsz=64+32; align=4; l=2;
+	} else error(-1);
+} else {
+	switch(car(caddr(type))) {
+	case INT:	    bitsz=32; align=4; break;
+	case UNSIGNED:	    bitsz=32; align=4; break;
+	case CHAR:          bitsz= 8; align=1; break;
+	case UCHAR: 	    bitsz= 8; align=1; break;
+	case SHORT:         bitsz=16; align=2; break;
+	case USHORT:        bitsz=16; align=2; break;
+	case LONGLONG:      bitsz=64; align=4; l=1; break;
+	case ULONGLONG:     bitsz=64; align=4; l=1; break;
+	default: error(-1);
+	}
+}
+*pbitpos = cadr(caddr(type));
+*pbitsize = caddr(caddr(type));
+*psign = sign;
+*pbitsz = bitsz;
+*palign = align;
+*pl = l;
+}
+/*
+bit field alignment calcuration
+this is architecture depenedent
+*/
+#define NON_ALIGNED_BFD 1
+extern int
+code_bit_field_disp(int type,int *poffset,int *bfd,int *sz)
+{
+int sign,bitsz,align;
+int i;
+int bitpos = *bfd;
+int offset = *poffset;
+int l;
+int bitsize,bitpos0;
+set_bitsz(type,&bitpos0,&bitsize,&sign,&bitsz,&align,&l);
+if (bitsize>bitsz) { error(BTERR); bitsize = bitsz; }
+/* bfd means previous bit field bit offset */
+if (bitpos) {
+	/* previous field is bit field and spaces may remain */
+	/* calc previsous offset */
+	offset-=(bitpos+7)/8;
+#ifdef NON_ALIGNED_BFD
+	/* code for non-aligned non-hole bit-field */
+	/* remove extra previous offset from bitpos */
+	while(bitpos>align*8) {
+	    i = ((offset+(align))&~(align-1))-offset;
+	    offset+=i; bitpos-=i*8;
+	}
+	if (bitpos+bitsize > bitsz) {
+	    int stype=UNSIGNED;
+	    /* rewind extra previous offset */
+	    bitpos = *bfd; offset=*poffset;
+	    offset-=(bitpos+7)/8;
+	    /* extend store type to allow |---===|===---| */
+	    switch(car(caddr(type))) {
+	    case INT:	case UNSIGNED:
+		stype=ULONGLONG; align=4; break;
+	    case CHAR:   case UCHAR:
+		stype=USHORT; align=2; break;
+	    case SHORT:   case USHORT:
+		stype=UNSIGNED; align=4; break;
+	    case ULONGLONG: case LONGLONG:
+		/* dummy struct type. fields are never used */
+		stype=list4(STRUCT,12,0,0);align=4;break;
+	    default: error(-1);
+	    }
+	    /* remove extra previous offset from bitpos again */
+	    while(bitpos>align*8) {
+		i = ((offset+(align))&~(align-1))-offset;
+		offset+=i; bitpos-=i*8;
+	    }
+	    bitsz = size(stype)*8;
+	    /* fix store type */
+	    car(caddr(type)) = stype;
+	}
+#endif
+	/* previous remaining bit space can contain this type? */
+	i= offset;
+	for(l = bitpos;l>0;l -= 8,i++) {
+	    if ((i & (align-1))==0 && l+bitsize <= bitsz) {
+		/* alignment is correct and space remains */
+		*poffset=offset=i;
+		i = l+bitsize;
+		*bfd = (i==bitsz)?0:i;
+	        *sz = (i+7)/8;
+#ifdef BITPOS_DEBUG
+printf("## %d: bitpos=%d bitsize=%d bitsz=%d offset=%d\n",lineno,bitpos,bitsize,bitsz,*poffset);
+#endif
+		return l;
+	    }
+	}
+}
+/* first bit-field or no remaining bits */
+if ((i=(offset & (align-1)))) {
+	*poffset = (offset += (align-i));
+}
+bitpos = 0;
+*bfd = (bitsize==bitsz)?0:bitsize;
+*sz = (bitsize+7)/8;
+#ifdef BITPOS_DEBUG
+printf("## %d: bitpos=%d bitsize=%d bitsz=%d offset=%d\n",lineno,bitpos,bitsize,bitsz,*poffset);
+#endif
+return bitpos;
+}
+/* bit field value */
+/* reg contains container value, result should be in reg */
+extern void
+code_bit_field(int type,int adr,int reg)
+{
+int sign,bitsz,l,align;
+int bitsize,bitpos;
+int i,size;
+set_bitsz(type,&bitpos,&bitsize,&sign,&bitsz,&align,&l);
+size = bitsz/8;
+// printf("## %d: bitpos=%d bitsize=%d bitsz=%d\n",lineno,bitpos,bitsize,bitsz);
+/* this implementation returns -1 for int i:1; */
+if (l==1) {
+#if LONGLONG_CODE
+	// use_int(adr);
+	use_longlong(reg);
+lload(adr,reg,0);
+	/* shift left */
+	if ((i=bitsz-bitsize-bitpos))
+	    loprtc(LLSHIFT,reg,list2(CONST,i));
+	/* shift right */
+	if ((i=bitsz-bitsize))
+	    loprtc(sign?LRSHIFT:LURSHIFT,reg,list2(CONST,i));
+} else if (l==2) {   /* three int container */
+	int lvalue;
+	// use_int(adr);
+	use_longlong(reg);
+	lvalue = get_register();
+	code_register(adr,lvalue); adr = lvalue;
+/*
+<-----bitsize--------------->
+hhhhhh  mmmmmmmmmmmm  lllllll
+lllll  00000000000  mmmmmmmmmmmm  0000000  hhhhhhh
+|-----||-----------||------------||-------||-------|
+<-bitpos--->
+<----------------bitsz----------------------------->
+<-----32----------> <---32------> <----32---------->
+(r0:r1) <<= bitsz-bitsize-bitbos
+rest >> =  b;
+rest << =  a;   (b>a)   ==>    rest >> (b-a)
+(64+32-bitsize -bitpos - (bitsz-bitsize))
+= 64+32 -bitsz -bitbpos
+*/
+	/* load hhhhh */
+	code_ld(cload(0,0),(reg),SIZE_OF_INT*2,adr,cext_at(0,0));
+	/* load mmmmmm */
+	code_ld(cload(0,0),(reg),SIZE_OF_INT,adr,cext_at(0,0));
+	i = 64-(bitsize-(32-bitpos));
+	loprtc(LLSHIFT,reg,list2(CONST,i));
+	if (i<0||64<=i) error(-1);
+	/* load lllll */
+	code_ld(cload(0,0),adr,0,adr,cext_at(0,0));
+	i = (bitsize-(32-bitpos))-32;
+	oprtc(URSHIFT,adr,list2(CONST,i));
+	if (i<0||32<=i) error(-1);
+	printf("\tadd\t%s,%s,%s\n",
+			    register_name((reg)),
+			    register_name((reg)),
+			    register_name(adr));
+	i = 64-bitsize;
+	loprtc(sign?LRSHIFT:LURSHIFT,reg,list2(CONST,i));
+	if (i<0||64<=i) error(-1);
+	free_register(adr);
+#endif
+} else {
+	// use_int(adr);
+	use_int(reg);
+	code_ld(cload(size,sign),reg,0,adr,cext_at(0,0));
+	/* shift left */
+	if ((i=32-bitsize-bitpos))
+	    oprtc(LSHIFT,reg,list2(CONST,i));
+	/* shift right */
+	if ((i=32-bitsize))
+	    oprtc(sign?RSHIFT:URSHIFT,reg,list2(CONST,i));
+}
+}
+/* bit field replacement */
+static void
+make_mask_and_or(int mask,int tmp,char *trn,char *crn,char *lrn)
+{
+// printf("## mask 0x%08x ~0x%08x\n",mask,~mask);
+	code_const(~mask,tmp);
+	printf("\torr\t%s, %s, %s\n",trn,crn,trn);
+	/* do conjunction  */
+	printf("\tand\t%s, %s, %s\n",lrn,trn,lrn);
+	/* make or-mask  */
+	code_const(mask,tmp);
+	printf("\tand\t%s, %s, %s\n",trn,crn,trn);
+	/* do disjunction  */
+	printf("\torr\t%s, %s, %s\n",crn,trn,lrn);
+}
+extern void
+code_bit_replace(int adr,int value,int type)
+{
+int sign,bitsz,l,align;
+int bitsize,bitpos;
+int mask = 0;
+int tmp = -1,lvalue,size;
+char *crn,*lrn,*trn;
+set_bitsz(type,&bitpos,&bitsize,&sign,&bitsz,&align,&l);
+size = bitsz/8;
+// printf("## %d: bitpos=%d bitsize=%d bitsz=%d\n",lineno,bitpos,bitsize,bitsz);
+if (l==1) {
+#if LONGLONG_CODE
+	int tmp2;
+// use_int(adr);
+lvalue = get_lregister();
+	tmp2 = get_register();
+	code_register(adr,tmp2); adr = tmp2;
+lload(adr,lvalue,0);
+	use_longlong(value);
+	crn = lregister_name_high(value);
+	lrn = lregister_name_high(lvalue);
+	/* shift left */
+	if (bitpos)
+	    loprtc(LLSHIFT,value,list2(CONST,bitpos));
+	trn = register_name(tmp = get_register());
+	if (bitpos+bitsize>=32) {
+	    /* make and-mask upper */
+	    mask = make_mask(64-bitpos-bitsize,bitpos>=32?63-bitpos:31);
+	    make_mask_and_or(mask,tmp,trn,crn,lrn);
+	}
+	crn = lregister_name_low(value);
+	lrn = lregister_name_low(lvalue);
+	if (bitpos<32) {
+	    /* make and-mask lower */
+	    mask = make_mask(bitpos+bitsize>=32?0:32-bitpos-bitsize,31-bitpos);
+	    make_mask_and_or(mask,tmp,trn,crn,lrn);
+	}
+code_lassign(adr,value);
+	free_register(lvalue);
+	free_register(adr);
+} else if (l==2) {
+	int i;
+	int tmpvar;
+// use_int(adr);
+	use_longlong(value);
+	lvalue = get_register();
+	code_register(adr,lvalue); adr = lvalue;
+tmpvar=new_lvar(SIZE_OF_LONGLONG);
+	code_lassign_lvar(tmpvar,value);
+	trn = register_name(tmp = get_register());
+/* make and-mask upper */
+	i=bitpos;
+	if (i)
+	    oprtc(LSHIFT,(value),list2(CONST,i));
+	if (i<0||32<=i) error(-1);
+	crn = lregister_name_low(value);
+	code_ld(cload(0,0),(value),0,adr,cext_at(0,0));
+	lrn = lregister_name_high(value);
+mask = make_mask(0,31-bitpos);
+	make_mask_and_or(mask,tmp,trn,crn,lrn);
+	printf("\t%s\t%s, 0(%s)\n",cstore(0),crn,register_name(adr));
+/*
+<-----bitsize--------------->
+hhhhhh  mmmmmmmmmmmm  lllllll
+lllll  00000000000  mmmmmmmmmmmm  0000000  hhhhhhh
+|-----||-----------||------------||-------||-------|
+<-bitpos--->
+<----------------bitsz----------------------------->
+<-----32----------> <---32------> <----32---------->
+*/
+/* store middle */
+	code_lrlvar(tmpvar,value);
+	i=32-bitpos;
+	if (i)
+	    loprtc(LRSHIFT,value,list2(CONST,i));
+	if (i<0||64<=i) error(-1);
+	printf("\t%s\t%s, 16(%s)\n",cstore(0),crn,register_name(adr));
+/* make and-mask lower */
+	code_ld(cload(0,0),(value),8,adr,cext_at(0,0));
+	if (i<0||64<=i) error(-1);
+	mask = make_mask(bitsz-bitpos-bitsize,31);
+	make_mask_and_or(mask,tmp,trn,lrn,crn);
+	printf("\t%s\t%s, 32(%s)\n",cstore(0),lrn,register_name(adr));
+	free_lvar(tmpvar);
+	free_register(adr);
+#endif
+} else {
+	// use_int(adr);
+	use_int(value);
+lvalue = get_register();
+	code_ld(cload(size,sign),lvalue,0,adr,cext_at(0,0));
+	crn = register_name(value);
+	lrn = register_name(lvalue);
+	/* shift left */
+	if (bitpos)
+	    oprtc(LSHIFT,value,list2(CONST,bitpos));
+	trn = register_name(tmp = get_register());
+	/* make and-mask */
+	mask = make_mask(32-bitpos-bitsize,31-bitpos);
+	make_mask_and_or(mask,tmp,trn,crn,lrn);
+code_assign(adr,size,value);
+	free_register(lvalue);
+}
+if (tmp!=-1) free_register(tmp);
+if (use) {
+code_bit_field(type,adr,USE_CREG);
+}
+}
+static void
+make_mask_and_or_const(int mask,char *crn,int c)
+{
+char *trn;
+int tmp = -1;
+int m;
+// printf("## mask 0x%08x ~0x%08x\n",mask,~mask);
+if ((m=(~mask|c))!=-1) {
+	if (is_stage1_const(m,0)>0) {
+	    printf("\tand\t%s, %s, #%d\n",crn,crn,m);
+	} else {
+	    trn = register_name(tmp=get_register());
+	    code_const((~mask|c),tmp);
+	    /* do conjunction  */
+	    printf("\tand\t%s, %s, %s\n",crn,trn,crn);
+	}
+}
+if (tmp!=-1) { free_register(tmp); tmp=-1; }
+/* make or-mask  */
+c = mask&c;
+if (c!=0) {
+	/* do disjunction  */
+	if (is_stage1_const(c,0)>0) {
+	    printf("\torr\t%s, %s, #%d\n",crn,crn,c);
+	} else {
+	    trn = register_name(tmp=get_register());
+	    code_const(c,tmp);
+	    printf("\torr\t%s, %s, %s\n",crn,trn,crn);
+	}
+}
+if (tmp!=-1) free_register(tmp);
+}
+extern void
+code_bit_replace_const(int value,int adr,int type)
+{
+int sign,bitsz,l,align;
+int bitsize,bitpos,size;
+int mask = 0;
+int c;
+int lvalue;
+#if LONGLONG_CODE
+long long lc;
+int tmp;
+#endif
+char *crn;
+set_bitsz(type,&bitpos,&bitsize,&sign,&bitsz,&align,&l);
+size = bitsz/8;
+// printf("## %d: bitpos=%d bitsize=%d bitsz=%d\n",lineno,bitpos,bitsize,bitsz);
+if (l==1) {
+#if LONGLONG_CODE
+use_int(adr);
+lvalue = get_lregister();
+lload(adr,lvalue,0);
+	crn = lregister_name_high(lvalue);
+	/* shift left */
+	lc = lcadr(value);
+	lc <<= bitpos;
+	if (bitpos+bitsize>=32) {
+	    /* make and-mask upper */
+	    mask = make_mask(64-bitpos-bitsize,bitpos>=32?63-bitpos:31);
+	    make_mask_and_or_const(mask,crn,(int)(lc>>32));
+	}
+	crn = lregister_name_low(lvalue);
+	if (bitpos<32) {
+	    /* make and-mask lower */
+	    mask = make_mask(bitpos+bitsize>=32?0:32-bitpos-bitsize,31-bitpos);
+	    make_mask_and_or_const(mask,crn,(int)lc);
+	}
+code_lassign(adr,lvalue);
+	free_register(adr);
+free_register(lvalue);
+} else if (l==2) {  // three int container
+	char *trn;
+/*
+hhhhhh  mmmmmmmmmmmm  lllllll
+lllll  00000000000  mmmmmmmmmmmm  0000000  hhhhhhh
+|-----||-----------||------------||-------||-------|
+*/
+	use_int(adr);
+	crn = register_name(adr);
+	trn = register_name(tmp = get_register());
+	/* shift right */
+	lc = lcadr(value);
+	/* make and-mask upper */
+	code_ld(cload(0,0),tmp,0,adr,cext_at(0,0));
+	mask = make_mask(0,31-bitpos);
+	make_mask_and_or_const(mask,trn,(int)(lc<<bitpos));
+	printf("\t%s\t%s, 0(%s)\n",cstore(0),trn,crn);
+	/* store middle */
+	code_const((int)(lc>>(32-bitpos)),tmp);
+	printf("\t%s\t%s, 16(%s)\n",cstore(0),trn,crn);
+	/* make and-mask lower */
+	code_ld(cload(0,0),tmp,8,adr,cext_at(0,0));
+	mask = make_mask(bitsz-bitpos-bitsize,31);
+	make_mask_and_or_const(mask,trn,(int)(lc>>(64-bitpos)));
+	printf("\t%s\t%s, 32(%s)\n",cstore(0),trn,crn);
+	free_register(tmp);
+#endif
+} else {
+	use_int(adr);
+	lvalue = get_register();
+	code_ld(cload(size,sign),lvalue,0,adr,cext_at(0,0));
+	crn = register_name(lvalue);
+	/* shift left */
+	c = cadr(value);
+	c <<= bitpos;
+	/* make and-mask */
+mask = make_mask(32-bitpos-bitsize,31-bitpos);
+	make_mask_and_or_const(mask,crn,c);
+code_assign(adr,size,lvalue);
+free_register(lvalue);
+}
+if (use) {
+code_bit_field(type,adr,USE_CREG);
+}
+}
+#endif
+/* end */

Mercurial > hg > CbC > old > device

comparison mc-code-spu.c @ 661:f566ac85f2e0