+ def_cgmmsize() that returns a vector tcgsize for arraydefs (as generated

    for certain parameter locations in the x86-64 parameter manager)
  * full support for vector types in the high level code generator by
    translating arraydefs passed to a_*mm*() methods into vector tcgsizes

git-svn-id: trunk@24762 -

compiler/defutil.pas

@@ -296,6 +296,10 @@ interface
     { #Return an orddef (integer) correspondig to a tcgsize }
     function cgsize_orddef(size: tcgsize): torddef;
 
+    {# Same as def_cgsize, except that it will interpret certain arrays as
+       vectors and return OS_M* sizes for them }
+    function def_cgmmsize(def: tdef): tcgsize;
+
     {# returns true, if the type passed is can be used with windows automation }
     function is_automatable(p : tdef) : boolean;
 
@@ -1272,6 +1276,36 @@ implementation
         end;
       end;
 
+    function def_cgmmsize(def: tdef): tcgsize;
+      begin
+        case def.typ of
+          arraydef:
+            begin
+              if tarraydef(def).elementdef.typ in [orddef,floatdef] then
+                begin
+                  { this is not correct, OS_MX normally mean that the vector
+                    contains elements of size X. However, vectors themselves
+                    can also have different sizes (e.g. a vector of 2 singles on
+                    SSE) and the total size is currently more important }
+                  case def.size of
+                    1: result:=OS_M8;
+                    2: result:=OS_M16;
+                    4: result:=OS_M32;
+                    8: result:=OS_M64;
+                    16: result:=OS_M128;
+                    32: result:=OS_M256;
+                    else
+                      internalerror(2013060103);
+                  end;
+                end
+              else
+                result:=def_cgsize(def);
+            end
+          else
+            result:=def_cgsize(def);
+        end;
+      end;
+
     { In Windows 95 era, ordinals were restricted to [u8bit,s32bit,s16bit,bool16bit]
       As of today, both signed and unsigned types from 8 to 64 bits are supported. }
     function is_automatable(p : tdef) : boolean;

compiler/hlcg2ll.pas

@@ -667,19 +667,16 @@ implementation
       tmpreg: tregister;
       tocgsize: tcgsize;
     begin
-      { no vector support yet }
-      if shuffle<>mms_movescalar then
-        internalerror(2012071225);
-      { sanity check }
-      if def_cgsize(fromsize)<>loc.size then
+      if def_cgmmsize(fromsize)<>loc.size then
         internalerror(2012071226);
-      tocgsize:=getintmmcgsize(reg,def_cgsize(tosize));
+      tocgsize:=getintmmcgsize(reg,def_cgmmsize(tosize));
       case loc.loc of
         LOC_SUBSETREG,LOC_CSUBSETREG,
         LOC_SUBSETREF,LOC_CSUBSETREF:
           begin
             tmpreg:=cg.getintregister(list,loc.size);
             a_load_loc_reg(list,fromsize,fromsize,loc,tmpreg);
+            { integer register -> no def_cgmmsize but plain }
             cg.a_loadmm_intreg_reg(list,def_cgsize(fromsize),tocgsize,tmpreg,reg,shuffle);
           end
         else
@@ -692,11 +689,8 @@ implementation
       fromcgsize: tcgsize;
       tocgsize: tcgsize;
     begin
-      { no vector support yet }
-      if shuffle<>mms_movescalar then
-        internalerror(2012062305);
-      fromcgsize:=getintmmcgsize(reg1,def_cgsize(fromsize));
-      tocgsize:=getintmmcgsize(reg2,def_cgsize(tosize));
+      fromcgsize:=getintmmcgsize(reg1,def_cgmmsize(fromsize));
+      tocgsize:=getintmmcgsize(reg2,def_cgmmsize(tosize));
       { records may be stored in mmregisters, but def_cgsize will return an
         integer size for them... }
       cg.a_loadmm_reg_reg(list,fromcgsize,tocgsize,reg1,reg2,shuffle);
@@ -706,41 +700,32 @@ implementation
     var
       tocgsize: tcgsize;
     begin
-      { no vector support yet }
-      if shuffle<>mms_movescalar then
-        internalerror(2012062306);
       { records may be stored in mmregisters, but def_cgsize will return an
         integer size for them... }
-      tocgsize:=getintmmcgsize(reg,def_cgsize(tosize));
-      cg.a_loadmm_ref_reg(list,def_cgsize(fromsize),tocgsize,ref,reg,shuffle);
+      tocgsize:=getintmmcgsize(reg,def_cgmmsize(tosize));
+      cg.a_loadmm_ref_reg(list,def_cgmmsize(fromsize),tocgsize,ref,reg,shuffle);
     end;
 
   procedure thlcg2ll.a_loadmm_reg_ref(list: TAsmList; fromsize, tosize: tdef; reg: tregister; const ref: treference; shuffle: pmmshuffle);
     var
       fromcgsize: tcgsize;
     begin
-      { no vector support yet }
-      if shuffle<>mms_movescalar then
-        internalerror(2012062307);
       { records may be stored in mmregisters, but def_cgsize will return an
         integer size for them... }
-      fromcgsize:=getintmmcgsize(reg,def_cgsize(fromsize));
-      cg.a_loadmm_reg_ref(list,fromcgsize,def_cgsize(tosize),reg,ref,shuffle);
+      fromcgsize:=getintmmcgsize(reg,def_cgmmsize(fromsize));
+      cg.a_loadmm_reg_ref(list,fromcgsize,def_cgmmsize(tosize),reg,ref,shuffle);
     end;
 
   procedure thlcg2ll.a_loadmm_reg_loc(list: TAsmList; fromsize, tosize: tdef; const reg: tregister; const loc: tlocation; shuffle: pmmshuffle);
     var
       fromcgsize: tcgsize;
     begin
-      { no vector support yet }
-      if shuffle<>mms_movescalar then
-        internalerror(2012071215);
       { sanity check }
-      if def_cgsize(tosize)<>loc.size then
+      if def_cgmmsize(tosize)<>loc.size then
         internalerror(2012071216);
       { records may be stored in mmregisters, but def_cgsize will return an
         integer size for them... }
-      fromcgsize:=getintmmcgsize(reg,def_cgsize(fromsize));
+      fromcgsize:=getintmmcgsize(reg,def_cgmmsize(fromsize));
       cg.a_loadmm_reg_loc(list,fromcgsize,reg,loc,shuffle);
     end;
 
@@ -748,76 +733,52 @@ implementation
     var
       fromcgsize: tcgsize;
     begin
-      { no vector support yet }
-      if shuffle<>mms_movescalar then
-        internalerror(2012071217);
       { records may be stored in mmregisters, but def_cgsize will return an
         integer size for them... }
-      fromcgsize:=getintmmcgsize(reg,def_cgsize(fromsize));
+      fromcgsize:=getintmmcgsize(reg,def_cgmmsize(fromsize));
       cg.a_loadmm_reg_cgpara(list,fromcgsize,reg,cgpara,shuffle);
     end;
 
   procedure thlcg2ll.a_loadmm_ref_cgpara(list: TAsmList; fromsize: tdef; const ref: treference; const cgpara: TCGPara; shuffle: pmmshuffle);
     begin
-      { no vector support yet }
-      if shuffle<>mms_movescalar then
-        internalerror(2012071218);
-      cg.a_loadmm_ref_cgpara(list,def_cgsize(fromsize),ref,cgpara,shuffle);
+      cg.a_loadmm_ref_cgpara(list,def_cgmmsize(fromsize),ref,cgpara,shuffle);
     end;
 
   procedure thlcg2ll.a_loadmm_loc_cgpara(list: TAsmList; fromsize: tdef; const loc: tlocation; const cgpara: TCGPara; shuffle: pmmshuffle);
     begin
-      { no vector support yet }
-      if shuffle<>mms_movescalar then
-        internalerror(2012071219);
       { sanity check }
-      if def_cgsize(fromsize)<>loc.size then
+      if def_cgmmsize(fromsize)<>loc.size then
         internalerror(2012071220);
       cg.a_loadmm_loc_cgpara(list,loc,cgpara,shuffle);
     end;
 
   procedure thlcg2ll.a_opmm_reg_reg(list: TAsmList; Op: TOpCG; size: tdef; src, dst: tregister; shuffle: pmmshuffle);
     begin
-      { no vector support yet }
-      if size.typ<>floatdef then
-        internalerror(2012071221);
-      cg.a_opmm_reg_reg(list,op,def_cgsize(size),src,dst,shuffle);
+      cg.a_opmm_reg_reg(list,op,def_cgmmsize(size),src,dst,shuffle);
     end;
 
   procedure thlcg2ll.a_opmm_ref_reg(list: TAsmList; Op: TOpCG; size: tdef; const ref: treference; reg: tregister; shuffle: pmmshuffle);
     begin
-      { no vector support yet }
-      if size.typ<>floatdef then
-        internalerror(2012071222);
-      cg.a_opmm_ref_reg(list,op,def_cgsize(size),ref,reg,shuffle);
+      cg.a_opmm_ref_reg(list,op,def_cgmmsize(size),ref,reg,shuffle);
     end;
 
   procedure thlcg2ll.a_opmm_loc_reg(list: TAsmList; Op: TOpCG; size: tdef; const loc: tlocation; reg: tregister; shuffle: pmmshuffle);
     begin
-      { no vector support yet }
-      if size.typ<>floatdef then
-        internalerror(2012071223);
-      cg.a_opmm_loc_reg(list,op,def_cgsize(size),loc,reg,shuffle);
+      cg.a_opmm_loc_reg(list,op,def_cgmmsize(size),loc,reg,shuffle);
     end;
 
   procedure thlcg2ll.a_opmm_reg_ref(list: TAsmList; Op: TOpCG; size: tdef; reg: tregister; const ref: treference; shuffle: pmmshuffle);
     begin
-      { no vector support yet }
-      if size.typ<>floatdef then
-        internalerror(2012071224);
-      cg.a_opmm_reg_ref(list,op,def_cgsize(size),reg,ref,shuffle);
+      cg.a_opmm_reg_ref(list,op,def_cgmmsize(size),reg,ref,shuffle);
     end;
 
   procedure thlcg2ll.a_loadmm_intreg_reg(list: TAsmList; fromsize, tosize: tdef; intreg, mmreg: tregister; shuffle: pmmshuffle);
     var
       tocgsize: tcgsize;
     begin
-      { no vector support yet }
-      if shuffle<>mms_movescalar then
-        internalerror(2012071227);
-      { records may be stored in mmregisters, but def_cgsize will return an
+      { records may be stored in mmregisters, but def_cgmmsize will return an
         integer size for them... }
-      tocgsize:=getintmmcgsize(mmreg,def_cgsize(tosize));
+      tocgsize:=getintmmcgsize(mmreg,def_cgmmsize(tosize));
       cg.a_loadmm_intreg_reg(list,def_cgsize(fromsize),tocgsize,intreg,mmreg,shuffle);
     end;
 
@@ -825,12 +786,9 @@ implementation
     var
       fromcgsize: tcgsize;
     begin
-      { no vector support yet }
-      if shuffle<>mms_movescalar then
-        internalerror(2012071228);
       { records may be stored in mmregisters, but def_cgsize will return an
         integer size for them... }
-      fromcgsize:=getintmmcgsize(mmreg,def_cgsize(fromsize));
+      fromcgsize:=getintmmcgsize(mmreg,def_cgmmsize(fromsize));
       cg.a_loadmm_reg_intreg(list,fromcgsize,def_cgsize(tosize),mmreg,intreg,shuffle);
     end;
 

compiler/hlcgobj.pas

@@ -630,10 +630,8 @@ implementation
             result:=getaddressregister(list,size);
           R_FPUREGISTER:
             result:=getfpuregister(list,size);
-(*
           R_MMREGISTER:
             result:=getmmregister(list,size);
-*)
           else
             internalerror(2010122901);
         end;
@@ -796,23 +794,23 @@ implementation
            begin
               reference_reset_base(ref,cgpara.location^.reference.index,cgpara.location^.reference.offset,cgpara.alignment);
               a_load_ref_ref(list,size,cgpara.def,r,ref);
-           end
-(*
+           end;
          LOC_MMREGISTER,LOC_CMMREGISTER:
            begin
-              case location^.size of
+              case cgpara.location^.size of
                 OS_F32,
                 OS_F64,
                 OS_F128:
-                  a_loadmm_ref_reg(list,cgpara.def,cgpara.def,r,location^.register,mms_movescalar);
+                  a_loadmm_ref_reg(list,size,cgpara.def,r,cgpara.location^.register,mms_movescalar);
+(*
                 OS_M8..OS_M128,
                 OS_MS8..OS_MS128:
-                  a_loadmm_ref_reg(list,cgpara.def,cgpara.def,r,location^.register,nil);
+                  a_loadmm_ref_reg(list,size,cgpara.def,r,cgpara.location^.register,nil);
+*)
                 else
                   internalerror(2010120417);
               end;
            end
-*)
          else
            internalerror(2010120418);
       end;
@@ -2298,9 +2296,6 @@ implementation
     var
       tmpreg: tregister;
     begin
-      { no vector support yet }
-      if shuffle<>mms_movescalar then
-        internalerror(2012062302);
       case loc.loc of
         LOC_MMREGISTER,LOC_CMMREGISTER:
           a_loadmm_reg_reg(list,fromsize,tosize,loc.register,reg,shuffle);
@@ -2322,9 +2317,6 @@ implementation
 
   procedure thlcgobj.a_loadmm_reg_loc(list: TAsmList; fromsize, tosize: tdef; const reg: tregister; const loc: tlocation; shuffle: pmmshuffle);
     begin
-      { no vector support yet }
-      if shuffle<>mms_movescalar then
-        internalerror(2012062303);
       case loc.loc of
         LOC_MMREGISTER,LOC_CMMREGISTER:
           a_loadmm_reg_reg(list,fromsize,tosize,reg,loc.register,shuffle);
@@ -2339,9 +2331,6 @@ implementation
     var
       href  : treference;
     begin
-      { no vector support yet }
-      if shuffle<>mms_movescalar then
-        internalerror(2012062304);
        cgpara.check_simple_location;
        paramanager.alloccgpara(list,cgpara);
        case cgpara.location^.loc of
@@ -2369,9 +2358,6 @@ implementation
        hr : tregister;
        hs : tmmshuffle;
     begin
-      { no vector support yet }
-      if shuffle<>mms_movescalar then
-        internalerror(2012062308);
        cgpara.check_simple_location;
        hr:=getmmregister(list,cgpara.def);
        a_loadmm_ref_reg(list,fromsize,cgpara.def,ref,hr,shuffle);