{ Copyright (c) 1998-2002 by Jonas Maebe, member of the Free Pascal development team This unit contains the common subexpression elimination procedure. This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS for A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, inc., 675 Mass Ave, Cambridge, MA 02139, USA. **************************************************************************** } unit CSOpt386; {$i fpcdefs.inc} interface uses aasmbase,aasmtai,aasmdata,aasmcpu, cpuinfo, cpubase, cgbase; function CSE(asml: TAsmList; first, last: tai; pass: longint): boolean; function doReplaceReg(hp: taicpu; newReg, orgReg: tsuperregister): boolean; function changeOp(var o: toper; newReg, orgReg: tsuperregister): boolean; function storeBack(start, current: tai; orgReg, newReg: tsuperregister): boolean; function NoHardCodedRegs(p: taicpu; orgReg, newReg: tsuperregister): boolean; function RegSizesOK(oldReg,newReg: tsuperregister; p: taicpu): boolean; implementation uses {$ifdef csdebug} cutils, {$else} {$ifdef replaceregdebug}cutils,{$endif} {$endif} globtype, verbose, procinfo, globals, daopt386, rgobj, rropt386,cgutils; { function TaiInSequence(P: tai; Const Seq: TContent): Boolean; var P1: tai; Counter: Byte; TmpResult: Boolean; begin TmpResult := False; P1 := Seq.StartMod; Counter := 1; while not(TmpResult) and (Counter <= Seq.NrofMods) do begin if (P = P1) then TmpResult := True; inc(Counter); p1 := tai(p1.Next); end; TaiInSequence := TmpResult; end; } function modifiesConflictingMemLocation(p1: tai; supreg: tsuperregister; c: tregContent; var regsStillValid: tregset; onlymem: boolean; var invalsmemwrite: boolean): boolean; var p: taicpu; tmpRef: treference; regCounter: tsuperregister; opCount: longint; dummy: boolean; begin modifiesConflictingMemLocation := false; invalsmemwrite := false; if p1.typ <> ait_instruction then exit; p := taicpu(p1); case p.opcode of A_MOV,A_MOVSX,A_MOVZX: if p.oper[1]^.typ = top_ref then for regCounter := RS_EAX to RS_EDI do begin if (p.oper[0]^.typ<>top_reg) or (getregtype(p.oper[0]^.reg) <> R_INTREGISTER) then break; if writeToMemDestroysContents(getsupreg(p.oper[0]^.reg),p.oper[1]^.ref^, regCounter,topsize2tcgsize[p.opsize],c[regCounter],dummy) then begin exclude(regsStillValid,regCounter); modifiesConflictingMemLocation := not(supreg in regsStillValid); end; if (regcounter = supreg) then invalsmemwrite := invalsmemwrite or dummy; end else { if is_reg_var[getsupreg(p.oper[1]^.reg)] then } if not onlymem then for regCounter := RS_EAX to RS_EDI do begin if writeDestroysContents(p.oper[1]^,regCounter,topsize2tcgsize[p.opsize],c[regCounter],dummy) then begin exclude(regsStillValid,regCounter); modifiesConflictingMemLocation := not(supreg in regsStillValid); end end; A_DIV, A_IDIV, A_MUL, A_IMUL: begin if not onlymem then if (p.ops = 1) then begin for regCounter := RS_EAX to RS_EDI do begin if writeToRegDestroysContents(RS_EDX,regCounter,c[regCounter]) then begin exclude(regsStillValid,RS_EDX); modifiesConflictingMemLocation := not(supreg in regsStillValid); end; if writeToRegDestroysContents(RS_EAX,regCounter,c[regCounter]) then begin exclude(regsStillValid,RS_EAX); modifiesConflictingMemLocation := not(supreg in regsStillValid); end; end end else { only possible for imul } { last operand is always destination } for regCounter := RS_EAX to RS_EDI do begin if writeDestroysContents(p.oper[p.ops-1]^,regCounter,topsize2tcgsize[p.opsize],c[regCounter],dummy) then begin exclude(regsStillValid,regCounter); modifiesConflictingMemLocation := not(supreg in regsStillValid); end end end; else for opCount := 1 to maxinschanges do case InsProp[p.opcode].Ch[opCount] of Ch_MOp1,CH_WOp1,CH_RWOp1: if not(onlymem) or (p.oper[0]^.typ = top_ref) then { or ((p.oper[0]^.typ = top_reg) and } { is_reg_var[getsupreg(p.oper[0]^.reg)]) then } for regCounter := RS_EAX to RS_EDI do begin if writeDestroysContents(p.oper[0]^,regCounter,topsize2tcgsize[p.opsize],c[regCounter],dummy) then begin exclude(regsStillValid,regCounter); modifiesConflictingMemLocation := not(supreg in regsStillValid); end; if (regcounter = supreg) then invalsmemwrite := invalsmemwrite or dummy; end; Ch_MOp2,CH_WOp2,CH_RWOp2: if not(onlymem) or (p.oper[1]^.typ = top_ref) then { or ((p.oper[1]^.typ = top_reg) and } { is_reg_var[getsupreg(p.oper[1]^.reg)]) then } for regCounter := RS_EAX to RS_EDI do begin if writeDestroysContents(p.oper[1]^,regCounter,topsize2tcgsize[p.opsize],c[regCounter],dummy) then begin exclude(regsStillValid,regCounter); modifiesConflictingMemLocation := not(supreg in regsStillValid); end; if (regcounter = supreg) then invalsmemwrite := invalsmemwrite or dummy; end; Ch_MOp3,CH_WOp3,CH_RWOp3: if not(onlymem) or (p.oper[2]^.typ = top_ref) then { or ((p.oper[2]^.typ = top_reg) and } { is_reg_var[getsupreg(p.oper[2]^.reg)]) then } for regCounter := RS_EAX to RS_EDI do begin if writeDestroysContents(p.oper[2]^,regCounter,topsize2tcgsize[p.opsize],c[regCounter],dummy) then begin exclude(regsStillValid,regCounter); modifiesConflictingMemLocation := not(supreg in regsStillValid); end; if (regcounter = supreg) then invalsmemwrite := invalsmemwrite or dummy; end; Ch_WMemEDI: begin fillchar(tmpref,sizeof(tmpref),0); tmpRef.base := NR_EDI; tmpRef.index := NR_EDI; for regCounter := RS_EAX to RS_EDI do begin if writeToMemDestroysContents(RS_INVALID,tmpRef,regCounter,OS_32,c[regCounter],dummy) then begin exclude(regsStillValid,regCounter); modifiesConflictingMemLocation := not(supreg in regsStillValid); end; if (regcounter = supreg) then invalsmemwrite := invalsmemwrite or dummy; end; end; end; end; end; function isSimpleMemLoc(const ref: treference): boolean; begin { isSimpleMemLoc := (ref.index = RS_NO) and not(ref.base in (rg.usableregsint+[RS_EDI]));} isSimpleMemLoc := (ref.index = NR_NO) and ((ref.base = NR_NO) or not(getsupreg(ref.base) in [RS_EAX,RS_EBX,RS_ECX,RS_EDX,RS_ESI,RS_EDI])); end; {checks whether the current instruction sequence (starting with p) and the one between StartMod and EndMod of Reg are the same. if so, the number of instructions that match is stored in Found and true is returned, otherwise Found holds the number of instructions between StartMod and EndMod and false is returned} function CheckSequence(p: tai; var prev: tai; supreg: tsuperregister; var Found: Longint; var reginfo: toptreginfo; findPrevSeqs: boolean): Boolean; var regsNotRead, regsStillValid : tregset; checkingPrevSequences, passedFlagsModifyingInstr : boolean; function getPrevSequence(p: tai; supreg: tsuperregister; currentPrev: tai; var newPrev: tai): tsuperregister; const current_reg: tsuperregister = RS_INVALID; function stillValid(p: tai): boolean; var hp: tai; begin { only regvars are still used at jump instructions } if (cs_opt_regvar in current_settings.optimizerswitches) and (p.typ = ait_instruction) and taicpu(p).is_jmp then regsstillvalid := regsstillvalid - ptaiprop(p.optinfo)^.usedregs; stillValid := (p.typ = ait_instruction) and (taicpu(p).opcode <> a_jmp) and (ptaiprop(p.optinfo)^.regs[supreg].wstate = ptaiprop(currentPrev.optinfo)^.regs[supreg].wstate) and { in case destroyreg is called with doIncState = false } (ptaiprop(p.optinfo)^.regs[supreg].typ = ptaiprop(currentPrev.optinfo)^.regs[supreg].typ) and (supreg in (regsNotRead * regsStillValid)); { stop if the register was still used right before a (conditional) } { jump, since in that case its current contents could still be } { used in the other path of the jump) } if (p.typ = ait_instruction) and (taicpu(p).is_jmp) and getlastinstruction(p,hp) then stillValid := stillValid and not(supreg in ptaiprop(hp.optinfo)^.usedregs); passedFlagsModifyingInstr := passedFlagsModifyingInstr or instrWritesFlags(currentPrev); end; function findChangedRegister(p: tai): tsuperregister; var regCounter, loopstart: tsuperregister; begin if (current_reg <> RS_INVALID) then loopstart := succ(current_reg) else loopstart := RS_EAX; for regCounter := loopstart to RS_EDI do with ptaiprop(p.optinfo)^.regs[regCounter] do if ((startmod <> ptaiprop(currentPrev.optinfo)^.regs[regCounter].startmod) or (nrofMods <> ptaiprop(currentPrev.optinfo)^.regs[regCounter].nrofMods)) and (ptaiprop(p.optinfo)^.regs[regCounter].typ in [con_ref,con_noRemoveRef]) then begin findChangedRegister := regCounter; current_reg := regCounter; exit; end; current_reg := RS_INVALID; findChangedRegister := RS_INVALID; end; var hp, prevFound: tai; tmpResult, regCounter: tsuperregister; invalsmemwrite: boolean; begin if (current_reg <> RS_EDI) and (current_reg <> RS_INVALID) then begin tmpResult := findChangedRegister(currentPrev); if tmpResult <> RS_INVALID then begin getPrevSequence := tmpResult; exit; end; end; getPrevSequence := RS_INVALID; passedFlagsModifyingInstr := passedFlagsModifyingInstr or instrWritesFlags(currentPrev); if (cs_opt_regvar in current_settings.optimizerswitches) and (currentprev.typ = ait_instruction) and taicpu(currentprev).is_jmp then regsstillvalid := regsstillvalid - ptaiprop(currentprev.optinfo)^.usedregs; if not getLastInstruction(currentPrev,hp) then exit; prevFound := currentPrev; tmpResult := RS_INVALID; while (tmpResult = RS_INVALID) and stillValid(hp) and (ptaiprop(prevFound.optinfo)^.canBeRemoved or not(modifiesConflictingMemLocation(prevFound,supreg, ptaiprop(p.optinfo)^.regs,regsStillValid,false, invalsmemwrite))) do begin { only update the regsread for the instructions we already passed } if not(ptaiprop(prevFound.optinfo)^.canBeRemoved) then for regCounter := RS_EAX to RS_EDI do if regReadByInstruction(regCounter,prevFound) then exclude(regsNotRead,regCounter); { in case getPreviousInstruction fails and sets hp to nil in the } { next iteration } prevFound := hp; if not(ptaiprop(hp.optinfo)^.canBeRemoved) then tmpResult := findChangedRegister(hp); if not getLastInstruction(hp,hp) then break; end; getPrevSequence := tmpResult; if tmpResult <> RS_INVALID then newPrev := prevFound; end; function getNextRegToTest(var prev: tai; currentReg: tsuperregister): tsuperregister; begin getNextRegToTest := RS_INVALID; if not checkingPrevSequences then begin if (currentreg = RS_INVALID) then currentreg := RS_EAX else inc(currentreg); while (currentReg <= RS_EDI) and not(ptaiprop(prev.optinfo)^.regs[currentReg].typ in [con_ref,con_noRemoveRef]) do inc(currentReg); if currentReg > RS_EDI then begin if (taicpu(p).oper[0]^.typ <> top_ref) or isSimpleMemLoc(taicpu(p).oper[0]^.ref^) then begin checkingPrevSequences := true; end else getNextRegToTest := RS_INVALID; end else getNextRegToTest := currentReg; end; if checkingPrevSequences then if findPrevSeqs then getNextRegToTest := getPrevSequence(p,supreg,prev,prev) else getNextRegToTest := RS_INVALID; end; function changedreginvalidatedbetween(const oldreginfo: toptreginfo; var newreginfo: toptreginfo; startp,endp,current: tai): boolean; var orgdiffregs,diffregs: tregset; runner: tai; invalsmemwrite: boolean; begin diffregs := newreginfo.newregsencountered - oldreginfo.newregsencountered; orgdiffregs := diffregs; if diffregs <> [] then begin runner := startp; repeat modifiesConflictingMemLocation(runner,RS_EAX { dummy },ptaiprop(current.optinfo)^.regs,diffregs,true,invalsmemwrite); if orgdiffregs <> diffregs then begin changedreginvalidatedbetween := true; newreginfo := oldreginfo; exit; end; getnextinstruction(runner,runner); until (runner = endp); end; changedreginvalidatedbetween := false; end; var prevreginfo: toptreginfo; hp2, hp3{, EndMod}, prevhp3, highPrev, orgPrev, pprev: tai; {Cnt,} OldNrofMods: Longint; startRegInfo, OrgRegInfo, HighRegInfo: toptreginfo; regModified, lastregloadremoved: array[RS_EAX..RS_ESP] of boolean; HighFound, OrgRegFound: longint; regcounter, regCounter2, tmpreg, base, index: tsuperregister; OrgRegResult: Boolean; TmpResult, flagResultsNeeded: Boolean; begin {CheckSequence} TmpResult := False; FillChar(OrgRegInfo, Sizeof(OrgRegInfo), 0); FillChar(startRegInfo, sizeof(startRegInfo), 0); FillChar(HighRegInfo, sizeof(HighRegInfo), 0); FillChar(prevreginfo, sizeof(prevreginfo), 0); OrgRegFound := 0; HighFound := 0; OrgRegResult := False; highPrev := nil; orgPrev := nil; with startRegInfo do begin newRegsEncountered := [RS_EBP, RS_ESP]; fillword(new2oldreg,sizeof(new2oldreg),RS_INVALID); new2OldReg[RS_EBP] := RS_EBP; new2OldReg[RS_ESP] := RS_ESP; oldRegsEncountered := newRegsEncountered; end; checkingPrevSequences := false; passedFlagsModifyingInstr := false; flagResultsNeeded := false; regsNotRead := [RS_EAX,RS_EBX,RS_ECX,RS_EDX,RS_ESP,RS_EBP,RS_EDI,RS_ESI]; regsStillValid := regsNotRead; GetLastInstruction(p, prev); pprev := prev; tmpreg:=RS_INVALID; regCounter := getNextRegToTest(prev,tmpreg); while (regcounter <> RS_INVALID) do begin fillchar(regModified,sizeof(regModified),0); fillchar(lastregloadremoved,sizeof(lastregloadremoved),0); reginfo := startRegInfo; Found := 0; hp2 := ptaiprop(prev.optinfo)^.Regs[regcounter].StartMod; if (prev <> ptaiprop(prev.optinfo)^.Regs[regcounter].StartMod) then OldNrofMods := ptaiprop(prev.optinfo)^.Regs[regcounter].NrofMods else OldNrofMods := 1; hp3 := p; if checkingprevsequences then prevreginfo := reginfo; while (Found <> OldNrofMods) and { old new } InstructionsEquivalent(hp2, hp3, reginfo) and (not(checkingprevsequences) or not(changedreginvalidatedbetween(prevreginfo,reginfo,prev,p,hp3))) do begin if checkingprevsequences then begin prevreginfo := reginfo; end; if (hp3.typ = ait_instruction) and ((taicpu(hp3).opcode = A_MOV) or (taicpu(hp3).opcode = A_MOVZX) or (taicpu(hp3).opcode = A_LEA) or (taicpu(hp3).opcode = A_MOVSX)) and (taicpu(hp3).oper[1]^.typ = top_reg) and not(regInOp(getsupreg(taicpu(hp3).oper[1]^.reg),taicpu(hp3).oper[0]^)) then begin tmpreg := getsupreg(taicpu(hp3).oper[1]^.reg); lastregloadremoved[tmpreg] := ptaiprop(hp2.optinfo)^.canberemoved; reginfo.lastReload[tmpreg] := hp3; case taicpu(hp3).oper[0]^.typ of top_ref: begin base := getsupreg(taicpu(hp3).oper[0]^.ref^.base); index := getsupreg(taicpu(hp3).oper[0]^.ref^.index); if (found <> 0) and ((taicpu(hp3).oper[0]^.ref^.base = NR_NO) or regModified[base] or (base = getsupreg(current_procinfo.framepointer))) and ((taicpu(hp3).oper[0]^.ref^.index = NR_NO) or regModified[index]) and not(regInRef(tmpReg,taicpu(hp3).oper[0]^.ref^)) then begin with ptaiprop(hp3.optinfo)^.regs[tmpreg] do if nrofMods > (oldNrofMods - found) then oldNrofMods := found + nrofMods; { next is safe because instructions are equivalent } with ptaiprop(hp2.optinfo)^.regs[getsupreg(taicpu(hp2).oper[1]^.reg)] do if nrofMods > (oldNrofMods - found) then oldNrofMods := found + nrofMods; end; end; top_reg: if regModified[getsupreg(taicpu(hp3).oper[0]^.reg)] then begin with ptaiprop(hp3.optinfo)^.regs[tmpreg] do if nrofMods > (oldNrofMods - found) then oldNrofMods := found + nrofMods; with ptaiprop(hp2.optinfo)^.regs[getsupreg(taicpu(hp2).oper[1]^.reg)] do if nrofMods > (oldNrofMods - found) then oldNrofMods := found + nrofMods; end; end; end; for regCounter2 := RS_EAX to RS_EDI do regModified[regCounter2] := regModified[regCounter2] or regModifiedByInstruction(regCounter2,hp3); if flagResultsNeeded then flagResultsNeeded := not instrReadsFlags(hp3); if not flagResultsNeeded then flagResultsNeeded := ptaiprop(hp3.optinfo)^.FlagsUsed; inc(Found); prevhp3 := hp3; if (Found <> OldNrofMods) then if not GetNextInstruction(hp2, hp2) or not GetNextInstruction(hp3, hp3) then break; end; if assigned(hp3) then begin prevhp3 := hp3; getnextinstruction(hp3,hp3); end; if not assigned(hp3) or { a marker has no optinfo, which is used below } (hp3.typ = ait_marker) then hp3 := prevhp3; { a) movl -4(%ebp),%edx movl -12(%ebp),%ecx ... movl -8(%ebp),%eax movl -12(%ebp),%edx (marked as removable) movl (%eax,%edx),%eax (replaced by "movl (%eax,%ecx),%eax") ... movl -8(%ebp),%eax movl -12(%ebp),%edx movl (%eax,%edx),%eax movl (%edx),%edx -> the "movl -12(ebp),%edx" can't be removed in the last sequence, because edx has not been replaced with ecx there, and edx is still used after the sequence b) tests/webtbs/tw4266.pp } { hp2 = instruction after previous sequence, pprev = instruction before } { current sequence, prev = instruction where the loads of the registers } { will be inserted } for regCounter2 := RS_EAX to RS_EDI do if (reginfo.new2OldReg[regCounter2] <> RS_INVALID) and { case a) above } (((regCounter2 in ptaiprop(hp3.optinfo)^.usedRegs) and (not regLoadedWithNewValue(regCounter2,false,hp3) and lastregloadremoved[regcounter2])) or { case b) above } ((ptaiprop(hp2.optinfo)^.regs[regCounter2].wstate <> ptaiprop(pprev.optinfo)^.regs[regcounter2].wstate)) or ((ptaiprop(hp2.optinfo)^.regs[reginfo.new2OldReg[regCounter2]].wstate <> ptaiprop(prev.optinfo)^.regs[reginfo.new2OldReg[regCounter2]].wstate))) then begin found := 0; break; end; if checkingPrevSequences then begin for regCounter2 := RS_EAX to RS_EDI do if (reginfo.new2OldReg[regCounter2] <> RS_INVALID) and (reginfo.new2OldReg[regCounter2] <> regCounter2) and (not(regCounter2 in (regsNotRead * regsStillValid)) or not(reginfo.new2OldReg[regCounter2] in regsStillValid)) then begin found := 0; break; end; if passedFlagsModifyingInstr and flagResultsNeeded then found := 0; end; TmpResult := true; if (found <> OldNrofMods) then TmpResult := false else if assigned(hp3) then for regcounter2 := RS_EAX to RS_EDI do if (regcounter2 in reginfo.regsLoadedforRef) and regModified[regcounter2] and (regcounter2 in ptaiprop(hp3.optinfo)^.usedRegs) and not regLoadedWithNewValue(regcounter2,false,hp3) then begin TmpResult := False; if (found > 0) then {this is correct because we only need to turn off the CanBeRemoved flag when an instruction has already been processed by CheckSequence (otherwise CanBeRemoved can't be true and thus can't have to be turned off). if it has already been processed by CheckSequence and flagged to be removed, it means that it has been checked against a previous sequence and that it was equal (otherwise CheckSequence would have returned false and the instruction wouldn't have been removed). if this "if found > 0" check is left out, incorrect optimizations are performed.} Found := ptaiprop(tai(p).optinfo)^.Regs[supreg].NrofMods; break; end; if TmpResult and (Found > HighFound) then begin highPrev := prev; HighFound := Found; HighRegInfo := reginfo; end; if (regcounter = supreg) then begin orgPrev := prev; OrgRegFound := Found; OrgRegResult := TmpResult; OrgRegInfo := reginfo end; regCounter := getNextRegToTest(prev,regCounter); end; if (HighFound > 0) and (not(OrgRegResult) Or (HighFound > OrgRegFound)) then begin CheckSequence := True; prev := highPrev; reginfo := HighRegInfo; Found := HighFound end else begin CheckSequence := OrgRegResult; prev := orgPrev; Found := OrgRegFound; reginfo := OrgRegInfo; end; end; {CheckSequence} procedure SetAlignReg(p: tai); Const alignSearch = 12; var regsUsable: TRegSet; prevInstrCount, nextInstrCount: Longint; prevState, nextWState,nextRState: Array[RS_EAX..RS_EDI] of byte; regCounter, lastRemoved: tsuperregister; prev, next: tai; {$ifdef alignregdebug} temp: tai; {$endif alignregdebug} begin regsUsable := [RS_EAX,RS_ECX,RS_EDX,RS_EBX,{R_ESP,RS_EBP,}RS_ESI,RS_EDI]; for regCounter := RS_EAX to RS_EDI do begin prevState[regCounter] := ptaiprop(p.optinfo)^.Regs[regCounter].wState; nextWState[regCounter] := ptaiprop(p.optinfo)^.Regs[regCounter].wState; nextRState[regCounter] := ptaiprop(p.optinfo)^.Regs[regCounter].rState; end; getLastInstruction(p,prev); getNextInstruction(p,next); lastRemoved := getsupreg(tai_align(p).reg); nextInstrCount := 0; prevInstrCount := 0; while ((assigned(prev) and assigned(prev.optinfo) and (prevInstrCount < alignSearch)) or (assigned(next) and assigned(next.optinfo) and (nextInstrCount < alignSearch))) and (regsUsable <> []) do begin {$ifdef alignregdebug} if assigned(prev) then begin temp := tai_comment.Create(strpnew('got here')); temp.next := prev.next; temp.previous := prev; prev.next := temp; if assigned(temp.next) then temp.next.previous := temp; end; {$endif alignregdebug} if assigned(prev) and assigned(prev.optinfo) and (prevInstrCount < alignSearch) then begin if (prev.typ = ait_instruction) and (insProp[taicpu(prev).opcode].ch[1] <> Ch_ALL) and (taicpu(prev).opcode <> A_JMP) then begin inc(prevInstrCount); for regCounter := RS_EAX to RS_EDI do begin if (regCounter in regsUsable) and (ptaiprop(prev.optinfo)^.Regs[regCounter].wState <> prevState[regCounter]) then begin lastRemoved := regCounter; exclude(regsUsable,regCounter); {$ifdef alignregdebug} temp := tai_comment.Create(strpnew( std_regname(newreg(R_INTREGISTER,regCounter,R_SUBWHOLE))+' removed'))); temp.next := prev.next; temp.previous := prev; prev.next := temp; if assigned(temp.next) then temp.next.previous := temp; if regsUsable = [] then begin temp := tai_comment.Create(strpnew( 'regsUsable empty here'))); temp.next := prev.next; temp.previous := prev; prev.next := temp; if assigned(temp.next) then temp.next.previous := temp; end; {$endif alignregdebug} end; prevState[regCounter] := ptaiprop(prev.optinfo)^.Regs[regCounter].wState; end; getLastInstruction(prev,prev); end else if GetLastInstruction(prev,prev) and assigned(prev.optinfo) then for regCounter := RS_EAX to RS_EDI do prevState[regCounter] := ptaiprop(prev.optinfo)^.Regs[regCounter].wState end; if assigned(next) and assigned(next.optinfo) and (nextInstrCount < alignSearch) then begin if (next.typ = ait_instruction) and (insProp[taicpu(next).opcode].ch[1] <> Ch_ALL) and (taicpu(next).opcode <> A_JMP) then begin inc(nextInstrCount); for regCounter := RS_EAX to RS_EDI do begin if (regCounter in regsUsable) and ((ptaiprop(next.optinfo)^.Regs[regCounter].wState <> nextWState[regCounter]) or (ptaiprop(next.optinfo)^.Regs[regCounter].rState <> nextRState[regCounter])) then begin lastRemoved := regCounter; exclude(regsUsable,regCounter); {$ifdef alignregdebug} temp := tai_comment.Create(strpnew( std_regname(newreg(R_INTREGISTER,regCounter,R_SUBWHOLE))+' removed'))); temp.next := next.next; temp.previous := next; next.next := temp; if assigned(temp.next) then temp.next.previous := temp; if regsUsable = [] then begin temp := tai_comment.Create(strpnew( 'regsUsable empty here'))); temp.next := next.next; temp.previous := next; next.next := temp; if assigned(temp.next) then temp.next.previous := temp; end; {$endif alignregdebug} end; nextWState[regCounter] := ptaiprop(next.optinfo)^.Regs[regCounter].wState; nextRState[regCounter] := ptaiprop(next.optinfo)^.Regs[regCounter].rState; end end else for regCounter := RS_EAX to RS_EDI do begin nextWState[regCounter] := ptaiprop(next.optinfo)^.Regs[regCounter].wState; nextRState[regCounter] := ptaiprop(next.optinfo)^.Regs[regCounter].rState; end; getNextInstruction(next,next); end; end; if regsUsable <> [] then for regCounter := RS_EAX to RS_EDI do if regCounter in regsUsable then begin lastRemoved := regCounter; break end; {$ifdef alignregdebug} next := tai_comment.Create(strpnew(std_regname(newreg(R_INTREGISTER,lastremoved,R_SUBWHOLE))+ ' chosen as alignment register'))); next.next := p.next; next.previous := p; p.next := next; if assigned(next.next) then next.next.previous := next; {$endif alignregdebug} tai_align(p).reg := newreg(R_INTREGISTER,lastRemoved,R_SUBWHOLE); end; procedure clearmemwrites(p: tai; supreg: tsuperregister); var beginmemwrite: tai; begin beginmemwrite := ptaiprop(p.optinfo)^.regs[supreg].memwrite; repeat ptaiprop(p.optinfo)^.regs[supreg].memwrite := nil; until not getnextinstruction(p,p) or (ptaiprop(p.optinfo)^.regs[supreg].memwrite <> beginmemwrite); end; procedure ClearRegContentsFrom(asml: TAsmList; supreg: tsuperregister; p, endP: tai); { first clears the contents of reg from p till endP. then the contents are } { cleared until the first instruction that changes reg } var {$ifdef replaceregdebug} hp: tai; l: longint; {$endif replaceregdebug} regcounter: tsuperregister; oldStartmod: tai; regstoclear: tregset; begin {$ifdef replaceregdebug} l := random(1000); hp := tai_comment.Create(strpnew( 'cleared '+std_regname(newreg(R_INTREGISTER,supreg,R_SUBWHOLE))+' from here... '+tostr(l))); insertllitem(asml,p.previous,p,hp); {$endif replaceregdebug} ptaiprop(p.optinfo)^.Regs[supreg].typ := con_unknown; regstoclear := [supreg]; while (p <> endP) do begin for regcounter := RS_EAX to RS_EDI do begin if (regcounter <> supreg) and assigned(ptaiprop(p.optinfo)^.regs[supreg].memwrite) and reginref(regcounter,ptaiprop(p.optinfo)^.regs[supreg].memwrite.oper[1]^.ref^) then clearmemwrites(p,regcounter); { needs double loop to cheack for each dependency combination? } if assigned(ptaiprop(p.optinfo)^.regs[regcounter].startmod) and sequencedependsonreg(ptaiprop(p.optinfo)^.regs[regcounter],regcounter,supreg) then include(regstoclear,regcounter); if regcounter in regstoclear then with ptaiprop(p.optinfo)^.Regs[regcounter] do begin typ := con_unknown; memwrite := nil; startmod := nil; nrofmods := 0; end; end; getNextInstruction(p,p); end; oldStartmod := ptaiprop(p.optinfo)^.Regs[supreg].startmod; repeat for regcounter := RS_EAX to RS_EDI do begin { needs double loop to cheack for each dependency combination? } if assigned(ptaiprop(p.optinfo)^.regs[regcounter].startmod) and sequencedependsonreg(ptaiprop(p.optinfo)^.regs[regcounter],regcounter,supreg) then include(regstoclear,regcounter); with ptaiprop(p.optinfo)^.Regs[supreg] do if regcounter in regstoclear then begin typ := con_unknown; memwrite := nil; end; end; until not getNextInstruction(p,p) or (ptaiprop(p.optinfo)^.Regs[supreg].startmod <> oldStartmod); {$ifdef replaceregdebug} if assigned(p) then begin hp := tai_comment.Create(strpnew( 'cleared '+std_regname(newreg(R_INTREGISTER,supreg,R_SUBWHOLE))+' till here... '+tostr(l))); insertllitem(asml,p.previous,p,hp); end; {$endif replaceregdebug} end; procedure RestoreRegContentsTo(asml: TAsmList; supreg: tsuperregister; const c: TContent; p, endP: tai); var {$ifdef replaceregdebug} l: longint; {$endif replaceregdebug} hp: tai; validregs, prevvalidregs: tregset; regcounter: tsuperregister; tmpState, newrstate: byte; prevcontenttyp: byte; memconflict: boolean; invalsmemwrite: boolean; begin {$ifdef replaceregdebug} l := random(1000); hp := tai_comment.Create(strpnew( 'restored '+std_regname(newreg(R_INTREGISTER,supreg,R_SUBWHOLE))+' with data from here... '+tostr(l))); insertllitem(asml,p.previous,p,hp); {$endif replaceregdebug} { ptaiprop(p.optinfo)^.Regs[reg] := c;} newrstate := c.rstate; incstate(newrstate,$7f); memconflict := false; invalsmemwrite := false; validregs := [RS_EAX..RS_EDI]; prevvalidregs := validregs; while (p <> endP) and not(memconflict) and not(invalsmemwrite) do begin if not(ptaiprop(p.optinfo)^.canberemoved) and regreadbyinstruction(supreg,p) then incstate(newrstate,1); // is this a write to memory that destroys the contents we are restoring? memconflict := modifiesConflictingMemLocation(p,supreg,ptaiprop(p.optinfo)^.regs,validregs,false,invalsmemwrite); if (validregs <> prevvalidregs) then begin prevvalidregs := validregs >< prevvalidregs; for regcounter := RS_EAX to RS_EDI do if regcounter in prevvalidregs then clearRegContentsFrom(asml,regcounter,p,endP); end; prevvalidregs := validregs; if (not memconflict and not invalsmemwrite) then begin ptaiprop(p.optinfo)^.Regs[supreg] := c; ptaiprop(p.optinfo)^.Regs[supreg].rstate := newrstate; end else begin clearRegContentsFrom(asml,supreg,p,endP); {$ifdef replaceregdebug} if assigned(p) then begin hp := tai_comment.Create(strpnew( 'stopping restoring of '+std_regname(newreg(R_INTREGISTER,supreg,R_SUBWHOLE))+'because memory conflict... '+tostr(l))); insertllitem(asml,p,p.next,hp); end; {$endif replaceregdebug} exit end; getNextInstruction(p,p); end; tmpState := ptaiprop(p.optinfo)^.Regs[supreg].wState; if (newrstate = ptaiprop(p.optinfo)^.Regs[supreg].rState) then begin incstate(ptaiprop(p.optinfo)^.regs[supreg].rstate,63); if not getnextinstruction(p,hp) then exit; if (ptaiprop(hp.optinfo)^.regs[supreg].rstate = ptaiprop(p.optinfo)^.regs[supreg].rstate) then internalerror(2004122710); end; repeat newrstate := ptaiprop(p.optinfo)^.Regs[supreg].rState; prevcontenttyp := ptaiprop(p.optinfo)^.Regs[supreg].typ; // is this a write to memory that destroys the contents we are restoring? memconflict := modifiesConflictingMemLocation(p,supreg,ptaiprop(p.optinfo)^.regs,validregs,false,invalsmemwrite); if (validregs <> prevvalidregs) then begin prevvalidregs := validregs >< prevvalidregs; for regcounter := RS_EAX to RS_EDI do if regcounter in prevvalidregs then clearRegContentsFrom(asml,regcounter,p,p); end; prevvalidregs := validregs; if (not memconflict and not invalsmemwrite) then begin ptaiprop(p.optinfo)^.Regs[supreg] := c; ptaiprop(p.optinfo)^.Regs[supreg].rstate := newrstate; end; until invalsmemwrite or memconflict or not getNextInstruction(p,p) or (ptaiprop(p.optinfo)^.Regs[supreg].wState <> tmpState) or (p.typ = ait_label) or ((prevcontenttyp <> con_invalid) and (ptaiprop(p.optinfo)^.Regs[supreg].typ = con_invalid)); if assigned(p) and (p.typ <> ait_marker) then if ((p.typ = ait_label) or memconflict or invalsmemwrite) then clearRegContentsFrom(asml,supreg,p,p) else if (ptaiprop(p.optinfo)^.Regs[supreg].rstate = newrstate) then incstate(ptaiprop(p.optinfo)^.Regs[supreg].rstate,20); {$ifdef replaceregdebug} if assigned(p) then begin hp := tai_comment.Create(strpnew( 'restored '+std_regname(newreg(R_INTREGISTER,supreg,R_SUBWHOLE))+' till here... '+tostr(l))); insertllitem(asml,p,p.next,hp); end; {$endif replaceregdebug} end; function NoHardCodedRegs(p: taicpu; orgReg, newReg: tsuperregister): boolean; var chCount: byte; begin case p.opcode of A_IMUL: noHardCodedRegs := p.ops <> 1; A_SHL,A_SHR,A_ROR,A_ROL,A_SAR,A_SHLD,A_SHRD: noHardCodedRegs := (p.oper[0]^.typ <> top_reg) or ((orgReg <> RS_ECX) and (newReg <> RS_ECX)); else begin NoHardCodedRegs := true; with InsProp[p.opcode] do for chCount := 1 to maxinschanges do if Ch[chCount] in ([Ch_REAX..Ch_MEDI,Ch_WMemEDI,Ch_All]-[Ch_RESP,Ch_WESP,Ch_RWESP]) then begin NoHardCodedRegs := false; break end; end; end; end; function ChangeReg(var Reg: TRegister; newReg, orgReg: tsuperregister): boolean; begin changereg := false; if (reg <> NR_NO) and (getregtype(reg) = R_INTREGISTER) and (getsupreg(reg) = newreg) then begin changereg := true; setsupreg(reg,orgreg); end; end; function changeOp(var o: toper; newReg, orgReg: tsuperregister): boolean; var tmpresult: boolean; begin changeOp := false; case o.typ of top_reg: changeOp := changeReg(o.reg,newReg,orgReg); top_ref: begin tmpresult := changeReg(o.ref^.base,newReg,orgReg); changeop := changeReg(o.ref^.index,newReg,orgReg) or tmpresult; end; end; end; procedure updateStates(orgReg,newReg: tsuperregister; hp: tai; writeStateToo: boolean); var prev: tai; newOrgRegRState, newOrgRegWState: byte; begin newOrgRegwState := 0; if getLastInstruction(hp,prev) then with ptaiprop(prev.optinfo)^ do begin newOrgRegRState := byte(longint(regs[orgReg].rState) + longint(ptaiprop(hp.optinfo)^.regs[newReg].rState) - regs[newReg].rstate); if writeStateToo then newOrgRegWState := byte(longint(regs[orgReg].wState) + longint(ptaiprop(hp.optinfo)^.regs[newReg].wState) - regs[newReg].wstate); end else with ptaiprop(hp.optinfo)^.regs[newReg] do begin newOrgRegRState := rState; if writeStateToo then newOrgRegWState := wState; end; with ptaiprop(hp.optinfo)^.regs[orgReg] do begin rState := newOrgRegRState; if writeStateToo then wState := newOrgRegwState; end; end; function doReplaceReg(hp: taicpu; newReg, orgReg: tsuperregister): boolean; var opCount: longint; tmpResult: boolean; begin tmpresult := false; for opCount := 0 to hp.ops-1 do tmpResult := changeOp(hp.oper[opCount]^,newReg,orgReg) or tmpResult; doReplaceReg := tmpResult; end; function RegSizesOK(oldReg,newReg: tsuperregister; p: taicpu): boolean; { oldreg and newreg must be 32bit components } var opCount: longint; tmpreg: tsuperregister; begin RegSizesOK := true; { if only one of them is a general purpose register ... } if (IsGP32reg(oldReg) xor IsGP32Reg(newReg)) then begin for opCount := 0 to p.ops-1 do if (p.oper[opCount]^.typ = top_reg) and (getsubreg(p.oper[opCount]^.reg) in [R_SUBL,R_SUBH]) then begin tmpreg := getsupreg(p.oper[opCount]^.reg); if (tmpreg = oldreg) or (tmpreg = newreg) then begin RegSizesOK := false; break end end; end; end; function doReplaceReadReg(p: taicpu; newReg,orgReg: tsuperregister): boolean; var opCount: longint; begin doReplaceReadReg := false; { handle special case } case p.opcode of A_IMUL: begin case p.ops of 1: internalerror(1301001); 2,3: begin if changeOp(p.oper[0]^,newReg,orgReg) then begin { updateStates(orgReg,newReg,p,false);} doReplaceReadReg := true; end; if p.ops = 3 then if changeOp(p.oper[1]^,newReg,orgReg) then begin { updateStates(orgReg,newReg,p,false);} doReplaceReadReg := true; end; end; end; end; A_DIV,A_IDIV,A_MUL: internalerror(1301002); else begin for opCount := 0 to p.ops-1 do if p.oper[opCount]^.typ = top_ref then if changeOp(p.oper[opCount]^,newReg,orgReg) then begin { updateStates(orgReg,newReg,p,false);} doReplaceReadReg := true; end; for opCount := 1 to maxinschanges do case InsProp[p.opcode].Ch[opCount] of Ch_ROp1: if p.oper[0]^.typ = top_reg then if changeReg(p.oper[0]^.reg,newReg,orgReg) then begin { updateStates(orgReg,newReg,p,false);} doReplaceReadReg := true; end; Ch_ROp2: if p.oper[1]^.typ = top_reg then if changeReg(p.oper[1]^.reg,newReg,orgReg) then begin { updateStates(orgReg,newReg,p,false);} doReplaceReadReg := true; end; Ch_ROp3: if p.oper[2]^.typ = top_reg then if changeReg(p.oper[2]^.reg,newReg,orgReg) then begin { updateStates(orgReg,newReg,p,false);} doReplaceReadReg := true; end; end; end; end; end; procedure updateState(supreg: tsuperregister; p: tai); { this procedure updates the read and write states of the instructions } { coming after p. It's called when the read/write state of p has been } { changed and this change has to be propagated to the following } { instructions as well } var newRState, newWState: byte; prevRState, prevWState: byte; doRState, doWState: boolean; begin { get the new read/write states from p } with ptaiprop(p.optinfo)^.regs[supreg] do begin newRState := rState; newWState := wState; end; if not GetNextInstruction(p,p) then exit; { get the old read/write states from the next instruction, to know } { when we can stop updating } with ptaiprop(p.optinfo)^.regs[supreg] do begin prevRState := rState; prevWState := wState; end; { adjust the states if this next instruction reads/writes the register } if regReadByInstruction(supreg,p) then incState(newRState,1); if regModifiedByInstruction(supreg,p) then incState(newWState,1); { do we still have to update the read and/or write states? } doRState := true; doWState := true; repeat { update the states } with ptaiprop(p.optinfo)^.regs[supreg] do begin if doRState then rState := newRState; if doWState then wState := newWState; end; if not getNextInstruction(p,p) then break; with ptaiprop(p.optinfo)^.regs[supreg] do begin { stop updating the read state if it changes } doRState := doRState and (rState = prevRState); { if, by accident, this changed state is the same as the one } { we've been using, change it to a value that's definitely } { different from the previous and next state } if not doRState and (rState = newRState) then begin incState(newRState,1); prevRState := rState; doRState := true; end; { ditto for the write state } doWState := doWState and (WState = prevWState); if not doWState and (wState = newWState) then begin incState(newWState,1); prevWState := wState; doWState := true; end; end; { stop when we don't have to update either state anymore } until not(doRState or doWState); end; function storeBack(start, current: tai; orgReg, newReg: tsuperregister): boolean; { returns true if p1 contains an instruction that stores the contents } { of newReg back to orgReg } begin storeback := false; if (current.typ = ait_instruction) and (taicpu(current).opcode = A_MOV) and (taicpu(current).oper[0]^.typ = top_reg) and (getsupreg(taicpu(current).oper[0]^.reg) = newReg) and (taicpu(current).oper[1]^.typ = top_reg) and (getsupreg(taicpu(current).oper[1]^.reg) = orgReg) then case taicpu(current).opsize of S_B: storeback := true; S_W: storeback := taicpu(start).opsize <> S_B; S_L: storeback := taicpu(start).opsize = S_L; else internalerror(2003121501); end; end; function canreplacereg(orgsupreg, newsupreg: tsuperregister; p: tai; orgRegCanBeModified: boolean; var resnewregmodified, resorgregread, resremovelast: boolean; var returnendp: tai): boolean; var endP, hp: tai; removeLast, sequenceEnd, tmpResult, newRegModified, orgRegRead: boolean; begin canreplacereg := false; tmpResult := true; sequenceEnd := false; newRegModified := false; orgRegRead := false; removeLast := false; endP := p; while tmpResult and not sequenceEnd do begin tmpResult := getNextInstruction(endP,endP) and (endp.typ = ait_instruction) and not(taicpu(endp).is_jmp); if tmpresult and not assigned(endp.optinfo) then begin { hp := tai_comment.Create(strpnew('next no optinfo')); hp.next := endp; hp.previous := endp.previous; endp.previous := hp; if assigned(hp.previous) then hp.previous.next := hp;} exit; end; if tmpResult and { don't take into account instructions that will be removed } not (ptaiprop(endp.optinfo)^.canBeRemoved) then begin { if the newsupreg gets stored back to the oldReg, we can change } { "mov %oldReg,%newReg; ; mov %newReg, } { %oldReg" to "" } removeLast := storeBack(p,endP, orgsupreg, newsupreg); sequenceEnd := { no support for (i)div, mul and imul with hardcoded operands } noHardCodedRegs(taicpu(endP),orgsupreg,newsupreg) and { if newsupreg gets loaded with a new value, we can stop } { replacing newsupreg with oldReg here (possibly keeping } { the original contents of oldReg so we still know them } { afterwards) } (RegLoadedWithNewValue(newsupreg,true,taicpu(endP)) or { we can also stop if we reached the end of the use of } { newReg's current contents } (GetNextInstruction(endp,hp) and FindRegDealloc(newsupreg,hp))); { to be able to remove the first and last instruction of } { movl %reg1, %reg2 } { (replacing reg2 with reg1 here) } { movl %reg2, %reg1 } { %reg2 must not be use afterwards (it can be as the } { result of a peepholeoptimization) } removeLast := removeLast and sequenceEnd; newRegModified := newRegModified or (not(regLoadedWithNewValue(newsupreg,true,taicpu(endP))) and RegModifiedByInstruction(newsupreg,endP)); orgRegRead := newRegModified and RegReadByInstruction(orgsupreg,endP); sequenceEnd := SequenceEnd and (removeLast or { since newsupreg will be replaced by orgsupreg, we can't allow that newsupreg } { gets modified if orgsupreg is still read afterwards (since after } { replacing, this would mean that orgsupreg first gets modified and then } { gets read in the assumption it still contains the unmodified value) } not(newRegModified and orgRegRead)) (* and { since newsupreg will be replaced by orgsupreg, we can't allow that newsupreg } { gets modified if orgRegCanBeModified = false } { this now gets checked after the loop (JM) } (orgRegCanBeModified or not(newRegModified)) *); tmpResult := not(removeLast) and not(newRegModified and orgRegRead) and (* (orgRegCanBeModified or not(newRegModified)) and *) (* already checked at the top (endp.typ = ait_instruction) and *) NoHardCodedRegs(taicpu(endP),orgsupreg,newsupreg) and RegSizesOk(orgsupreg,newsupreg,taicpu(endP)) and not RegModifiedByInstruction(orgsupreg,endP); end; end; canreplacereg := sequenceEnd and (removeLast or (orgRegCanBeModified or not(newRegModified))) and (not(assigned(endp)) or not(endp.typ = ait_instruction) or (noHardCodedRegs(taicpu(endP),orgsupreg,newsupreg) and RegSizesOk(orgsupreg,newsupreg,taicpu(endP)) and not(newRegModified and (orgsupreg in ptaiprop(endp.optinfo)^.usedRegs) and not(RegLoadedWithNewValue(orgsupreg,true,taicpu(endP)))))); if canreplacereg then begin resnewregmodified := newregmodified; resorgregread := orgregread; resremovelast := removelast; end; { needed for replaceregdebug code } returnendp := endp; end; function ReplaceReg(asml: TAsmList; orgsupreg, newsupreg: tsuperregister; p, seqstart: tai; const c: TContent; orgRegCanBeModified: Boolean; var returnEndP: tai): Boolean; { Tries to replace orgsupreg with newsupreg in all instructions coming after p } { until orgsupreg gets loaded with a new value. Returns true if successful, } { false otherwise. if successful, the contents of newsupreg are set to c, } { which should hold the contents of newsupreg before the current sequence } { started } { if the function returns true, returnEndP holds the last instruction } { where newsupreg was replaced by orgsupreg } var endP, hp: tai; removeLast, newRegModified, orgRegRead, stateChanged, readStateChanged: Boolean; {$ifdef replaceregdebug} l: longint; {$endif replaceregdebug} begin replacereg := false; readStateChanged := false; if canreplacereg(orgsupreg,newsupreg,p,orgregcanbemodified,newregmodified, orgregread, removelast,endp) then begin {$ifdef replaceregdebug} l := random(1000); hp := tai_comment.Create(strpnew( 'replacing '+std_regname(newreg(R_INTREGISTER,newsupreg,R_SUBWHOLE))+' with '+std_regname(newreg(R_INTREGISTER,orgsupreg,R_SUBWHOLE))+ ' from here... '+tostr(l))); insertllitem(asml,p.previous,p,hp); hp := tai_comment.Create(strpnew( 'replaced '+std_regname(newreg(R_INTREGISTER,newsupreg,R_SUBWHOLE))+' with '+std_regname(newreg(R_INTREGISTER,orgsupreg,R_SUBWHOLE))+ ' till here ' + tostr(l))); insertllitem(asml,endp,endp.next,hp); {$endif replaceregdebug} replaceReg := true; returnEndP := endP; if not getNextInstruction(p,hp) then exit; stateChanged := false; while hp <> endP do begin if {not(ptaiprop(hp.optinfo)^.canBeRemoved) and } (hp.typ = ait_instruction) then stateChanged := doReplaceReg(taicpu(hp),newsupreg,orgsupreg) or stateChanged; if stateChanged then updateStates(orgsupreg,newsupreg,hp,true); getNextInstruction(hp,hp) end; if assigned(endp) and (endp.typ = ait_instruction) then readStateChanged := doReplaceReadReg(taicpu(endP),newsupreg,orgsupreg); if stateChanged or readStateChanged then updateStates(orgsupreg,newsupreg,endP,stateChanged); if stateChanged or readStateChanged then updateState(orgsupreg,endP); { We replaced newreg with oldreg between p and endp, so restore the contents } { of newreg there with its contents from before the sequence. } if removeLast or RegLoadedWithNewValue(newsupreg,true,endP) then GetLastInstruction(endP,hp) else hp := endP; RestoreRegContentsTo(asml,newsupreg,c,seqstart,hp); { Ot is possible that the new register was modified (e.g. an add/sub), so if } { it was replaced by oldreg in that instruction, oldreg's contents have been } { changed. To take this into account, we simply set the contents of orgsupreg } { to "unknown" after this sequence } if newRegModified then ClearRegContentsFrom(asml,orgsupreg,p,hp); if removeLast then ptaiprop(endp.optinfo)^.canBeRemoved := true; allocRegBetween(asml,newreg(R_INTREGISTER,orgsupreg,R_SUBWHOLE),p,endP,ptaiprop(p.optinfo)^.usedregs); end {$ifdef replaceregdebug} else begin l := random(1000); hp := tai_comment.Create(strpnew( 'replacing '+std_regname(newreg(R_INTREGISTER,newsupreg,R_SUBWHOLE))+' with '+std_regname(newreg(R_INTREGISTER,orgsupreg,R_SUBWHOLE))+ ' from here... '+ tostr(l))); insertllitem(asml,p.previous,p,hp); hp := tai_comment.Create(strpnew( 'replacing '+std_regname(newreg(R_INTREGISTER,newsupreg,R_SUBWHOLE))+' with '+std_regname(newreg(R_INTREGISTER,orgsupreg,R_SUBWHOLE))+ ' failed here ' + tostr(l))); insertllitem(asml,endp,endp.next,hp); end; {$endif replaceregdebug} end; function FindRegWithConst(p: tai; size: topsize; l: aint; var Res: TRegister): Boolean; {Finds a register which contains the constant l} var Counter: tsuperregister; {$ifdef testing} hp: tai; {$endif testing} begin Result:=false; Counter := RS_EAX; repeat {$ifdef testing} if (ptaiprop(p.optinfo)^.regs[counter].typ in [con_const,con_noRemoveConst]) then begin hp := tai_comment.Create(strpnew( 'checking const load of '+tostr(l)+' here...')); hp.next := ptaiprop(p.optinfo)^.Regs[Counter].StartMod; hp.previous := ptaiprop(p.optinfo)^.Regs[Counter].StartMod^.previous; ptaiprop(p.optinfo)^.Regs[Counter].StartMod^.previous := hp; if assigned(hp.previous) then hp.previous.next := hp; end; {$endif testing} if (ptaiprop(p.optinfo)^.regs[counter].typ in [con_const,con_noRemoveConst]) and (taicpu(ptaiprop(p.optinfo)^.Regs[Counter].StartMod).opsize = size) and (taicpu(ptaiprop(p.optinfo)^.Regs[Counter].StartMod).oper[0]^.typ = top_const) and (taicpu(ptaiprop(p.optinfo)^.Regs[Counter].StartMod).oper[0]^.val = l) then begin res:=taicpu(ptaiprop(p.optinfo)^.Regs[Counter].StartMod).oper[1]^.reg; result:=true; exit; end; inc(counter); until (Counter > RS_EDI); end; procedure removePrevNotUsedLoad(asml: TAsmList; p: tai; supreg: tsuperregister; check: boolean); { if check = true, it means the procedure has to check whether it isn't } { possible that the contents are still used after p (used when removing } { instructions because of a "call"), otherwise this is not necessary } { (e.g. when you have a "mov 8(%ebp),%eax", you can be sure the previous } { value of %eax isn't used anymore later on) } var hp1, next, beforestartmod: tai; begin if getLastInstruction(p,hp1) then with ptaiprop(hp1.optinfo)^.regs[supreg] do if (typ in [con_ref,con_invalid,con_const]) and (nrofMods = 1) and (rState = ptaiprop(startmod.optinfo)^.regs[supreg].rState) and (not(check) or (not(regInInstruction(supreg,p)) and (not(supreg in ptaiprop(hp1.optinfo)^.usedRegs) or findRegDealloc(supreg,p)))) then begin ptaiprop(startMod.optinfo)^.canBeRemoved := true; getnextinstruction(p,next); { give the register that was modified by this instruction again } { the contents it had before this instruction } if getlastinstruction(startmod,beforestartmod) then RestoreRegContentsTo(asml,supreg,ptaiprop(beforestartmod.optinfo)^.regs[supreg], startmod,hp1) else ClearRegContentsFrom(asml,supreg,startmod,hp1); end; end; {$ifdef notused} function is_mov_for_div(p: taicpu): boolean; begin is_mov_for_div := (p.opcode = A_MOV) and (p.oper[0]^.typ = top_const) and (p.oper[1]^.typ = top_reg) and (p.oper[1]^.reg = RS_EDX) and getNextInstruction(p,p) and (p.typ = ait_instruction) and ((p.opcode = A_DIV) or (p.opcode = A_IDIV)); end; {$endif notused} function memtoreg(t: taicpu; const ref: treference; var startp: tai): tregister; var hp: tai; p: ptaiprop; regcounter: tsuperregister; optimizable: boolean; begin memtoreg := NR_NO; if not getlastinstruction(t,hp) or not issimplememloc(ref) then exit; p := ptaiprop(hp.optinfo); optimizable := false; for regcounter := RS_EAX to RS_EDI do begin if (assigned(p^.regs[regcounter].memwrite) and refsequal(ref,p^.regs[regcounter].memwrite.oper[1]^.ref^)) then begin optimizable := true; hp := p^.regs[regcounter].memwrite; end else if ((p^.regs[regcounter].typ in [CON_REF,CON_NOREMOVEREF]) and (p^.regs[regcounter].nrofmods = 1) and ((taicpu(p^.regs[regcounter].startmod).opcode = A_MOV) or (taicpu(p^.regs[regcounter].startmod).opcode = A_MOVZX) or (taicpu(p^.regs[regcounter].startmod).opcode = A_MOVSX)) and (taicpu(p^.regs[regcounter].startmod).oper[0]^.typ = top_ref) and refsequal(ref,taicpu(p^.regs[regcounter].startmod).oper[0]^.ref^)) then begin optimizable := true; hp := p^.regs[regcounter].startmod; end; if optimizable then if ((t.opsize <> S_B) or not(regcounter in [RS_ESI,RS_EDI])) and sizescompatible(taicpu(hp).opsize,t.opsize) then begin case t.opsize of S_B: begin memtoreg := newreg(R_INTREGISTER,regcounter,R_SUBL) end; S_W,S_BW: begin memtoreg := newreg(R_INTREGISTER,regcounter,R_SUBW); if (t.opsize = S_BW) then begin t.opcode := A_MOV; t.opsize := S_W; end; end; S_L,S_BL,S_WL: begin memtoreg := newreg(R_INTREGISTER,regcounter,R_SUBWHOLE); if (t.opsize <> S_L) then begin t.opcode := A_MOV; t.opsize := S_L; end; end; end; startp := hp; exit; end; end; memtoreg := NR_NO; end; procedure removeLocalStores(const t1: tai); {var p: tai; regcount: tregister; } begin { for regcount := LoGPReg to HiGPReg do if assigned(pTaiProp(t1.optinfo)^.regs[regcount].memwrite) and (taicpu(pTaiProp(t1.optinfo)^.regs[regcount].memwrite).oper[1]^.ref^.base = current_procinfo.framepointer) then begin pTaiProp(pTaiProp(t1.optinfo)^.regs[regcount].memwrite.optinfo)^.canberemoved := true; clearmemwrites(pTaiProp(t1.optinfo)^.regs[regcount].memwrite,regcount); end; } end; procedure loadcseregs(asml: TAsmList; const reginfo: toptreginfo; curseqend, prevseqstart, curseqstart, curprev: tai; cnt: longint); var regsloaded: tregset; regloads, reguses: array[RS_EAX..RS_EDI] of tai; regcounter: tsuperregister; hp, hp2: tai; insertpos, insertoptinfo, prevseq_next: tai; i: longint; opc: tasmop; begin regsloaded := []; fillchar(regloads,sizeof(regloads),0); fillchar(reguses,sizeof(reguses),0); getnextinstruction(prevseqstart,prevseq_next); for regcounter := RS_EAX To RS_EDI do if (reginfo.new2oldreg[regcounter] <> RS_INVALID) Then begin include(regsloaded,regcounter); if assigned(ptaiprop(prevseqstart.optinfo)^.Regs[reginfo.new2oldreg[regcounter]].StartMod) then AllocRegBetween(asml,newreg(R_INTREGISTER,reginfo.new2oldreg[regcounter],R_SUBWHOLE), ptaiprop(prevseqstart.optinfo)^.Regs[reginfo.new2oldreg[regcounter]].StartMod,curseqstart, ptaiprop(ptaiprop(prevseqstart.optinfo)^.Regs[reginfo.new2oldreg[regcounter]].StartMod.optinfo)^.usedregs) else AllocRegBetween(asml,newreg(R_INTREGISTER,reginfo.new2oldreg[regcounter],R_SUBWHOLE), prevseqstart,curseqstart,ptaiprop(prevseqstart.optinfo)^.usedregs); if curprev <> prevseqstart then begin if assigned(reginfo.lastReload[regCounter]) then getLastInstruction(reginfo.lastReload[regCounter],hp) else if assigned(reginfo.lastReload[reginfo.new2oldreg[regCounter]]) then getLastInstruction(reginfo.lastReload[reginfo.new2OldReg[regCounter]],hp) else hp := curprev; clearRegContentsFrom(asml,regCounter,prevSeq_next,hp); getnextInstruction(hp,hp); allocRegBetween(asml,newreg(R_INTREGISTER,regCounter,R_SUBWHOLE),prevseqstart,hp, ptaiprop(prevseqstart.optinfo)^.usedregs); end; if not(regcounter in reginfo.RegsLoadedforRef) and {old reg new reg} (reginfo.new2oldreg[regcounter] <> regcounter) then begin getLastInstruction(curseqend,hp); opc := A_MOV; insertpos := prevseq_next; insertoptinfo := prevseqstart; if assigned(reguses[regcounter]) then if assigned(regloads[reginfo.new2oldreg[regcounter]]) then opc := A_XCHG else begin insertoptinfo := reguses[regcounter]; insertpos := tai(insertoptinfo.next) end else if assigned(regloads[reginfo.new2oldreg[regcounter]]) then begin insertpos := regloads[reginfo.new2oldreg[regcounter]]; if not getlastinstruction(insertpos,insertoptinfo) then internalerror(2006060701); end; hp := Tai_Marker.Create(mark_NoPropInfoStart); InsertLLItem(asml, insertpos.previous,insertpos, hp); hp2 := taicpu.Op_Reg_Reg(opc, S_L, {old reg new reg} newreg(R_INTREGISTER,reginfo.new2oldreg[regcounter],R_SUBWHOLE), newreg(R_INTREGISTER,regcounter,R_SUBWHOLE)); if (opc = A_XCHG) and (taicpu(regloads[reginfo.new2oldreg[regcounter]]).opcode <> A_XCHG) then begin asml.remove(regloads[reginfo.new2oldreg[regcounter]]); regloads[reginfo.new2oldreg[regcounter]].free; regloads[reginfo.new2oldreg[regcounter]] := hp2; reguses[regcounter] := hp2; end; regloads[regcounter] := hp2; reguses[reginfo.new2oldreg[regcounter]] := hp2; new(ptaiprop(hp2.optinfo)); ptaiprop(hp2.optinfo)^ := ptaiprop(insertoptinfo.optinfo)^; ptaiprop(hp2.optinfo)^.canBeRemoved := false; InsertLLItem(asml, insertpos.previous, insertpos, hp2); hp := Tai_Marker.Create(mark_NoPropInfoEnd); InsertLLItem(asml, insertpos.previous, insertpos, hp); { adjusts states in previous instruction so that it will } { definitely be different from the previous or next state } incstate(ptaiprop(hp2.optinfo)^. regs[reginfo.new2oldreg[regcounter]].rstate,20); incstate(ptaiprop(hp2.optinfo)^. regs[regCounter].wstate,20); updateState(reginfo.new2oldreg[regcounter],hp2); updateState(regcounter,hp2); end else { imagine the following code: } { normal wrong optimized } { movl 8(%ebp), %eax movl 8(%ebp), %eax } { movl (%eax), %eax movl (%eax), %eax } { cmpl 8(%ebp), %eax cmpl 8(%ebp), %eax } { jne l1 jne l1 } { movl 8(%ebp), %eax } { movl (%eax), %edi movl %eax, %edi } { movl %edi, -4(%ebp) movl %edi, -4(%ebp) } { movl 8(%ebp), %eax } { pushl 70(%eax) pushl 70(%eax) } { } { The error is that at the moment that the last instruction is executed, } { %eax doesn't contain 8(%ebp) anymore. Solution: the contents of } { registers that are completely removed from a sequence (= registers in } { RegLoadedforRef), have to be changed to their contents from before the } { sequence. } { if regcounter in reginfo.RegsLoadedforRef then } begin hp := curseqstart; { cnt still holds the number of instructions } { of the sequence, so go to the end of it } for i := 1 to pred(cnt) do getNextInstruction(hp,hp); { curprev = instruction prior to start of sequence } restoreRegContentsTo(asml,regCounter, ptaiprop(curprev.optinfo)^.Regs[regcounter], curseqstart,hp); end; end; end; procedure replaceoperandwithreg(asml: TAsmList; p: tai; opnr: byte; reg: tregister); var hp: tai; begin { new instruction -> it's info block is not in the big one allocated at the start } hp := Tai_Marker.Create(mark_NoPropInfoStart); InsertLLItem(asml, p.previous,p, hp); { duplicate the original instruction and replace it's designated operant with the register } hp := tai(p.getcopy); taicpu(hp).loadreg(opnr,reg); { add optimizer state info } new(ptaiprop(hp.optinfo)); ptaiprop(hp.optinfo)^ := ptaiprop(p.optinfo)^; { new instruction can not be removed } ptaiprop(hp.optinfo)^.canBeRemoved := false; { but the old one can } ptaiprop(p.optinfo)^.canBeRemoved := true; { insert end marker } InsertLLItem(asml, p.previous, p, hp); hp := Tai_Marker.Create(mark_NoPropInfoEnd); InsertLLItem(asml, p.previous, p, hp); end; procedure doCSE(asml: TAsmList; First, Last: tai; findPrevSeqs, doSubOpts: boolean); {marks the instructions that can be removed by RemoveInstructs. They're not removed immediately because sometimes an instruction needs to be checked in two different sequences} var cnt, cnt2, {cnt3,} orgNrofMods: longint; p, hp1, hp2, hp4, hp5, prevSeq: tai; reginfo: toptreginfo; memreg: tregister; regcounter: tsuperregister; begin p := First; SkipHead(p); hp1 := nil; hp2 := nil; hp4 := nil; hp5 := nil; cnt := 0; while (p <> Last) do begin case p.typ of ait_align: if not(tai_align(p).use_op) then SetAlignReg(p); ait_instruction: begin case taicpu(p).opcode of { Does not work anymore with register calling because the registers are released before the call A_CALL: for regCounter := RS_EAX to RS_EBX do removePrevNotUsedLoad(asml,p,regCounter,true); } A_CLD: if GetLastInstruction(p, hp1) and (ptaiprop(hp1.optinfo)^.DirFlag = F_NotSet) then ptaiprop(tai(p).optinfo)^.CanBeRemoved := True; A_LEA, A_MOV, A_MOVZX, A_MOVSX: begin hp2 := p; case taicpu(p).oper[0]^.typ of top_ref, top_reg: if (taicpu(p).oper[1]^.typ = top_reg) then begin With ptaiprop(p.optinfo)^.Regs[getsupreg(taicpu(p).oper[1]^.reg)] do begin if (startmod = p) then orgNrofMods := nrofMods else orgNrofMods := 0; if (p = StartMod) and GetLastInstruction (p, hp1) and not(hp1.typ in [ait_marker,ait_label]) then {so we don't try to check a sequence when p is the first instruction of the block} begin {$ifdef csdebug} hp5 := tai_comment.Create(strpnew( 'cse checking '+std_regname(taicpu(p).oper[1]^.reg))); insertLLItem(asml,p,p.next,hp5); {$endif csdebug} if CheckSequence(p,prevSeq,getsupreg(taicpu(p).oper[1]^.reg), Cnt, reginfo, findPrevSeqs) and (Cnt > 0) then begin (* hp1 := nil; { although it's perfectly ok to remove an instruction which doesn't contain } { the register that we've just checked (CheckSequence takes care of that), } { the sequence containing this other register should also be completely } { checked and removed, otherwise we may get situations like this: } { } { movl 12(%ebp), %edx movl 12(%ebp), %edx } { movl 16(%ebp), %eax movl 16(%ebp), %eax } { movl 8(%edx), %edx movl 8(%edx), %edx } { movl (%eax), eax movl (%eax), eax } { cmpl %eax, %edx cmpl %eax, %edx } { jnz l123 getting converted to jnz l123 } { movl 12(%ebp), %edx movl 4(%eax), eax } { movl 16(%ebp), %eax } { movl 8(%edx), %edx } { movl 4(%eax), eax } *) { not anymore: if the start of a new sequence is found while checking (e.g. } { above that of eax while checking edx, this new sequence is automatically } { also checked } Cnt2 := 1; while Cnt2 <= Cnt do begin {$ifndef noremove} ptaiprop(p.optinfo)^.CanBeRemoved := True {$endif noremove} ; inc(Cnt2); GetNextInstruction(p, p); end; {hp4 is used to get the contents of the registers before the sequence} GetLastInstruction(hp2, hp4); {$IfDef CSDebug} for regcounter := RS_EAX To RS_EDI do if (regcounter in reginfo.RegsLoadedforRef) then begin hp5 := tai_comment.Create(strpnew('New: '+std_regname(newreg(R_INTREGISTER,regcounter,R_SUBNONE))+', Old: '+ std_regname(newreg(R_INTREGISTER,reginfo.new2oldreg[regcounter],R_SUBNONE)))); InsertLLItem(asml, tai(hp2.previous), hp2, hp5); end; {$EndIf CSDebug} { if some registers were different in the old and the new sequence, move } { the contents of those old registers to the new ones } loadcseregs(asml,reginfo,p,prevseq,hp2,hp4,cnt); continue; end end; end; { try to replace the new reg with the old reg } if not(ptaiprop(p.optinfo)^.canBeRemoved) then if (taicpu(p).oper[0]^.typ = top_reg) and (taicpu(p).oper[1]^.typ = top_reg) and { only remove if we're not storing something in a regvar } (getsupreg(taicpu(p).oper[1]^.reg) in [RS_EAX,RS_EBX,RS_ECX,RS_EDX,RS_ESI,RS_EDI]) and { (taicpu(p).oper[1]^.reg in (rg.usableregsint+[RS_EDI])) and} (taicpu(p).opcode = A_MOV) and getLastInstruction(p,hp4) and { we only have to start replacing from the instruction after the mov, } { but replacereg only starts with getnextinstruction(p,p) } replaceReg(asml,getsupreg(taicpu(p).oper[0]^.reg), getsupreg(taicpu(p).oper[1]^.reg),p,p, ptaiprop(hp4.optinfo)^.regs[getsupreg(taicpu(p).oper[1]^.reg)],false,hp1) then begin ptaiprop(p.optinfo)^.canBeRemoved := true; { this is just a regular move that was here, so the source register should be } { allocated already at this point -> only allocate from here onwards } if not(getsupreg(taicpu(p).oper[0]^.reg) in pTaiProp(p.optinfo)^.usedregs) then internalerror(2004101011); allocRegBetween(asml,taicpu(p).oper[0]^.reg, p,hp1,pTaiProp(p.optinfo)^.usedregs) end else begin if (taicpu(p).oper[1]^.typ = top_reg) and not regInOp(getsupreg(taicpu(p).oper[1]^.reg),taicpu(p).oper[0]^) then removePrevNotUsedLoad(asml,p,getsupreg(taicpu(p).oper[1]^.reg),false); if doSubOpts and (taicpu(p).opcode <> A_LEA) and (taicpu(p).oper[0]^.typ = top_ref) then begin memreg := memtoreg(taicpu(p), taicpu(p).oper[0]^.ref^,hp5); if memreg <> NR_NO then if (taicpu(p).opcode = A_MOV) and (taicpu(p).oper[1]^.typ = top_reg) and (taicpu(p).oper[1]^.reg = memreg) then begin pTaiProp(p.optinfo)^.canberemoved := true; allocregbetween(asml,memreg,hp5,p,ptaiprop(hp5.optinfo)^.usedregs); end else begin replaceoperandwithreg(asml,p,0,memreg); allocregbetween(asml,memreg,hp5,p,ptaiprop(hp5.optinfo)^.usedregs); regcounter := getsupreg(memreg); incstate(pTaiProp(p.optinfo)^.regs[regcounter].rstate,1); updatestate(regcounter,p); end; end; end; { at first, only try optimizations of large blocks, because doing } { doing smaller ones may prevent bigger ones from completing in } { in the next pass } if not doSubOpts and (orgNrofMods <> 0) then begin p := hp2; for cnt := 1 to pred(orgNrofMods) do getNextInstruction(p,p); end; end; top_Const: begin case taicpu(p).oper[1]^.typ of Top_Reg: begin regCounter := getsupreg(taicpu(p).oper[1]^.reg); if GetLastInstruction(p, hp1) then With ptaiprop(hp1.optinfo)^.Regs[regCounter] do if (typ in [con_const,con_noRemoveConst]) and (taicpu(startMod).opsize >= taicpu(p).opsize) and opsequal(taicpu(StartMod).oper[0]^,taicpu(p).oper[0]^) then begin ptaiprop(p.optinfo)^.CanBeRemoved := True; allocRegBetween(asml,taicpu(p).oper[1]^.reg,startmod,p, ptaiprop(startmod.optinfo)^.usedregs); end else removePrevNotUsedLoad(asml,p,getsupreg(taicpu(p).oper[1]^.reg),false); end; Top_Ref: if (taicpu(p).oper[0]^.typ = top_const) and getLastInstruction(p,hp1) and findRegWithConst(hp1,taicpu(p).opsize,taicpu(p).oper[0]^.val,memreg) then begin taicpu(p).loadreg(0,memreg); { mark the used register as read } incstate(ptaiprop(p.optinfo)^. regs[getsupreg(memreg)].rstate,20); updateState(getsupreg(memreg),p); allocRegBetween(asml,memreg, ptaiprop(hp1.optinfo)^.regs[getsupreg(memreg)].startMod,p, ptaiprop(ptaiprop(hp1.optinfo)^.regs[getsupreg(memreg)].startMod.optinfo)^.usedregs); end; end; end; end; end; A_LEAVE: begin if getlastinstruction(p,hp1) then removeLocalStores(hp1); end; A_STD: if GetLastInstruction(p, hp1) and (ptaiprop(hp1.optinfo)^.DirFlag = F_Set) then ptaiprop(tai(p).optinfo)^.CanBeRemoved := True; else begin for cnt := 1 to maxinschanges do begin case InsProp[taicpu(p).opcode].Ch[cnt] of Ch_ROp1: if (taicpu(p).oper[0]^.typ = top_ref) and ((taicpu(p).opcode < A_F2XM1) or ((taicpu(p).opcode > A_IN) and (taicpu(p).opcode < A_OUT)) or (taicpu(p).opcode = A_PUSH) or ((taicpu(p).opcode >= A_RCL) and (taicpu(p).opcode <= A_XOR))) then begin memreg := memtoreg(taicpu(p), taicpu(p).oper[0]^.ref^,hp5); if memreg <> NR_NO then begin replaceoperandwithreg(asml,p,0,memreg); allocregbetween(asml,memreg,hp5,p,ptaiprop(hp5.optinfo)^.usedregs); regcounter := getsupreg(memreg); incstate(pTaiProp(p.optinfo)^.regs[regcounter].rstate,1); updatestate(regcounter,p); end; end; Ch_MOp1: if not(cs_opt_size in current_settings.optimizerswitches) and (taicpu(p).oper[0]^.typ = top_ref) then begin memreg := memtoreg(taicpu(p), taicpu(p).oper[0]^.ref^,hp5); if (memreg <> NR_NO) and (not getNextInstruction(p,hp1) or (RegLoadedWithNewValue(getsupreg(memreg),false,hp1) or FindRegDealloc(getsupreg(memreg),hp1))) then begin hp1 := Tai_Marker.Create(mark_NoPropInfoEnd); insertllitem(asml,p,p.next,hp1); hp1 := taicpu.op_reg_ref(A_MOV,reg2opsize(memreg), memreg,taicpu(p).oper[0]^.ref^); new(ptaiprop(hp1.optinfo)); pTaiProp(hp1.optinfo)^ := pTaiProp(p.optinfo)^; insertllitem(asml,p,p.next,hp1); regcounter := getsupreg(memreg); incstate(pTaiProp(hp1.optinfo)^.regs[regcounter].rstate,1); updatestate(regcounter,hp1); hp1 := Tai_Marker.Create(mark_NoPropInfoStart); insertllitem(asml,p,p.next,hp1); replaceoperandwithreg(asml,p,0,memreg); allocregbetween(asml,memreg,hp5, tai(p.next.next),ptaiprop(hp5.optinfo)^.usedregs); ClearRegContentsFrom(asml,regcounter,hp5,p); end; end; Ch_ROp2: if ((taicpu(p).opcode = A_CMP) or (taicpu(p).opcode = A_TEST)) and (taicpu(p).oper[1]^.typ = top_ref) then begin memreg := memtoreg(taicpu(p), taicpu(p).oper[1]^.ref^,hp5); if memreg <> NR_NO then begin replaceoperandwithreg(asml,p,1,memreg); allocregbetween(asml,memreg,hp5,p,ptaiprop(hp5.optinfo)^.usedregs); regcounter := getsupreg(memreg); incstate(pTaiProp(p.optinfo)^.regs[regcounter].rstate,1); updatestate(regcounter,p); end; end; Ch_MOp2: if not(cs_opt_size in current_settings.optimizerswitches) and (taicpu(p).oper[1]^.typ = top_ref) and ((taicpu(p).opcode < A_BT) or ((taicpu(p).opcode > A_IN) and (taicpu(p).opcode < A_OUT)) or (taicpu(p).opcode = A_PUSH) or ((taicpu(p).opcode >= A_RCL) and (taicpu(p).opcode <= A_XOR))) then begin memreg := memtoreg(taicpu(p), taicpu(p).oper[1]^.ref^,hp5); if (memreg <> NR_NO) and (not getNextInstruction(p,hp1) or (RegLoadedWithNewValue(getsupreg(memreg),false,hp1) or FindRegDealloc(getsupreg(memreg),hp1))) then begin hp1 := Tai_Marker.Create(mark_NoPropInfoEnd); insertllitem(asml,p,p.next,hp1); hp1 := taicpu.op_reg_ref(A_MOV,reg2opsize(memreg), memreg,taicpu(p).oper[1]^.ref^); new(ptaiprop(hp1.optinfo)); pTaiProp(hp1.optinfo)^ := pTaiProp(p.optinfo)^; insertllitem(asml,p,p.next,hp1); regcounter := getsupreg(memreg); incstate(pTaiProp(hp1.optinfo)^.regs[regcounter].rstate,1); updatestate(regcounter,hp1); hp1 := Tai_Marker.Create(mark_NoPropInfoStart); insertllitem(asml,p,p.next,hp1); replaceoperandwithreg(asml,p,1,memreg); allocregbetween(asml,memreg,hp5, tai(p.next.next),ptaiprop(hp5.optinfo)^.usedregs); ClearRegContentsFrom(asml,regcounter,hp5,p); end; end; end; end; end; end end; end; GetNextInstruction(p, p); end; end; function removeInstructs(asml: TAsmList; first, last: tai): boolean; { Removes the marked instructions and disposes the PTaiProps of the other } { instructions } var p, hp1: tai; nopropinfolevel: longint; begin removeInstructs := false; p := First; nopropinfolevel := 0; while (p <> Last) do begin if (p.typ = ait_marker) and (Tai_marker(p).kind = mark_NoPropInfoStart) then begin hp1 := tai(p.next); asml.remove(p); p.free; nopropinfolevel := 1; while (nopropinfolevel <> 0) do begin p := tai(hp1.next); {$ifndef noinstremove} { allocregbetween can insert new ait_regalloc objects } { without optinfo } if (hp1.typ = ait_marker) then begin case Tai_marker(hp1).kind of { they can be nested! } mark_NoPropInfoStart: inc(nopropinfolevel); mark_NoPropInfoEnd: dec(nopropinfolevel); else begin hp1 := p; continue; end; end; asml.remove(hp1); hp1.free; end else if assigned(hp1.optinfo) then if ptaiprop(hp1.optinfo)^.canBeRemoved then begin dispose(ptaiprop(hp1.optinfo)); hp1.optinfo := nil; asml.remove(hp1); hp1.free; end else {$endif noinstremove} begin dispose(ptaiprop(hp1.optinfo)); hp1.optinfo := nil; end; hp1 := p; end; end else {$ifndef noinstremove} if assigned(p.optinfo) and ptaiprop(p.optinfo)^.canBeRemoved then begin hp1 := tai(p.next); asml.Remove(p); p.free; p := hp1; removeInstructs := true; end else {$endif noinstremove} begin p.optinfo := nil; p := tai(p.next); end; end; end; function CSE(asml: TAsmList; First, Last: tai; pass: longint): boolean; begin doCSE(asml, First, Last, not(cs_opt_level3 in current_settings.optimizerswitches) or (pass >= 2), not(cs_opt_level3 in current_settings.optimizerswitches) or (pass >= 1)); { register renaming } if not(cs_opt_level3 in current_settings.optimizerswitches) or (pass > 0) then doRenaming(asml, first, last); cse := removeInstructs(asml, first, last); end; end.