tristan/ZealOS
1
0
Fork 0
mirror of https://github.com/Zeal-Operating-System/ZealOS.git synced 2024-12-28 08:16:31 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Reformat OptPass3.CC

Browse source
This commit is contained in:
TomAwezome 2020-07-25 19:00:42 -05:00 committed by VoidNV
parent 780974b6e1
commit 7f6c288b3f
3 changed files with 336 additions and 288 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

BIN
Zenith-latest-2020-07-25-13_30_14.iso → Zenith-latest-2020-07-25-19_00_26.iso
View file

Binary file not shown.

223
src/Compiler/OptPass3.CC
View file

@ -2,8 +2,7 @@ U0 OptPass3(CCompCtrl *cc,COptReg *reg_offsets)
{ {
CHashClass *tmpc, *tmpc1, *tmpc2; CHashClass *tmpc, *tmpc1, *tmpc2;
CCodeMisc *lb; CCodeMisc *lb;
CIntermediateCode *tmpi,*tmpi1,*tmpi2,*tmpi_next, CIntermediateCode *tmpi,*tmpi1, *tmpi2, *tmpi_next, *tmpil1, *tmpil2;
*tmpil1,*tmpil2;
I64 code, i, j, l, member_count, used_reg_mask = 0; I64 code, i, j, l, member_count, used_reg_mask = 0;
CMemberList *tmpm; CMemberList *tmpm;
COptMemberVar *mv = NULL; COptMemberVar *mv = NULL;
@ -13,55 +12,67 @@ U0 OptPass3(CCompCtrl *cc,COptReg *reg_offsets)
ps->ptr = 0; ps->ptr = 0;
ps->ptr2 = 0; ps->ptr2 = 0;
for (i=0;i<REG_REGS_NUM;i++) { for (i = 0; i < REG_REGS_NUM; i++)
{
reg_offsets[i].offset = I64_MAX; reg_offsets[i].offset = I64_MAX;
reg_offsets[i].m = NULL; reg_offsets[i].m = NULL;
} }
if (cc->htc.fun) { if (cc->htc.fun)
{
member_count = cc->htc.fun->member_count; member_count = cc->htc.fun->member_count;
if (Bt(&cc->htc.fun->flags, Ff_DOT_DOT_DOT)) if (Bt(&cc->htc.fun->flags, Ff_DOT_DOT_DOT))
member_count += 2; member_count += 2;
mv = CAlloc(member_count * sizeof(COptMemberVar)); mv = CAlloc(member_count * sizeof(COptMemberVar));
member_count = 0; member_count = 0;
tmpm = cc->htc.fun->member_list_and_root; tmpm = cc->htc.fun->member_list_and_root;
while (tmpm) { while (tmpm)
{
tmpc = OptClassFwd(tmpm->member_class); tmpc = OptClassFwd(tmpm->member_class);
if (0<=tmpm->reg<REG_REGS_NUM) { if (0 <= tmpm->reg<REG_REGS_NUM)
{
if (Bts(&used_reg_mask, tmpm->reg)) if (Bts(&used_reg_mask, tmpm->reg))
PrintWarn("Reg in use\n $$LK,\"FL:%s,%d\"$$ '%s' in '%s'\n", PrintWarn("Reg in use\n $$LK,\"FL:%s,%d\"$$ '%s' in '%s'\n",
cc->lex_include_stack->full_name, cc->lex_include_stack->full_name,
cc->lex_include_stack->line_num, tmpm->str, cc->htc.fun->str); cc->lex_include_stack->line_num, tmpm->str, cc->htc.fun->str);
reg_offsets[tmpm->reg].offset = tmpm->offset; reg_offsets[tmpm->reg].offset = tmpm->offset;
reg_offsets[tmpm->reg].m = tmpm; reg_offsets[tmpm->reg].m = tmpm;
} else if (tmpc->raw_type!=RT_F64 && tmpm->reg!=REG_NONE || }
tmpm->reg==REG_ALLOC) { else if (tmpc->raw_type != RT_F64 && tmpm->reg != REG_NONE || tmpm->reg == REG_ALLOC)
{
if (tmpm->reg == REG_ALLOC) if (tmpm->reg == REG_ALLOC)
mv[member_count].score = I64_MAX / 2; //big but not too big mv[member_count].score = I64_MAX / 2; //big but not too big
mv[member_count].offset_start = tmpm->offset; mv[member_count].offset_start = tmpm->offset;
mv[member_count].offset_end = tmpm->offset + MaxI64(1, tmpm->size); mv[member_count].offset_end = tmpm->offset + MaxI64(1, tmpm->size);
mv[member_count++].m = tmpm; mv[member_count++].m = tmpm;
} else if (tmpm->reg==REG_ALLOC) }
else if (tmpm->reg == REG_ALLOC)
PrintWarn("Can't reg var\n $$LK,\"FL:%s,%d\"$$ '%s' in '%s'\n", PrintWarn("Can't reg var\n $$LK,\"FL:%s,%d\"$$ '%s' in '%s'\n",
cc->lex_include_stack->full_name, cc->lex_include_stack->full_name,
cc->lex_include_stack->line_num, tmpm->str, cc->htc.fun->str); cc->lex_include_stack->line_num, tmpm->str, cc->htc.fun->str);
tmpm = tmpm->next; tmpm = tmpm->next;
} }
} else }
else
member_count = 0; member_count = 0;
tmpi = cc->coc.coc_head.next; tmpi = cc->coc.coc_head.next;
while (code=tmpi->ic_code) { while (code = tmpi->ic_code)
{
tmpi_next = tmpi->next; tmpi_next = tmpi->next;
if (code == IC_NOP1) if (code == IC_NOP1)
OptFree(tmpi); OptFree(tmpi);
else { else
if (tmpil1=OptLag(tmpi)) { {
if (tmpil1 = OptLag(tmpi))
{
if (!(tmpil2 = OptLag(tmpil1))) if (!(tmpil2 = OptLag(tmpil1)))
tmpil2 = &cmp.ic_nop; tmpil2 = &cmp.ic_nop;
} else }
else
tmpil1 = tmpil2 = &cmp.ic_nop; tmpil1 = tmpil2 = &cmp.ic_nop;
tmpc = tmpi->ic_class; tmpc = tmpi->ic_class;
switch [intermediate_code_table[code].arg_count] { switch [intermediate_code_table[code].arg_count]
{
case IS_V_ARG: case IS_V_ARG:
ps->ptr -= tmpi->ic_data >> 3; ps->ptr -= tmpi->ic_data >> 3;
break; break;
@ -90,15 +101,18 @@ U0 OptPass3(CCompCtrl *cc,COptReg *reg_offsets)
case IS_0_ARG: //nobound switch case IS_0_ARG: //nobound switch
break; break;
} }
if (intermediate_code_table[code].res_count) { if (intermediate_code_table[code].res_count)
{
tmpi->res.type = MDF_STACK + CompRawType(tmpc); tmpi->res.type = MDF_STACK + CompRawType(tmpc);
tmpi->ic_flags |= ICF_RES_WAS_STACK; tmpi->ic_flags |= ICF_RES_WAS_STACK;
ParsePush(ps, tmpi); ParsePush(ps, tmpi);
} }
switch [code] { switch [code]
{
case IC_IMM_F64: case IC_IMM_F64:
tmpi->ic_flags &= ~ICF_RES_TO_F64; tmpi->ic_flags &= ~ICF_RES_TO_F64;
if (tmpi->ic_flags&ICF_RES_TO_INT) { if (tmpi->ic_flags & ICF_RES_TO_INT)
{
tmpi->ic_data = ToI64(tmpi->ic_data(F64)); tmpi->ic_data = ToI64(tmpi->ic_data(F64));
tmpi->ic_flags &= ~ICF_RES_TO_INT; tmpi->ic_flags &= ~ICF_RES_TO_INT;
tmpi->ic_code = IC_IMM_I64; tmpi->ic_code = IC_IMM_I64;
@ -106,7 +120,8 @@ U0 OptPass3(CCompCtrl *cc,COptReg *reg_offsets)
break; break;
case IC_IMM_I64: case IC_IMM_I64:
tmpi->ic_flags &= ~ICF_RES_TO_INT; tmpi->ic_flags &= ~ICF_RES_TO_INT;
if (tmpi->ic_flags&ICF_RES_TO_F64) { if (tmpi->ic_flags & ICF_RES_TO_F64)
{
tmpi->ic_data(F64) = ToF64(tmpi->ic_data); tmpi->ic_data(F64) = ToF64(tmpi->ic_data);
tmpi->ic_flags &= ~ICF_RES_TO_F64; tmpi->ic_flags &= ~ICF_RES_TO_F64;
tmpi->ic_code = IC_IMM_F64; tmpi->ic_code = IC_IMM_F64;
@ -118,7 +133,8 @@ U0 OptPass3(CCompCtrl *cc,COptReg *reg_offsets)
break; break;
case IC_DEREF: case IC_DEREF:
tmpi->arg1_type_pointed_to = tmpi->res.type.raw_type; tmpi->arg1_type_pointed_to = tmpi->res.type.raw_type;
if (tmpi1->ic_code==IC_LEA) { if (tmpi1->ic_code == IC_LEA)
{
tmpi->ic_flags |= tmpi1->ic_flags; tmpi->ic_flags |= tmpi1->ic_flags;
tmpi->arg1.reg = tmpi1->arg1.reg; tmpi->arg1.reg = tmpi1->arg1.reg;
tmpi->arg1.disp = tmpi1->arg1.disp; tmpi->arg1.disp = tmpi1->arg1.disp;
@ -128,12 +144,15 @@ U0 OptPass3(CCompCtrl *cc,COptReg *reg_offsets)
OptFree(tmpi1); OptFree(tmpi1);
if (tmpi->arg1.reg == REG_RBP) if (tmpi->arg1.reg == REG_RBP)
for (i = 0; i < member_count; i++) for (i = 0; i < member_count; i++)
if (mv[i].offset_start==tmpi->arg1.disp) { if (mv[i].offset_start == tmpi->arg1.disp)
{
mv[i].lea_balance--; mv[i].lea_balance--;
mv[i].score++; mv[i].score++;
break; break;
} }
} else if (tmpil1->ic_code==IC_ADD_CONST) { }
else if (tmpil1->ic_code == IC_ADD_CONST)
{
if (tmpil2->ic_code == IC_REG) { if (tmpil2->ic_code == IC_REG) {
tmpi->ic_flags |= tmpil2->ic_flags | tmpil1->ic_flags; tmpi->ic_flags |= tmpil2->ic_flags | tmpil1->ic_flags;
tmpi->arg1.reg = tmpil2->arg1.reg; tmpi->arg1.reg = tmpil2->arg1.reg;
@ -153,10 +172,10 @@ U0 OptPass3(CCompCtrl *cc,COptReg *reg_offsets)
CompMinTypePointed(tmpi, CompRawTypePointed(tmpi->t.arg1_class)); CompMinTypePointed(tmpi, CompRawTypePointed(tmpi->t.arg1_class));
case IC_DEREF_PP: case IC_DEREF_PP:
case IC_DEREF_MM: case IC_DEREF_MM:
if (tmpi1->ic_code==IC_LEA && tmpi1->arg1.type&MDF_DISP && if (tmpi1->ic_code == IC_LEA && tmpi1->arg1.type & MDF_DISP && tmpi1->arg1.reg == REG_RBP)
tmpi1->arg1.reg==REG_RBP)
for (i = 0; i < member_count; i++) for (i = 0; i < member_count; i++)
if (mv[i].offset_start==tmpi1->arg1.disp) { if (mv[i].offset_start == tmpi1->arg1.disp)
{
mv[i].lea_balance--; mv[i].lea_balance--;
mv[i].score++; mv[i].score++;
break; break;
@ -165,17 +184,20 @@ U0 OptPass3(CCompCtrl *cc,COptReg *reg_offsets)
break; break;
case IC_MUL: case IC_MUL:
case IC_DIV: case IC_DIV:
if (tmpc->raw_type==RT_F64) { if (tmpc->raw_type == RT_F64)
{
CompF2PushPop(tmpi, tmpi1, tmpi2); CompF2PushPop(tmpi, tmpi1, tmpi2);
break; break;
} }
break; break;
case IC_ADD: case IC_ADD:
if (tmpc->raw_type==RT_F64) { if (tmpc->raw_type == RT_F64)
{
CompF2PushPop(tmpi, tmpi1, tmpi2); CompF2PushPop(tmpi, tmpi1, tmpi2);
break; break;
} }
if (OptFixupBinaryOp2(&tmpi1,&tmpi2)) { if (OptFixupBinaryOp2(&tmpi1, &tmpi2))
{
tmpi->ic_flags |= tmpi1->ic_flags; tmpi->ic_flags |= tmpi1->ic_flags;
if (tmpi->t.arg1_tree != tmpi2) if (tmpi->t.arg1_tree != tmpi2)
tmpi->t.arg1_class = tmpi->t.arg2_class; tmpi->t.arg1_class = tmpi->t.arg2_class;
@ -184,14 +206,16 @@ U0 OptPass3(CCompCtrl *cc,COptReg *reg_offsets)
tmpi->arg1_type_pointed_to = tmpi->res.type.raw_type; tmpi->arg1_type_pointed_to = tmpi->res.type.raw_type;
tmpi->arg2.type = MDF_NULL; tmpi->arg2.type = MDF_NULL;
OptFree(tmpi1); OptFree(tmpi1);
if (tmpil2->ic_code==IC_REG && tmpil2->arg1.reg==REG_RBP) { if (tmpil2->ic_code == IC_REG && tmpil2->arg1.reg == REG_RBP)
{
tmpi->ic_flags |= tmpil2->ic_flags; tmpi->ic_flags |= tmpil2->ic_flags;
tmpi->ic_code = IC_LEA; tmpi->ic_code = IC_LEA;
tmpi->arg1.reg = REG_RBP; tmpi->arg1.reg = REG_RBP;
tmpi->arg1.type = MDF_DISP + tmpi->arg1.type.raw_type; tmpi->arg1.type = MDF_DISP + tmpi->arg1.type.raw_type;
tmpi->arg1.disp = tmpi->ic_data; tmpi->arg1.disp = tmpi->ic_data;
for (i = 0; i < member_count; i++) for (i = 0; i < member_count; i++)
if (mv[i].offset_start<=tmpi->ic_data<mv[i].offset_end) { if (mv[i].offset_start <= tmpi->ic_data < mv[i].offset_end)
{
mv[i].lea_balance++; mv[i].lea_balance++;
mv[i].score++; mv[i].score++;
break; break;
@ -201,11 +225,13 @@ U0 OptPass3(CCompCtrl *cc,COptReg *reg_offsets)
} }
break; break;
case IC_SUB: case IC_SUB:
if (tmpc->raw_type==RT_F64) { if (tmpc->raw_type == RT_F64)
{
CompF2PushPop(tmpi, tmpi1, tmpi2); CompF2PushPop(tmpi, tmpi1, tmpi2);
break; break;
} }
if (tmpi2->ic_code==IC_IMM_I64) { if (tmpi2->ic_code == IC_IMM_I64)
{
tmpi->ic_flags |= tmpi2->ic_flags; tmpi->ic_flags |= tmpi2->ic_flags;
tmpi->ic_data = tmpi2->ic_data; tmpi->ic_data = tmpi2->ic_data;
tmpi->ic_code = IC_SUB_CONST; tmpi->ic_code = IC_SUB_CONST;
@ -235,10 +261,10 @@ U0 OptPass3(CCompCtrl *cc,COptReg *reg_offsets)
case IC_AND_EQU: case IC_AND_EQU:
case IC_OR_EQU: case IC_OR_EQU:
case IC_XOR_EQU: case IC_XOR_EQU:
if (tmpi1->ic_code==IC_LEA && tmpi1->arg1.type&MDF_DISP && if (tmpi1->ic_code == IC_LEA && tmpi1->arg1.type & MDF_DISP && tmpi1->arg1.reg == REG_RBP)
tmpi1->arg1.reg==REG_RBP)
for (i = 0; i < member_count; i++) for (i = 0; i < member_count; i++)
if (mv[i].offset_start==tmpi1->arg1.disp) { if (mv[i].offset_start == tmpi1->arg1.disp)
{
mv[i].lea_balance--; mv[i].lea_balance--;
mv[i].score++; mv[i].score++;
break; break;
@ -248,11 +274,11 @@ U0 OptPass3(CCompCtrl *cc,COptReg *reg_offsets)
break; break;
case IC_RETURN_VAL: case IC_RETURN_VAL:
case IC_RETURN_VAL2: case IC_RETURN_VAL2:
if (tmpc) { if (tmpc)
{
if (tmpc->raw_type == RT_F64 && tmpil1->ic_class->raw_type != RT_F64) if (tmpc->raw_type == RT_F64 && tmpil1->ic_class->raw_type != RT_F64)
tmpil1->ic_flags |= ICF_RES_TO_F64; tmpil1->ic_flags |= ICF_RES_TO_F64;
else if (tmpc->raw_type!=RT_F64 && else if (tmpc->raw_type != RT_F64 && tmpil1->ic_class->raw_type == RT_F64)
tmpil1->ic_class->raw_type==RT_F64)
tmpil1->ic_flags |= ICF_RES_TO_INT; tmpil1->ic_flags |= ICF_RES_TO_INT;
} }
break; break;
@ -274,9 +300,9 @@ U0 OptPass3(CCompCtrl *cc,COptReg *reg_offsets)
case IC_ASM: case IC_ASM:
tmpaot = tmpi->ic_data; tmpaot = tmpi->ic_data;
tmpie = tmpaot->next_ie; tmpie = tmpaot->next_ie;
while (tmpie!=&tmpaot->next_ie) { while (tmpie != &tmpaot->next_ie)
if (IET_REL_I0<=tmpie->type<=IET_IMM_I64 && {
tmpie->str && tmpie->flags&IEF_GOTO_LABEL && if (IET_REL_I0 <= tmpie->type <= IET_IMM_I64 && tmpie->str && tmpie->flags & IEF_GOTO_LABEL &&
(lb = COCGoToLabelFind(cc, tmpie->str))) (lb = COCGoToLabelFind(cc, tmpie->str)))
lb->use_count++; //Prevent deadcode elimination. lb->use_count++; //Prevent deadcode elimination.
tmpie = tmpie->next; tmpie = tmpie->next;
@ -284,8 +310,8 @@ U0 OptPass3(CCompCtrl *cc,COptReg *reg_offsets)
break; break;
case IC_BR_NOT_EQU: case IC_BR_NOT_EQU:
case IC_BR_EQU_EQU: case IC_BR_EQU_EQU:
if ((tmpi1->ic_code==IC_IMM_I64 || if ((tmpi1->ic_code == IC_IMM_I64 || tmpi1->ic_code == IC_IMM_F64) && !tmpi1->ic_data)
tmpi1->ic_code==IC_IMM_F64) && !tmpi1->ic_data) { {
OptFree(tmpi1); OptFree(tmpi1);
MemCopy(&tmpi->arg1, &tmpi->arg2, sizeof(CICArg)); MemCopy(&tmpi->arg1, &tmpi->arg2, sizeof(CICArg));
tmpi->arg2.type = MDF_NULL; tmpi->arg2.type = MDF_NULL;
@ -295,24 +321,30 @@ U0 OptPass3(CCompCtrl *cc,COptReg *reg_offsets)
code = tmpi->ic_code = IC_BR_NOT_ZERO; code = tmpi->ic_code = IC_BR_NOT_ZERO;
tmpi1 = tmpi2; tmpi1 = tmpi2;
tmpc1 = tmpc2; tmpc1 = tmpc2;
} else if ((tmpi2->ic_code==IC_IMM_I64 || }
tmpi2->ic_code==IC_IMM_F64) && !tmpi2->ic_data) { else if ((tmpi2->ic_code == IC_IMM_I64 || tmpi2->ic_code == IC_IMM_F64) && !tmpi2->ic_data)
{
OptFree(tmpi2); OptFree(tmpi2);
tmpi->arg2.type = MDF_NULL; tmpi->arg2.type = MDF_NULL;
if (code == IC_BR_EQU_EQU) if (code == IC_BR_EQU_EQU)
code = tmpi->ic_code = IC_BR_ZERO; code = tmpi->ic_code = IC_BR_ZERO;
else else
code = tmpi->ic_code = IC_BR_NOT_ZERO; code = tmpi->ic_code = IC_BR_NOT_ZERO;
} else }
else
goto here1; goto here1;
case IC_BR_ZERO: case IC_BR_ZERO:
case IC_BR_NOT_ZERO: case IC_BR_NOT_ZERO:
if (tmpi1->ic_code==IC_IMM_I64 || tmpi1->ic_code==IC_IMM_F64) { if (tmpi1->ic_code == IC_IMM_I64 || tmpi1->ic_code == IC_IMM_F64)
if (code==IC_BR_ZERO ^^ tmpi1->ic_data) { {
if (code == IC_BR_ZERO ^^ tmpi1->ic_data)
{
OptFree(tmpi1); OptFree(tmpi1);
tmpi->arg1.type = MDF_NULL; tmpi->arg1.type = MDF_NULL;
tmpi->ic_code = IC_JMP; tmpi->ic_code = IC_JMP;
} else { }
else
{
OptFree(tmpi1); OptFree(tmpi1);
tmpi = OptFree(tmpi); tmpi = OptFree(tmpi);
break; break;
@ -320,18 +352,22 @@ U0 OptPass3(CCompCtrl *cc,COptReg *reg_offsets)
} }
goto here1; goto here1;
case IC_BR_AND_ZERO: case IC_BR_AND_ZERO:
if (tmpi1->ic_code==IC_IMM_I64) { if (tmpi1->ic_code == IC_IMM_I64)
{
i = Bsr(tmpi1->ic_data); i = Bsr(tmpi1->ic_data);
if (0<=i==Bsf(tmpi1->ic_data)) { if (0 <= i == Bsf(tmpi1->ic_data))
{
tmpi1->ic_data = i; tmpi1->ic_data = i;
tmpi->ic_flags |= ICF_BY_VAL; tmpi->ic_flags |= ICF_BY_VAL;
tmpi->ic_code = IC_BR_NOT_BT; tmpi->ic_code = IC_BR_NOT_BT;
goto here1; goto here1;
} }
} }
if (tmpi2->ic_code==IC_IMM_I64) { if (tmpi2->ic_code == IC_IMM_I64)
{
i = Bsr(tmpi2->ic_data); i = Bsr(tmpi2->ic_data);
if (0<=i==Bsf(tmpi2->ic_data)) { if (0 <= i == Bsf(tmpi2->ic_data))
{
tmpi2->ic_data = i; tmpi2->ic_data = i;
tmpi->ic_flags |= ICF_SWAP|ICF_BY_VAL; tmpi->ic_flags |= ICF_SWAP|ICF_BY_VAL;
tmpi->ic_code = IC_BR_NOT_BT; tmpi->ic_code = IC_BR_NOT_BT;
@ -339,18 +375,22 @@ U0 OptPass3(CCompCtrl *cc,COptReg *reg_offsets)
} }
goto here1; goto here1;
case IC_BR_AND_NOT_ZERO: case IC_BR_AND_NOT_ZERO:
if (tmpi1->ic_code==IC_IMM_I64) { if (tmpi1->ic_code == IC_IMM_I64)
{
i = Bsr(tmpi1->ic_data); i = Bsr(tmpi1->ic_data);
if (0<=i==Bsf(tmpi1->ic_data)) { if (0 <= i == Bsf(tmpi1->ic_data))
{
tmpi1->ic_data = i; tmpi1->ic_data = i;
tmpi->ic_flags |= ICF_BY_VAL; tmpi->ic_flags |= ICF_BY_VAL;
tmpi->ic_code = IC_BR_BT; tmpi->ic_code = IC_BR_BT;
goto here1; goto here1;
} }
} }
if (tmpi2->ic_code==IC_IMM_I64) { if (tmpi2->ic_code == IC_IMM_I64)
{
i = Bsr(tmpi2->ic_data); i = Bsr(tmpi2->ic_data);
if (0<=i==Bsf(tmpi2->ic_data)) { if (0 <= i == Bsf(tmpi2->ic_data))
{
tmpi2->ic_data = i; tmpi2->ic_data = i;
tmpi->ic_flags |= ICF_SWAP|ICF_BY_VAL; tmpi->ic_flags |= ICF_SWAP|ICF_BY_VAL;
tmpi->ic_code = IC_BR_BT; tmpi->ic_code = IC_BR_BT;
@ -359,10 +399,10 @@ U0 OptPass3(CCompCtrl *cc,COptReg *reg_offsets)
goto here1; goto here1;
case IC_BR_MM_ZERO: case IC_BR_MM_ZERO:
case IC_BR_MM_NOT_ZERO: case IC_BR_MM_NOT_ZERO:
if (tmpi1->ic_code==IC_LEA && tmpi1->arg1.type&MDF_DISP && if (tmpi1->ic_code == IC_LEA && tmpi1->arg1.type & MDF_DISP && tmpi1->arg1.reg == REG_RBP)
tmpi1->arg1.reg==REG_RBP)
for (i = 0; i < member_count; i++) for (i = 0; i < member_count; i++)
if (mv[i].offset_start==tmpi1->arg1.disp) { if (mv[i].offset_start == tmpi1->arg1.disp)
{
mv[i].lea_balance--; mv[i].lea_balance--;
mv[i].score++; mv[i].score++;
break; break;
@ -531,40 +571,49 @@ have a unusual ModR addressing mode in the x86_64 architecture, so I only use
R12 and R13 as non-pointer register variables, such as index variables i, j, k. R12 and R13 as non-pointer register variables, such as index variables i, j, k.
*/ */
if (cc->htc.fun) { if (cc->htc.fun)
{
cc->htc.fun->used_reg_mask = cc->htc.fun->used_reg_mask & cc->htc.fun->used_reg_mask = cc->htc.fun->used_reg_mask &
~(REGG_LOCAL_VARS | REGG_LOCAL_NON_PTR_VARS) | used_reg_mask; ~(REGG_LOCAL_VARS | REGG_LOCAL_NON_PTR_VARS) | used_reg_mask;
if (!Bt(&cc->opts,OPTf_NO_REG_VAR) && if (!Bt(&cc->opts, OPTf_NO_REG_VAR) && !(cc->flags & CCF_NO_REG_OPT))
!(cc->flags & CCF_NO_REG_OPT)) { {
QuickSort(mv, member_count, sizeof(COptMemberVar), &OptMVCompare); QuickSort(mv, member_count, sizeof(COptMemberVar), &OptMVCompare);
while (member_count && !mv[member_count - 1].score) while (member_count && !mv[member_count - 1].score)
member_count--; member_count--;
j = 0; j = 0;
for (i=0;i<member_count;i++) { for (i = 0; i < member_count; i++)
if (!mv[i].lea_balance && mv[i].offset_start) {//addr operator cancels {
if (!mv[i].lea_balance && mv[i].offset_start)
{//addr operator cancels
mv[j].m = mv[i].m; mv[j].m = mv[i].m;
mv[j].offset_start = mv[i].offset_start; mv[j].offset_start = mv[i].offset_start;
mv[j++].offset_end = mv[i].offset_end; mv[j++].offset_end = mv[i].offset_end;
} else { }
else
{
if (mv[i].m->reg == REG_ALLOC) if (mv[i].m->reg == REG_ALLOC)
PrintWarn("Can't reg var\n $$LK,\"FL:%s,%d\"$$ '%s' in '%s'\n", PrintWarn("Can't reg var\n $$LK,\"FL:%s,%d\"$$ '%s' in '%s'\n",
cc->lex_include_stack->full_name, cc->lex_include_stack->full_name,
cc->lex_include_stack->line_num, mv[i].m->str, cc->htc.fun->str); cc->lex_include_stack->line_num, mv[i].m->str, cc->htc.fun->str);
} }
} }
if (j>0) { if (j > 0)
{
if (Bt(&cc->flags, CCf_PASS_TRACE_PRESENT)) if (Bt(&cc->flags, CCf_PASS_TRACE_PRESENT))
"Fun:%s\n", cc->htc.fun->str; "Fun:%s\n", cc->htc.fun->str;
if (j>cmp.num_reg_vars) { if (j > cmp.num_reg_vars)
{
l = 0; l = 0;
for (i=0;i<j && l<cmp.num_non_ptr_vars;i++) { for (i = 0; i < j && l < cmp.num_non_ptr_vars; i++)
{
tmpm = mv[i].m; tmpm = mv[i].m;
tmpc = OptClassFwd(tmpm->member_class); tmpc = OptClassFwd(tmpm->member_class);
if (!tmpc->ptr_stars_count && !tmpm->dim.next) { if (!tmpc->ptr_stars_count && !tmpm->dim.next)
while (l<cmp.num_non_ptr_vars && {
Bts(&cc->htc.fun->used_reg_mask,cmp.non_ptr_vars_map[l])) while (l < cmp.num_non_ptr_vars && Bts(&cc->htc.fun->used_reg_mask, cmp.non_ptr_vars_map[l]))
l++; l++;
if (l<cmp.num_non_ptr_vars) { if (l < cmp.num_non_ptr_vars)
{
tmpm->reg = cmp.non_ptr_vars_map[l++]; tmpm->reg = cmp.non_ptr_vars_map[l++];
reg_offsets[tmpm->reg].offset = mv[i].offset_start; reg_offsets[tmpm->reg].offset = mv[i].offset_start;
reg_offsets[tmpm->reg].m = tmpm; reg_offsets[tmpm->reg].m = tmpm;
@ -572,42 +621,39 @@ R12 and R13 as non-pointer register variables, such as index variables i,j,k.
"Reg %Z Var \"%-15ts\" %016X[RBP]\n", tmpm->reg, "ST_U64_REGS", "Reg %Z Var \"%-15ts\" %016X[RBP]\n", tmpm->reg, "ST_U64_REGS",
tmpm->str, reg_offsets[tmpm->reg].offset; tmpm->str, reg_offsets[tmpm->reg].offset;
mv[i].offset_start = 0; //flag as reg var mv[i].offset_start = 0; //flag as reg var
if (tmpm->size<8 && if (tmpm->size < 8 && !StrIMatch("Bool", tmpm->member_class->str) &&
!StrIMatch("Bool",tmpm->member_class->str) &&
tmpm->member_class->type & HTT_INTERNAL_TYPE) tmpm->member_class->type & HTT_INTERNAL_TYPE)
PrintWarn("Using 64-bit reg var.\n " PrintWarn("Using 64-bit reg var.\n "
"$$LK,\"FL:%s,%d\"$$ '%s' in '%s'\n", "$$LK,\"FL:%s,%d\"$$ '%s' in '%s'\n",
cc->lex_include_stack->full_name, cc->lex_include_stack->full_name,
cc->lex_include_stack->line_num, cc->lex_include_stack->line_num, tmpm->str, cc->htc.fun->str);
tmpm->str,cc->htc.fun->str);
} }
} }
} }
} }
l = 0; l = 0;
for (i=0;i<j && l<cmp.num_reg_vars;i++) { for (i = 0; i < j && l < cmp.num_reg_vars;i++)
{
tmpm = mv[i].m; tmpm = mv[i].m;
//if not just flagged as reg var //if not just flagged as reg var
if (mv[i].offset_start && (!mv[i].m->dim.next|| if (mv[i].offset_start && (!mv[i].m->dim.next || tmpm->offset > 0 && StrCompare(tmpm->str, "argv")))
tmpm->offset>0 && StrCompare(tmpm->str,"argv"))) { {
while (l<cmp.num_reg_vars && while (l < cmp.num_reg_vars && Bts(&cc->htc.fun->used_reg_mask, cmp.to_reg_vars_map[l]))
Bts(&cc->htc.fun->used_reg_mask,cmp.to_reg_vars_map[l]))
l++; l++;
if (l<cmp.num_reg_vars) { if (l < cmp.num_reg_vars)
{
tmpm->reg = cmp.to_reg_vars_map[l++]; tmpm->reg = cmp.to_reg_vars_map[l++];
reg_offsets[tmpm->reg].offset = mv[i].offset_start; reg_offsets[tmpm->reg].offset = mv[i].offset_start;
reg_offsets[tmpm->reg].m = tmpm; reg_offsets[tmpm->reg].m = tmpm;
if (Bt(&cc->flags, CCf_PASS_TRACE_PRESENT)) if (Bt(&cc->flags, CCf_PASS_TRACE_PRESENT))
"Reg %Z Var \"%-15ts\" %016X[RBP]\n",tmpm->reg,"ST_U64_REGS", "Reg %Z Var \"%-15ts\" %016X[RBP]\n",tmpm->reg,"ST_U64_REGS",
tmpm->str, reg_offsets[tmpm->reg].offset; tmpm->str, reg_offsets[tmpm->reg].offset;
if (tmpm->size<8 && if (tmpm->size < 8 && !StrIMatch("Bool", tmpm->member_class->str) &&
!StrIMatch("Bool",tmpm->member_class->str) &&
tmpm->member_class->type & HTT_INTERNAL_TYPE) tmpm->member_class->type & HTT_INTERNAL_TYPE)
PrintWarn("Using 64-bit reg var.\n " PrintWarn("Using 64-bit reg var.\n "
"$$LK,\"FL:%s,%d\"$$ '%s' in '%s'\n", "$$LK,\"FL:%s,%d\"$$ '%s' in '%s'\n",
cc->lex_include_stack->full_name, cc->lex_include_stack->full_name,
cc->lex_include_stack->line_num, cc->lex_include_stack->line_num, tmpm->str, cc->htc.fun->str);
tmpm->str,cc->htc.fun->str);
} }
} }
} }
@ -615,7 +661,8 @@ R12 and R13 as non-pointer register variables, such as index variables i,j,k.
} }
Free(mv); Free(mv);
} }
if (ps->ptr>2) { if (ps->ptr > 2)
{
"Pass:%d Stack:%08X\n", cc->pass, ps->ptr; "Pass:%d Stack:%08X\n", cc->pass, ps->ptr;
LexExcept(cc, "Compiler Optimization Error at "); LexExcept(cc, "Compiler Optimization Error at ");
} }

1
src/Home/FilesRefactored.DD
View file

@ -57,6 +57,7 @@ StartOS.CC
LexLib.CC LexLib.CC
OptLib.CC OptLib.CC
OptPass012.CC OptPass012.CC
OptPass3.CC
OpCodes.DD OpCodes.DD
CompilerA.HH CompilerA.HH
CompilerB.HH CompilerB.HH