651 lines
16 KiB
C++
651 lines
16 KiB
C++
I64 CmpType(CHashClass *tempc)
|
|
{
|
|
if (tempc) {
|
|
while (tempc->fwd_class)
|
|
tempc=tempc->fwd_class;
|
|
return tempc->sub_type;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
I64 CmpPType(CHashClass *tempc)
|
|
{
|
|
if (tempc) {
|
|
if (tempc->ptr_cnt)
|
|
tempc--;
|
|
while (tempc->fwd_class)
|
|
tempc=tempc->fwd_class;
|
|
return tempc->sub_type;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
U0 CmpF1PushPop(CIntermediateCode *tempi,CIntermediateCode *tempi2)
|
|
{
|
|
if (Bt(fpop_bitmap,tempi2->ic_opcode)|| tempi2->ic_flags&ICF_R_TO_F64)
|
|
Bts(&tempi->ic_flags,ICf_DONT_PUSH_FLOAT0);
|
|
}
|
|
|
|
U0 CmpF2PushPop(CIntermediateCode *tempi,CIntermediateCode *tempi1,CIntermediateCode *tempi2)
|
|
{
|
|
if ((tempi2->ic_opcode==IC_MOV || tempi2->ic_opcode==IC_F64) &&
|
|
!(tempi2->ic_flags&ICF_R_TO_F64) &&
|
|
(Bt(fpop_bitmap,tempi1->ic_opcode) || tempi1->ic_flags&ICF_R_TO_F64))
|
|
Bts(&tempi->ic_flags,ICf_DONT_PUSH_FLOAT0);
|
|
else if ((Bt(fpop_bitmap,tempi2->ic_opcode) || tempi2->ic_flags&ICF_R_TO_F64)&&
|
|
!(tempi1->ic_flags&ICF_R_TO_F64))
|
|
Bts(&tempi->ic_flags,ICf_DONT_PUSH_FLOAT0);
|
|
}
|
|
|
|
class OptMemberVar
|
|
{
|
|
I64 score,offset,lea_balance;
|
|
CMemberList *m;
|
|
};
|
|
|
|
I64 OptMVCompare(OptMemberVar *mv1,OptMemberVar *mv2)
|
|
{
|
|
return mv2->score-mv1->score;
|
|
}
|
|
|
|
U0 OptPass3(CLex *lx,CHashFun *fun_class,COptReg *register_offsets)
|
|
{
|
|
CHashClass *tempc,*tempc1,*tempc2,*tempc3;
|
|
CCodeBlkMisc *lb;
|
|
CIntermediateCode *tempi,*tempi1,*tempi2,*tempi3,
|
|
*tempil1,*tempil2,
|
|
*temp_lag[4];
|
|
I64 code,i,j,l,member_cnt,used_reg_mask=0;
|
|
CMemberList *tempm;
|
|
CPrsStk *ps=OptStart(lx,temp_lag);
|
|
OptMemberVar *mv=NULL;
|
|
for (i=0;i<NUM_REGS;i++) {
|
|
register_offsets[i].offset=MAX_I64;
|
|
register_offsets[i].m=NULL;
|
|
}
|
|
if (fun_class) {
|
|
member_cnt=fun_class->member_cnt;
|
|
if (Bt(&fun_class->flags,Ff_DOT_DOT_DOT))
|
|
member_cnt+=2;
|
|
mv=CAlloc(member_cnt*sizeof(OptMemberVar));
|
|
member_cnt=0;
|
|
tempm=fun_class->member_list;
|
|
while (tempm) {
|
|
tempc=tempm->member_class;
|
|
while (tempc->fwd_class)
|
|
tempc=tempc->fwd_class;
|
|
if (0<=tempm->register<NUM_REGS) {
|
|
if (Bts(&used_reg_mask,tempm->register))
|
|
PrintFWarn("%S\n $$LK-A,\"FL:%s,%d\"$$ '%s' in '%s'\n","ST_REG_IN_USE",
|
|
lx->cur_lfn->name,lx->cur_lfn->line_num,tempm->str,fun_class->str);
|
|
register_offsets[tempm->register].offset=tempm->offset;
|
|
register_offsets[tempm->register].m=tempm;
|
|
} else if (tempc->sub_type!=IT_F64 && tempm->register!=CREG_NONE ||
|
|
tempm->register==CREG_ALLOC) {
|
|
if (tempm->register==CREG_ALLOC)
|
|
mv[member_cnt].score=MAX_I64/2; //big but not too big
|
|
mv[member_cnt].offset=tempm->offset;
|
|
mv[member_cnt++].m=tempm;
|
|
} else {
|
|
if (tempm->register==CREG_ALLOC)
|
|
PrintFWarn("%S\n $$LK-A,\"FL:%s,%d\"$$ '%s' in '%s'\n","ST_CANT_REG_VAR",
|
|
lx->cur_lfn->name,lx->cur_lfn->line_num,tempm->str,fun_class->str);
|
|
}
|
|
tempm=tempm->next;
|
|
}
|
|
} else
|
|
member_cnt=0;
|
|
|
|
tempi=lx->cbh.cb_in_ptr;
|
|
if (tempi->ic_opcode==IC_START)
|
|
tempi++;
|
|
while (code=tempi->ic_opcode) {
|
|
if (code!=IC_NOP) {
|
|
OptNext(tempi,temp_lag);
|
|
tempil1=temp_lag[1];
|
|
tempil2=temp_lag[2];
|
|
tempc=tempi->ic_class;
|
|
nobound_switch (cmp_arg_cnt[code]) {
|
|
case 9:
|
|
ps->ptr-=tempi->ic_data>>3;
|
|
break;
|
|
case 3:
|
|
tempi3=PrsPop(ps);
|
|
if (tempi3->ic_flags&ICF_R_TO_F64)
|
|
tempc3=sys_internal_types[IT_F64];
|
|
else if (tempi3->ic_flags & ICF_R_TO_INT)
|
|
tempc3=sys_internal_types[IT_I64];
|
|
else
|
|
tempc3=tempi->t.p3c;
|
|
tempi->p3.type=TY_STK+CmpType(tempc3);
|
|
tempi->p3.ptype=CmpPType(tempc3);
|
|
tempi->ic_flags|=ICF_P3_WAS_STK;
|
|
case 2:
|
|
tempi2=PrsPop(ps);
|
|
if (tempi2->ic_flags&ICF_R_TO_F64)
|
|
tempc2=sys_internal_types[IT_F64];
|
|
else if (tempi2->ic_flags & ICF_R_TO_INT)
|
|
tempc2=sys_internal_types[IT_I64];
|
|
else
|
|
tempc2=tempi->t.p2c;
|
|
tempi->p2.type=TY_STK+CmpType(tempc2);
|
|
tempi->p2.ptype=CmpPType(tempc2);
|
|
tempi->ic_flags|=ICF_P2_WAS_STK;
|
|
case 1:
|
|
tempi1=PrsPop(ps);
|
|
if (tempi1->ic_flags&ICF_R_TO_F64)
|
|
tempc1=sys_internal_types[IT_F64];
|
|
else if (tempi1->ic_flags & ICF_R_TO_INT)
|
|
tempc1=sys_internal_types[IT_I64];
|
|
else
|
|
tempc1=tempi->t.p1c;
|
|
tempi->p1.type=TY_STK+CmpType(tempc1);
|
|
tempi->p1.ptype=CmpPType(tempc1);
|
|
tempi->ic_flags|=ICF_P1_WAS_STK;
|
|
break;
|
|
case 0: //nobound_switch
|
|
break;
|
|
}
|
|
if (cmp_result_cnt[code]) {
|
|
tempi->r.type=TY_STK+CmpType(tempc);
|
|
tempi->r.ptype=CmpPType(tempc);
|
|
tempi->ic_flags|=ICF_R_WAS_STK;
|
|
PrsPush(ps,tempi);
|
|
}
|
|
nobound_switch (code) {
|
|
case IC_F64:
|
|
tempi->ic_flags&=~ICF_R_TO_F64;
|
|
if (tempi->ic_flags&ICF_R_TO_INT) {
|
|
tempi->ic_data=ToI64(tempi->ic_data(F64));
|
|
tempi->ic_flags&=~ICF_R_TO_INT;
|
|
tempi->ic_opcode=IC_IMM;
|
|
}
|
|
break;
|
|
case IC_IMM:
|
|
tempi->ic_flags&=~ICF_R_TO_INT;
|
|
if (tempi->ic_flags&ICF_R_TO_F64) {
|
|
tempi->ic_data(F64)=ToF64(tempi->ic_data);
|
|
tempi->ic_flags&=~ICF_R_TO_F64;
|
|
tempi->ic_opcode=IC_F64;
|
|
}
|
|
break;
|
|
case IC_STR_CONST:
|
|
case IC_FS:
|
|
case IC_GS:
|
|
case IC_MOV_FS:
|
|
case IC_MOV_GS:
|
|
case IC_RIP:
|
|
case IC_PUSH_CMP:
|
|
break;
|
|
case IC_RBP:
|
|
tempi->ic_opcode=IC_REG;
|
|
tempi->p1.reg=CREG_RBP;
|
|
break;
|
|
case IC_REG:
|
|
case IC_COM:
|
|
case IC_NATIVE_TYPECAST:
|
|
case IC_NOT:
|
|
case IC_UNARY_MINUS:
|
|
break;
|
|
case IC_DEREF:
|
|
tempi->p1.ptype=tempi->r.type&IT_MASK;
|
|
if (tempi1->ic_opcode==IC_LEA) {
|
|
tempi->ic_flags|=tempi1->ic_flags;
|
|
tempi1->ic_opcode=IC_NOP;
|
|
tempi->p1.reg=tempi1->p1.reg;
|
|
tempi->p1.disp=tempi1->p1.disp;
|
|
tempi->p1.type=TY_DISP+tempi->r.type&IT_MASK;
|
|
tempi->p1.ptype=tempi->r.ptype;
|
|
tempi->ic_opcode=IC_MOV;
|
|
if (tempi->p1.reg==CREG_RBP)
|
|
for (i=0;i<member_cnt;i++)
|
|
if (mv[i].offset==tempi->p1.disp) {
|
|
mv[i].lea_balance--;
|
|
mv[i].score+=1+tempi->ic_indent_level;
|
|
break;
|
|
}
|
|
} else if (tempil1->ic_opcode==IC_ADD_CONST) {
|
|
if (tempil2->ic_opcode==IC_REG) {
|
|
tempi->ic_flags|=tempil2->ic_flags|tempil1->ic_flags;
|
|
tempil2->ic_opcode=IC_NOP;
|
|
tempil1->ic_opcode=IC_NOP;
|
|
tempi->p1.reg=tempil2->p1.reg;
|
|
tempi->p1.disp=tempi->ic_data;
|
|
tempi->p1.type=TY_DISP+tempi->r.type&IT_MASK;
|
|
tempi->p1.ptype=tempi->r.ptype;
|
|
tempi->ic_opcode=IC_MOV;
|
|
}
|
|
}
|
|
break;
|
|
case IC__PP:
|
|
case IC__MM:
|
|
case IC_PP_:
|
|
case IC_MM_:
|
|
tempi->r.ptype=CmpPType(tempi->t.p1c);
|
|
case IC_DEREF_PP:
|
|
case IC_DEREF_MM:
|
|
if (tempi1->ic_opcode==IC_LEA &&
|
|
tempi1->p1.type&TY_MASK==TY_DISP &&
|
|
tempi1->p1.reg==CREG_RBP)
|
|
for (i=0;i<member_cnt;i++)
|
|
if (mv[i].offset==tempi1->p1.disp) {
|
|
mv[i].lea_balance--;
|
|
mv[i].score+=1+tempi->ic_indent_level;
|
|
break;
|
|
}
|
|
tempi->p1.ptype=tempi->r.type&IT_MASK;
|
|
break;
|
|
case IC_POWER:
|
|
case IC_SHL:
|
|
case IC_SHR:
|
|
case IC_MOD:
|
|
case IC_AND:
|
|
case IC_OR:
|
|
case IC_XOR:
|
|
break;
|
|
|
|
case IC_MUL:
|
|
case IC_DIV:
|
|
if (tempc->sub_type==IT_F64) {
|
|
CmpF2PushPop(tempi,tempi1,tempi2);
|
|
break;
|
|
}
|
|
break;
|
|
case IC_ADD:
|
|
if (tempc->sub_type==IT_F64) {
|
|
CmpF2PushPop(tempi,tempi1,tempi2);
|
|
break;
|
|
}
|
|
if (OptFixupBinaryOp2(&tempi1,&tempi2)) {
|
|
tempi->ic_flags|=tempi1->ic_flags;
|
|
tempi1->ic_opcode=IC_NOP;
|
|
if (tempi->t.p1t!=tempi2)
|
|
tempi->t.p1c=tempi->t.p2c;
|
|
tempi->ic_data=tempi1->ic_data;
|
|
tempi->ic_opcode=IC_ADD_CONST;
|
|
tempi->p1.ptype=tempi->r.type&IT_MASK;
|
|
tempi->p2.type=TY_NULL;
|
|
if (tempil2->ic_opcode==IC_REG &&
|
|
tempil2->p1.reg==CREG_RBP) {
|
|
tempi->ic_flags|=tempil2->ic_flags;
|
|
tempil2->ic_opcode=IC_NOP;
|
|
tempi->ic_opcode=IC_LEA;
|
|
tempi->p1.reg=CREG_RBP;
|
|
tempi->p1.type=TY_DISP+tempi->p1.type&IT_MASK;
|
|
tempi->p1.disp=tempi->ic_data;
|
|
for (i=0;i<member_cnt;i++)
|
|
if (mv[i].offset==tempi->ic_data) {
|
|
mv[i].lea_balance++;
|
|
mv[i].score+=1+tempi->ic_indent_level;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
case IC_SUB:
|
|
if (tempc->sub_type==IT_F64) {
|
|
CmpF2PushPop(tempi,tempi1,tempi2);
|
|
break;
|
|
}
|
|
if (tempi2->ic_opcode==IC_IMM) {
|
|
tempi->ic_flags|=tempi2->ic_flags;
|
|
tempi2->ic_opcode=IC_NOP;
|
|
tempi->ic_data=tempi2->ic_data;
|
|
tempi->ic_opcode=IC_SUB_CONST;
|
|
tempi->p2.type=TY_NULL;
|
|
}
|
|
break;
|
|
case IC_LESS:
|
|
case IC_GREATER:
|
|
case IC_LESS_EQUAL:
|
|
case IC_GREATER_EQUAL:
|
|
if (tempi->ic_flags&ICF_USE_F64)
|
|
CmpF2PushPop(tempi,tempi1,tempi2);
|
|
break;
|
|
case IC_EQUAL_EQUAL:
|
|
case IC_NOT_EQUAL:
|
|
case IC_AND_AND:
|
|
case IC_OR_OR:
|
|
case IC_XOR_XOR:
|
|
case IC_COLON:
|
|
break;
|
|
|
|
case IC_MUL_EQUAL:
|
|
case IC_DIV_EQUAL:
|
|
case IC_ADD_EQUAL:
|
|
case IC_SUB_EQUAL:
|
|
if (tempc->sub_type==IT_F64)
|
|
CmpF1PushPop(tempi,tempi2);
|
|
case IC_ASSIGN_PP:
|
|
case IC_ASSIGN_MM:
|
|
case IC_ASSIGN:
|
|
case IC_SHL_EQUAL:
|
|
case IC_SHR_EQUAL:
|
|
case IC_MOD_EQUAL:
|
|
case IC_AND_EQUAL:
|
|
case IC_OR_EQUAL:
|
|
case IC_XOR_EQUAL:
|
|
if (tempi1->ic_opcode==IC_LEA &&
|
|
tempi1->p1.type&TY_MASK==TY_DISP &&
|
|
tempi1->p1.reg==CREG_RBP)
|
|
for (i=0;i<member_cnt;i++)
|
|
if (mv[i].offset==tempi1->p1.disp) {
|
|
mv[i].lea_balance--;
|
|
mv[i].score+=1+tempi->ic_indent_level;
|
|
break;
|
|
}
|
|
tempi->p1.ptype=tempi->r.type&IT_MASK;
|
|
tempi->r.ptype=CmpPType(tempi->t.p1c);
|
|
break;
|
|
case IC_RETURN_VAL:
|
|
case IC_RETURN_VAL2:
|
|
if (tempc) {
|
|
if (tempc->sub_type==IT_F64 && tempil1->ic_class->sub_type!=IT_F64)
|
|
tempil1->ic_flags|=ICF_R_TO_F64;
|
|
else if (tempc->sub_type!=IT_F64 && tempil1->ic_class->sub_type==IT_F64)
|
|
tempil1->ic_flags|=ICF_R_TO_INT;
|
|
}
|
|
break;
|
|
case IC_SQR:
|
|
case IC_ABS:
|
|
case IC_SQRT:
|
|
case IC_SIN:
|
|
case IC_COS:
|
|
case IC_TAN:
|
|
case IC_ATAN:
|
|
if (tempc->sub_type==IT_F64)
|
|
CmpF1PushPop(tempi,tempi1);
|
|
break;
|
|
case IC_SHL_CONST:
|
|
case IC_SHR_CONST:
|
|
case IC_ENTER:
|
|
case IC_ADD_RSP:
|
|
case IC_ADD_RSP1:
|
|
case IC_CALL:
|
|
case IC_CALL_INDIRECT:
|
|
case IC_CALL_INDIRECT2:
|
|
case IC_CALL_EXTERN:
|
|
case IC_CALL_IMPORT:
|
|
case IC_CLI:
|
|
case IC_STI:
|
|
case IC_HLT:
|
|
case IC_PUSHFD:
|
|
case IC_POPFD:
|
|
case IC_PUSH:
|
|
case IC_POP:
|
|
case IC_CLD:
|
|
case IC_STD:
|
|
case IC_INVLPG:
|
|
case IC_CLFLUSH:
|
|
case IC_PAUSE:
|
|
case IC_GET_FLAGS:
|
|
case IC_RDTSC:
|
|
case IC_HPET:
|
|
case IC_SET_FLAGS:
|
|
case IC_GET_BASE_PTR:
|
|
case IC_SET_BASE_PTR:
|
|
case IC_GET_STK_PTR:
|
|
case IC_GET_RAX:
|
|
case IC_SET_STK_PTR:
|
|
case IC_SET_RAX:
|
|
case IC_ABS_ADDR:
|
|
case IC_HEAP_GLBL:
|
|
case IC_ADDR_IMPORT:
|
|
case IC_TYPE:
|
|
case IC_BT:
|
|
case IC_BTS:
|
|
case IC_BTR:
|
|
case IC_BTC:
|
|
case IC_BEQU:
|
|
case IC_LBTS:
|
|
case IC_LBTR:
|
|
case IC_LBTC:
|
|
case IC_LBEQU:
|
|
case IC_BSF:
|
|
case IC_BSR:
|
|
case IC_PREEMPT:
|
|
case IC_SIGN_I64:
|
|
case IC_TOUPPER:
|
|
case IC_TO_I64:
|
|
case IC_TO_F64:
|
|
case IC_TO_BOOL:
|
|
case IC_ABS_I64:
|
|
case IC_LIMIT_I64:
|
|
case IC_LIMIT_U64:
|
|
case IC_MIN_I64:
|
|
case IC_MAX_I64:
|
|
case IC_MIN_U64:
|
|
case IC_MAX_U64:
|
|
case IC_MOD_U64:
|
|
case IC_SQR_I64:
|
|
case IC_SQR_U64:
|
|
case IC_SWAP_U8:
|
|
case IC_SWAP_U16:
|
|
case IC_SWAP_U32:
|
|
case IC_SWAP_U64:
|
|
case IC_QUE_INIT:
|
|
case IC_QUE_INS:
|
|
case IC_QUE_INS_REV:
|
|
case IC_QUE_REM:
|
|
case IC_MEMCPY:
|
|
case IC_MEMSET:
|
|
case IC_MEMSET_U16:
|
|
case IC_MEMSET_U32:
|
|
case IC_MEMSET_U64:
|
|
case IC_INU32:
|
|
case IC_INU16:
|
|
case IC_INU8:
|
|
case IC_STRLEN:
|
|
case IC_OUTU32:
|
|
case IC_OUTU16:
|
|
case IC_OUTU8:
|
|
case IC_ASM:
|
|
break;
|
|
case IC_NOBOUND_SWITCH:
|
|
case IC_SWITCH:
|
|
lb=tempi->ic_data;
|
|
lb=lb->dft;
|
|
while (lb->fwd)
|
|
lb=lb->fwd;
|
|
lb->flags|=CBMF_USED;
|
|
break;
|
|
case IC_BR_ZERO:
|
|
case IC_BR_NOT_ZERO:
|
|
if (tempi1->ic_opcode==IC_IMM ||
|
|
tempi1->ic_opcode==IC_F64) {
|
|
tempi1->ic_opcode=IC_NOP;
|
|
tempi->p1.type=TY_NULL;
|
|
tempi1->r.type=TY_NULL;
|
|
if (code==IC_BR_ZERO ^^ tempi1->ic_data)
|
|
tempi->ic_opcode=IC_JMP;
|
|
else {
|
|
tempi->ic_opcode=IC_NOP;
|
|
tempi->ic_class=NULL;
|
|
break;
|
|
}
|
|
}
|
|
goto here1;
|
|
case IC_BR_AND_ZERO:
|
|
if (tempi1->ic_opcode==IC_IMM) {
|
|
i=Bsr(tempi1->ic_data);
|
|
if (0<=i==Bsf(tempi1->ic_data)) {
|
|
tempi1->ic_data=i;
|
|
tempi->ic_flags|=ICF_NOT_ADDR;
|
|
tempi->ic_opcode=IC_BR_NOT_BT;
|
|
goto here1;
|
|
}
|
|
}
|
|
if (tempi2->ic_opcode==IC_IMM) {
|
|
i=Bsr(tempi2->ic_data);
|
|
if (0<=i==Bsf(tempi2->ic_data)) {
|
|
tempi2->ic_data=i;
|
|
tempi->ic_flags|=ICF_SWAP|ICF_NOT_ADDR;
|
|
tempi->ic_opcode=IC_BR_NOT_BT;
|
|
}
|
|
}
|
|
goto here1;
|
|
case IC_BR_AND_NOT_ZERO:
|
|
if (tempi1->ic_opcode==IC_IMM) {
|
|
i=Bsr(tempi1->ic_data);
|
|
if (0<=i==Bsf(tempi1->ic_data)) {
|
|
tempi1->ic_data=i;
|
|
tempi->ic_flags|=ICF_NOT_ADDR;
|
|
tempi->ic_opcode=IC_BR_BT;
|
|
goto here1;
|
|
}
|
|
}
|
|
if (tempi2->ic_opcode==IC_IMM) {
|
|
i=Bsr(tempi2->ic_data);
|
|
if (0<=i==Bsf(tempi2->ic_data)) {
|
|
tempi2->ic_data=i;
|
|
tempi->ic_flags|=ICF_SWAP|ICF_NOT_ADDR;
|
|
tempi->ic_opcode=IC_BR_BT;
|
|
}
|
|
}
|
|
goto here1;
|
|
case IC_BR_MM_ZERO:
|
|
case IC_BR_MM_NOT_ZERO:
|
|
if (tempi1->ic_opcode==IC_LEA &&
|
|
tempi1->p1.type&TY_MASK==TY_DISP &&
|
|
tempi1->p1.reg==CREG_RBP)
|
|
for (i=0;i<member_cnt;i++)
|
|
if (mv[i].offset==tempi1->p1.disp) {
|
|
mv[i].lea_balance--;
|
|
mv[i].score+=1+tempi->ic_indent_level;
|
|
break;
|
|
}
|
|
tempi->p1.ptype=CmpType(tempc);
|
|
goto here1;
|
|
case IC_BR_GREATER_EQUAL:
|
|
case IC_BR_LESS_EQUAL:
|
|
case IC_BR_GREATER:
|
|
case IC_BR_LESS:
|
|
if (tempi->ic_flags&ICF_USE_F64)
|
|
CmpF2PushPop(tempi,tempi1,tempi2);
|
|
case IC_BR_GREATER_EQUAL2:
|
|
case IC_BR_LESS_EQUAL2:
|
|
case IC_BR_GREATER2:
|
|
case IC_BR_LESS2:
|
|
case IC_BR_NOT_EQUAL2:
|
|
case IC_BR_EQUAL_EQUAL2:
|
|
case IC_BR_NOT_EQUAL:
|
|
case IC_BR_EQUAL_EQUAL:
|
|
case IC_GET_LABEL:
|
|
case IC_BR_BT:
|
|
case IC_BR_BTS:
|
|
case IC_BR_BTR:
|
|
case IC_BR_BTC:
|
|
case IC_BR_NOT_BT:
|
|
case IC_BR_NOT_BTS:
|
|
case IC_BR_NOT_BTR:
|
|
case IC_BR_NOT_BTC:
|
|
case IC_BR_LBTS:
|
|
case IC_BR_LBTR:
|
|
case IC_BR_LBTC:
|
|
case IC_BR_NOT_LBTS:
|
|
case IC_BR_NOT_LBTR:
|
|
case IC_BR_NOT_LBTC:
|
|
case IC_JMP:
|
|
here1:
|
|
lb=tempi->ic_data;
|
|
if (!(tempi->ic_flags&ICF_PUSH_CMP))
|
|
while (lb->fwd)
|
|
lb=lb->fwd;
|
|
lb->flags|=CBMF_USED;
|
|
break;
|
|
case IC_LEAVE:
|
|
case IC_RET:
|
|
break;
|
|
case IC_ADDR:
|
|
case IC_NOP:
|
|
case IC_END:
|
|
case IC_QUESTION:
|
|
case IC_IRQ:
|
|
case IC_END_EXP:
|
|
case IC_CALL_END:
|
|
case IC_CALL_END2:
|
|
case IC_CALL_START:
|
|
case IC_PUSH_REGS:
|
|
case IC_POP_REGS:
|
|
case IC_LABEL:
|
|
break;
|
|
case IC_NOP1:
|
|
ps->ptr+=tempi->ic_data;
|
|
break;
|
|
|
|
default:
|
|
OptMissing(lx,tempi);
|
|
}
|
|
}
|
|
tempi++;
|
|
}
|
|
if (fun_class) {
|
|
fun_class->used_reg_mask=fun_class->used_reg_mask&~(CREG_VARS_MASK|CREG_NON_PTR_MASK)|used_reg_mask;
|
|
if (!Bt(&lx->opts,OPTf_NO_REG_VAR) &&
|
|
!(lx->flags & LF_NO_REG_OPT)) {
|
|
QSort(mv,member_cnt,sizeof(OptMemberVar),&OptMVCompare);
|
|
while (member_cnt && !mv[member_cnt-1].score)
|
|
member_cnt--;
|
|
j=0;
|
|
for (i=0;i<member_cnt;i++) {
|
|
if (!mv[i].lea_balance && mv[i].offset) {//addr operator cancels
|
|
mv[j].m=mv[i].m;
|
|
mv[j++].offset=mv[i].offset;
|
|
} else {
|
|
if (mv[i].m->register==CREG_ALLOC)
|
|
PrintFWarn("%S\n $$LK-A,\"FL:%s,%d\"$$ '%s' in '%s'\n","ST_CANT_REG_VAR",
|
|
lx->cur_lfn->name,lx->cur_lfn->line_num,mv[i].m->str,fun_class->str);
|
|
}
|
|
}
|
|
if (j>0) {
|
|
if (j>num_reg_vars) {
|
|
l=0;
|
|
for (i=0;i<j && l<num_non_ptr_vars;i++) {
|
|
tempm=mv[i].m;
|
|
tempc=tempm->member_class;
|
|
while (tempc->fwd_class)
|
|
tempc=tempc->fwd_class;
|
|
if (!tempc->ptr_cnt && !tempm->dim.next) {
|
|
while (l<num_non_ptr_vars &&
|
|
Bts(&fun_class->used_reg_mask,to_non_ptr_vars_map[l]))
|
|
l++;
|
|
if (l<num_non_ptr_vars) {
|
|
tempm->register=to_non_ptr_vars_map[l++];
|
|
register_offsets[tempm->register].offset=mv[i].offset;
|
|
register_offsets[tempm->register].m=tempm;
|
|
if (Bt(&lx->flags,Lf_OPT_TRACE_PRESENT))
|
|
"Fun:%s\nReg %Z Var \"%s\" %08X[RBP]\n",
|
|
fun_class->str,tempm->register,"ST_U64_REGS",
|
|
tempm->str,register_offsets[tempm->register].offset;
|
|
mv[i].offset=0; //flag as reg var
|
|
}
|
|
}
|
|
}
|
|
}
|
|
l=0;
|
|
for (i=0;i<j && l<num_reg_vars;i++) {
|
|
tempm=mv[i].m;
|
|
//if not just flagged as reg var
|
|
if (mv[i].offset && (!mv[i].m->dim.next||
|
|
tempm->offset>0 && StrCmp(tempm->str,"argv"))) {
|
|
while (l<num_reg_vars &&
|
|
Bts(&fun_class->used_reg_mask,to_reg_vars_map[l]))
|
|
l++;
|
|
if (l<num_reg_vars) {
|
|
tempm->register=to_reg_vars_map[l++];
|
|
register_offsets[tempm->register].offset=mv[i].offset;
|
|
register_offsets[tempm->register].m=tempm;
|
|
if (Bt(&lx->flags,Lf_OPT_TRACE_PRESENT))
|
|
"Reg %Z Var \"%s\" %08X[RBP]\n",tempm->register,"ST_U64_REGS",
|
|
tempm->str,register_offsets[tempm->register].offset;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
Free(mv);
|
|
}
|
|
OptEnd(lx,ps);
|
|
}
|
|
|