mirror of
https://gitlab.com/freepascal.org/fpc/source.git
synced 2025-07-31 20:06:22 +02:00
1204 lines
44 KiB
ObjectPascal
1204 lines
44 KiB
ObjectPascal
{
|
|
$Id$
|
|
Copyright (c) 1999 by Jonas Maebe, member of the Free Pascal
|
|
Development Team
|
|
|
|
This unit contains the processor independent assembler optimizer
|
|
object.
|
|
|
|
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 AoptObj;
|
|
|
|
{ general, processor independent objects for use by the assembler optimizer }
|
|
|
|
Interface
|
|
|
|
uses Cobjects, cpubase, aoptcpub;
|
|
|
|
{***************** Constants *****************}
|
|
|
|
Const
|
|
|
|
{ ait_* types which don't result in executable code or which don't influence }
|
|
{ the way the program runs/behaves }
|
|
|
|
SkipInstr = [ait_comment, ait_align, ait_symbol
|
|
{$ifdef GDB}
|
|
,ait_stabs, ait_stabn, ait_stab_function_name
|
|
{$endif GDB}
|
|
,ait_regalloc, ait_tempalloc
|
|
];
|
|
|
|
{Possible register content types}
|
|
con_Unknown = 0;
|
|
con_ref = 1;
|
|
con_const = 2;
|
|
|
|
{***************** Types ****************}
|
|
|
|
Type
|
|
|
|
TRegArray = Array[LoReg..HiReg] of TRegister;
|
|
TRegSet = Set of LoReg..HiReg;
|
|
PRegInfo = ^TReginfo;
|
|
|
|
{ info about the equivalence of registers when comparing two code sequences}
|
|
TRegInfo = Object
|
|
{ registers encountered in the new and old sequence }
|
|
NewRegsEncountered, OldRegsEncountered,
|
|
{ registers which only have been loaded for use as base or }
|
|
{ index in a reference later on }
|
|
RegsLoadedForRef: TRegSet;
|
|
{ to which register in the old sequence corresponds every }
|
|
{ register in the new sequence }
|
|
New2OldReg: TRegArray;
|
|
|
|
Constructor init;
|
|
{ clear all information store in the object }
|
|
Procedure Clear;
|
|
{ the contents of OldReg in the old sequence are now being }
|
|
{ loaded into NewReg in the new sequence }
|
|
Procedure AddReg(OldReg, NewReg: TRegister); Virtual;
|
|
{ the contents of OldOp in the old sequence are now being }
|
|
{ loaded into NewOp in the new sequence. It is assumed that }
|
|
{ OldOp and NewOp are equivalent }
|
|
Procedure AddOp(const OldOp, NewOp:Toper);
|
|
{ check if a register in the old sequence (OldReg) can be }
|
|
{ equivalent to a register in the new sequence (NewReg) if }
|
|
{ the operation OpAct is performed on it. The RegInfo is }
|
|
{ updated (not necessary to call AddReg afterwards }
|
|
Function RegsEquivalent(OldReg, NewReg: TRegister;
|
|
OpAct: TopAction): Boolean;
|
|
{ check if a reference in the old sequence (OldRef) can be }
|
|
{ equivalent to a reference in the new sequence (NewRef) if }
|
|
{ the operation OpAct is performed on it. The RegInfo is }
|
|
{ updated (not necessary to call AddOp afterwards }
|
|
Function RefsEquivalent(Const OldRef, NewRef: TReference;
|
|
OpAct: TOpAction): Boolean;
|
|
{ check if an operand in the old sequence (OldOp) can be }
|
|
{ equivalent to an operand in the new sequence (NewOp) if }
|
|
{ the operation OpAct is performed on it. The RegInfo is }
|
|
{ updated (not necessary to call AddOp afterwards }
|
|
Function OpsEquivalent(const OldOp, NewOp: toper;
|
|
OpAct: TopAction): Boolean;
|
|
{ check if an instruction in the old sequence (OldP) can be }
|
|
{ equivalent to an instruction in the new sequence (Newp) }
|
|
{ The RegInfo is updated }
|
|
Function InstructionsEquivalent(OldP, NewP: Pai): Boolean;
|
|
End;
|
|
|
|
|
|
{ possible actions on an operand: read, write or modify (= read & write) }
|
|
TOpAction = (OpAct_Read, OpAct_Write, OpAct_Modify, OpAct_Unknown);
|
|
|
|
{ the properties of a cpu instruction }
|
|
TAsmInstrucProp = Record
|
|
{ what it changes }
|
|
Ch: Array[1..MaxCh] of TChange;
|
|
End;
|
|
|
|
{ Object to hold on information on which regiters are in use and which not }
|
|
TUsedRegs = Object
|
|
Constructor init;
|
|
Constructor InitWithValue(_RegSet: TRegSet);
|
|
{ update the info with the pairegalloc objects coming after }
|
|
{ p }
|
|
Procedure Update(p: Pai);
|
|
{ is Reg currently in use }
|
|
Function IsUsed(Reg: TRegister): Boolean;
|
|
{ get all the currently used registers }
|
|
Function GetUsedRegs: TRegSet;
|
|
Destructor Done;
|
|
|
|
Private
|
|
|
|
UsedRegs: TRegSet;
|
|
End;
|
|
|
|
{ size of the integer that holds the state number of a register. Can be any }
|
|
{ integer type, so it can be changed to reduce the size of the TContent }
|
|
{ structure or to improve alignment }
|
|
TStateInt = Byte;
|
|
|
|
TContent = Packed Record
|
|
{ start and end of block instructions that defines the }
|
|
{ content of this register. If Typ = con_const, then }
|
|
{ Longint(StartMod) = value of the constant) } }
|
|
StartMod: pai;
|
|
{ starts at 0, gets increased everytime the register is }
|
|
{ written to }
|
|
WState: TStateInt;
|
|
{ starts at 0, gets increased everytime the register is read }
|
|
{ from }
|
|
RState: TStateInt;
|
|
{ how many instructions starting with StarMod does the block }
|
|
{ consist of }
|
|
NrOfMods: Byte;
|
|
{ the type of the content of the register: unknown, memory }
|
|
{ (variable) or constant }
|
|
Typ: Byte;
|
|
End;
|
|
|
|
{ Contents of the integer registers }
|
|
|
|
TRegContent = Array[LoGPReg..HiGPReg] Of TContent;
|
|
|
|
PPaiProp = ^TPaiProp;
|
|
|
|
{ information object with the contents of every register. Every Pai object }
|
|
{ gets one of these assigned: a pointer to it is stored in the OptInfo field }
|
|
TPaiProp = Object
|
|
Regs: TRegContent;
|
|
{ info about allocation of general purpose integer registers }
|
|
UsedRegs: TUsedRegs;
|
|
{ info about the conditional registers }
|
|
CondRegs: TCondRegs;
|
|
{ can this instruction be removed? }
|
|
CanBeRemoved: Boolean;
|
|
|
|
Constructor init;
|
|
|
|
{ destroy the contents of a register, as well as those whose }
|
|
{ contents are based on those of that register }
|
|
Procedure DestroyReg(Reg: TRegister; var NrOfInstrSinceLastMod:
|
|
TInstrSinceLastMod);
|
|
{ if the contents of WhichReg (can be R_NO in case of a }
|
|
{ constant) are written to memory at the location Ref, the }
|
|
{ contents of the registers that depend on Ref have to be }
|
|
{ destroyed }
|
|
Procedure DestroyRefs(Const Ref: TReference; WhichReg: TRegister);
|
|
{ an instruction reads from operand o }
|
|
Procedure ReadOp(const o:toper);
|
|
{ an instruction reads from reference Ref }
|
|
Procedure ReadRef(Ref: PReference);
|
|
{ an instruction reads from register Reg }
|
|
Procedure ReadReg(Reg: TRegister);
|
|
{ an instruction writes/modifies operand o and this has }
|
|
{ special side-effects or modifies the contents in such a }
|
|
{ way that we can't simply add this instruction to the }
|
|
{ sequence of instructions that describe the contents of the }
|
|
{ operand, so destroy it }
|
|
Procedure DestroyOp(const o:Toper);
|
|
{ destroy the contetns of all registers }
|
|
Procedure DestroyAllRegs;
|
|
{$ifdef arithopt}
|
|
{ a register's contents are modified, but not destroyed }
|
|
{ (the new value depends on the old one) }
|
|
Procedure ModifyReg(reg: TRegister);
|
|
{ an operand's contents are modified, but not destroyed }
|
|
{ (the new value depends on the old one) }
|
|
Procedure ModifyOp(const oper: TOper);
|
|
{$endif arithopt}
|
|
|
|
{ increase the write state of a register (call every time a }
|
|
{ register is written to) }
|
|
Procedure IncWState(Reg: TRegister);
|
|
{ increase the read state of a register (call every time a }
|
|
{ register is read from }
|
|
Procedure IncRState(Reg: TRegister);
|
|
{ get the write state of a register }
|
|
Function GetWState(Reg: TRegister): TStateInt;
|
|
{ get the read state of a register }
|
|
Function GetRState(Reg: TRegister): TStateInt;
|
|
|
|
{ get the type of contents of a register }
|
|
Function GetRegContentKind(Reg: TRegister): Byte;
|
|
|
|
Destructor Done;
|
|
|
|
Private
|
|
|
|
Procedure IncState(Reg: TRegister);
|
|
|
|
End;
|
|
|
|
{ the number of instructions that we have encountered since the last }
|
|
{ modification of a register }
|
|
TInstrSinceLastMod = Array[LoGPReg..HiGPReg] Of Byte;
|
|
|
|
TLabelTableItem = Record
|
|
PaiObj: Pai;
|
|
{$IfDef JumpAnal}
|
|
InstrNr: Longint;
|
|
RefsFound: Word;
|
|
JmpsProcessed: Word
|
|
{$EndIf JumpAnal}
|
|
End;
|
|
|
|
TLabelTable = Array[0..2500000] Of TLabelTableItem;
|
|
PLabelTable = ^TLabelTable;
|
|
TLabelInfo = Record
|
|
{ the highest and lowest label number occurring in the current code }
|
|
{ fragment }
|
|
LowLabel, HighLabel: AWord;
|
|
LabelDif: AWord;
|
|
{ table that contains the addresses of the Pai_Label objects associated }
|
|
{ with each label number }
|
|
LabelTable: PLableTable;
|
|
End;
|
|
|
|
|
|
{***** General optimizer object, used to derive others from *****}
|
|
|
|
Type TAOptObj = Object
|
|
{ the PAasmOutput list this optimizer instance works on }
|
|
AsmL: PAasmOutput;
|
|
|
|
{ The labelinfo record contains the addresses of the Pai objects }
|
|
{ that are labels, how many labels there are and the min and max }
|
|
{ label numbers }
|
|
LabelInfo: PLabelInfo;
|
|
|
|
{ Start and end of the block that is currently being optimized }
|
|
BlockStart, BlockEnd: Pai;
|
|
|
|
{ _AsmL is the PAasmOutpout list that has to be optimized, }
|
|
{ _BlockStart and _BlockEnd the start and the end of the block }
|
|
{ that has to be optimized and _LabelInfo a pointer to a }
|
|
{ TLabelInfo record }
|
|
Constructor Init(_AsmL: PAasmOutput; _BlockStart, _BlockEnd: Pai;
|
|
_LabelInfo: PLabelInfo);
|
|
|
|
{ processor independent methods }
|
|
|
|
{ returns true if the label L is found between hp and the next }
|
|
{ instruction }
|
|
Function FindLabel(L: PasmLabel; Var hp: Pai): Boolean;
|
|
|
|
{ inserts new_one between prev and foll in AsmL }
|
|
Procedure InsertLLItem(AsmL: PAasmOutput; prev, foll, new_one:
|
|
PLinkedList_Item);
|
|
|
|
{ returns true if register Reg is used by instruction p1 }
|
|
Function RegInInstruction(Reg: TRegister; p1: Pai): Boolean;
|
|
{ returns true if register Reg is used in the reference Ref }
|
|
Function RegInRef(Reg: TRegister; Const Ref: TReference): Boolean;
|
|
{ returns whether the reference Ref is used somewhere in the loading }
|
|
{ sequence Constent }
|
|
Function TAOptObj.RefInSequence(Const Ref: TReference;
|
|
Content: TContent): Boolean;
|
|
{ returns whether the instruction P reads from and/or writes to Reg }
|
|
Function TAOptObj.RefInInstruction(Const Ref: TReference; p: Pai): Boolean;
|
|
{ returns true if the instruction p1 modifies the register Reg }
|
|
Function RegModifiedByInstruction(Reg: TRegister; p1: Pai): Boolean;
|
|
|
|
{ gets the next Pai object after current that contains info relevant }
|
|
{ to the optimizer in p1. If there is none, it returns false and }
|
|
{ sets p1 to nil }
|
|
Function GetNextInstruction(Current: Pai; Var Next: Pai): Boolean;
|
|
{ gets the previous Pai object after current that contains info }
|
|
{ relevant to the optimizer in last. If there is none, it retuns }
|
|
{ false and sets last to nil }
|
|
Function GetLastInstruction(Current: Pai; Var Last: Pai): Boolean;
|
|
{ If P is a Pai object releveant to the optimizer, it is left }
|
|
{ unchanged. If it is not relevant tot he optimizer, the first }
|
|
{ object after P that is relevant is stored in P }
|
|
Procedure SkipHead(var P: Pai);
|
|
|
|
{ returns true if the operands o1 and o2 are completely equal }
|
|
Function OpsEqual(const o1,o2:toper): Boolean;
|
|
|
|
{ Returns true if a ait_alloc object for Reg is found in the block }
|
|
{ of Pai's starting with StartPai and ending with the next "real" }
|
|
{ instruction }
|
|
Function FindRegAlloc(Reg: TRegister; StartPai: Pai): Boolean;
|
|
|
|
{ processor dependent methods }
|
|
|
|
{ returns the maximum width component of Reg. Only has to be }
|
|
{ overridden for the 80x86 (afaik) }
|
|
Function RegMaxSize(Reg: TRegister): TRegister; Virtual;
|
|
{ returns true if Reg1 and Reg2 are of the samae width. Only has to }
|
|
{ overridden for the 80x86 (afaik) }
|
|
Function RegsSameSize(Reg1, Reg2: TRegister): Boolean; Virtual;
|
|
{ returns whether P is a load instruction (load contents from a }
|
|
{ memory location or (register) variable into a register) }
|
|
Function IsLoadInstr(p: pai): Boolean; Virtual;
|
|
{ returns whether P is a store instruction (store contents from a }
|
|
{ register to a memory location or to a (register) variable) }
|
|
Function IsStoreInstr(p: pai): Boolean; Virtual;
|
|
{ returns whether the instruction P reads from register Reg }
|
|
Function RegReadByInstr(Reg: TRegister; p: Pai); Virtual;
|
|
{ convert a TChange value into the corresponding register }
|
|
Function TCh2Reg(Ch: TChange): TRegister; Virtual;
|
|
End;
|
|
|
|
{***************** Implementation *****************}
|
|
|
|
Implementation
|
|
|
|
{*********************** TReginfo ***********************}
|
|
|
|
Constructor TRegInfo.Init;
|
|
Begin
|
|
Clear;
|
|
End;
|
|
|
|
Constructor TRegInfo.Init;
|
|
Begin
|
|
RegsLoadedForRef := [];
|
|
NewRegsEncountered := [ProcInfo.FramePointer, R_ESP];
|
|
OldRegsEncountered := [ProcInfo.FramePointer, R_ESP];
|
|
New2OldReg[ProcInfo.FramePointer] := ProcInfo.FramePointer;
|
|
New2OldReg[R_ESP] := R_ESP;
|
|
End;
|
|
|
|
Procedure TRegInfo.AddReg(OldReg, NewReg: TRegister);
|
|
{ updates the ???RegsEncountered and ???2???Reg fields of RegInfo. Assumes }
|
|
{ that OldReg and NewReg have the same size (has to be chcked in advance }
|
|
{ with RegsSameSize) and that neither equals R_NO }
|
|
{ has to be overridden for architectures like the 80x86 when not all GP }
|
|
{ regs are of the same size }
|
|
Begin
|
|
NewRegsEncountered := NewRegsEncountered + [NewReg];
|
|
OldRegsEncountered := OldRegsEncountered + [OldReg];
|
|
New2OldReg[NewReg] := OldReg;
|
|
End;
|
|
|
|
Procedure TRegInfo.AddOp(const OldOp, NewOp:Toper);
|
|
Begin
|
|
Case OldOp.typ Of
|
|
Top_Reg:
|
|
If (OldOp.reg <> R_NO) Then
|
|
AddReg(OldOp.reg, NewOp.reg);
|
|
Top_Ref:
|
|
Begin
|
|
If OldOp.ref^.base <> R_NO Then
|
|
AddReg(OldOp.ref^.base, NewOp.ref^.base);
|
|
{$ifdef RefsHaveIndexReg}
|
|
If OldOp.ref^.index <> R_NO Then
|
|
AddReg(OldOp.ref^.index, NewOp.ref^.index);
|
|
{$endif RefsHaveIndexReg}
|
|
End;
|
|
End;
|
|
End;
|
|
|
|
Function TRegInfo.RegsEquivalent(OldReg, NewReg: TRegister;
|
|
OPAct: TOpAction): Boolean;
|
|
Begin
|
|
If Not((OldReg = R_NO) Or (NewReg = R_NO)) Then
|
|
If RegsSameSize(OldReg, NewReg) Then
|
|
{here we always check for the 32 bit component, because it is possible that
|
|
the 8 bit component has not been set, event though NewReg already has been
|
|
processed. This happens if it has been compared with a register that doesn't
|
|
have an 8 bit component (such as EDI). In that case the 8 bit component is
|
|
still set to R_NO and the comparison in the Else-part will fail}
|
|
If (RegMaxSize(OldReg) in OldRegsEncountered) Then
|
|
If (RegMaxSize(NewReg) in NewRegsEncountered) Then
|
|
RegsEquivalent := (OldReg = New2OldReg[NewReg])
|
|
|
|
{ If we haven't encountered the new register yet, but we have encountered the
|
|
old one already, the new one can only be correct if it's being written to
|
|
(and consequently the old one is also being written to), otherwise
|
|
|
|
movl -8(%ebp), %eax and movl -8(%ebp), %eax
|
|
movl (%eax), %eax movl (%edx), %edx
|
|
|
|
are considered equivalent}
|
|
|
|
Else
|
|
If (OpAct = OpAct_Write) Then
|
|
Begin
|
|
AddReg(OldReg, NewReg);
|
|
RegsEquivalent := True
|
|
End
|
|
Else Regsequivalent := False
|
|
Else
|
|
If Not(RegMaxSize(NewReg) in NewRegsEncountered) Then
|
|
Begin
|
|
AddReg(OldReg, NewReg);
|
|
RegsEquivalent := True
|
|
End
|
|
Else RegsEquivalent := False
|
|
Else RegsEquivalent := False
|
|
Else RegsEquivalent := OldReg = NewReg
|
|
End;
|
|
|
|
Function TRegInfo.RefsEquivalent(Const OldRef, NewRef: TReference;
|
|
OpAct: TOpAction): Boolean;
|
|
Begin
|
|
If OldRef.is_immediate Then
|
|
RefsEquivalent := NewRef.is_immediate and (OldRef.Offset = NewRef.Offset)
|
|
Else
|
|
RefsEquivalent := (OldRef.Offset+OldRef.OffsetFixup =
|
|
NewRef.Offset+NewRef.OffsetFixup) And
|
|
RegsEquivalent(OldRef.Base, NewRef.Base, OpAct)
|
|
{$ifdef RefsHaveindex}
|
|
And RegsEquivalent(OldRef.Index, NewRef.Index, OpAct)
|
|
{$endif RefsHaveIndex}
|
|
{$ifdef RefsHaveScale}
|
|
And (OldRef.ScaleFactor = NewRef.ScaleFactor)
|
|
{$endif RefsHaveScale}
|
|
And (OldRef.Symbol = NewRef.Symbol)
|
|
{$ifdef RefsHaveSegment}
|
|
And (OldRef.Segment = NewRef.Segment)
|
|
{$endif RefsHaveSegment}
|
|
;
|
|
End;
|
|
|
|
Function TRegInfo.OpsEquivalent(const OldOp, NewOp: toper; OpAct: TopAction):
|
|
Boolean;
|
|
Begin {checks whether the two ops are equivalent}
|
|
OpsEquivalent := False;
|
|
if OldOp.typ=NewOp.typ then
|
|
Case OldOp.typ Of
|
|
Top_Const: OpsEquivalent := OldOp.value = NewOp.value;
|
|
Top_Reg:
|
|
OpsEquivalent := RegsEquivalent(OldOp.reg,NewOp.reg, OpAct);
|
|
Top_Ref:
|
|
OpsEquivalent := RefsEquivalent(OldOp.ref^, NewOp.ref^, OpAct);
|
|
Top_None:
|
|
OpsEquivalent := True
|
|
End;
|
|
End;
|
|
|
|
Function TRegInfo.InstructionsEquivalent(OldP, NewP: Pai): Boolean;
|
|
{ checks whether two PInstr instructions are equal }
|
|
Var Count: TNatInt;
|
|
TmpResult: Boolean;
|
|
Begin
|
|
If Assigned(OldP) And Assigned(NewP) And
|
|
(Pai(OldP)^.typ = ait_instruction) And
|
|
(Pai(NewP)^.typ = ait_instruction) And
|
|
(PInstr(OldP)^.opcode = PInstr(NewP)^.opcode) And
|
|
(PInstr(OldP)^.oper[0].typ = PInstr(NewP)^.oper[0].typ) And
|
|
(PInstr(OldP)^.oper[1].typ = PInstr(NewP)^.oper[1].typ) And
|
|
(PInstr(OldP)^.oper[2].typ = PInstr(NewP)^.oper[2].typ)
|
|
Then
|
|
{ both instructions have the same structure: }
|
|
{ "<operator> <operand of type1>, <operand of type 2>" }
|
|
If IsLoadInstr(OldP) {then also NewP = loadinstr} Then
|
|
If Not(RegInRef(PInstr(OldP)^.oper[LoadDst].reg,
|
|
PInstr(OldP)^.oper[LoadSrc].ref^)) Then
|
|
{ the "old" instruction is a load of a register with a new value, not with }
|
|
{ a value based on the contents of this register (so no "mov (reg), reg") }
|
|
If Not(RegInRef(PInstr(NewP)^.oper[LoadDst].reg,
|
|
PInstr(NewP)^.oper[LoadSrc].ref^)) And
|
|
RefsEqual(PInstr(OldP)^.oper[LoadSrc].ref^,
|
|
PInstr(NewP)^.oper[LoadSrc].ref^)
|
|
Then
|
|
{ the "new" instruction is also a load of a register with a new value, and }
|
|
{ this value is fetched from the same memory location }
|
|
Begin
|
|
With PInstr(NewP)^.oper[LoadSrc].ref^ Do
|
|
Begin
|
|
If Not(Base in [ProcInfo.FramePointer, R_NO, StackPtr])
|
|
{ it won't do any harm if the register is already in RegsLoadedForRef }
|
|
Then RegsLoadedForRef := RegsLoadedForRef + [Base];
|
|
{$ifdef RefsHaveIndex}
|
|
If Not(Index in [ProcInfo.FramePointer, R_NO, R_StackPtr])
|
|
Then RegsLoadedForRef := RegsLoadedForRef + [Index];
|
|
{$endif RefsHaveIndex}
|
|
End;
|
|
{ add the registers from the reference (.oper[Src]) to the RegInfo, all }
|
|
{ registers from the reference are the same in the old and in the new }
|
|
{ instruction sequence }
|
|
AddOp(PInstr(OldP)^.oper[Src], PInstr(OldP)^.oper[Src]);
|
|
{ the registers from .oper[Dest] have to be equivalent, but not necessarily }
|
|
{ equal }
|
|
InstructionsEquivalent :=
|
|
RegsEquivalent(PInstr(OldP)^.oper[Dest].reg,
|
|
PInstr(NewP)^.oper[Dest].reg, OpAct_Write);
|
|
End
|
|
{ the registers are loaded with values from different memory locations. If }
|
|
{ this were allowed, the instructions "mov -4(%esi),%eax" and }
|
|
{ "mov -4(%ebp),%eax" would be considered equivalent }
|
|
Else InstructionsEquivalent := False
|
|
Else
|
|
{ load register with a value based on the current value of this register }
|
|
Begin
|
|
With PInstr(NewP)^.oper[0].ref^ Do
|
|
{ Assume the registers occurring in the reference have only been loaded with }
|
|
{ the value they contain now to calculate an address (so the value they have }
|
|
{ now, won't be stored to memory later on)}
|
|
Begin
|
|
If Not(Base in [ProcInfo.FramePointer,
|
|
RegMaxSize(PInstr(NewP)^.oper[LoadDst].reg),
|
|
R_NO,StackPtr])
|
|
{ It won't do any harm if the register is already in RegsLoadedForRef }
|
|
Then
|
|
Begin
|
|
RegsLoadedForRef := RegsLoadedForRef + [Base];
|
|
{$ifdef csdebug}
|
|
Writeln(att_reg2str[base], ' added');
|
|
{$endif csdebug}
|
|
end;
|
|
{$Ifdef RefsHaveIndex}
|
|
If Not(Index in [ProcInfo.FramePointer,
|
|
RegMaxSize(PInstr(NewP)^.oper[LoadDst].reg),
|
|
R_NO,StackPtr])
|
|
Then
|
|
Begin
|
|
RegsLoadedForRef := RegsLoadedForRef + [Index];
|
|
{$ifdef csdebug}
|
|
Writeln(att_reg2str[index], ' added');
|
|
{$endif csdebug}
|
|
end;
|
|
{$endif RefsHaveIndex}
|
|
End;
|
|
|
|
{ now, remove the destination register of the load from the }
|
|
{ RegsLoadedForReg, since if it's loaded with a new value, it certainly }
|
|
{ will still be used later on }
|
|
If Not(RegMaxSize(PInstr(NewP)^.oper[LoadDst].reg) In
|
|
[ProcInfo.FramePointer,R_NO,StackPtr])
|
|
Then
|
|
Begin
|
|
RegsLoadedForRef := RegsLoadedForRef -
|
|
[RegMaxSize(PInstr(NewP)^.oper[LoadDst].reg)];
|
|
{$ifdef csdebug}
|
|
Writeln(att_reg2str[Reg32(Pai386(NewP)^.oper[1].reg)], ' removed');
|
|
{$endif csdebug}
|
|
end;
|
|
InstructionsEquivalent :=
|
|
OpsEquivalent(PInstr(OldP)^.oper[LoadSrc],
|
|
PInstr(NewP)^.oper[LoadSrc], OpAct_Read) And
|
|
OpsEquivalent(PInstr(OldP)^.oper[LoadDst],
|
|
PInstr(NewP)^.oper[LoadDst], OpAct_Write)
|
|
End
|
|
Else
|
|
{an instruction that's not a load instruction}
|
|
Begin
|
|
Count := 0;
|
|
TmpResult := true;
|
|
Repeat
|
|
TmpResult :=
|
|
OpsEquivalent(PInstr(OldP)^.oper[Count], PInstr(NewP)^.oper[Count],
|
|
OpAct_Unknown);
|
|
Inc(Count)
|
|
Until (Count = MaxOps) or not(TmpResult);
|
|
InstructionsEquivalent := TmpResult
|
|
End
|
|
{ the instructions haven't even got the same structure, so they're certainly }
|
|
{ not equivalent }
|
|
Else InstructionsEquivalent := False;
|
|
End;
|
|
|
|
{*************************** TUsedRegs ***************************}
|
|
|
|
Constructor TUsedRegs.init;
|
|
Begin
|
|
UsedRegs := [];
|
|
End;
|
|
|
|
Constructor TUsedRegisters.InitWithValue(Const _RegSet: TRegSet);
|
|
Begin
|
|
RegSet := _RegSet;
|
|
End;
|
|
|
|
Procedure TUsedRegs.Update(p: Pai);
|
|
{updates UsedRegs with the RegAlloc Information coming after P}
|
|
Begin
|
|
Repeat
|
|
While Assigned(p) And
|
|
((p^.typ in (SkipInstr - [ait_RegAlloc])) or
|
|
((p^.typ = ait_label) And
|
|
Not(Pai_Label(p)^.l^.is_used))) Do
|
|
p := Pai(p^.next);
|
|
While Assigned(p) And
|
|
(p^.typ=ait_RegAlloc) Do
|
|
Begin
|
|
if pairegalloc(p)^.allocation then
|
|
UsedRegs := UsedRegs + [PaiRegAlloc(p)^.Reg]
|
|
else
|
|
UsedRegs := UsedRegs - [PaiRegAlloc(p)^.Reg];
|
|
p := pai(p^.next);
|
|
End;
|
|
Until Not(Assigned(p)) Or
|
|
(Not(p^.typ in SkipInstr) And
|
|
Not((p^.typ = ait_label) And
|
|
Not(Pai_Label(p)^.l^.is_used)));
|
|
End;
|
|
|
|
Function TUsedRegs.IsUsed(Reg: TRegister): Boolean;
|
|
Begin
|
|
IsUsed := Reg in UsedRegs
|
|
End;
|
|
|
|
Function TUsedRegs.GetUsedRegs: TRegSet;
|
|
Begin
|
|
GetUsedRegs := UsedRegs;
|
|
End;
|
|
|
|
{*************************** TPaiProp ***************************}
|
|
|
|
Constructor TPaiProp.Init;
|
|
Begin
|
|
UsedRegs.Init;
|
|
CondRegs.init;
|
|
{ DirFlag: TFlagContents; I386 specific}
|
|
End;
|
|
|
|
Procedure TPaiProp.DestroyReg(Reg: TRegister; var NrOfInstrSinceLastMod:
|
|
TInstrSinceLastMod);
|
|
{ Destroys the contents of the register Reg in the PPaiProp p1, as well as }
|
|
{ the contents of registers are loaded with a memory location based on Reg }
|
|
Var TmpWState, TmpRState: Byte;
|
|
Counter: TRegister;
|
|
Begin
|
|
Reg := Reg32(Reg);
|
|
NrOfInstrSinceLastMod[Reg] := 0;
|
|
If (Reg >= R_EAX) And (Reg <= R_EDI)
|
|
Then
|
|
Begin
|
|
With Regs[Reg] Do
|
|
Begin
|
|
IncState(WState);
|
|
TmpWState := WState;
|
|
TmpRState := RState;
|
|
FillChar(Regs[Reg], SizeOf(TContent), 0);
|
|
WState := TmpWState;
|
|
RState := TmpRState;
|
|
End;
|
|
For Counter := R_EAX to R_EDI Do
|
|
With Regs[Counter] Do
|
|
If (Typ = Con_Ref) And
|
|
RegInSequence(Reg, Regs[Counter])
|
|
Then
|
|
Begin
|
|
IncState(WState);
|
|
TmpWState := WState;
|
|
TmpRState := RState;
|
|
FillChar(Regs[Counter], SizeOf(TContent), 0);
|
|
WState := TmpWState;
|
|
RState := TmpRState;
|
|
End;
|
|
End;
|
|
End;
|
|
|
|
Procedure TPaiProp.DestroyRefs(Const Ref: TReference; WhichReg: TRegister);
|
|
{destroys all registers which possibly contain a reference to Ref, WhichReg
|
|
is the register whose contents are being written to memory (if this proc
|
|
is called because of a "mov?? %reg, (mem)" instruction)}
|
|
Var Counter: TRegister;
|
|
Begin
|
|
WhichReg := RegMaxSize(WhichReg);
|
|
If ((Ref.base = ProcInfo.FramePointer) And
|
|
{$ifdef refsHaveIndex}
|
|
(Ref.Index = R_NO)
|
|
{$endif refsHaveIndex}
|
|
) Or
|
|
Assigned(Ref.Symbol)
|
|
Then
|
|
{write something to a parameter, a local or global variable, so
|
|
* with uncertain optimizations on:
|
|
- destroy the contents of registers whose contents have somewhere a
|
|
"mov?? (Ref), %reg". WhichReg (this is the register whose contents
|
|
are being written to memory) is not destroyed if it's StartMod is
|
|
of that form and NrOfMods = 1 (so if it holds ref, but is not a
|
|
pointer or value based on Ref)
|
|
* with uncertain optimizations off:
|
|
- also destroy registers that contain any pointer}
|
|
For Counter := LoGPReg to HiGPReg Do
|
|
With Regs[Counter] Do
|
|
Begin
|
|
If (typ = Con_Ref) And
|
|
((Not(cs_UncertainOpts in aktglobalswitches) And
|
|
(NrOfMods <> 1)
|
|
) Or
|
|
(RefInSequence(Ref,Regs[Counter]) And
|
|
((Counter <> WhichReg) Or
|
|
((NrOfMods <> 1) And
|
|
{StarMod is always of the type ait_instruction}
|
|
(PInstr(StartMod)^.oper[0].typ = top_ref) And
|
|
RefsEqual(PInstr(StartMod)^.oper[0].ref^, Ref)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
Then
|
|
DestroyReg(Counter)
|
|
End
|
|
Else
|
|
{write something to a pointer location, so
|
|
* with uncertain optimzations on:
|
|
- do not destroy registers which contain a local/global variable or a
|
|
parameter, except if DestroyRefs is called because of a "movsl"
|
|
* with uncertain optimzations off:
|
|
- destroy every register which contains a memory location
|
|
}
|
|
For Counter := LoGPReg to HiGPReg Do
|
|
With Regs[Counter] Do
|
|
If (typ = Con_Ref) And
|
|
(Not(cs_UncertainOpts in aktglobalswitches) Or
|
|
{$ifdef i386}
|
|
{for movsl}
|
|
(Ref.Base = R_EDI) Or
|
|
{$endif}
|
|
{don't destroy if reg contains a parameter, local or global variable}
|
|
Not((NrOfMods = 1) And
|
|
(PInstr(StartMod)^.oper[0].typ = top_ref) And
|
|
((PInstr(StartMod)^.oper[0].ref^.base = ProcInfo.FramePointer) Or
|
|
Assigned(PInstr(StartMod)^.oper[0].ref^.Symbol)
|
|
)
|
|
)
|
|
)
|
|
Then DestroyReg(Counter)
|
|
End;
|
|
|
|
Procedure TPaiProp.DestroyAllRegs;
|
|
Var Counter: TRegister;
|
|
Begin {initializes/desrtoys all registers}
|
|
For Counter := R_EAX To R_EDI Do
|
|
DestroyReg(Counter);
|
|
CondRegs.Init;
|
|
{ FPURegs.Init; }
|
|
End;
|
|
|
|
Procedure TPaiProp.DestroyOp(const o:Toper);
|
|
Begin
|
|
Case o.typ Of
|
|
top_reg: DestroyReg(o.reg);
|
|
top_ref: DestroyRefs(o.ref^, R_NO);
|
|
top_symbol:;
|
|
End;
|
|
End;
|
|
|
|
Procedure TPaiProp.ReadReg(Reg: TRegister);
|
|
Begin
|
|
Reg := RegMaxSize(Reg);
|
|
If Reg in General_Registers Then
|
|
IncRState(RegMaxSize(Reg))
|
|
End;
|
|
|
|
Procedure TPaiProp.ReadRef(Ref: PReference);
|
|
Begin
|
|
If Ref^.Base <> R_NO Then
|
|
ReadReg(Ref^.Base);
|
|
If Ref^.Index <> R_NO Then
|
|
ReadReg(Ref^.Index);
|
|
End;
|
|
|
|
Procedure TPaiProp.ReadOp(const o:toper);
|
|
Begin
|
|
Case o.typ Of
|
|
top_reg: ReadReg(o.reg);
|
|
top_ref: ReadRef(o.ref);
|
|
top_symbol : ;
|
|
End;
|
|
End;
|
|
|
|
{$ifdef arithopt}
|
|
Procedure TPaiProp.ModifyReg(reg: TRegister; Var NrOfInstrSinceLastMod:
|
|
TInstrSinceLastMod);
|
|
Begin
|
|
With Regs[reg] Do
|
|
If (Typ = Con_Ref)
|
|
Then
|
|
Begin
|
|
IncState(WState);
|
|
{also store how many instructions are part of the sequence in the first
|
|
instructions PPaiProp, so it can be easily accessed from within
|
|
CheckSequence}
|
|
Inc(NrOfMods, NrOfInstrSinceLastMod[Reg]);
|
|
PPaiProp(StartMod^.OptInfo)^.Regs[Reg].NrOfMods := NrOfMods;
|
|
NrOfInstrSinceLastMod[Reg] := 0;
|
|
End
|
|
Else
|
|
DestroyReg(Reg, NrOfInstrSinceLastMod);
|
|
End;
|
|
|
|
Procedure TPaiProp.ModifyOp(const oper: TOper);
|
|
Begin
|
|
If oper.typ = top_reg Then
|
|
ModifyReg(RegMaxSize(oper.reg))
|
|
Else
|
|
Begin
|
|
ReadOp(oper);
|
|
DestroyOp(oper);
|
|
End
|
|
End;
|
|
{$endif arithopt}
|
|
|
|
Procedure TPaiProp.IncWState(Reg: TRegister);{$ifdef fpc} inline;{$endif fpc}
|
|
Begin
|
|
IncState(Regs[Reg].WState);
|
|
End;
|
|
|
|
Procedure TPaiProp.IncRState(Reg: TRegister);{$ifdef fpc} inline;{$endif fpc}
|
|
Begin
|
|
IncState(Regs[Reg].RState);
|
|
End;
|
|
|
|
Procedure TPaiProp.IncState(Var s: TStateInt); {$ifdef fpc} inline;{$endif fpc}
|
|
Begin
|
|
If s <> $ff Then Inc(s)
|
|
Else s := 0
|
|
End;
|
|
|
|
Function TPaiProp.GetWState(Reg: TRegister): TStateInt;
|
|
Begin
|
|
GetWState := Regs[Reg].WState
|
|
End;
|
|
|
|
Function TPaiProp.GetRState(Reg: TRegister): TStateInt;
|
|
Begin
|
|
GetRState := Regs[Reg].RState
|
|
End;
|
|
|
|
Function TPaiProp.GetRegContentKind(Reg: TRegister): Byte;
|
|
Begin
|
|
GetRegContentKind := Regs[Reg].typ
|
|
End;
|
|
|
|
{******************* TAOptObj *******************}
|
|
|
|
Constructor TAoptObj.Init(_AsmL: PAasmOutput; _BlockStart, _BlockEnd: Pai;
|
|
_LabelInfo: PLabelInfo);
|
|
Begin
|
|
AsmL := _AsmL;
|
|
BlockStart := _BlockStart;
|
|
BlockEnd := _BlockEnd;
|
|
LabelInfo := _LabelInfo
|
|
End;
|
|
|
|
Function TAOptObj.FindLabel(L: PasmLabel; Var hp: Pai): Boolean;
|
|
Var TempP: Pai;
|
|
Begin
|
|
TempP := hp;
|
|
While Assigned(TempP) and
|
|
(TempP^.typ In SkipInstr + [ait_label]) Do
|
|
If (TempP^.typ <> ait_Label) Or
|
|
(pai_label(TempP)^.l <> L)
|
|
Then GetNextInstruction(TempP, TempP)
|
|
Else
|
|
Begin
|
|
hp := TempP;
|
|
FindLabel := True;
|
|
exit
|
|
End;
|
|
FindLabel := False;
|
|
End;
|
|
|
|
Procedure TAOptObj.InsertLLItem(AsmL: PAasmOutput; prev, foll, new_one:
|
|
PLinkedList_Item);
|
|
Begin
|
|
If Assigned(prev) Then
|
|
If Assigned(foll) Then
|
|
Begin
|
|
If Assigned(new_one) Then
|
|
Begin
|
|
new_one^.previous := prev;
|
|
new_one^.next := foll;
|
|
prev^.next := new_one;
|
|
foll^.previous := new_one;
|
|
new_one^.fileinfo := foll^.fileinfo
|
|
End
|
|
End
|
|
Else AsmL^.Concat(new_one)
|
|
Else If Assigned(Foll) Then AsmL^.Insert(new_one)
|
|
End;
|
|
|
|
Function TAOptObj.RegInInstruction(Reg: TRegister; p1: Pai): Boolean;
|
|
Var Count: TNatInt;
|
|
TmpResult: Boolean;
|
|
Begin
|
|
TmpResult := False;
|
|
Count := 0;
|
|
If (p1^.typ = ait_instruction) Then
|
|
Repeat
|
|
TmpResult := RegInOp(Reg, PInstr(p1)^.oper[Count]);
|
|
Inc(Count)
|
|
Until (Count = MaxOps) or TmpResult;
|
|
RegInInstruction := TmpResult
|
|
End;
|
|
|
|
Function TAOptObj.RegInOp(Reg: TRegister; const op: toper): Boolean;
|
|
Begin
|
|
Case op.typ Of
|
|
Top_Reg: RegInOp := Reg = op.reg;
|
|
Top_Ref: RegInOp := RegInRef(Reg, op.ref^)
|
|
Else RegInOp := False
|
|
End
|
|
End;
|
|
|
|
Function TAOptObj.RegModifiedByInstruction(Reg: TRegister; p1: Pai): Boolean;
|
|
Var hp: Pai;
|
|
Begin
|
|
If GetLastInstruction(p1, hp)
|
|
Then
|
|
RegModifiedByInstruction :=
|
|
PPAiProp(p1^.OptInfo)^.Regs[Reg].WState <>
|
|
PPAiProp(hp^.OptInfo)^.Regs[Reg].WState
|
|
Else RegModifiedByInstruction := True;
|
|
End;
|
|
|
|
Function TAOptObj.GetNextInstruction(Current: Pai; Var Next: Pai): Boolean;
|
|
Begin
|
|
Repeat
|
|
Current := Pai(Current^.Next);
|
|
While Assigned(Current) And
|
|
((Current^.typ In SkipInstr) or
|
|
((Current^.typ = ait_label) And
|
|
Not(Pai_Label(Current)^.l^.is_used))) Do
|
|
Current := Pai(Current^.Next);
|
|
If Assigned(Current) And
|
|
(Current^.typ = ait_Marker) And
|
|
(Pai_Marker(Current)^.Kind = NoPropInfoStart) Then
|
|
Begin
|
|
While Assigned(Current) And
|
|
((Current^.typ <> ait_Marker) Or
|
|
(Pai_Marker(Current)^.Kind <> NoPropInfoEnd)) Do
|
|
Current := Pai(Current^.Next);
|
|
End;
|
|
Until Not(Assigned(Current)) Or
|
|
(Current^.typ <> ait_Marker) Or
|
|
(Pai_Marker(Current)^.Kind <> NoPropInfoEnd);
|
|
Next := Current;
|
|
If Assigned(Current) And
|
|
Not((Current^.typ In SkipInstr) or
|
|
((Current^.typ = ait_label) And
|
|
Not(Pai_Label(Current)^.l^.is_used)))
|
|
Then GetNextInstruction := True
|
|
Else
|
|
Begin
|
|
Next := Nil;
|
|
GetNextInstruction := False;
|
|
End;
|
|
End;
|
|
|
|
Function TAOptObj.GetLastInstruction(Current: Pai; Var Last: Pai): Boolean;
|
|
Begin
|
|
Repeat
|
|
Current := Pai(Current^.previous);
|
|
While Assigned(Current) And
|
|
(((Current^.typ = ait_Marker) And
|
|
Not(Pai_Marker(Current)^.Kind in [AsmBlockEnd,NoPropInfoEnd])) or
|
|
(Current^.typ In SkipInstr) or
|
|
((Current^.typ = ait_label) And
|
|
Not(Pai_Label(Current)^.l^.is_used))) Do
|
|
Current := Pai(Current^.previous);
|
|
If Assigned(Current) And
|
|
(Current^.typ = ait_Marker) And
|
|
(Pai_Marker(Current)^.Kind = NoPropInfoEnd) Then
|
|
Begin
|
|
While Assigned(Current) And
|
|
((Current^.typ <> ait_Marker) Or
|
|
(Pai_Marker(Current)^.Kind <> NoPropInfoStart)) Do
|
|
Current := Pai(Current^.previous);
|
|
End;
|
|
Until Not(Assigned(Current)) Or
|
|
(Current^.typ <> ait_Marker) Or
|
|
(Pai_Marker(Current)^.Kind <> NoPropInfoStart);
|
|
If Not(Assigned(Current)) or
|
|
(Current^.typ In SkipInstr) or
|
|
((Current^.typ = ait_label) And
|
|
Not(Pai_Label(Current)^.l^.is_used)) or
|
|
((Current^.typ = ait_Marker) And
|
|
(Pai_Marker(Current)^.Kind = AsmBlockEnd))
|
|
Then
|
|
Begin
|
|
Last := Nil;
|
|
GetLastInstruction := False
|
|
End
|
|
Else
|
|
Begin
|
|
Last := Current;
|
|
GetLastInstruction := True;
|
|
End;
|
|
End;
|
|
|
|
Procedure TAOptObj.SkipHead(var P: Pai);
|
|
{ skips Pai objects at the start of a block that don't do anything }
|
|
Var OldP: Pai;
|
|
Begin
|
|
Repeat
|
|
OldP := P;
|
|
If (P^.typ in SkipInstr) Or
|
|
((P^.typ = ait_marker) And
|
|
(Pai_Marker(P)^.Kind = AsmBlockEnd)) Then
|
|
GetNextInstruction(P, P)
|
|
Else If ((P^.Typ = Ait_Marker) And
|
|
(Pai_Marker(P)^.Kind = NoPropInfoStart)) Then
|
|
{ a marker of the type NoPropInfoStart can't be the first instruction of a }
|
|
{ paasmoutput list }
|
|
GetNextInstruction(Pai(P^.Previous),P);
|
|
If (P^.Typ = Ait_Marker) And
|
|
(Pai_Marker(P)^.Kind = AsmBlockStart) Then
|
|
Begin
|
|
P := Pai(P^.Next);
|
|
While (P^.typ <> Ait_Marker) Or
|
|
(Pai_Marker(P)^.Kind <> AsmBlockEnd) Do
|
|
P := Pai(P^.Next)
|
|
End;
|
|
Until P = OldP
|
|
End;
|
|
|
|
Function TAOptObj.OpsEqual(const o1,o2:toper): Boolean;
|
|
Begin
|
|
if o1.typ=o2.typ then
|
|
Case o1.typ Of
|
|
Top_Reg :
|
|
OpsEqual:=o1.reg=o2.reg;
|
|
Top_Ref :
|
|
OpsEqual := RefsEqual(o1.ref^, o2.ref^);
|
|
Top_Const :
|
|
OpsEqual:=o1.val=o2.val;
|
|
Top_Symbol :
|
|
OpsEqual:=(o1.sym=o2.sym) and (o1.symofs=o2.symofs);
|
|
Top_None :
|
|
OpsEqual := True
|
|
else OpsEqual := False
|
|
End;
|
|
End;
|
|
|
|
Function TAOptObj.FindRegAlloc(Reg: TRegister; StartPai: Pai): Boolean;
|
|
Begin
|
|
FindRegAlloc:=False;
|
|
Repeat
|
|
While Assigned(StartPai) And
|
|
((StartPai^.typ in (SkipInstr - [ait_regAlloc])) Or
|
|
((StartPai^.typ = ait_label) and
|
|
Not(Pai_Label(StartPai)^.l^.Is_Used))) Do
|
|
StartPai := Pai(StartPai^.Next);
|
|
If Assigned(StartPai) And
|
|
(StartPai^.typ = ait_regAlloc) and (PairegAlloc(StartPai)^.allocation) Then
|
|
Begin
|
|
if PairegAlloc(StartPai)^.Reg = Reg then
|
|
begin
|
|
FindRegAlloc:=true;
|
|
exit;
|
|
end;
|
|
StartPai := Pai(StartPai^.Next);
|
|
End
|
|
else
|
|
exit;
|
|
Until false;
|
|
End;
|
|
|
|
Function TAOptObj.RefsEqual(Const R1, R2: TReference): Boolean;
|
|
Begin
|
|
If R1.is_immediate Then
|
|
RefsEqual := R2.is_immediate and (R1.Offset = R2.Offset)
|
|
Else
|
|
RefsEqual := (R1.Offset+R1.OffsetFixup = R2.Offset+R2.OffsetFixup)
|
|
And (R1.Base = R2.Base)
|
|
{$ifdef RefsHaveindex}
|
|
And (R1.Index = R2.Index)
|
|
{$endif RefsHaveindex}
|
|
{$ifdef RefsHaveScale}
|
|
And (R1.ScaleFactor = R2.ScaleFactor)
|
|
{$endif RefsHaveScale}
|
|
And (R1.Symbol = R2.Symbol)
|
|
{$ifdef RefsHaveSegment}
|
|
And (R1.Segment = R2.Segment)
|
|
{$endif RefsHaveSegment}
|
|
;
|
|
|
|
Function TAOptObj.RegInRef(Reg: TRegister; Const Ref: TReference): Boolean;
|
|
Begin
|
|
Reg := RegMaxSize(Reg);
|
|
RegInRef := (Ref.Base = Reg)
|
|
{$ifdef RefsHaveIndexReg}
|
|
Or (Ref.Index = Reg)
|
|
{$endif RefsHaveIndexReg}
|
|
End;
|
|
|
|
Function TAOptObj.RegModifiedByInstruction(Reg: TRegister; p1: Pai): Boolean;
|
|
Var hp: Pai;
|
|
Begin
|
|
If GetLastInstruction(p1, hp)
|
|
Then
|
|
RegModifiedByInstruction :=
|
|
PPAiProp(p1^.OptInfo)^.GetWState <>
|
|
PPAiProp(hp^.OptInfo)^.GetWState
|
|
Else RegModifiedByInstruction := True;
|
|
End;
|
|
|
|
Function TAOptObj.RefInInstruction(Const Ref: TReference; p: Pai): Boolean;
|
|
Var Count: TNatInt;
|
|
TmpResult: Boolean;
|
|
Begin
|
|
TmpResult := False;
|
|
If (p^.typ = ait_instruction) Then
|
|
Begin
|
|
Count := 0;
|
|
Repeat
|
|
If (PInstr(p)^.oper[Count].typ = Top_Ref) Then
|
|
TmpResult := RefsEqual(Ref, PInstr(p)^.oper[Count].ref^);
|
|
Inc(Count);
|
|
Until (Count = MaxOps) or TmpResult;
|
|
End;
|
|
RefInInstruction := TmpResult;
|
|
End;
|
|
|
|
Function TAOptObj.RefInSequence(Const Ref: TReference; Content: TContent):
|
|
Boolean;
|
|
Var p: Pai;
|
|
Counter: Byte;
|
|
TmpResult: Boolean;
|
|
Begin
|
|
p := Content.StartMod;
|
|
TmpResult := False;
|
|
Counter := 1;
|
|
While Not(TmpResult) And
|
|
(Counter <= Content.NrOfMods) Do
|
|
Begin
|
|
If (p^.typ = ait_instruction) And
|
|
RefInInstruction(Ref, p)
|
|
Then TmpResult := True;
|
|
Inc(Counter);
|
|
GetNextInstruction(p,p)
|
|
End;
|
|
RefInSequence := TmpResult
|
|
End;
|
|
|
|
Function TAOptObj.RegMaxSize(Reg: TRegister): TRegister;
|
|
Begin
|
|
RegMaxSize := Reg
|
|
End;
|
|
|
|
Function TAOptObj.RegsSameSize(Reg1, Reg2: TRegister): Boolean;
|
|
Begin
|
|
RegsSameSize := True
|
|
End;
|
|
|
|
Function TAOptObj.IsLoadInstr(p: pai): Boolean;
|
|
Begin
|
|
Abstract
|
|
End;
|
|
|
|
Function TAOptObj.RegReadByInstr(Reg: TRegister; p: Pai);
|
|
Begin
|
|
Abstract
|
|
End;
|
|
|
|
Function TAOptObj.IsStoreInstr(p: pai): Boolean;
|
|
Begin
|
|
Abstract
|
|
End;
|
|
|
|
Function TAOptObj.TCh2Reg(Ch: TChange): TRegister;
|
|
Begin
|
|
Abstract
|
|
End;
|
|
|
|
End.
|
|
|
|
{
|
|
$Log$
|
|
Revision 1.2 1999-08-09 14:07:24 jonas
|
|
commit.msg
|
|
|
|
Revision 1.1 1999/08/08 13:24:50 jonas
|
|
+ added copyright header/GNU license info
|
|
* made the assembler optimizer almost completely OOP
|
|
* some code style clean up and extra comments
|
|
* moved from the new/aopt to the /new and /new/i386 dirs
|
|
|
|
} |