avxtestgenerator: working on new testmethods avx512-memref-operands - 'compressed disp8*N'

git-svn-id: https://svn.freepascal.org/svn/fpc/branches/tg74@48187 3ad0048d-3df7-0310-abae-a5850022a9f2

3 files changed, 1271 insertions, 15 deletions

diff --git a/avx512-0037785/tests/utils/avx/asmtestgenerator.pas b/avx512-0037785/tests/utils/avx/asmtestgenerator.pas
index 21423df5ff..01df2c3afc 100644
--- a/avx512-0037785/tests/utils/avx/asmtestgenerator.pas
+++ b/avx512-0037785/tests/utils/avx/asmtestgenerator.pas
@@ -32,6 +32,8 @@ type
              otXMEM32, otXMEM64, otYMEM32, otYMEM64, otZMEM32, otZMEM64,
              otB32, otB64, otKREG);
 
+  TOpMemType = Set of TOpType;
+
   TOperandListItem = class(TObject)
   private
     FOpActive: boolean;
@@ -89,12 +91,15 @@ type
 
     function InternalCalcTestData(const aInst, aOp1, aOp2, aOp3, aOp4: String): TStringList;
     function InternalCalcTestDataMREF(const aInst, aOp1, aOp2, aOp3, aOp4: String): TStringList;
+    function InternalCalcTestDataCDISP8(const aInst, aOp1, aOp2, aOp3, aOp4: String): TStringList;
   public
     constructor Create;
     destructor Destroy; override;
 
     class procedure CalcTestData(aX64, aAVX512, aSAE: boolean; const aInst, aOp1, aOp2, aOp3, aOp4: String; aSL: TStringList);
     class procedure CalcTestDataMREF(aX64, aAVX512, aSAE: boolean; const aInst, aOp1, aOp2, aOp3, aOp4: String; aSL: TStringList);
+    class procedure CalcTestDataCDisp8(aX64, aAVX512, aSAE: boolean; const aInst, aOp1, aOp2, aOp3, aOp4: String; aSL: TStringList);
+
 
     class procedure CalcTestInstFile;
     class procedure ListMemRefState;
@@ -161,6 +166,9 @@ const
                                                  msiZMem32, msiZMem64,
                                                  msiVMemMultiple, msiVMemRegSize];
 
+  OTMEMTYPES: TOpMemType = [otXMMRM, otXMMRM16, otXMMRM8, otYMMRM, otZMMRM,
+                            otMem8, otMem16, otMem32, otMem64, otMem128, otMem256, otMem512,
+                            otRM32, otRM64, otB32, otB64];
 
 var
   InsTabCache : PInsTabCache;
@@ -3548,6 +3556,1050 @@ begin
   end;
 end;
 
+function TAsmTestGenerator.InternalCalcTestDataCDISP8(const aInst, aOp1, aOp2,
+  aOp3, aOp4: String): TStringList;
+var
+  i: integer;
+  Item: TOperandListItem;
+  OItem1: TOperandListItem;
+  OItem2: TOperandListItem;
+  OItem3: TOperandListItem;
+  OItem4: TOperandListItem;
+
+  il_Op: integer;
+  il_Op1: integer;
+  il_Op2: integer;
+  il_Op3: integer;
+  il_Op4: integer;
+
+  sSuffix: string;
+  sl_Operand: String;
+  sl_Inst   : String;
+  sl_RegCombi: String;
+  sl_Prefix: String;
+  UsePrefix: boolean;
+  il_Operands: integer;
+  UsedParams: cardinal;
+  UseDefault: boolean;
+  sl_RegCombi1: string;
+  sl_RegCombi2: string;
+  sl_RegCombi3: string;
+  MaskRegNeeded:boolean;
+
+
+  function PrepareOperandTyp(const aTyp: String): String;
+  begin
+    result := aTyp;
+    if copy(result, length(result), 1) = '*' then result := copy(result, 1, length(result) - 1);
+    if result = 'XMMRM128' then result := 'XMMRM';
+    if result = 'YMMRM256' then result := 'YMMRM';
+  end;
+
+
+begin
+  result := TStringList.Create;
+
+  OItem1 := TOperandListItem.Create;
+  try
+    OItem2 := TOperandListItem.Create;
+    try
+      OItem3 := TOperandListItem.Create;
+      try
+        OItem4 := TOperandListItem.Create;
+        try
+
+          UsePrefix := (UpperCase(aInst) = 'VCVTPD2DQ') OR
+                       (UpperCase(aInst) = 'VCVTPD2PS') OR
+                       (UpperCase(aInst) = 'VCVTSI2SD') OR
+                       (UpperCase(aInst) = 'VCVTSI2SS') OR
+                       (UpperCase(aInst) = 'VCVTTPD2DQ') or
+                       (UpperCase(aInst) = 'VPMOVZXWQ') or
+                       (UpperCase(aInst) = 'VCVTPD2UDQ') or
+                       (UpperCase(aInst) = 'VCVTPD2UDQ') or
+                       (UpperCase(aInst) = 'VCVTTPD2UDQ') or
+                       (UpperCase(aInst) = 'VCVTUQQ2PS') or
+                       (UpperCase(aInst) = 'VCVTQQ2PS') or
+                       (UpperCase(aInst) = 'VCVTUSI2SD') or
+                       (UpperCase(aInst) = 'VCVTUSI2SS') or
+                       (UpperCase(aInst) = 'VFPCLASSPD') or
+                       (UpperCase(aInst) = 'VFPCLASSPS') or
+                       (UpperCase(aInst) = 'VCMPSS')
+
+                       ;
+
+
+          MaskRegNeeded := (Pos('VGATHER', Uppercase(aInst)) = 1) or
+                           (Pos('VPGATHER', Uppercase(aInst)) = 1) or
+			   (Pos('VPSCATTER', Uppercase(aInst)) = 1) or
+			   (Pos('VSCATTER', Uppercase(aInst)) = 1);
+
+          for il_Op := 1 to 4 do
+          begin
+            sl_Prefix := '';
+
+            case il_Op of
+              1: begin
+                   Item := OItem1;
+                   sl_Operand := aOp1;
+                 end;
+              2: begin
+                   Item := OItem2;
+                   sl_Operand := aOp2;
+                 end;
+              3: begin
+                   Item := OItem3;
+                   sl_Operand := aOp3;
+                 end;
+              4: begin
+                   Item := OItem4;
+                   sl_Operand := aOp4;
+                 end;
+            end;
+
+            sl_Operand := PrepareOperandTyp(sl_Operand);
+
+            if (AnsiSameText(sl_Operand, 'XMMREG')) then
+            begin
+              Item.OpNumber := il_Op;
+              Item.OpTyp    := otXMMReg;
+              Item.OpActive := true;
+
+              Item.Values.Add('XMM0');
+            end
+            else if (AnsiSameText(sl_Operand, 'XMMREG_M')) or
+                    (AnsiSameText(sl_Operand, 'XMMREG_MZ')) or
+                    (AnsiSameText(sl_Operand, 'XMMREG_ER')) or
+                    (AnsiSameText(sl_Operand, 'XMMREG_SAE')) then
+            begin
+              Item.OpNumber := il_Op;
+              Item.OpTyp    := otXMMReg;
+              Item.OpActive := true;
+
+              sSuffix := '';
+              if Pos('_MZ', AnsiUppercase(sl_Operand)) > 0 then sSuffix := ' {k1} {z}'
+               else if Pos('_M', AnsiUppercase(sl_Operand)) > 0 then sSuffix := ' {k1}';
+
+              if Pos('_ER', sl_Operand) > 0 then sSuffix := ', {ru-sae}'
+               else if FSAE and (Pos('_SAE', AnsiUppercase(sl_Operand)) > 0) then sSuffix := ', {sae}';
+
+              Item.Values.Add('XMM0' + sSuffix);
+              if (sSuffix <> '') and
+                 (MaskRegNeeded = false) then Item.Values.Add('XMM0');
+            end
+            else if (AnsiSameText(sl_Operand, 'XMMRM')) or
+                    (AnsiSameText(sl_Operand, 'XMMRM_M')) or
+                    (AnsiSameText(sl_Operand, 'XMMRM_MZ')) or
+                    (AnsiSameText(sl_Operand, 'XMMRM_ER')) or
+                    (AnsiSameText(sl_Operand, 'XMMRM_SAE')) then
+            begin
+              Item.OpNumber := il_Op;
+              Item.OpTyp    := otXMMRM;
+              Item.OpActive := true;
+
+              if UsePrefix then sl_Prefix := 'oword ';
+
+              if x64 then MemRegBaseIndexCombi(sl_Prefix, '', FReg64Base, FReg64Index, Item.Values)
+               else MemRegBaseIndexCombi(sl_Prefix, '', FReg32Base, FReg32Index, Item.Values);
+            end
+            else if (AnsiSameText(sl_Operand, 'XMMRM8')) or
+                    (AnsiSameText(sl_Operand, 'XMMRM8_M')) or
+                    (AnsiSameText(sl_Operand, 'XMMRM8_MZ')) or
+                    (AnsiSameText(sl_Operand, 'XMMRM8_ER')) or
+                    (AnsiSameText(sl_Operand, 'XMMRM8_SAE')) then
+            begin
+              Item.OpNumber := il_Op;
+              Item.OpTyp    := otXMMRM8;
+              Item.OpActive := true;
+
+              if UsePrefix then sl_Prefix := 'byte ';
+
+              if x64 then MemRegBaseIndexCombi(sl_Prefix, '', FReg64Base, FReg64Index, Item.Values)
+               else MemRegBaseIndexCombi(sl_Prefix, '', FReg32Base, FReg32Index, Item.Values);
+            end
+            else if (AnsiSameText(sl_Operand, 'XMMRM16')) or
+                    (AnsiSameText(sl_Operand, 'XMMRM16_M')) or
+                    (AnsiSameText(sl_Operand, 'XMMRM16_MZ')) or
+                    (AnsiSameText(sl_Operand, 'XMMRM16_ER')) or
+                    (AnsiSameText(sl_Operand, 'XMMRM16_SAE'))
+                    then
+            begin
+              Item.OpNumber := il_Op;
+              Item.OpTyp    := otXMMRM16;
+              Item.OpActive := true;
+
+              if UsePrefix then sl_Prefix := 'word ';
+
+              if x64 then MemRegBaseIndexCombi(sl_Prefix, '', FReg64Base, FReg64Index, Item.Values)
+               else MemRegBaseIndexCombi(sl_Prefix, '', FReg32Base, FReg32Index, Item.Values);
+            end
+            else if (AnsiSameText(sl_Operand, 'YMMREG')) then
+            begin
+              Item.OpNumber := il_Op;
+              Item.OpTyp    := otYMMReg;
+              Item.OpActive := true;
+
+              Item.Values.Add('YMM0');
+            end
+            else if (AnsiSameText(sl_Operand, 'YMMREG_M')) or
+                    (AnsiSameText(sl_Operand, 'YMMREG_MZ')) or
+                    (AnsiSameText(sl_Operand, 'YMMREG_ER')) or
+                    (AnsiSameText(sl_Operand, 'YMMREG_SAE'))
+                    then
+            begin
+              Item.OpNumber := il_Op;
+              Item.OpTyp    := otYMMReg;
+              Item.OpActive := true;
+
+              sSuffix := '';
+              if Pos('_MZ', AnsiUppercase(sl_Operand)) > 0 then sSuffix := ' {k1} {z}'
+               else if Pos('_M', AnsiUppercase(sl_Operand)) > 0 then sSuffix := ' {k1}';
+
+              if Pos('_ER', AnsiUppercase(sl_Operand)) > 0 then sSuffix := ', {rd-sae}'
+               else if FSAE and (Pos('_SAE', AnsiUppercase(sl_Operand)) > 0) then sSuffix := ', {sae}';
+
+              Item.Values.Add('YMM0' + sSuffix);
+              if (sSuffix <> '') and
+                 (MaskRegNeeded = false) then Item.Values.Add('YMM0');
+            end
+            else if (AnsiSameText(sl_Operand, 'YMMRM'))  or
+                    (AnsiSameText(sl_Operand, 'YMMRM_M')) or
+                    (AnsiSameText(sl_Operand, 'YMMRM_MZ')) or
+                    (AnsiSameText(sl_Operand, 'YMMRM_ER')) or
+                    (AnsiSameText(sl_Operand, 'YMMRM_SAE'))
+                    then
+            begin
+              Item.OpNumber := il_Op;
+              Item.OpTyp    := otYMMRM;
+              Item.OpActive := true;
+
+              if UsePrefix then sl_Prefix := 'yword ';
+
+              sSuffix := '';
+              if Pos('_MZ', AnsiUppercase(sl_Operand)) > 0 then sSuffix := ' {k1} {z}'
+               else if Pos('_M', AnsiUppercase(sl_Operand)) > 0 then sSuffix := ' {k1}';
+
+              if Pos('_ER', AnsiUppercase(sl_Operand)) > 0 then sSuffix := ', {rd-sae}'
+               else if FSAE and (Pos('_SAE', AnsiUppercase(sl_Operand)) > 0) then sSuffix := ', {sae}';
+
+              if x64 then MemRegBaseIndexCombi(sl_Prefix, '', FReg64Base, FReg64Index, Item.Values)
+               else MemRegBaseIndexCombi(sl_Prefix, '', FReg32Base, FReg32Index, Item.Values);
+            end
+            else if (AnsiSameText(sl_Operand, 'ZMMREG')) then
+            begin
+              Item.OpNumber := il_Op;
+              Item.OpTyp    := otZMMReg;
+              Item.OpActive := true;
+
+              Item.Values.Add('ZMM0');
+            end
+            else if (AnsiSameText(sl_Operand, 'ZMMREG_M')) or
+                    (AnsiSameText(sl_Operand, 'ZMMREG_MZ')) or
+                    (AnsiSameText(sl_Operand, 'ZMMREG_ER')) or
+                    (AnsiSameText(sl_Operand, 'ZMMREG_SAE'))
+                    then
+            begin
+              Item.OpNumber := il_Op;
+              Item.OpTyp    := otZMMReg;
+              Item.OpActive := true;
+
+              sSuffix := '';
+              if Pos('_MZ', AnsiUppercase(sl_Operand)) > 0 then sSuffix := ' {k1} {z}'
+               else if Pos('_M', AnsiUppercase(sl_Operand)) > 0 then sSuffix := ' {k1}';
+
+              if Pos('_ER', AnsiUppercase(sl_Operand)) > 0 then sSuffix := ', {rd-sae}'
+               else if FSAE and (Pos('_SAE', AnsiUppercase(sl_Operand)) > 0) then sSuffix := ', {sae}';
+
+              if x64 then MemRegBaseIndexCombi(sl_Prefix, '', FReg64Base, FReg64Index, Item.Values)
+               else MemRegBaseIndexCombi(sl_Prefix, '', FReg32Base, FReg32Index, Item.Values);
+            end
+            else if (AnsiSameText(sl_Operand, 'ZMMRM')) or
+                    (AnsiSameText(sl_Operand, 'ZMMRM_M')) or
+                    (AnsiSameText(sl_Operand, 'ZMMRM_MZ')) or
+                    (AnsiSameText(sl_Operand, 'XMMRM_ER')) or
+                    (AnsiSameText(sl_Operand, 'XMMRM_SAE'))
+                    then
+            begin
+              Item.OpNumber := il_Op;
+              Item.OpTyp    := otZMMRM;
+              Item.OpActive := true;
+
+              if UsePrefix then sl_Prefix := 'zword ';
+
+              sSuffix := '';
+              if Pos('_MZ', AnsiUppercase(sl_Operand)) > 0 then sSuffix := ' {k1} {z}'
+               else if Pos('_M', AnsiUppercase(sl_Operand)) > 0 then sSuffix := ' {k1}';
+
+              if Pos('_ER', AnsiUppercase(sl_Operand)) > 0 then sSuffix := ', {rd-sae}'
+               else if FSAE and (Pos('_SAE', AnsiUppercase(sl_Operand)) > 0) then sSuffix := ', {sae}';
+
+              if x64 then MemRegBaseIndexCombi(sl_Prefix, '', FReg64Base, FReg64Index, Item.Values)
+               else MemRegBaseIndexCombi(sl_Prefix, '', FReg32Base, FReg32Index, Item.Values);
+            end
+            else if AnsiSameText(sl_Operand, 'MEM8') then
+            begin
+              Item.OpNumber := il_Op;
+              Item.OpTyp    := otMEM8;
+              Item.OpActive := true;
+
+
+
+	      if UsePrefix then sl_Prefix := 'byte ';
+
+
+              sSuffix := '';
+
+	      if x64 then
+              begin
+                MemRegBaseIndexCombi(sl_Prefix, '', FReg64Base, FReg64Index, Item.Values);
+                //MemRegBaseIndexCombi(FReg6432Base, FReg6432Index, Item.Values);
+              end
+              else MemRegBaseIndexCombi(sl_prefix, '', FReg32Base, FReg32Index, Item.Values);
+            end
+            else if AnsiSameText(sl_Operand, 'MEM16') or
+                    AnsiSameText(sl_Operand, 'MEM16_M') then
+            begin
+              Item.OpNumber := il_Op;
+              Item.OpTyp    := otMEM16;
+              Item.OpActive := true;
+
+              if UsePrefix then sl_Prefix := 'word ';
+
+              sSuffix := '';
+              if Pos('_M', AnsiUppercase(sl_Operand)) > 0 then sSuffix := ' {k1}';
+
+              if x64 then
+              begin
+                MemRegBaseIndexCombi(sl_Prefix, sSuffix, FReg64Base, FReg64Index, Item.Values);
+                //MemRegBaseIndexCombi(FReg6432Base, FReg6432Index, Item.Values);
+              end
+              else MemRegBaseIndexCombi(sl_Prefix, sSuffix, FReg32Base, FReg32Index, Item.Values);
+            end
+            else if AnsiSameText(sl_Operand, 'MEM32') or
+                    AnsiSameText(sl_Operand, 'MEM32_M') or
+                    AnsiSameText(sl_Operand, 'MEM32_MZ') then
+            begin
+              Item.OpNumber := il_Op;
+              Item.OpTyp    := otMEM32;
+              Item.OpActive := true;
+
+              if UsePrefix then sl_Prefix := 'dword ';
+
+              sSuffix := '';
+
+	      if Pos('_M', AnsiUppercase(sl_Operand)) > 0 then sSuffix := ' {k1}';
+              if Pos('_MZ', AnsiUppercase(sl_Operand)) > 0 then sSuffix := ' {k1} {z}';
+
+
+              if x64 then
+              begin
+                MemRegBaseIndexCombi(sl_prefix, sSuffix, FReg64Base, FReg64Index, Item.Values);
+                //MemRegBaseIndexCombi(FReg6432Base, FReg6432Index, Item.Values);
+              end
+              else MemRegBaseIndexCombi(sl_prefix, sSuffix, FReg32Base, FReg32Index, Item.Values);
+            end
+            else if (AnsiSameText(sl_Operand, 'MEM64')) or
+                    (AnsiSameText(sl_Operand, 'MEM64_M')) or
+                    (AnsiSameText(sl_Operand, 'MEM64_MZ')) then
+            begin
+              Item.OpNumber := il_Op;
+              Item.OpTyp    := otMEM64;
+              Item.OpActive := true;
+
+              if UsePrefix then sl_Prefix := 'qword ';
+
+              sSuffix := '';
+              if Pos('_M', AnsiUppercase(sl_Operand)) > 0 then sSuffix := ' {k1}';
+              if Pos('_MZ', AnsiUppercase(sl_Operand)) > 0 then sSuffix := ' {k1} {z}';
+
+              if x64 then
+              begin
+                MemRegBaseIndexCombi(sl_Prefix, sSuffix, FReg64Base, FReg64Index, Item.Values);
+                //MemRegBaseIndexCombi(FReg6432Base, FReg6432Index, Item.Values);
+              end
+              else MemRegBaseIndexCombi(sl_prefix, sSuffix, FReg32Base, FReg32Index, Item.Values);
+            end
+            else if (AnsiSameText(sl_Operand, 'MEM128')) or
+                    (AnsiSameText(sl_Operand, 'MEM128_M')) or
+                    (AnsiSameText(sl_Operand, 'MEM128_MZ')) then
+            begin
+              Item.OpNumber := il_Op;
+              Item.OpTyp    := otMEM128;
+              Item.OpActive := true;
+
+              if UsePrefix then sl_Prefix := 'oword ';
+
+              sSuffix := '';
+              if Pos('_M', AnsiUppercase(sl_Operand)) > 0 then sSuffix := ' {k1}';
+              if Pos('_MZ', AnsiUppercase(sl_Operand)) > 0 then sSuffix := ' {k1} {z}';
+
+              if x64 then
+              begin
+                MemRegBaseIndexCombi(sl_prefix, sSuffix, FReg64Base, FReg64Index, Item.Values);
+                //MemRegBaseIndexCombi(FReg6432Base, FReg6432Index, Item.Values);
+              end
+              else MemRegBaseIndexCombi(sl_prefix, sSuffix, FReg32Base, FReg32Index, Item.Values);
+            end
+            else if (AnsiSameText(sl_Operand, 'MEM256')) or
+                    (AnsiSameText(sl_Operand, 'MEM256_M')) or
+                    (AnsiSameText(sl_Operand, 'MEM256_MZ')) then
+            begin
+              Item.OpNumber := il_Op;
+              Item.OpTyp    := otMEM256;
+              Item.OpActive := true;
+
+              if UsePrefix then sl_Prefix := 'yword ';
+
+              sSuffix := '';
+              if Pos('_M', AnsiUppercase(sl_Operand)) > 0 then sSuffix := ' {k1}';
+              if Pos('_MZ', AnsiUppercase(sl_Operand)) > 0 then sSuffix := ' {k1} {z}';
+
+
+              if x64 then
+              begin
+                MemRegBaseIndexCombi(sl_prefix, sSuffix, FReg64Base, FReg64Index, Item.Values);
+                //MemRegBaseIndexCombi(FReg6432Base, FReg6432Index, Item.Values);
+              end
+              else MemRegBaseIndexCombi(sl_prefix, sSuffix, FReg32Base, FReg32Index, Item.Values);
+            end
+            else if (AnsiSameText(sl_Operand, 'MEM512')) or
+                    (AnsiSameText(sl_Operand, 'MEM512_M')) or
+                    (AnsiSameText(sl_Operand, 'MEM512_MZ')) then
+            begin
+              Item.OpNumber := il_Op;
+              Item.OpTyp    := otMEM512;
+              Item.OpActive := true;
+
+              if UsePrefix then sl_Prefix := 'zword ';
+
+              sSuffix := '';
+              if Pos('_M', AnsiUppercase(sl_Operand)) > 0 then sSuffix := ' {k1}';
+              if Pos('_MZ', AnsiUppercase(sl_Operand)) > 0 then sSuffix := ' {k1} {z}';
+
+
+              if x64 then
+              begin
+                MemRegBaseIndexCombi(sl_prefix, sSuffix, FReg64Base, FReg64Index, Item.Values);
+                //MemRegBaseIndexCombi(FReg6432Base, FReg6432Index, Item.Values);
+              end
+              else MemRegBaseIndexCombi(sl_prefix, sSuffix, FReg32Base, FReg32Index, Item.Values);
+            end
+            else if AnsiSameText(sl_Operand, 'REG8') then
+            begin
+              Item.OpNumber := il_Op;
+              Item.OpTyp    := otREG8;
+              Item.OpActive := true;
+
+              if x64 then
+              begin
+                Item.Values.AddStrings(FReg8);
+              end
+              else Item.Values.AddStrings(FReg8);
+            end
+            else if AnsiSameText(sl_Operand, 'REG16') then
+            begin
+              Item.OpNumber := il_Op;
+              Item.OpTyp    := otREG16;
+              Item.OpActive := true;
+
+              if x64 then
+              begin
+                Item.Values.AddStrings(FReg16);
+              end
+              else Item.Values.AddStrings(FReg16);
+            end
+            else if AnsiSameText(sl_Operand, 'REG32') then
+            begin
+              Item.OpNumber := il_Op;
+              Item.OpTyp    := otREG32;
+              Item.OpActive := true;
+
+              if x64 then
+              begin
+                Item.Values.AddStrings(FReg32Base);
+              end
+              else Item.Values.AddStrings(FReg32Base);
+            end
+            else if AnsiSameText(sl_Operand, 'REG64') then
+            begin
+              Item.OpNumber := il_Op;
+              Item.OpTyp    := otREG64;
+              Item.OpActive := true;
+
+              if x64 then
+              begin
+                Item.Values.AddStrings(FReg64Base);
+              end;
+            end
+            else if AnsiSameText(sl_Operand, 'RM32') then
+            begin
+              Item.OpNumber := il_Op;
+              Item.OpTyp    := otRM32;
+              Item.OpActive := true;
+
+              Item.Values.AddStrings(FReg32Base);
+
+              if UsePrefix then sl_Prefix := 'dword ';
+
+              if x64 then
+              begin
+                MemRegBaseIndexCombi(sl_Prefix, '', FReg64Base, FReg64Index, Item.Values);
+                //MemRegBaseIndexCombi(FReg6432Base, FReg6432Index, Item.Values);
+              end
+              else MemRegBaseIndexCombi(sl_prefix, '', FReg32Base, FReg32Index, Item.Values);
+            end
+            else if AnsiSameText(sl_Operand, 'RM64') then
+            begin
+              Item.OpNumber := il_Op;
+              Item.OpTyp    := otRM32;
+              Item.OpActive := true;
+
+
+
+              if UsePrefix then sl_Prefix := 'qword ';
+
+              if x64 then
+              begin
+                Item.Values.AddStrings(FReg64Base);
+                MemRegBaseIndexCombi(sl_Prefix, '', FReg64Base, FReg64Index, Item.Values);
+                //MemRegBaseIndexCombi(FReg6432Base, FReg6432Index, Item.Values);
+              end
+              else MemRegBaseIndexCombi(sl_prefix, '', FReg32Base, FReg32Index, Item.Values);
+            end
+            else if AnsiSameText(sl_Operand, 'IMM8') then
+            begin
+              Item.OpNumber := il_Op;
+              Item.OpTyp    := otIMM8;
+              Item.OpActive := true;
+
+              Item.Values.Add('0');
+            end
+            else if AnsiSameText(sl_Operand, 'XMEM32') or
+                    AnsiSameText(sl_Operand, 'XMEM32_M') then
+            begin
+              Item.OpNumber := il_Op;
+              Item.OpTyp    := otXMEM32;
+              Item.OpActive := true;
+
+              if UsePrefix then sl_Prefix := 'oword ';
+
+              sSuffix := '';
+              if Pos('_M', AnsiUppercase(sl_Operand)) > 0 then sSuffix := ' {k1}';
+
+              if x64 then
+              begin
+		VectorMemRegBaseIndexCombi(sl_prefix, sSuffix, FReg64Base, FReg64XMMIndex, Item.Values);
+		if (sSuffix <> '') and
+                   (MaskRegNeeded = false) then
+ 		 VectorMemRegBaseIndexCombi(sl_prefix, '', FReg64Base, FReg64XMMIndex, Item.Values);
+              end
+              else
+              begin
+                VectorMemRegBaseIndexCombi(sl_prefix, sSuffix, FReg32Base, FReg32XMMIndex, Item.Values);
+		if (sSuffix <> '') and
+                   (MaskRegNeeded = false) then
+                 VectorMemRegBaseIndexCombi(sl_prefix, '', FReg32Base, FReg32XMMIndex, Item.Values);
+              end;
+            end
+            else if AnsiSameText(sl_Operand, 'XMEM64') or
+                    AnsiSameText(sl_Operand, 'XMEM64_M') then
+            begin
+              Item.OpNumber := il_Op;
+              Item.OpTyp    := otXMEM64;
+              Item.OpActive := true;
+
+              //if UsePrefix then sl_Prefix := 'oword ';
+              //
+              //if x64 then
+              //begin
+              //  VectorMemRegBaseIndexCombi(sl_prefix, FReg64Base, FReg64XMMIndex, Item.Values);
+              //end
+              //else
+              //begin
+              //  VectorMemRegBaseIndexCombi(sl_prefix, FReg32Base, FReg32XMMIndex, Item.Values);
+              //end;
+
+              sSuffix := '';
+              if Pos('_M', AnsiUppercase(sl_Operand)) > 0 then sSuffix := ' {k1}';
+
+              if x64 then
+              begin
+                VectorMemRegBaseIndexCombi(sl_prefix, sSuffix, FReg64Base, FReg64XMMIndex, Item.Values);
+                if (sSuffix <> '') and
+                   (MaskRegNeeded = false)
+                        then
+ 		 VectorMemRegBaseIndexCombi(sl_prefix, '', FReg64Base, FReg64XMMIndex, Item.Values);
+              end
+              else
+              begin
+                VectorMemRegBaseIndexCombi(sl_prefix, sSuffix, FReg32Base, FReg32XMMIndex, Item.Values);
+                if (sSuffix <> '') and
+                   (MaskRegNeeded = false)
+                        then
+ 		 VectorMemRegBaseIndexCombi(sl_prefix, '', FReg32Base, FReg32XMMIndex, Item.Values);
+              end;
+
+            end
+            else if AnsiSameText(sl_Operand, 'YMEM32') or
+                    AnsiSameText(sl_Operand, 'YMEM32_M') then
+            begin
+              Item.OpNumber := il_Op;
+              Item.OpTyp    := otYMEM32;
+              Item.OpActive := true;
+
+              if UsePrefix then sl_Prefix := 'yword ';
+
+              //if x64 then
+              //begin
+              //  VectorMemRegBaseIndexCombi(sl_prefix, FReg64Base, FReg64YMMIndex, Item.Values);
+              //end
+              //else
+              //begin
+              //  VectorMemRegBaseIndexCombi(sl_prefix, FReg32Base, FReg32YMMIndex, Item.Values);
+              //end;
+
+              sSuffix := '';
+              if Pos('_M', AnsiUppercase(sl_Operand)) > 0 then sSuffix := ' {k1}';
+
+              if x64 then
+              begin
+                VectorMemRegBaseIndexCombi(sl_prefix, sSuffix, FReg64Base, FReg64YMMIndex, Item.Values);
+                if (sSuffix <> '') and
+                   (MaskRegNeeded = false)
+                        then
+		 VectorMemRegBaseIndexCombi(sl_prefix, '', FReg64Base, FReg64YMMIndex, Item.Values);
+              end
+              else
+              begin
+                VectorMemRegBaseIndexCombi(sl_prefix, sSuffix, FReg32Base, FReg32YMMIndex, Item.Values);
+                if (sSuffix <> '') and
+                   (MaskRegNeeded = false)
+                        then
+		 VectorMemRegBaseIndexCombi(sl_prefix, '', FReg32Base, FReg32YMMIndex, Item.Values);
+              end;
+
+            end
+            else if AnsiSameText(sl_Operand, 'YMEM64') or
+                    AnsiSameText(sl_Operand, 'YMEM64_M') then
+            begin
+              Item.OpNumber := il_Op;
+              Item.OpTyp    := otYMEM64;
+              Item.OpActive := true;
+
+              if UsePrefix then sl_Prefix := 'yword ';
+
+              //if x64 then
+              //begin
+              //  VectorMemRegBaseIndexCombi(sl_prefix, FReg64Base, FReg64YMMIndex, Item.Values);
+              //end
+              //else
+              //begin
+              //  VectorMemRegBaseIndexCombi(sl_prefix, FReg32Base, FReg32YMMIndex, Item.Values);
+              //end;
+
+              sSuffix := '';
+              if Pos('_M', AnsiUppercase(sl_Operand)) > 0 then sSuffix := ' {k1}';
+
+              if x64 then
+              begin
+                VectorMemRegBaseIndexCombi(sl_prefix, sSuffix, FReg64Base, FReg64YMMIndex, Item.Values);
+		if (sSuffix <> '') and
+                   (MaskRegNeeded = false)
+                        then
+                 VectorMemRegBaseIndexCombi(sl_prefix, '', FReg64Base, FReg64YMMIndex, Item.Values);
+              end
+              else
+              begin
+                VectorMemRegBaseIndexCombi(sl_prefix, sSuffix, FReg32Base, FReg32YMMIndex, Item.Values);
+                if (sSuffix <> '') and
+                   (MaskRegNeeded = false)
+                        then
+		 VectorMemRegBaseIndexCombi(sl_prefix, '', FReg32Base, FReg32YMMIndex, Item.Values);
+              end;
+
+            end
+            else if AnsiSameText(sl_Operand, 'ZMEM32') or
+                    AnsiSameText(sl_Operand, 'ZMEM32_M')  then
+            begin
+              Item.OpNumber := il_Op;
+              Item.OpTyp    := otZMEM32;
+              Item.OpActive := true;
+
+              if UsePrefix then sl_Prefix := 'zword ';
+
+              //if x64 then
+              //begin
+              //  VectorMemRegBaseIndexCombi(sl_prefix, FReg64Base, FReg64ZMMIndex, Item.Values);
+              //end
+              //else
+              //begin
+              //  VectorMemRegBaseIndexCombi(sl_prefix, FReg32Base, FReg32ZMMIndex, Item.Values);
+              //end;
+
+              sSuffix := '';
+              if Pos('_M', AnsiUppercase(sl_Operand)) > 0 then sSuffix := ' {k1}';
+
+              if x64 then
+              begin
+                VectorMemRegBaseIndexCombi(sl_prefix, sSuffix, FReg64Base, FReg64ZMMIndex, Item.Values);
+		if (sSuffix <> '') and
+                   (MaskRegNeeded = false)
+                        then
+                 VectorMemRegBaseIndexCombi(sl_prefix, '', FReg64Base, FReg64ZMMIndex, Item.Values);
+              end
+              else
+              begin
+                VectorMemRegBaseIndexCombi(sl_prefix, sSuffix, FReg32Base, FReg32ZMMIndex, Item.Values);
+		if (sSuffix <> '') and
+                   (MaskRegNeeded = false)
+                        then
+                 VectorMemRegBaseIndexCombi(sl_prefix, '', FReg32Base, FReg32ZMMIndex, Item.Values);
+              end;
+
+            end
+            else if AnsiSameText(sl_Operand, 'ZMEM64') or
+                    AnsiSameText(sl_Operand, 'ZMEM64_M') then
+            begin
+              Item.OpNumber := il_Op;
+              Item.OpTyp    := otZMEM64;
+              Item.OpActive := true;
+
+              if UsePrefix then sl_Prefix := 'zword ';
+
+              //if x64 then
+              //begin
+              //  VectorMemRegBaseIndexCombi(sl_prefix, FReg64Base, FReg64ZMMIndex, Item.Values);
+              //end
+              //else
+              //begin
+              //  VectorMemRegBaseIndexCombi(sl_prefix, FReg32Base, FReg32ZMMIndex, Item.Values);
+              //end;
+
+              sSuffix := '';
+              if Pos('_M', AnsiUppercase(sl_Operand)) > 0 then sSuffix := ' {k1}';
+
+              if x64 then
+              begin
+                VectorMemRegBaseIndexCombi(sl_prefix, sSuffix, FReg64Base, FReg64ZMMIndex, Item.Values);
+		if (sSuffix <> '') and
+                   (MaskRegNeeded = false)
+                        then
+                 VectorMemRegBaseIndexCombi(sl_prefix, '', FReg64Base, FReg64ZMMIndex, Item.Values);
+              end
+              else
+              begin
+                VectorMemRegBaseIndexCombi(sl_prefix, sSuffix, FReg32Base, FReg32ZMMIndex, Item.Values);
+                if (sSuffix <> '') and
+                   (MaskRegNeeded = false)
+                        then
+		 VectorMemRegBaseIndexCombi(sl_prefix, '', FReg32Base, FReg32ZMMIndex, Item.Values);
+              end;
+
+            end
+            else if AnsiSameText(sl_Operand, '2B32') then
+            begin
+              Item.OpNumber := il_Op;
+              Item.OpTyp    := otB32;
+              Item.OpActive := true;
+
+
+              if x64 then
+              begin
+                MemRegBaseIndexCombi(sl_Prefix, ' {1to2}',  FReg64Base, FReg64Index, Item.Values);
+                //MemRegBaseIndexCombi(FReg6432Base, FReg6432Index, Item.Values);
+              end
+              else MemRegBaseIndexCombi(sl_prefix, ' {1to2}', FReg32Base, FReg32Index, Item.Values);
+            end
+            else if AnsiSameText(sl_Operand, '4B32') then
+            begin
+              Item.OpNumber := il_Op;
+              Item.OpTyp    := otB32;
+              Item.OpActive := true;
+
+
+              if x64 then
+              begin
+                MemRegBaseIndexCombi(sl_Prefix, ' {1to4}',  FReg64Base, FReg64Index, Item.Values);
+                //MemRegBaseIndexCombi(FReg6432Base, FReg6432Index, Item.Values);
+              end
+              else MemRegBaseIndexCombi(sl_prefix, ' {1to4}', FReg32Base, FReg32Index, Item.Values);
+            end
+            else if AnsiSameText(sl_Operand, '8B32') then
+            begin
+              Item.OpNumber := il_Op;
+              Item.OpTyp    := otB32;
+              Item.OpActive := true;
+
+
+              if x64 then
+              begin
+                MemRegBaseIndexCombi(sl_Prefix, ' {1to8}',  FReg64Base, FReg64Index, Item.Values);
+                //MemRegBaseIndexCombi(FReg6432Base, FReg6432Index, Item.Values);
+              end
+              else MemRegBaseIndexCombi(sl_prefix, ' {1to8}', FReg32Base, FReg32Index, Item.Values);
+            end
+            else if AnsiSameText(sl_Operand, '16B32') then
+            begin
+              Item.OpNumber := il_Op;
+              Item.OpTyp    := otB32;
+              Item.OpActive := true;
+
+
+              if x64 then
+              begin
+                MemRegBaseIndexCombi(sl_Prefix, ' {1to16}',  FReg64Base, FReg64Index, Item.Values);
+                //MemRegBaseIndexCombi(FReg6432Base, FReg6432Index, Item.Values);
+              end
+              else MemRegBaseIndexCombi(sl_prefix, ' {1to16}', FReg32Base, FReg32Index, Item.Values);
+            end
+            else if AnsiSameText(sl_Operand, '2B64') then
+            begin
+              Item.OpNumber := il_Op;
+              Item.OpTyp    := otB64;
+              Item.OpActive := true;
+
+
+              if x64 then
+              begin
+                MemRegBaseIndexCombi(sl_Prefix, ' {1to2}',  FReg64Base, FReg64Index, Item.Values);
+                //MemRegBaseIndexCombi(FReg6432Base, FReg6432Index, Item.Values);
+              end
+              else MemRegBaseIndexCombi(sl_prefix, ' {1to2}', FReg32Base, FReg32Index, Item.Values);
+            end
+            else if AnsiSameText(sl_Operand, '4B64') then
+            begin
+              Item.OpNumber := il_Op;
+              Item.OpTyp    := otB64;
+              Item.OpActive := true;
+
+
+              if x64 then
+              begin
+                MemRegBaseIndexCombi(sl_Prefix, ' {1to4}',  FReg64Base, FReg64Index, Item.Values);
+                //MemRegBaseIndexCombi(FReg6432Base, FReg6432Index, Item.Values);
+              end
+              else MemRegBaseIndexCombi(sl_prefix, ' {1to4}', FReg32Base, FReg32Index, Item.Values);
+            end
+            else if AnsiSameText(sl_Operand, '8B64') then
+            begin
+              Item.OpNumber := il_Op;
+              Item.OpTyp    := otB64;
+              Item.OpActive := true;
+
+
+              if x64 then
+              begin
+                MemRegBaseIndexCombi(sl_Prefix, ' {1to8}',  FReg64Base, FReg64Index, Item.Values);
+                //MemRegBaseIndexCombi(FReg6432Base, FReg6432Index, Item.Values);
+              end
+              else MemRegBaseIndexCombi(sl_prefix, ' {1to8}', FReg32Base, FReg32Index, Item.Values);
+            end
+            else if AnsiSameText(sl_Operand, '16B64') then
+            begin
+              Item.OpNumber := il_Op;
+              Item.OpTyp    := otB64;
+              Item.OpActive := true;
+
+
+              if x64 then
+              begin
+                MemRegBaseIndexCombi(sl_Prefix, ' {1to16}',  FReg64Base, FReg64Index, Item.Values);
+                //MemRegBaseIndexCombi(FReg6432Base, FReg6432Index, Item.Values);
+              end
+              else MemRegBaseIndexCombi(sl_prefix, ' {1to16}', FReg32Base, FReg32Index, Item.Values);
+            end
+            else if AnsiSameText(sl_Operand, 'KREG') or
+                    AnsiSameText(sl_Operand, 'KREG_M') then
+            begin
+              Item.OpNumber := il_Op;
+              Item.OpTyp    := otKREG;
+              Item.OpActive := true;
+
+              sSuffix := '';
+              if Pos('_M', AnsiUppercase(sl_Operand)) > 0 then sSuffix := ' {k1}';
+
+              if UsePrefix then sl_Prefix := '';
+
+              for i := 0 to FRegKREG.Count - 1 do
+               Item.Values.Add(FRegKREG[i] + sSuffix);
+            end
+            else if trim(sl_Operand) = '' then
+            begin
+              Item.OpNumber := il_Op;
+              Item.OpTyp    := otUnknown;
+              Item.OpActive := false;
+
+              Item.Values.Add('');
+            end
+            else
+            begin
+              Item.OpNumber := il_Op;
+              Item.OpTyp    := otUnknown;
+              Item.OpActive := false;
+
+              Item.Values.Add('?' + sl_Operand);
+            end
+
+          end;
+
+          sl_RegCombi := '';
+
+
+          il_Operands := 0;
+          UsedParams  := 0;
+
+          if OItem1.OpActive then
+          begin
+            inc(il_Operands);
+            UsedParams := UsedParams or 1;
+          end;
+
+          if OItem2.OpActive then
+          begin
+            inc(il_Operands);
+            UsedParams := UsedParams or 2;
+          end;
+
+          if OItem3.OpActive then
+          begin
+            inc(il_Operands);
+            UsedParams := UsedParams or 4;
+          end;
+
+          if OItem4.OpActive then
+          begin
+            inc(il_Operands);
+            UsedParams := UsedParams or 8;
+          end;
+
+          case il_Operands of
+              1: UseDefault := UsedParams <> 1;
+              2: UseDefault := UsedParams <> 3;
+              3: UseDefault := UsedParams <> 7;
+              4: UseDefault := UsedParams <> 15;
+            else UseDefault := true;
+          end;
+
+          //UseDefault := true;
+
+          if UseDefault then
+          begin
+            sl_Inst := format('%-20s', [aInst]);
+
+            for il_Op1 := 0 to OItem1.Values.Count - 1 do
+            begin
+              for il_Op2 := 0 to OItem2.Values.Count - 1 do
+              begin
+                for il_Op3 := 0 to OItem3.Values.Count - 1 do
+                begin
+                  for il_Op4 := 0 to OItem4.Values.Count - 1 do
+                  begin
+                    sl_RegCombi := '';
+
+                    if OItem1.OpActive then
+                    begin
+                      if sl_RegCombi <> '' then sl_RegCombi := sl_RegCombi + ', ';
+                      sl_RegCombi := sl_RegCombi + OItem1.Values[il_Op1];
+                    end;
+
+                    if OItem2.OpActive then
+                    begin
+                      if sl_RegCombi <> '' then sl_RegCombi := sl_RegCombi + ', ';
+                      sl_RegCombi := sl_RegCombi + OItem2.Values[il_Op2];
+                    end;
+
+                    if OItem3.OpActive then
+                    begin
+                      if sl_RegCombi <> '' then sl_RegCombi := sl_RegCombi + ', ';
+                      sl_RegCombi := sl_RegCombi + OItem3.Values[il_Op3];
+                    end;
+
+                    if OItem4.OpActive then
+                    begin
+                      if sl_RegCombi <> '' then sl_RegCombi := sl_RegCombi + ', ';
+                      sl_RegCombi := sl_RegCombi + OItem4.Values[il_Op4];
+                    end;
+
+                    if sl_RegCombi <> '' then
+                    begin
+                      //result.Add(format('%-20s%s', [aInst, sl_RegCombi]));
+                      result.Add(sl_Inst + sl_RegCombi);
+                      sl_RegCombi := '';
+                    end;
+                  end;
+                end;
+              end;
+            end;
+          end
+          else
+          begin
+            sl_Inst := format('%-20s', [aInst]);
+
+            for il_Op1 := 0 to OItem1.Values.Count - 1 do
+            begin
+              if OItem1.OpActive then
+              begin
+                sl_RegCombi1 := OItem1.Values[il_Op1];
+              end
+              else sl_RegCombi1 := '';
+
+              for il_Op2 := 0 to OItem2.Values.Count - 1 do
+              begin
+                if OItem2.OpActive then
+                begin
+                  sl_RegCombi2 := sl_RegCombi1 + ', ' + OItem2.Values[il_Op2];
+                end
+                else sl_RegCombi2 := sl_RegCombi1;
+
+                for il_Op3 := 0 to OItem3.Values.Count - 1 do
+                begin
+                  if OItem3.OpActive then
+                  begin
+                    sl_RegCombi3 := sl_RegCombi2 + ', ' + OItem3.Values[il_Op3];
+                  end
+                  else sl_RegCombi3 := sl_RegCombi2;
+
+                  for il_Op4 := 0 to OItem4.Values.Count - 1 do
+                  begin
+                    if OItem4.OpActive then
+                    begin
+                      sl_RegCombi := sl_RegCombi3 + ', ' + OItem4.Values[il_Op4];
+                    end
+                    else sl_RegCombi := sl_RegCombi3;
+
+                    if (sl_RegCombi <> '') and
+                       (
+                        (OItem1.OpActive and (OItem1.OpTyp in OTMEMTYPES)) or
+                        (OItem2.OpActive and (OItem2.OpTyp in OTMEMTYPES)) or
+                        (OItem3.OpActive and (OItem3.OpTyp in OTMEMTYPES)) or
+                        (OItem4.OpActive and (OItem4.OpTyp in OTMEMTYPES))
+                       ) then
+                    begin
+                      //result.Add(format('%-20s%s', [aInst, sl_RegCombi]));
+                      result.Add(sl_Inst + sl_RegCombi);
+
+
+
+                      sl_RegCombi := '';
+                    end;
+                  end;
+                end;
+              end;
+            end;
+          end;
+        finally
+          FreeAndNil(OItem4);
+        end;
+      finally
+        FreeAndNil(OItem3);
+      end;
+    finally
+      FreeAndNil(OItem2);
+    end;
+  finally
+    FreeAndNil(OItem1);
+  end;
+end;
+
 
 constructor TAsmTestGenerator.Create;
 begin
@@ -3921,6 +4973,28 @@ begin
   end;
 end;
 
+class procedure TAsmTestGenerator.CalcTestDataCDisp8(aX64, aAVX512,
+  aSAE: boolean; const aInst, aOp1, aOp2, aOp3, aOp4: String; aSL: TStringList);
+var
+  sl: TStringList;
+begin
+  with TAsmTestGenerator.Create do
+  try
+    Fx64 := aX64;
+    FAVX512 := aAVX512;
+    FSAE    := aSAE;
+
+    sl := InternalCalcTestDataCDisp8(aInst, aOp1, aOp2, aOp3, aOp4);
+    try
+      aSL.AddStrings(sl);
+    finally
+      FreeAndNil(sl);
+    end;
+  finally
+    Free;
+  end;
+end;
+
 
 
 class procedure TAsmTestGenerator.CalcTestInstFile;
diff --git a/avx512-0037785/tests/utils/avx/avxopcodes.pas b/avx512-0037785/tests/utils/avx/avxopcodes.pas
index 9915b8d80a..4c4b6ba7db 100644
--- a/avx512-0037785/tests/utils/avx/avxopcodes.pas
+++ b/avx512-0037785/tests/utils/avx/avxopcodes.pas
@@ -8,7 +8,7 @@ uses Classes;
 
 type
 
-  TTestFileTyp = (tfNasm, tfFPC, tfFasm, tfFPCInc, tfFPCMRef);
+  TTestFileTyp = (tfNasm, tfFPC, tfFasm, tfFPCInc, tfFPCMRef, tfFPCCDisp8);
 
   { TAVXTestGenerator }
 
@@ -18,7 +18,10 @@ type
   protected
     procedure Init;
 
+    function SaveFile(aAsmList: TStringList; aOpcode, aDestPath, aFileExt: String; aHeaderList, aFooterList: TStringList): boolean;
+
     function InternalMakeTestFiles(aMRef, aX64, aAVX512, aSAE: boolean; aDestPath, aFilemask, aFileExt: String; aOpCodeList, aHeaderList, aFooterList: TStringList): boolean;
+    function InternalMakeTestFilesCDisp8(aX64, aAVX512, aSAE: boolean; aDestPath, aFilemask, aFileExt: String; aOpCodeList, aHeaderList, aFooterList: TStringList): boolean;
 
   public
     constructor Create;
@@ -3277,6 +3280,22 @@ begin
   FOpCodeList.Add('VPSHUFBITQMB,1,1,1,kreg_m,zmmreg,zmmrm,');
 end;
 
+function TAVXTestGenerator.SaveFile(aAsmList: TStringList; aOpcode, aDestPath,
+  aFileExt: String; aHeaderList, aFooterList: TStringList): boolean;
+begin
+  begin
+    result := false;
+
+    if aAsmList.Count > 0 then
+    begin
+      aAsmList.Insert(0, StringReplace(aHeaderList.Text, '$$$OPCODE$$$', aOpCode, [rfReplaceAll]));
+      aAsmList.AddStrings(StringReplace(aFooterList.Text, '$$$OPCODE$$$', aOpCode, [rfReplaceAll]));
+
+      aAsmList.SaveToFile(IncludeTrailingBackslash(aDestPath) + aOpCode + aFileExt);
+    end;
+  end;
+end;
+
 function TAVXTestGenerator.InternalMakeTestFiles(aMRef, aX64, aAVX512, aSAE: boolean; aDestPath, aFilemask, aFileExt: String;
                                         aOpCodeList, aHeaderList, aFooterList: TStringList): boolean;
 var
@@ -3292,18 +3311,18 @@ var
   NewOpCode: String;
   FoundNewOpcode: boolean;
 
-  function SaveFile(aAsmList: TStringList; aOpcode, aDestPath, aFileExt: String; aHeaderList, aFooterList: TStringList): boolean;
-  begin
-    result := false;
-
-    if aAsmList.Count > 0 then
-    begin
-      aAsmList.Insert(0, StringReplace(aHeaderList.Text, '$$$OPCODE$$$', aOpCode, [rfReplaceAll]));
-      aAsmList.AddStrings(StringReplace(aFooterList.Text, '$$$OPCODE$$$', aOpCode, [rfReplaceAll]));
-
-      aAsmList.SaveToFile(IncludeTrailingBackslash(aDestPath) + aOpCode + aFileExt);
-    end;
-  end;
+  //function SaveFile(aAsmList: TStringList; aOpcode, aDestPath, aFileExt: String; aHeaderList, aFooterList: TStringList): boolean;
+  //begin
+  //  result := false;
+  //
+  //  if aAsmList.Count > 0 then
+  //  begin
+  //    aAsmList.Insert(0, StringReplace(aHeaderList.Text, '$$$OPCODE$$$', aOpCode, [rfReplaceAll]));
+  //    aAsmList.AddStrings(StringReplace(aFooterList.Text, '$$$OPCODE$$$', aOpCode, [rfReplaceAll]));
+  //
+  //    aAsmList.SaveToFile(IncludeTrailingBackslash(aDestPath) + aOpCode + aFileExt);
+  //  end;
+  //end;
 
 begin
   result := false;
@@ -3395,6 +3414,101 @@ begin
   end;
 end;
 
+function TAVXTestGenerator.InternalMakeTestFilesCDisp8(aX64, aAVX512,
+  aSAE: boolean; aDestPath, aFilemask, aFileExt: String; aOpCodeList,
+  aHeaderList, aFooterList: TStringList): boolean;
+var
+  i,j: integer;
+  sData: string;
+  sDestFile: string;
+  sLocalVarDataTyp: string;
+  sl: TStringList;
+  slAsm: TStringList;
+  slLocalHeader: TStringList;
+  slFilemask: TStringList;
+  LastOpCode: String;
+  NewOpCode: String;
+  FoundNewOpcode: boolean;
+
+begin
+  result := false;
+
+  aOpCodeList.Sort;
+
+  sl := TStringList.Create;
+  try
+    slAsm := TStringList.Create;
+    try
+      slFilemask := TStringList.Create;
+      try
+        slFilemask.CommaText := ansilowercase(aFilemask);
+
+        LastOpCode := '';
+
+        for i := 0 to aOpCodeList.Count - 1 do
+        begin
+          sl.Clear;
+          sl.CommaText := aOpCodeList[i];
+
+          while sl.Count < 8 do sl.Add('');
+
+          NewOpCode := ansilowercase(sl[0]);
+
+          FoundNewOpcode := false;
+          for j := 0 to slFilemask.Count - 1 do
+          begin
+            if Pos(slFilemask[j], NewOpCode) = 1 then
+             FoundNewOpcode := true;
+          end;
+
+          if not(FoundNewOpcode) and (slFilemask.Count > 0) then
+           NewOpcode := '';
+
+          if NewOpCode <> '' then
+          begin
+            if (not(aX64) and (sl[1] = '1')) or // i386
+               (aX64 and (sl[2] = '1')) then    // x86_64
+            begin
+	      sDestFile := format('%s_%d%s', [NewOpcode, i, trim(copy(sl[4],1,1) + copy(sl[5],1,1) + copy(sl[6],1,1) + copy(sl[7],1,1))]);
+
+              slLocalHeader := TStringList.Create;
+              try
+                slLocalHeader.Text := aHeaderList.text;
+
+	        if (sl[4]  = '') and
+                   (sl[5]  = '') and
+                   (sl[6]  = '') and
+                   (sl[7]  = '') then
+                begin                                        // Opcode with no Params, e.g. VZEROALL
+                  slAsm.Add('    ' + sl[0]);
+                end
+                else
+	        begin
+   	          TAsmTestGenerator.CalcTestData(aX64, aAVX512 and (sl[3] = '1'), aSAE, sl[0], sl[4], sl[5], sl[6], sl[7], slAsm);
+	        end;
+
+                SaveFile(slAsm, sDestFile, aDestPath, aFileExt, slLocalHeader, aFooterList);
+                writeln(format('%s%s%s', [aDestPath, sDestFile, aFileExt]));
+
+              finally
+                FreeAndNil(slLocalHeader);
+              end;
+
+              slAsm.Clear;
+            end;
+          end;
+        end;
+      finally
+        FreeAndNil(slFilemask);
+      end;
+    finally
+      FreeAndNil(slAsm);
+    end;
+  finally
+    FreeAndNil(sl);
+  end;
+end;
+
 function TAVXTestGenerator.MakeTestFiles(aTyp: TTestFileTyp; aX64, aAVX512, aSAE: boolean;
   aDestPath, aFilemask: String): boolean;
 var
@@ -3542,6 +3656,70 @@ begin
                   slFooter.Add('begin');
                   slFooter.Add('end.');
                 end;
+         tfFPCCDisp8:
+                begin
+                  writeln(format('outputformat: fpc  platform: %s  path: %s',
+                                 [cPlatform[aX64], aDestPath]));
+
+                  FileExt := '.pp';
+
+                  slHeader.Add('Program $$$OPCODE$$$;');
+                  slHeader.Add('{$asmmode intel}');
+
+                  slHeader.Add('const');
+                  slHeader.Add('  cDataBlockByte: Array[0..255] of byte = ( $00, $01, $02, $03, $04, $05, $06, $07, $08, $09, $0A, $0B, $0C, $0D, $0E, $0F,');
+                  slHeader.Add('                                            $10, $11, $12, $13, $14, $15, $16, $17, $18, $19, $1A, $1B, $1C, $1D, $1E, $1F,');
+                  slHeader.Add('                                            $20, $21, $22, $23, $24, $25, $26, $27, $28, $29, $2A, $2B, $2C, $2D, $2E, $2F,');
+                  slHeader.Add('                                            $30, $31, $32, $33, $34, $35, $36, $37, $38, $39, $3A, $3B, $3C, $3D, $3E, $3F,');
+                  slHeader.Add('                                            $40, $41, $42, $43, $44, $45, $46, $47, $48, $49, $4A, $4B, $4C, $4D, $4E, $4F,');
+                  slHeader.Add('                                            $50, $51, $52, $53, $54, $55, $56, $57, $58, $59, $5A, $5B, $5C, $5D, $5E, $5F,');
+                  slHeader.Add('                                            $60, $61, $62, $63, $64, $65, $66, $67, $68, $69, $6A, $6B, $6C, $6D, $6E, $6F,');
+                  slHeader.Add('                                            $70, $71, $72, $73, $74, $75, $76, $77, $78, $79, $7A, $7B, $7C, $7D, $7E, $7F,');
+                  slHeader.Add('                                            $80, $81, $82, $83, $84, $85, $86, $87, $88, $89, $8A, $8B, $8C, $8D, $8E, $8F,');
+                  slHeader.Add('                                            $90, $91, $92, $93, $94, $95, $96, $97, $98, $99, $9A, $9B, $9C, $9D, $9E, $9F,');
+                  slHeader.Add('                                            $A0, $A1, $A2, $A3, $A4, $A5, $A6, $A7, $A8, $A9, $AA, $AB, $AC, $AD, $AE, $AF,');
+                  slHeader.Add('                                            $B0, $B1, $B2, $B3, $B4, $B5, $B6, $B7, $B8, $B9, $BA, $BB, $BC, $BD, $BE, $BF,');
+                  slHeader.Add('                                            $C0, $C1, $C2, $C3, $C4, $C5, $C6, $C7, $C8, $C9, $CA, $CB, $CC, $CD, $CE, $CF,');
+                  slHeader.Add('                                            $D0, $D1, $D2, $D3, $D4, $D5, $D6, $D7, $D8, $D9, $DA, $DB, $DC, $DD, $DE, $DF,');
+                  slHeader.Add('                                            $E0, $E1, $E2, $E3, $E4, $E5, $E6, $E7, $E8, $E9, $EA, $EB, $EC, $ED, $EE, $EF,');
+                  slHeader.Add('                                            $F0, $F1, $F2, $F3, $F4, $F5, $F6, $F7, $F8, $F9, $FA, $FB, $FC, $FD, $FE, $FF);');
+
+
+
+                  slHeader.Add('begin');
+                  slHeader.Add('  asm');
+
+                  slHeader.Add('      vpxord   zmm0,  zmm0,  zmm0');
+                  slHeader.Add('      vpxord   xmm1,  xmm1,  xmm1');
+                  slHeader.Add('      vpxord   xmm2,  xmm2,  xmm2');
+                  slHeader.Add('      vpxord   xmm3,  xmm3,  xmm3');
+                  slHeader.Add('      vpxord   xmm4,  xmm4,  xmm4');
+                  slHeader.Add('      vpcmpeqb   k1,  zmm0,  zmm0');
+
+                  if aX64 then
+                  begin
+                    slHeader.Add('      lea       rax, cDataBlockByte');
+                    slHeader.Add('      push      rax');
+                  end
+                  else
+                  begin
+                    slHeader.Add('      lea       eax, cDataBlockByte');
+                    slHeader.Add('      push      eax');
+                  end;
+
+                  for i := 1 to 10 do
+                   slHeader.Add('NOP');
+
+                  if aX64 then slFooter.Add('        pop rax')
+                   else slFooter.Add('        pop eax');
+
+                  for i := 1 to 10 do
+                   slFooter.Add('NOP');
+
+                  slFooter.Add('  end;');
+                  slFooter.Add('end.');
+
+                end;
          tfFPCInc: begin
                   writeln(format('outputformat: fpc  platform: %s  path: %s',
                                  [cPlatform[aX64], aDestPath]));
@@ -3617,7 +3795,10 @@ begin
                 end;
       end;
 
-      InternalMakeTestFiles(aTyp = tfFPCMRef, aX64, aAVX512, aSAE, aDestPath, aFilemask, Fileext, FOpCodeList, slHeader, slFooter);
+      case aTyp of
+        tfFPCCDisp8: InternalMakeTestFilesCDisp8(aX64, aAVX512, aSAE, aDestPath, aFilemask, Fileext, FOpCodeList, slHeader, slFooter);
+                else InternalMakeTestFiles(aTyp = tfFPCMRef, aX64, aAVX512, aSAE, aDestPath, aFilemask, Fileext, FOpCodeList, slHeader, slFooter);
+      end;
 
     finally
       FreeAndNil(slFooter);
diff --git a/avx512-0037785/tests/utils/avx/avxtestgenerator.pp b/avx512-0037785/tests/utils/avx/avxtestgenerator.pp
index 0b2fc0f2b1..680c7a1ed6 100644
--- a/avx512-0037785/tests/utils/avx/avxtestgenerator.pp
+++ b/avx512-0037785/tests/utils/avx/avxtestgenerator.pp
@@ -42,7 +42,7 @@ begin
         writeln('make avx assembler-testfiles');
         writeln('');
         writeln('-h  help');
-        writeln('-f  [fpc,fpcmref,nasm,fasm,fpcinc] outputformat');
+        writeln('-f  [fpc,fpcmref,fpccd8,nasm,fasm,fpcinc] outputformat');
         writeln('-l  list opcode-memrefsize-states');
         writeln('-m  create only these testfile(s) (e.g. -mvgather,vpgather)');
         writeln('-o  destination path');
@@ -62,6 +62,7 @@ begin
           'n': MakeTestFiles(tfNasm, x64, AVX512, false, Path, Filemask);
           'I': MakeTestFiles(tfFPCInc, x64, AVX512, false, Path, Filemask);
           'm': MakeTestFiles(tfFPCMRef, x64, AVX512, false, Path, Filemask);
+          'd': MakeTestFiles(tfFPCCDisp8, x64, AVX512, false, Path, Filemask);
           'l': ListMemRefState;
         end;
       end;