* changed state to WState (WriteState), added RState for future use in

     instruction scheduling
  * RegAlloc data from the CG is now completely being patched and corrected (I
     think)

compiler/daopt386.pas

@@ -1,6 +1,6 @@
 {
     $Id$
-    Copyright (c) 1997-98 by Jonas Maebe
+    Copyright (c) 1997-98 by the Free Pascal Development Team
 
     This unit contains the data flow analyzer and several helper procedures
     and functions.
@@ -110,7 +110,7 @@ Type
              {read and write from/to a register}
              C_RWEAX, C_RWECX, C_RWEDX, C_RWEBX, C_RWESP, C_RWEBP, C_RWESI, C_RWEDI,
              C_CDirFlag {clear direction flag}, C_SDirFlag {set dir flag},
-             C_Flags, C_FPU,
+             C_RFlags, C_WFlags, C_RWFlags, C_FPU,
              C_ROp1, C_WOp1, C_RWOp1,
              C_ROp2, C_WOp2, C_RWOp2,
              C_ROp3, C_WOp3, C_RWOp3,
@@ -132,8 +132,10 @@ Type
        content of this register. If Typ = con_const, then
        Longint(StartMod) = value of the constant)}
                StartMod: Pointer;
-      {starts at 1, gets increased everytime the register is modified}
-               State: Word;
+      {starts at 0, gets increased everytime the register is modified}
+               WState: Byte;
+      {starts at 0, gets increased everytime the register is read from}
+               RState: Byte;
       {how many instructions starting with StarMod does the block consist of}
                NrOfMods: Byte;
       {if one register gets a block assigned from an other register,
@@ -166,22 +168,21 @@ Type
              End;
 
   PPaiProp = ^TPaiProp;
-{$IfDef TP}
-  TPaiPropBlock = Array[1..(65520 div (((SizeOf(TPaiProp)+1)div 2)*2))] Of TPaiProp;
-{$else}
+
+{$IfNDef TP}
   TPaiPropBlock = Array[1..250000] Of TPaiProp;
-{$EndIf TP}
   PPaiPropBlock = ^TPaiPropBlock;
+{$EndIf TP}
 
   TInstrSinceLastMod = Array[R_EAX..R_EDI] Of Byte;
 
   TLabelTableItem = Record
                       PaiObj: Pai;
-{$IfNDef TP}
+{$IfDef JumpAnal}
                       InstrNr: Longint;
                       RefsFound: Word;
                       JmpsProcessed: Word
-{$EndIf TP}
+{$EndIf JumpAnal}
                     End;
 {$IfDef tp}
   TLabelTable = Array[0..10000] Of TLabelTableItem;
@@ -198,8 +199,11 @@ Type
 Var
 {the amount of PaiObjects in the current assembler list}
   NrOfPaiObjs: Longint;
-{Array which holds all (FPC) or as much as possible (TP) PPaiProps}
+
+{$IfNDef TP}
+{Array which holds all TPaiProps}
   PaiPropBlock: PPaiPropBlock;
+{$EndIf TP}
 
   LoLab, HiLab, LabDif: Longint;
 
@@ -216,45 +220,45 @@ Uses globals, systems, strings, verbose, hcodegen,
    {$endif i386}
 
 Const AsmInstr: Array[tasmop] Of TAsmInstrucProp = (
-   {MOV} (Ch: (C_WOp2, C_None, C_None)),
- {MOVZX} (Ch: (C_WOp2, C_None, C_None)),
- {MOVSX} (Ch: (C_WOp2, C_None, C_None)),
+   {MOV} (Ch: (C_WOp2, C_ROp1, C_None)),
+ {MOVZX} (Ch: (C_WOp2, C_ROp1, C_None)),
+ {MOVSX} (Ch: (C_WOp2, C_ROp1, C_None)),
  {LABEL} (Ch: (C_All, C_None, C_None)), {don't know value of any register}
-   {ADD} (Ch: (C_RWOp2, C_Flags, C_None)),
+   {ADD} (Ch: (C_RWOp2, C_ROp1, C_WFlags)),
   {CALL} (Ch: (C_All, C_None, C_None)), {don't know value of any register}
-  {IDIV} (Ch: (C_RWEAX, C_WEDX, C_Flags)),
-  {IMUL} (Ch: (C_WEAX, C_WEDX, C_Flags)), {handled separately, because several forms exist}
+  {IDIV} (Ch: (C_RWEAX, C_WEDX, C_WFlags)),
+  {IMUL} (Ch: (C_RWEAX, C_WEDX, C_WFlags)), {handled separately, because several forms exist}
    {JMP} (Ch: (C_None, C_None, C_None)),
-   {LEA} (Ch: (C_WOp2, C_None, C_None)),
-   {MUL} (Ch: (C_RWEAX, C_WEDX, C_Flags)),
-   {NEG} (Ch: (C_WOp1, C_None, C_None)),
-   {NOT} (Ch: (C_WOp1, C_Flags, C_None)),
+   {LEA} (Ch: (C_WOp2, C_ROp1, C_None)),
+   {MUL} (Ch: (C_RWEAX, C_WEDX, C_WFlags)),
+   {NEG} (Ch: (C_RWOp1, C_None, C_None)),
+   {NOT} (Ch: (C_RWOp1, C_WFlags, C_None)),
    {POP} (Ch: (C_WOp1, C_RWESP, C_None)),
- {POPAD} (Ch: (C_None, C_None, C_None)), {don't know value of any register}
+ {POPAD} (Ch: (C_All, C_None, C_None)), {don't know value of any register}
   {PUSH} (Ch: (C_RWESP, C_None, C_None)),
 {PUSHAD} (Ch: (C_RWESP, C_None, C_None)),
-   {RET} (Ch: (C_None, C_None, C_None)), {don't know value of any register}
-   {SUB} (Ch: (C_RWOp2, C_Flags, C_None)),
+   {RET} (Ch: (C_None, C_None, C_None)),
+   {SUB} (Ch: (C_RWOp2, C_ROp1, C_WFlags)),
   {XCHG} (Ch: (C_RWOp1, C_RWOp2, C_None)), {(will be) handled seperately}
-   {XOR} (Ch: (C_RWOp2, C_Flags, C_None)),
+   {XOR} (Ch: (C_RWOp2, C_ROp1, C_WFlags)),
   {FILD} (Ch: (C_FPU, C_None, C_None)),
-   {CMP} (Ch: (C_Flags, C_None, C_None)),
+   {CMP} (Ch: (C_RFlags, C_None, C_None)),
     {JZ} (Ch: (C_None, C_None, C_None)),
-   {INC} (Ch: (C_RWOp1, C_Flags, C_None)),
-   {DEC} (Ch: (C_RWOp1, C_Flags, C_None)),
-  {SETE} (Ch: (C_WOp1, C_None, C_None)),
- {SETNE} (Ch: (C_WOp1, C_None, C_None)),
-  {SETL} (Ch: (C_WOp1, C_None, C_None)),
-  {SETG} (Ch: (C_WOp1, C_None, C_None)),
- {SETLE} (Ch: (C_WOp1, C_None, C_None)),
- {SETGE} (Ch: (C_WOp1, C_None, C_None)),
-    {JE} (Ch: (C_None, C_None, C_None)),
-   {JNE} (Ch: (C_None, C_None, C_None)),
-    {JL} (Ch: (C_None, C_None, C_None)),
-    {JG} (Ch: (C_None, C_None, C_None)),
-   {JLE} (Ch: (C_None, C_None, C_None)),
-   {JGE} (Ch: (C_None, C_None, C_None)),
-    {OR} (Ch: (C_RWOp2, C_Flags, C_None)),
+   {INC} (Ch: (C_RWOp1, C_RFlags, C_None)),
+   {DEC} (Ch: (C_RWOp1, C_WFlags, C_None)),
+  {SETE} (Ch: (C_WOp1, C_RFlags, C_None)),
+ {SETNE} (Ch: (C_WOp1, C_RFlags, C_None)),
+  {SETL} (Ch: (C_WOp1, C_RFlags, C_None)),
+  {SETG} (Ch: (C_WOp1, C_RFlags, C_None)),
+ {SETLE} (Ch: (C_WOp1, C_RFlags, C_None)),
+ {SETGE} (Ch: (C_WOp1, C_RFlags, C_None)),
+    {JE} (Ch: (C_RFlags, C_None, C_None)),
+   {JNE} (Ch: (C_RFlags, C_None, C_None)),
+    {JL} (Ch: (C_RFlags, C_None, C_None)),
+    {JG} (Ch: (C_RFlags, C_None, C_None)),
+   {JLE} (Ch: (C_RFlags, C_None, C_None)),
+   {JGE} (Ch: (C_RFlags, C_None, C_None)),
+    {OR} (Ch: (C_RWOp2, C_WFlags, C_None)),
    {FLD} (Ch: (C_FPU, C_None, C_None)),
   {FADD} (Ch: (C_FPU, C_None, C_None)),
   {FMUL} (Ch: (C_FPU, C_None, C_None)),
@@ -263,26 +267,26 @@ Const AsmInstr: Array[tasmop] Of TAsmInstrucProp = (
   {FCHS} (Ch: (C_FPU, C_None, C_None)),
   {FLD1} (Ch: (C_FPU, C_None, C_None)),
  {FIDIV} (Ch: (C_FPU, C_None, C_None)),
-  {CLTD} (Ch: (C_WEDX, C_None, C_None)),
-   {JNZ} (Ch: (C_None, C_None, C_None)),
+  {CLTD} (Ch: (C_WEDX, C_REAX, C_None)),
+   {JNZ} (Ch: (C_RFlags, C_None, C_None)),
   {FSTP} (Ch: (C_WOp1, C_None, C_None)),
-   {AND} (Ch: (C_RWOp2, C_Flags, C_None)),
-   {JNO} (Ch: (C_None, C_None, C_None)),
+   {AND} (Ch: (C_RWOp2, C_WFlags, C_None)),
+   {JNO} (Ch: (C_RFlags, C_None, C_None)),
   {NOTH} (Ch: (C_None, C_None, C_None)), {***???***}
   {NONE} (Ch: (C_None, C_None, C_None)),
  {ENTER} (Ch: (C_RWESP, C_None, C_None)),
  {LEAVE} (Ch: (C_RWESP, C_None, C_None)),
    {CLD} (Ch: (C_CDirFlag, C_None, C_None)),
   {MOVS} (Ch: (C_RWESI, C_RWEDI, C_MemEDI)),
-   {REP} (Ch: (C_RWECX, C_None, C_None)),
-   {SHL} (Ch: (C_RWOp2, C_Flags, C_None)),
-   {SHR} (Ch: (C_RWOp2, C_Flags, C_None)),
- {BOUND} (Ch: (C_None, C_None, C_None)),
-   {JNS} (Ch: (C_None, C_None, C_None)),
-    {JS} (Ch: (C_None, C_None, C_None)),
-    {JO} (Ch: (C_None, C_None, C_None)),
-   {SAR} (Ch: (C_RWOp2, C_Flags, C_None)),
-  {TEST} (Ch: (C_Flags, C_None, C_None)),
+   {REP} (Ch: (C_RWECX, C_RFlags, C_None)),
+   {SHL} (Ch: (C_RWOp2, C_WFlags, C_None)),
+   {SHR} (Ch: (C_RWOp2, C_WFlags, C_None)),
+ {BOUND} (Ch: (C_ROp1, C_None, C_None)),
+   {JNS} (Ch: (C_RFlags, C_None, C_None)),
+    {JS} (Ch: (C_RFlags, C_None, C_None)),
+    {JO} (Ch: (C_RFlags, C_None, C_None)),
+   {SAR} (Ch: (C_RWOp2, C_WFlags, C_None)),
+  {TEST} (Ch: (C_WFlags, C_ROp1, C_ROp2)),
   {FCOM} (Ch: (C_FPU, C_None, C_None)),
  {FCOMP} (Ch: (C_FPU, C_None, C_None)),
 {FCOMPP} (Ch: (C_FPU, C_None, C_None)),
@@ -292,31 +296,31 @@ Const AsmInstr: Array[tasmop] Of TAsmInstrucProp = (
  {FSUBP} (Ch: (C_FPU, C_None, C_None)),
  {FDIVP} (Ch: (C_FPU, C_None, C_None)),
  {FNSTS} (Ch: (C_WOp1, C_None, C_None)),
-  {SAHF} (Ch: (C_Flags, C_None, C_None)),
+  {SAHF} (Ch: (C_WFlags, C_REAX, C_None)),
 {FDIVRP} (Ch: (C_FPU, C_None, C_None)),
 {FSUBRP} (Ch: (C_FPU, C_None, C_None)),
-  {SETC} (Ch: (C_WOp1, C_None, C_None)),
- {SETNC} (Ch: (C_WOp1, C_None, C_None)),
-    {JC} (Ch: (C_None, C_None, C_None)),
-   {JNC} (Ch: (C_None, C_None, C_None)),
-    {JA} (Ch: (C_None, C_None, C_None)),
-   {JAE} (Ch: (C_None, C_None, C_None)),
-    {JB} (Ch: (C_None, C_None, C_None)),
-   {JBE} (Ch: (C_None, C_None, C_None)),
-  {SETA} (Ch: (C_WOp1, C_None, C_None)),
- {SETAE} (Ch: (C_WOp1, C_None, C_None)),
-  {SETB} (Ch: (C_WOp1, C_None, C_None)),
- {SETBE} (Ch: (C_WOp1, C_None, C_None)),
-   {AAA} (Ch: (C_RWEAX, C_Flags, C_None)),
-   {AAD} (Ch: (C_RWEAX, C_Flags, C_None)),
-   {AAM} (Ch: (C_RWEAX, C_Flags, C_None)),
-   {AAS} (Ch: (C_RWEAX, C_Flags, C_None)),
+  {SETC} (Ch: (C_WOp1, C_RFlags, C_None)),
+ {SETNC} (Ch: (C_WOp1, C_RFlags, C_None)),
+    {JC} (Ch: (C_None, C_RFlags, C_None)),
+   {JNC} (Ch: (C_None, C_RFlags, C_None)),
+    {JA} (Ch: (C_None, C_RFlags, C_None)),
+   {JAE} (Ch: (C_None, C_RFlags, C_None)),
+    {JB} (Ch: (C_None, C_RFlags, C_None)),
+   {JBE} (Ch: (C_None, C_RFlags, C_None)),
+  {SETA} (Ch: (C_WOp1, C_RFlags, C_None)),
+ {SETAE} (Ch: (C_WOp1, C_RFlags, C_None)),
+  {SETB} (Ch: (C_WOp1, C_RFlags, C_None)),
+ {SETBE} (Ch: (C_WOp1, C_RFlags, C_None)),
+   {AAA} (Ch: (C_RWEAX, C_WFlags, C_None)),
+   {AAD} (Ch: (C_RWEAX, C_WFlags, C_None)),
+   {AAM} (Ch: (C_RWEAX, C_WFlags, C_None)),
+   {AAS} (Ch: (C_RWEAX, C_WFlags, C_None)),
    {CBW} (Ch: (C_RWEAX, C_None, C_None)),
    {CDQ} (Ch: (C_RWEAX, C_WEDX, C_None)),
-   {CLC} (Ch: (C_Flags, C_None, C_None)),
-   {CLI} (Ch: (C_Flags, C_None, C_None)),
+   {CLC} (Ch: (C_WFlags, C_None, C_None)),
+   {CLI} (Ch: (C_WFlags, C_None, C_None)),
   {CLTS} (Ch: (C_None, C_None, C_None)),
-   {CMC} (Ch: (C_Flags, C_None, C_None)),
+   {CMC} (Ch: (C_WFlags, C_None, C_None)),
    {CWD} (Ch: (C_RWEAX, C_WEDX, C_None)),
   {CWDE} (Ch: (C_RWEAX, C_None, C_None)),
    {DAA} (Ch: (C_RWEAX, C_None, C_None)),
@@ -330,109 +334,109 @@ Const AsmInstr: Array[tasmop] Of TAsmInstrucProp = (
  {PUSHA} (Ch: (C_RWESP, C_None, C_None)),
  {PUSHF} (Ch: (C_RWESP, C_None, C_None)),
 {PUSHFD} (Ch: (C_RWESP, C_None, C_None)),
-   {STC} (Ch: (C_Flags, C_None, C_None)),
+   {STC} (Ch: (C_WFlags, C_None, C_None)),
    {STD} (Ch: (C_SDirFlag, C_None, C_None)),
-   {STI} (Ch: (C_Flags, C_None, C_None)),
+   {STI} (Ch: (C_WFlags, C_None, C_None)),
   {STOS} (Ch: (C_MemEDI, C_RWEDI, C_None)),
   {WAIT} (Ch: (C_None, C_None, C_None)),
   {XLAT} (Ch: (C_WEAX, C_None, C_None)),
  {XLATB} (Ch: (C_WEAX, C_None, C_None)),
- {MOVSB} (Ch: (C_WOp2, C_None, C_None)),
-{MOVSBL} (Ch: (C_WOp2, C_None, C_None)),
-{MOVSBW} (Ch: (C_WOp2, C_None, C_None)),
-{MOVSWL} (Ch: (C_WOp2, C_None, C_None)),
- {MOVZB} (Ch: (C_WOp2, C_None, C_None)),
-{MOVZWL} (Ch: (C_WOp2, C_None, C_None)),
-  {POPA} (Ch: (C_None, C_None, C_None)), {don't know value of any register}
-    {IN} (Ch: (C_WOp2, C_None, C_None)),
-   {OUT} (Ch: (C_None, C_None, C_None)),
+ {MOVSB} (Ch: (C_WOp2, C_ROp1, C_None)),
+{MOVSBL} (Ch: (C_WOp2, C_ROp1, C_None)),
+{MOVSBW} (Ch: (C_WOp2, C_ROp1, C_None)),
+{MOVSWL} (Ch: (C_WOp2, C_ROp1, C_None)),
+ {MOVZB} (Ch: (C_WOp2, C_ROp1, C_None)),
+{MOVZWL} (Ch: (C_WOp2, C_ROp1, C_None)),
+  {POPA} (Ch: (C_All, C_None, C_None)), {don't know value of any register}
+    {IN} (Ch: (C_WOp2, C_ROp1, C_None)),
+   {OUT} (Ch: (C_ROp1, C_ROp2, C_None)),
    {LDS} (Ch: (C_WOp2, C_None, C_None)),
    {LCS} (Ch: (C_WOp2, C_None, C_None)),
    {LES} (Ch: (C_WOp2, C_None, C_None)),
    {LFS} (Ch: (C_WOp2, C_None, C_None)),
    {LGS} (Ch: (C_WOp2, C_None, C_None)),
    {LSS} (Ch: (C_WOp2, C_None, C_None)),
-  {POPF} (Ch: (C_RWESP, C_Flags, C_None)),
-   {SBB} (Ch: (C_RWOp2, C_Flags, C_None)),
-   {ADC} (Ch: (C_RWOp2, C_Flags, C_None)),
-   {DIV} (Ch: (C_RWEAX, C_WEDX, C_Flags)),
-   {ROR} (Ch: (C_RWOp2, C_Flags, C_None)),
-   {ROL} (Ch: (C_RWOp2, C_Flags, C_None)),
-   {RCL} (Ch: (C_RWOp2, C_Flags, C_None)),
-   {RCR} (Ch: (C_RWOp2, C_Flags, C_None)),
-   {SAL} (Ch: (C_RWOp2, C_Flags, C_None)),
-  {SHLD} (Ch: (C_RWOp3, C_Flags, C_None)),
-  {SHRD} (Ch: (C_RWOp3, C_Flags, C_None)),
+  {POPF} (Ch: (C_RWESP, C_WFlags, C_None)),
+   {SBB} (Ch: (C_RWOp2, C_ROp1, C_RWFlags)),
+   {ADC} (Ch: (C_RWOp2, C_ROp1, C_RWFlags)),
+   {DIV} (Ch: (C_RWEAX, C_WEDX, C_WFlags)),
+   {ROR} (Ch: (C_RWOp2, C_ROp1, C_RWFlags)),
+   {ROL} (Ch: (C_RWOp2, C_ROp1, C_RWFlags)),
+   {RCL} (Ch: (C_RWOp2, C_ROp1, C_RWFlags)),
+   {RCR} (Ch: (C_RWOp2, C_ROp1, C_RWFlags)),
+   {SAL} (Ch: (C_RWOp2, C_ROp1, C_RWFlags)),
+  {SHLD} (Ch: (C_RWOp3, C_RWFlags, C_ROp2)),
+  {SHRD} (Ch: (C_RWOp3, C_RWFlags, C_ROp1)),
  {LCALL} (Ch: (C_All, C_None, C_None)), {don't know value of any register}
   {LJMP} (Ch: (C_All, C_None, C_None)), {don't know value of any register}
   {LRET} (Ch: (C_All, C_None, C_None)), {don't know value of any register}
-  {JNAE} (Ch: (C_None, C_None, C_None)),
-   {JNB} (Ch: (C_None, C_None, C_None)),
-   {JNA} (Ch: (C_None, C_None, C_None)),
-  {JNBE} (Ch: (C_None, C_None, C_None)),
-    {JP} (Ch: (C_None, C_None, C_None)),
-   {JNP} (Ch: (C_None, C_None, C_None)),
-   {JPE} (Ch: (C_None, C_None, C_None)),
-   {JPO} (Ch: (C_None, C_None, C_None)),
-  {JNGE} (Ch: (C_None, C_None, C_None)),
-   {JNG} (Ch: (C_None, C_None, C_None)),
-   {JNL} (Ch: (C_None, C_None, C_None)),
-  {JNLE} (Ch: (C_None, C_None, C_None)),
-  {JCXZ} (Ch: (C_None, C_None, C_None)),
- {JECXZ} (Ch: (C_None, C_None, C_None)),
+  {JNAE} (Ch: (C_RFlags, C_None, C_None)),
+   {JNB} (Ch: (C_RFlags, C_None, C_None)),
+   {JNA} (Ch: (C_RFlags, C_None, C_None)),
+  {JNBE} (Ch: (C_RFlags, C_None, C_None)),
+    {JP} (Ch: (C_RFlags, C_None, C_None)),
+   {JNP} (Ch: (C_RFlags, C_None, C_None)),
+   {JPE} (Ch: (C_RFlags, C_None, C_None)),
+   {JPO} (Ch: (C_RFlags, C_None, C_None)),
+  {JNGE} (Ch: (C_RFlags, C_None, C_None)),
+   {JNG} (Ch: (C_RFlags, C_None, C_None)),
+   {JNL} (Ch: (C_RFlags, C_None, C_None)),
+  {JNLE} (Ch: (C_RFlags, C_None, C_None)),
+  {JCXZ} (Ch: (C_RECX, C_None, C_None)),
+ {JECXZ} (Ch: (C_RECX, C_None, C_None)),
   {LOOP} (Ch: (C_RWECX, C_None, C_None)),
-  {CMPS} (Ch: (C_RWESI, C_RWEDI, C_Flags)),
+  {CMPS} (Ch: (C_RWESI, C_RWEDI, C_WFlags)),
    {INS} (Ch: (C_RWEDI, C_MemEDI, C_None)),
   {OUTS} (Ch: (C_RWESI, C_None, C_None)),
-  {SCAS} (Ch: (C_RWEDI, C_Flags, C_None)),
-   {BSF} (Ch: (C_WOp2, C_Flags, C_None)),
-   {BSR} (Ch: (C_WOp2, C_Flags, C_None)),
-    {BT} (Ch: (C_Flags, C_None, C_None)),
-   {BTC} (Ch: (C_RWOp2, C_Flags, C_None)),
-   {BTR} (Ch: (C_RWOp2, C_Flags, C_None)),
-   {BTS} (Ch: (C_RWOp2, C_Flags, C_None)),
+  {SCAS} (Ch: (C_RWEDI, C_WFlags, C_None)),
+   {BSF} (Ch: (C_WOp2, C_WFlags, C_ROp1)),
+   {BSR} (Ch: (C_WOp2, C_WFlags, C_ROp1)),
+    {BT} (Ch: (C_WFlags, C_ROp1, C_None)),
+   {BTC} (Ch: (C_RWOp2, C_ROp1, C_WFlags)),
+   {BTR} (Ch: (C_RWOp2, C_ROp1, C_WFlags)),
+   {BTS} (Ch: (C_RWOp2, C_ROp1, C_WFlags)),
    {INT} (Ch: (C_All, C_None, C_None)), {don't know value of any register}
   {INT3} (Ch: (C_None, C_None, C_None)),
   {INTO} (Ch: (C_All, C_None, C_None)), {don't know value of any register}
-{BOUNDL} (Ch: (C_None, C_None, C_None)),
-{BOUNDW} (Ch: (C_None, C_None, C_None)),
- {LOOPZ} (Ch: (C_RWECX, C_None, C_None)),
- {LOOPE} (Ch: (C_RWECX, C_None, C_None)),
-{LOOPNZ} (Ch: (C_RWECX, C_None, C_None)),
-{LOOPNE} (Ch: (C_RWECX, C_None, C_None)),
-  {SETO} (Ch: (C_WOp1, C_None, C_None)),
- {SETNO} (Ch: (C_WOp1, C_None, C_None)),
-{SETNAE} (Ch: (C_WOp1, C_None, C_None)),
- {SETNB} (Ch: (C_WOp1, C_None, C_None)),
-  {SETZ} (Ch: (C_WOp1, C_None, C_None)),
- {SETNZ} (Ch: (C_WOp1, C_None, C_None)),
- {SETNA} (Ch: (C_WOp1, C_None, C_None)),
-{SETNBE} (Ch: (C_WOp1, C_None, C_None)),
-  {SETS} (Ch: (C_WOp1, C_None, C_None)),
- {SETNS} (Ch: (C_WOp1, C_None, C_None)),
-  {SETP} (Ch: (C_WOp1, C_None, C_None)),
- {SETPE} (Ch: (C_WOp1, C_None, C_None)),
- {SETNP} (Ch: (C_WOp1, C_None, C_None)),
- {SETPO} (Ch: (C_WOp1, C_None, C_None)),
-{SETNGE} (Ch: (C_WOp1, C_None, C_None)),
- {SETNL} (Ch: (C_WOp1, C_None, C_None)),
- {SETNG} (Ch: (C_WOp1, C_None, C_None)),
-{SETNLE} (Ch: (C_WOp1, C_None, C_None)),
-  {ARPL} (Ch: (C_Flags, C_None, C_None)),
+{BOUNDL} (Ch: (C_ROp1, C_None, C_None)),
+{BOUNDW} (Ch: (C_ROp1, C_None, C_None)),
+ {LOOPZ} (Ch: (C_RWECX, C_RFlags, C_None)),
+ {LOOPE} (Ch: (C_RWECX, C_RFlags, C_None)),
+{LOOPNZ} (Ch: (C_RWECX, C_RFlags, C_None)),
+{LOOPNE} (Ch: (C_RWECX, C_RFlags, C_None)),
+  {SETO} (Ch: (C_WOp1, C_RFlags, C_None)),
+ {SETNO} (Ch: (C_WOp1, C_RFlags, C_None)),
+{SETNAE} (Ch: (C_WOp1, C_RFlags, C_None)),
+ {SETNB} (Ch: (C_WOp1, C_RFlags, C_None)),
+  {SETZ} (Ch: (C_WOp1, C_RFlags, C_None)),
+ {SETNZ} (Ch: (C_WOp1, C_RFlags, C_None)),
+ {SETNA} (Ch: (C_WOp1, C_RFlags, C_None)),
+{SETNBE} (Ch: (C_WOp1, C_RFlags, C_None)),
+  {SETS} (Ch: (C_WOp1, C_RFlags, C_None)),
+ {SETNS} (Ch: (C_WOp1, C_RFlags, C_None)),
+  {SETP} (Ch: (C_WOp1, C_RFlags, C_None)),
+ {SETPE} (Ch: (C_WOp1, C_RFlags, C_None)),
+ {SETNP} (Ch: (C_WOp1, C_RFlags, C_None)),
+ {SETPO} (Ch: (C_WOp1, C_RFlags, C_None)),
+{SETNGE} (Ch: (C_WOp1, C_RFlags, C_None)),
+ {SETNL} (Ch: (C_WOp1, C_RFlags, C_None)),
+ {SETNG} (Ch: (C_WOp1, C_RFlags, C_None)),
+{SETNLE} (Ch: (C_WOp1, C_RFlags, C_None)),
+  {ARPL} (Ch: (C_WFlags, C_None, C_None)),
    {LAR} (Ch: (C_WOp2, C_None, C_None)),
   {LGDT} (Ch: (C_None, C_None, C_None)),
   {LIDT} (Ch: (C_None, C_None, C_None)),
   {LLDT} (Ch: (C_None, C_None, C_None)),
   {LMSW} (Ch: (C_None, C_None, C_None)),
-   {LSL} (Ch: (C_WOp2, C_Flags, C_None)),
+   {LSL} (Ch: (C_WOp2, C_WFlags, C_None)),
    {LTR} (Ch: (C_None, C_None, C_None)),
   {SGDT} (Ch: (C_WOp1, C_None, C_None)),
   {SIDT} (Ch: (C_WOp1, C_None, C_None)),
   {SLDT} (Ch: (C_WOp1, C_None, C_None)),
   {SMSW} (Ch: (C_WOp1, C_None, C_None)),
   {STR}  (Ch: (C_WOp1, C_None, C_None)),
-  {VERR} (Ch: (C_Flags, C_None, C_None)),
-  {VERW} (Ch: (C_Flags, C_None, C_None)),
+  {VERR} (Ch: (C_WFlags, C_None, C_None)),
+  {VERW} (Ch: (C_WFlags, C_None, C_None)),
   {FABS} (Ch: (C_FPU, C_None, C_None)),
   {FBLD} (Ch: (C_FPU, C_None, C_None)),
  {FBSTP} (Ch: (C_WOp1, C_None, C_None)),
@@ -546,10 +550,10 @@ Const AsmInstr: Array[tasmop] Of TAsmInstrucProp = (
 {FIDIVRL}(Ch: (C_FPU, C_None, C_None)),
 {FDIVRL} (Ch: (C_FPU, C_None, C_None)),
 {FIDIVRS}(Ch: (C_FPU, C_None, C_None)),
-  {REPE} (Ch: (C_RWECX, C_None, C_None)),
- {REPNE} (Ch: (C_RWECX, C_None, C_None)),
+  {REPE} (Ch: (C_RWECX, C_RFlags, C_None)),
+ {REPNE} (Ch: (C_RWECX, C_RFlags, C_None)),
  {FADDS} (Ch: (C_FPU, C_None, C_None)),
- {POPFD} (Ch: (C_RWESP, C_Flags, C_None)),
+ {POPFD} (Ch: (C_RWESP, C_WFlags, C_None)),
 {below are the MMX instructions}
 {A_EMMS} (Ch: (C_FPU, C_None, C_None)),
 {A_MOVD} (Ch: (C_WOp2, C_None, C_None)),
@@ -672,7 +676,9 @@ Procedure BuildLabelTableAndFixRegAlloc(AsmL: PAasmOutput; Var LabelTable: PLabe
 {Builds a table with the locations of the labels in the paasmoutput.
  Also fixes some RegDeallocs like "# %eax released; push (%eax)"}
 Var p, hp1, hp2: Pai;
+    UsedRegs: TRegSet;
 Begin
+  UsedRegs := [];
   If (LabelDif <> 0) Then
     Begin
 {$IfDef TP}
@@ -685,23 +691,49 @@ Begin
             p := pai(AsmL^.first);
             While Assigned(p) Do
               Begin
-                If (p^.typ = ait_label) And
-                   (Pai_Label(p)^.l^.is_used) Then
-                  LabelTable^[Pai_Label(p)^.l^.nb-LowLabel].PaiObj := p
-                Else
-                  If (p^.typ = ait_regdealloc) And
-                     Not(FindRegAlloc(PaiRegAlloc(p)^.Reg, Pai(p^.Next))) And
-                     GetNextInstruction(p, hp1) And
-                     (RegInInstruction(PaiRegAlloc(p)^.Reg, hp1)) Then
+                Case p^.typ Of
+                  ait_Label:
+                    If Pai_Label(p)^.l^.is_used Then
+                      LabelTable^[Pai_Label(p)^.l^.nb-LowLabel].PaiObj := p;
+                  ait_RegAlloc:
+                    Begin
+                      If Not(PaiRegAlloc(p)^.Reg in UsedRegs) Then
+                        UsedRegs := UsedRegs + [PaiRegAlloc(p)^.Reg]
+                      Else
+                        Begin
+                          hp1 := p;
+                          hp2 := nil;
+                          While GetLastInstruction(hp1, hp1) And
+                                Not(RegInInstruction(PaiRegAlloc(p)^.Reg, hp1)) Do
+                            hp2 := hp1;
+                         If hp2 <> nil Then
+                           Begin
+                             hp1 := New(PaiRegDeAlloc, Init(PaiRegAlloc(p)^.Reg));
+                             InsertLLItem(AsmL, Pai(hp2^.previous), hp2, hp1);
+                           End;
+                        End;
+                    End;
+                  ait_RegDeAlloc:
                     Begin
-                      hp2 := Pai(p^.previous);
-                      AsmL^.Remove(p);
-                      InsertLLItem(AsmL, hp1, Pai(hp1^.Next), p);
-                      p := hp2;
+                      UsedRegs := UsedRegs - [PaiRegDeAlloc(p)^.Reg];
+                      hp1 := p;
+                      hp2 := nil;
+                      While Not(FindRegAlloc(PaiRegDeAlloc(p)^.Reg, Pai(hp1^.Next))) And
+                            GetNextInstruction(hp1, hp1) And
+                            RegInInstruction(PaiRegDeAlloc(p)^.Reg, hp1) Do
+                        hp2 := hp1;
+                      If hp2 <> nil Then
+                        Begin
+                          hp1 := Pai(p^.previous);
+                          AsmL^.Remove(p);
+                          InsertLLItem(AsmL, hp2, Pai(hp2^.Next), p);
+                          p := hp1;
+                        End;
                     End;
+                End;
                 P := Pai(p^.Next);
                 While Assigned(p) And
-                      (p^.typ in (SkipInstr - [ait_regdealloc])) Do
+                      (p^.typ in (SkipInstr - [ait_regdealloc,ait_regalloc])) Do
                   P := Pai(P^.Next);
               End;
 {$IfDef TP}
@@ -967,8 +999,8 @@ Begin
   If GetLastInstruction(p1, hp)
     Then
       RegModifiedByInstruction :=
-        PPAiProp(p1^.fileinfo.line)^.Regs[Reg].State <>
-          PPAiProp(hp^.fileinfo.line)^.Regs[Reg].State
+        PPAiProp(p1^.fileinfo.line)^.Regs[Reg].WState <>
+          PPAiProp(hp^.fileinfo.line)^.Regs[Reg].WState
     Else RegModifiedByInstruction := True;
 End;
 
@@ -1047,8 +1079,8 @@ End;
 
 Procedure UpdateUsedRegs(Var UsedRegs: TRegSet; p: Pai);
 {updates UsedRegs with the RegAlloc Information coming after P}
+Var hp: Pai;
 Begin
-{  p := Pai(p^.next);}
   Repeat
     While Assigned(p) And
           ((p^.typ in (SkipInstr - [ait_RegAlloc, ait_RegDealloc])) or
@@ -1060,7 +1092,7 @@ Begin
       Begin
         Case p^.typ Of
           ait_RegAlloc: UsedRegs := UsedRegs + [PaiRegAlloc(p)^.Reg];
-          ait_regdealloc: UsedRegs := UsedRegs - [PaiRegAlloc(p)^.Reg];
+          ait_regdealloc: UsedRegs := UsedRegs - [PaiRegDeAlloc(p)^.Reg];
         End;
         p := pai(p^.next);
       End;
@@ -1101,11 +1133,11 @@ Begin
       Else InternalError($db)
 End;
 
-Procedure IncState(Var S: Word);
+Procedure IncState(Var S: Byte);
 {Increases S by 1, wraps around at $ffff to 0 (so we won't get overflow
  errors}
 Begin
-  If (s <> $ffff)
+  If (s <> $ff)
     Then Inc(s)
     Else s := 0
 End;
@@ -1154,7 +1186,7 @@ End;
 Procedure DestroyReg(p1: PPaiProp; 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 TmpState: Longint;
+Var TmpState: Byte;
     Counter: TRegister;
 Begin
   Reg := Reg32(Reg);
@@ -1164,10 +1196,10 @@ Begin
       Begin
         With p1^.Regs[Reg] Do
           Begin
-            IncState(State);
-            TmpState := State;
+            IncState(WState);
+            TmpState := WState;
             FillChar(p1^.Regs[Reg], SizeOf(TContent), 0);
-            State := TmpState;
+            WState := TmpState;
           End;
         For Counter := R_EAX to R_EDI Do
           With p1^.Regs[Counter] Do
@@ -1175,10 +1207,10 @@ Begin
                RegInSequence(Reg, p1^.Regs[Counter])
               Then
                 Begin
-                  IncState(State);
-                  TmpState := State;
+                  IncState(WState);
+                  TmpState := WState;
                   FillChar(p1^.Regs[Counter], SizeOf(TContent), 0);
-                  State := TmpState;
+                  WState := TmpState;
                 End;
        End;
 End;
@@ -1238,15 +1270,6 @@ Begin {checks whether the two ops are equal}
   End;
 End; *)
 
-(* Function RegsSameContent(p1, p2: Pai; Reg: TRegister): Boolean;
-{checks whether Reg has the same content in the PPaiProp of p1 and p2}
-Begin
-  Reg := Reg32(Reg);
-  RegsSameContent :=
-    PPaiProp(p1^.fileinfo.line)^.Regs[Reg].State =
-    PPaiProp(p2^.fileinfo.line)^.Regs[Reg].State;
-End; *)
-
 Function InstructionsEquivalent(p1, p2: Pai; Var RegInfo: TRegInfo): Boolean;
 Begin {checks whether two Pai386 instructions are equal}
   If Assigned(p1) And Assigned(p2) And
@@ -1498,7 +1521,7 @@ First: Pai): Pai;
 Var
     CurProp: PPaiProp;
 {$ifdef AnalyzeLoops}
-    TmpState,
+    TmpState: Byte;
 {$endif AnalyzeLoops}
     Cnt, InstrCnt : Longint;
     InstrProp: TAsmInstrucProp;
@@ -1539,18 +1562,11 @@ Begin
           Begin
             FillChar(CurProp^, SizeOf(CurProp^), 0);
 {            For TmpReg := R_EAX to R_EDI Do
-              CurProp^.Regs[TmpReg].State := 1;}
+              CurProp^.Regs[TmpReg].WState := 1;}
           End;
       CurProp^.UsedRegs := UsedRegs;
       CurProp^.CanBeRemoved := False;
       UpdateUsedRegs(UsedRegs, Pai(p^.Next));
-{$ifdef csdebug}
-      If R_EAX in usedregs then
-        begin
-          hp := new(pai_asm_comment,init(strpnew('eax in set')));
-          InsertLLItem(AsmL, p, p^.next, hp);
-        end;
-{$endif csdebug}
 {$ifdef TP}
       CurProp^.linesave := p^.fileinfo.line;
       PPaiProp(p^.fileinfo.line) := CurProp;
@@ -1588,8 +1604,8 @@ Begin
    previous intruction has been executed have to be taken into account as well}
                             For TmpReg := R_EAX to R_EDI Do
                               Begin
-                                If (CurProp^.Regs[TmpReg].State <>
-                                    PPaiProp(hp^.FileInfo.Line)^.Regs[TmpReg].State)
+                                If (CurProp^.Regs[TmpReg].WState <>
+                                    PPaiProp(hp^.FileInfo.Line)^.Regs[TmpReg].WState)
                                   Then DestroyReg(CurProp, TmpReg)
                               End
                       End
@@ -1670,8 +1686,8 @@ Begin
                     Else
                       Begin
                         For TmpReg := R_EAX to R_EDI Do
-                          If (PaiPropBlock^[InstrNr].Regs[TmpReg].State <>
-                             CurProp^.Regs[TmpReg].State) Then
+                          If (PaiPropBlock^[InstrNr].Regs[TmpReg].WState <>
+                             CurProp^.Regs[TmpReg].WState) Then
                             DestroyReg(@PaiPropBlock^[InstrNr], TmpReg);
                         Inc(JmpsProcessed);
                       End
@@ -1688,20 +1704,20 @@ Begin
                         Begin
                           Inc(JmpsProcessed);
                           For TmpReg := R_EAX to R_EDI Do
-                            If (PaiPropBlock^[InstrNr].Regs[TmpReg].State <>
-                                CurProp^.Regs[TmpReg].State)
+                            If (PaiPropBlock^[InstrNr].Regs[TmpReg].WState <>
+                                CurProp^.Regs[TmpReg].WState)
                               Then
                                 Begin
-                                  TmpState := PaiPropBlock^[InstrNr].Regs[TmpReg].State;
+                                  TmpState := PaiPropBlock^[InstrNr].Regs[TmpReg].WState;
                                   Cnt := InstrNr;
-                                  While (TmpState = PaiPropBlock^[Cnt].Regs[TmpReg].State) Do
+                                  While (TmpState = PaiPropBlock^[Cnt].Regs[TmpReg].WState) Do
                                     Begin
                                       DestroyReg(@PaiPropBlock^[Cnt], TmpReg);
                                       Inc(Cnt);
                                     End;
                                   While (Cnt <= InstrCnt) Do
                                     Begin
-                                      Inc(PaiPropBlock^[Cnt].Regs[TmpReg].State);
+                                      Inc(PaiPropBlock^[Cnt].Regs[TmpReg].WState);
                                       Inc(Cnt)
                                     End
                                 End;
@@ -1713,22 +1729,22 @@ Begin
                           Inc(JmpsProcessed);
                           For TmpReg := R_EAX to R_EDI Do
                             Begin
-                              TmpState := PaiPropBlock^[InstrNr].Regs[TmpReg].State;
+                              TmpState := PaiPropBlock^[InstrNr].Regs[TmpReg].WState;
                               Cnt := InstrNr;
-                              While (TmpState = PaiPropBlock^[Cnt].Regs[TmpReg].State) Do
+                              While (TmpState = PaiPropBlock^[Cnt].Regs[TmpReg].WState) Do
                                 Begin
                                   PaiPropBlock^[Cnt].Regs[TmpReg] := CurProp^.Regs[TmpReg];
                                   Inc(Cnt);
                                 End;
-                              TmpState := PaiPropBlock^[InstrNr].Regs[TmpReg].State;
-                              While (TmpState = PaiPropBlock^[Cnt].Regs[TmpReg].State) Do
+                              TmpState := PaiPropBlock^[InstrNr].Regs[TmpReg].WState;
+                              While (TmpState = PaiPropBlock^[Cnt].Regs[TmpReg].WState) Do
                                 Begin
                                   DestroyReg(@PaiPropBlock^[Cnt], TmpReg);
                                   Inc(Cnt);
                                 End;
                               While (Cnt <= InstrCnt) Do
                                 Begin
-                                  Inc(PaiPropBlock^[Cnt].Regs[TmpReg].State);
+                                  Inc(PaiPropBlock^[Cnt].Regs[TmpReg].WState);
                                   Inc(Cnt)
                                 End
                             End
@@ -1768,7 +1784,7 @@ Begin
                             Begin
                               With CurProp^.Regs[TmpReg] Do
                                 Begin
-                                  IncState(State);
+                                  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}
@@ -1788,7 +1804,7 @@ Begin
                                 End;
                             End;
 {$ifdef StateDebug}
-                  hp := new(pai_asm_comment,init(strpnew(att_reg2str[TmpReg]+': '+tostr(CurProp^.Regs[TmpReg].State))));
+                  hp := new(pai_asm_comment,init(strpnew(att_reg2str[TmpReg]+': '+tostr(CurProp^.Regs[TmpReg].WState))));
                   InsertLLItem(AsmL, p, p^.next, hp);
 {$endif StateDebug}
 
@@ -1801,8 +1817,6 @@ Begin
                               TmpReg := Reg32(TRegister(Pai386(p)^.op2));
                               With CurProp^.Regs[TmpReg] Do
                                 Begin
-                                {it doesn't matter that the state is changed,
-                                 it isn't looked at when removing constant reloads}
                                   DestroyReg(CurProp, TmpReg);
                                   typ := Con_Const;
                                   StartMod := Pai386(p)^.op1;
@@ -1851,9 +1865,13 @@ Begin
                         (InstrProp.Ch[Cnt] <> C_None) Do
                     Begin
                       Case InstrProp.Ch[Cnt] Of
+                        C_REAX..C_REDI: ;
                         C_WEAX..C_RWEDI: DestroyReg(CurProp, TCh2Reg(InstrProp.Ch[Cnt]));
                         C_CDirFlag: CurProp^.DirFlag := F_NotSet;
                         C_SDirFlag: CurProp^.DirFlag := F_Set;
+                        C_ROp1:;
+                        C_ROp2:;
+                        C_ROp3:;
                         C_WOp1..C_RWOp1: Destroy(p, Pai386(p)^.op1t, Pai386(p)^.op1);
                         C_WOp2..C_RWOp2: Destroy(p, Pai386(p)^.op2t, Pai386(p)^.op2);
                         C_WOp3..C_RWOp3: Destroy(p, Pai386(p)^.op3t, Pointer(Longint(TwoWords(Pai386(p)^.op2).word2)));
@@ -1863,7 +1881,7 @@ Begin
                             TmpRef.Base := R_EDI;
                             DestroyRefs(p, TmpRef, R_NO)
                           End;
-                        C_Flags, C_FPU:
+                        C_RFlags, C_WFlags, C_RWFlags, C_FPU:
                         Else
                           Begin
                             DestroyAllRegs(CurProp);
@@ -1898,7 +1916,7 @@ Begin
   NrOfPaiObjs := 0;
   While Assigned(P) Do
     Begin
-{$IfNDef TP}
+{$IfDef JumpAnal}
       Case P^.Typ Of
         ait_labeled_instruction:
           begin
@@ -1920,7 +1938,7 @@ Begin
                TmpStr := StrPas(PCSymbol(Pai386(p)^.op1)^.symbol);
                If}
       End;
-{$EndIf TP}
+{$EndIf JumpAnal}
       Inc(NrOfPaiObjs);
       GetNextInstruction(p, p);
     End;
@@ -1973,7 +1991,13 @@ End.
 
 {
  $Log$
- Revision 1.17  1998-10-02 17:30:20  jonas
+ Revision 1.18  1998-10-07 16:27:02  jonas
+   * changed state to WState (WriteState), added RState for future use in
+      instruction scheduling
+   * RegAlloc data from the CG is now completely being patched and corrected (I
+      think)
+
+ Revision 1.17  1998/10/02 17:30:20  jonas
    * small patches to regdealloc data
 
  Revision 1.16  1998/10/01 20:21:47  jonas
@@ -1983,7 +2007,7 @@ End.
    * small compiling problems fixed
 
  Revision 1.14  1998/09/20 17:12:36  jonas
- * small fix for uncertain optimizations & more cleaning up
+   * small fix for uncertain optimizations & more cleaning up
 
  Revision 1.12  1998/09/16 18:00:01  jonas
    * optimizer now completely dependant on GetNext/GetLast instruction, works again with -dRegAlloc