freepascal.compiler/compiler/new/aoptobj.pas

{
    $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, aoptcpu;

{***************** 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 }
               Procedure DestroyReg(Reg: TRegister);
               { 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
       { 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);
{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);
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);
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].ty
End;

{******************* TAOptObj *******************}

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.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

}