* renamed a_param_* to a_load_*_cgpara

git-svn-id: trunk@15305 -

compiler/arm/cgcpu.pas

@@ -40,9 +40,9 @@ unit cgcpu;
         { true, if the next arithmetic operation should modify the flags }
         cgsetflags : boolean;
 
-        procedure a_param_const(list : TAsmList;size : tcgsize;a : aint;const paraloc : TCGPara);override;
-        procedure a_param_ref(list : TAsmList;size : tcgsize;const r : treference;const paraloc : TCGPara);override;
-        procedure a_paramaddr_ref(list : TAsmList;const r : treference;const paraloc : TCGPara);override;
+        procedure a_load_const_cgpara(list : TAsmList;size : tcgsize;a : aint;const paraloc : TCGPara);override;
+        procedure a_load_ref_cgpara(list : TAsmList;size : tcgsize;const r : treference;const paraloc : TCGPara);override;
+        procedure a_loadaddr_ref_cgpara(list : TAsmList;const r : treference;const paraloc : TCGPara);override;
 
         procedure a_call_name(list : TAsmList;const s : string; weak: boolean);override;
         procedure a_call_reg(list : TAsmList;reg: tregister);override;
@@ -69,7 +69,7 @@ unit cgcpu;
         procedure a_loadfpu_ref_reg(list: TAsmList; fromsize, tosize: tcgsize; const ref: treference; reg: tregister); override;
         procedure a_loadfpu_reg_ref(list: TAsmList; fromsize, tosize: tcgsize; reg: tregister; const ref: treference); override;
 
-        procedure a_paramfpu_ref(list : TAsmList;size : tcgsize;const ref : treference;const paraloc : TCGPara);override;
+        procedure a_loadfpu_ref_cgpara(list : TAsmList;size : tcgsize;const ref : treference;const paraloc : TCGPara);override;
         {  comparison operations }
         procedure a_cmp_const_reg_label(list : TAsmList;size : tcgsize;cmp_op : topcmp;a : aint;reg : tregister;
           l : tasmlabel);override;
@@ -413,7 +413,7 @@ unit cgcpu;
        end;
 
 
-    procedure tcgarm.a_param_const(list : TAsmList;size : tcgsize;a : aint;const paraloc : TCGPara);
+    procedure tcgarm.a_load_const_cgpara(list : TAsmList;size : tcgsize;a : aint;const paraloc : TCGPara);
       var
         ref: treference;
       begin
@@ -434,7 +434,7 @@ unit cgcpu;
       end;
 
 
-    procedure tcgarm.a_param_ref(list : TAsmList;size : tcgsize;const r : treference;const paraloc : TCGPara);
+    procedure tcgarm.a_load_ref_cgpara(list : TAsmList;size : tcgsize;const r : treference;const paraloc : TCGPara);
       var
         tmpref, ref: treference;
         location: pcgparalocation;
@@ -482,7 +482,7 @@ unit cgcpu;
       end;
 
 
-    procedure tcgarm.a_paramaddr_ref(list : TAsmList;const r : treference;const paraloc : TCGPara);
+    procedure tcgarm.a_loadaddr_ref_cgpara(list : TAsmList;const r : treference;const paraloc : TCGPara);
       var
         ref: treference;
         tmpreg: tregister;
@@ -1227,7 +1227,7 @@ unit cgcpu;
        end;
 
 
-    procedure tcgarm.a_paramfpu_ref(list : TAsmList;size : tcgsize;const ref : treference;const paraloc : TCGPara);
+    procedure tcgarm.a_loadfpu_ref_cgpara(list : TAsmList;size : tcgsize;const ref : treference;const paraloc : TCGPara);
       var
          href,href2 : treference;
          hloc : pcgparalocation;
@@ -1246,7 +1246,7 @@ unit cgcpu;
                     a_load_ref_reg(list,OS_32,OS_32,href,hloc^.register);
                   OS_64,
                   OS_F64:
-                    cg64.a_param64_ref(list,href,paraloc);
+                    cg64.a_load64_ref_cgpara(list,href,paraloc);
                   else
                     a_load_ref_reg(list,hloc^.size,hloc^.size,href,hloc^.register);
                 end;
@@ -1814,11 +1814,11 @@ unit cgcpu;
         paramanager.getintparaloc(pocall_default,2,paraloc2);
         paramanager.getintparaloc(pocall_default,3,paraloc3);
         paramanager.allocparaloc(list,paraloc3);
-        a_param_const(list,OS_INT,len,paraloc3);
+        a_load_const_cgpara(list,OS_INT,len,paraloc3);
         paramanager.allocparaloc(list,paraloc2);
-        a_paramaddr_ref(list,dest,paraloc2);
+        a_loadaddr_ref_cgpara(list,dest,paraloc2);
         paramanager.allocparaloc(list,paraloc2);
-        a_paramaddr_ref(list,source,paraloc1);
+        a_loadaddr_ref_cgpara(list,source,paraloc1);
         paramanager.freeparaloc(list,paraloc3);
         paramanager.freeparaloc(list,paraloc2);
         paramanager.freeparaloc(list,paraloc1);

compiler/avr/cgcpu.pas

@@ -42,9 +42,9 @@ unit cgcpu;
         procedure init_register_allocators;override;
         procedure done_register_allocators;override;
 
-        procedure a_param_const(list : TAsmList;size : tcgsize;a : aint;const paraloc : TCGPara);override;
-        procedure a_param_ref(list : TAsmList;size : tcgsize;const r : treference;const paraloc : TCGPara);override;
-        procedure a_paramaddr_ref(list : TAsmList;const r : treference;const paraloc : TCGPara);override;
+        procedure a_load_const_cgpara(list : TAsmList;size : tcgsize;a : aint;const paraloc : TCGPara);override;
+        procedure a_load_ref_cgpara(list : TAsmList;size : tcgsize;const r : treference;const paraloc : TCGPara);override;
+        procedure a_loadaddr_ref_cgpara(list : TAsmList;const r : treference;const paraloc : TCGPara);override;
 
         procedure a_call_name(list : TAsmList;const s : string; weak: boolean);override;
         procedure a_call_reg(list : TAsmList;reg: tregister);override;
@@ -146,7 +146,7 @@ unit cgcpu;
       end;
 
 
-    procedure tcgavr.a_param_const(list : TAsmList;size : tcgsize;a : aint;const paraloc : TCGPara);
+    procedure tcgavr.a_load_const_cgpara(list : TAsmList;size : tcgsize;a : aint;const paraloc : TCGPara);
       var
         ref: treference;
       begin
@@ -167,7 +167,7 @@ unit cgcpu;
       end;
 
 
-    procedure tcgavr.a_param_ref(list : TAsmList;size : tcgsize;const r : treference;const paraloc : TCGPara);
+    procedure tcgavr.a_load_ref_cgpara(list : TAsmList;size : tcgsize;const r : treference;const paraloc : TCGPara);
       var
         tmpref, ref: treference;
         location: pcgparalocation;
@@ -208,7 +208,7 @@ unit cgcpu;
       end;
 
 
-    procedure tcgavr.a_paramaddr_ref(list : TAsmList;const r : treference;const paraloc : TCGPara);
+    procedure tcgavr.a_loadaddr_ref_cgpara(list : TAsmList;const r : treference;const paraloc : TCGPara);
       var
         ref: treference;
         tmpreg: tregister;
@@ -715,11 +715,11 @@ unit cgcpu;
         paramanager.getintparaloc(pocall_default,2,paraloc2);
         paramanager.getintparaloc(pocall_default,3,paraloc3);
         paramanager.allocparaloc(list,paraloc3);
-        a_param_const(list,OS_INT,len,paraloc3);
+        a_load_const_cgpara(list,OS_INT,len,paraloc3);
         paramanager.allocparaloc(list,paraloc2);
-        a_paramaddr_ref(list,dest,paraloc2);
+        a_loadaddr_ref_cgpara(list,dest,paraloc2);
         paramanager.allocparaloc(list,paraloc2);
-        a_paramaddr_ref(list,source,paraloc1);
+        a_loadaddr_ref_cgpara(list,source,paraloc1);
         paramanager.freeparaloc(list,paraloc3);
         paramanager.freeparaloc(list,paraloc2);
         paramanager.freeparaloc(list,paraloc1);

compiler/cg64f32.pas

@@ -76,10 +76,10 @@ unit cg64f32;
         procedure a_op64_loc_reg(list : TAsmList;op:TOpCG;size : tcgsize;const l : tlocation;reg : tregister64);override;
         procedure a_op64_const_ref(list : TAsmList;op:TOpCG;size : tcgsize;value : int64;const ref : treference);override;
 
-        procedure a_param64_reg(list : TAsmList;reg : tregister64;const paraloc : tcgpara);override;
-        procedure a_param64_const(list : TAsmList;value : int64;const paraloc : tcgpara);override;
-        procedure a_param64_ref(list : TAsmList;const r : treference;const paraloc : tcgpara);override;
-        procedure a_param64_loc(list : TAsmList;const l : tlocation;const paraloc : tcgpara);override;
+        procedure a_load64_reg_cgpara(list : TAsmList;reg : tregister64;const paraloc : tcgpara);override;
+        procedure a_load64_const_cgpara(list : TAsmList;value : int64;const paraloc : tcgpara);override;
+        procedure a_load64_ref_cgpara(list : TAsmList;const r : treference;const paraloc : tcgpara);override;
+        procedure a_load64_loc_cgpara(list : TAsmList;const l : tlocation;const paraloc : tcgpara);override;
 
         procedure a_loadmm_intreg64_reg(list: TAsmList; mmsize: tcgsize; intreg: tregister64; mmreg: tregister);override;
         procedure a_loadmm_reg_intreg64(list: TAsmList; mmsize: tcgsize; mmreg: tregister; intreg: tregister64);override;
@@ -641,7 +641,7 @@ unit cg64f32;
       end;
 
 
-    procedure tcg64f32.a_param64_reg(list : TAsmList;reg : tregister64;const paraloc : tcgpara);
+    procedure tcg64f32.a_load64_reg_cgpara(list : TAsmList;reg : tregister64;const paraloc : tcgpara);
       var
         tmplochi,tmploclo: tcgpara;
       begin
@@ -650,14 +650,14 @@ unit cg64f32;
         splitparaloc64(paraloc,tmploclo,tmplochi);
         { Keep this order of first hi before lo to have
           the correct push order for i386 }
-        cg.a_param_reg(list,OS_32,reg.reghi,tmplochi);
-        cg.a_param_reg(list,OS_32,reg.reglo,tmploclo);
+        cg.a_load_reg_cgpara(list,OS_32,reg.reghi,tmplochi);
+        cg.a_load_reg_cgpara(list,OS_32,reg.reglo,tmploclo);
         tmploclo.done;
         tmplochi.done;
       end;
 
 
-    procedure tcg64f32.a_param64_const(list : TAsmList;value : int64;const paraloc : tcgpara);
+    procedure tcg64f32.a_load64_const_cgpara(list : TAsmList;value : int64;const paraloc : tcgpara);
       var
         tmplochi,tmploclo: tcgpara;
       begin
@@ -666,14 +666,14 @@ unit cg64f32;
         splitparaloc64(paraloc,tmploclo,tmplochi);
         { Keep this order of first hi before lo to have
           the correct push order for i386 }
-        cg.a_param_const(list,OS_32,aint(hi(value)),tmplochi);
-        cg.a_param_const(list,OS_32,aint(lo(value)),tmploclo);
+        cg.a_load_const_cgpara(list,OS_32,aint(hi(value)),tmplochi);
+        cg.a_load_const_cgpara(list,OS_32,aint(lo(value)),tmploclo);
         tmploclo.done;
         tmplochi.done;
       end;
 
 
-    procedure tcg64f32.a_param64_ref(list : TAsmList;const r : treference;const paraloc : tcgpara);
+    procedure tcg64f32.a_load64_ref_cgpara(list : TAsmList;const r : treference;const paraloc : tcgpara);
       var
         tmprefhi,tmpreflo : treference;
         tmploclo,tmplochi : tcgpara;
@@ -689,24 +689,24 @@ unit cg64f32;
           inc(tmprefhi.offset,4);
         { Keep this order of first hi before lo to have
           the correct push order for i386 }
-        cg.a_param_ref(list,OS_32,tmprefhi,tmplochi);
-        cg.a_param_ref(list,OS_32,tmpreflo,tmploclo);
+        cg.a_load_ref_cgpara(list,OS_32,tmprefhi,tmplochi);
+        cg.a_load_ref_cgpara(list,OS_32,tmpreflo,tmploclo);
         tmploclo.done;
         tmplochi.done;
       end;
 
 
-    procedure tcg64f32.a_param64_loc(list : TAsmList;const l:tlocation;const paraloc : tcgpara);
+    procedure tcg64f32.a_load64_loc_cgpara(list : TAsmList;const l:tlocation;const paraloc : tcgpara);
       begin
         case l.loc of
           LOC_REGISTER,
           LOC_CREGISTER :
-            a_param64_reg(list,l.register64,paraloc);
+            a_load64_reg_cgpara(list,l.register64,paraloc);
           LOC_CONSTANT :
-            a_param64_const(list,l.value64,paraloc);
+            a_load64_const_cgpara(list,l.value64,paraloc);
           LOC_CREFERENCE,
           LOC_REFERENCE :
-            a_param64_ref(list,l.reference,paraloc);
+            a_load64_ref_cgpara(list,l.reference,paraloc);
           else
             internalerror(200203287);
         end;

compiler/cgobj.pas

@@ -126,7 +126,7 @@ unit cgobj;
              @param(r register source of the operand)
              @param(cgpara where the parameter will be stored)
           }
-          procedure a_param_reg(list : TAsmList;size : tcgsize;r : tregister;const cgpara : TCGPara);virtual;
+          procedure a_load_reg_cgpara(list : TAsmList;size : tcgsize;r : tregister;const cgpara : TCGPara);virtual;
           {# Pass a parameter, which is a constant, to a routine.
 
              A generic version is provided. This routine should
@@ -137,7 +137,7 @@ unit cgobj;
              @param(a value of constant to send)
              @param(cgpara where the parameter will be stored)
           }
-          procedure a_param_const(list : TAsmList;size : tcgsize;a : aint;const cgpara : TCGPara);virtual;
+          procedure a_load_const_cgpara(list : TAsmList;size : tcgsize;a : aint;const cgpara : TCGPara);virtual;
           {# Pass the value of a parameter, which is located in memory, to a routine.
 
              A generic version is provided. This routine should
@@ -148,7 +148,7 @@ unit cgobj;
              @param(r Memory reference of value to send)
              @param(cgpara where the parameter will be stored)
           }
-          procedure a_param_ref(list : TAsmList;size : tcgsize;const r : treference;const cgpara : TCGPara);virtual;
+          procedure a_load_ref_cgpara(list : TAsmList;size : tcgsize;const r : treference;const cgpara : TCGPara);virtual;
           {# Pass the value of a parameter, which can be located either in a register or memory location,
              to a routine.
 
@@ -158,7 +158,7 @@ unit cgobj;
              @param(nr parameter number (starting from one) of routine (from left to right))
              @param(cgpara where the parameter will be stored)
           }
-          procedure a_param_loc(list : TAsmList;const l : tlocation;const cgpara : TCGPara);
+          procedure a_load_loc_cgpara(list : TAsmList;const l : tlocation;const cgpara : TCGPara);
           {# Pass the address of a reference to a routine. This routine
              will calculate the address of the reference, and pass this
              calculated address as a parameter.
@@ -170,7 +170,7 @@ unit cgobj;
              @param(r reference to get address from)
              @param(nr parameter number (starting from one) of routine (from left to right))
           }
-          procedure a_paramaddr_ref(list : TAsmList;const r : treference;const cgpara : TCGPara);virtual;
+          procedure a_loadaddr_ref_cgpara(list : TAsmList;const r : treference;const cgpara : TCGPara);virtual;
 
           {# Load a cgparaloc into a memory reference.
 
@@ -182,7 +182,7 @@ unit cgobj;
                   In case this location is also a reference, it is assumed
                   to be the final part sublocation of the parameter and that it
                   contains all of the "sizeleft" bytes).)
-           @param(alignment the alignment of the paraloc in case it's a reference)
+           @param(align the alignment of the paraloc in case it's a reference)
           }
           procedure a_load_cgparaloc_ref(list : TAsmList;const paraloc : TCGParaLocation;const ref : treference;sizeleft : aint;align : longint);
 
@@ -191,7 +191,7 @@ unit cgobj;
            @param(regsize the size of the destination register)
            @param(paraloc the source parameter sublocation)
            @param(reg the destination register)
-           @param(alignment the alignment of the paraloc in case it's a reference)
+           @param(align the alignment of the paraloc in case it's a reference)
           }
           procedure a_load_cgparaloc_anyreg(list : TAsmList;regsize : tcgsize;const paraloc : TCGParaLocation;reg : tregister;align : longint);
 
@@ -286,8 +286,8 @@ unit cgobj;
           procedure a_loadfpu_ref_ref(list: TAsmList; fromsize, tosize: tcgsize; const ref1,ref2: treference);
           procedure a_loadfpu_loc_reg(list: TAsmList; tosize: tcgsize; const loc: tlocation; const reg: tregister);
           procedure a_loadfpu_reg_loc(list: TAsmList; fromsize: tcgsize; const reg: tregister; const loc: tlocation);
-          procedure a_paramfpu_reg(list : TAsmList;size : tcgsize;const r : tregister;const cgpara : TCGPara);virtual;
-          procedure a_paramfpu_ref(list : TAsmList;size : tcgsize;const ref : treference;const cgpara : TCGPara);virtual;
+          procedure a_loadfpu_reg_cgpara(list : TAsmList;size : tcgsize;const r : tregister;const cgpara : TCGPara);virtual;
+          procedure a_loadfpu_ref_cgpara(list : TAsmList;size : tcgsize;const ref : treference;const cgpara : TCGPara);virtual;
 
           { vector register move instructions }
           procedure a_loadmm_reg_reg(list: TAsmList; fromsize, tosize : tcgsize;reg1, reg2: tregister;shuffle : pmmshuffle); virtual;
@@ -295,9 +295,9 @@ unit cgobj;
           procedure a_loadmm_reg_ref(list: TAsmList; fromsize, tosize : tcgsize;reg: tregister; const ref: treference;shuffle : pmmshuffle); virtual;
           procedure a_loadmm_loc_reg(list: TAsmList; size: tcgsize; const loc: tlocation; const reg: tregister;shuffle : pmmshuffle);
           procedure a_loadmm_reg_loc(list: TAsmList; size: tcgsize; const reg: tregister; const loc: tlocation;shuffle : pmmshuffle);
-          procedure a_parammm_reg(list: TAsmList; size: tcgsize; reg: tregister;const cgpara : TCGPara;shuffle : pmmshuffle); virtual;
-          procedure a_parammm_ref(list: TAsmList; size: tcgsize; const ref: treference;const cgpara : TCGPara;shuffle : pmmshuffle); virtual;
-          procedure a_parammm_loc(list: TAsmList; const loc: tlocation; const cgpara : TCGPara;shuffle : pmmshuffle); virtual;
+          procedure a_loadmm_reg_cgpara(list: TAsmList; size: tcgsize; reg: tregister;const cgpara : TCGPara;shuffle : pmmshuffle); virtual;
+          procedure a_loadmm_ref_cgpara(list: TAsmList; size: tcgsize; const ref: treference;const cgpara : TCGPara;shuffle : pmmshuffle); virtual;
+          procedure a_loadmm_loc_cgpara(list: TAsmList; const loc: tlocation; const cgpara : TCGPara;shuffle : pmmshuffle); virtual;
           procedure a_opmm_reg_reg(list: TAsmList; Op: TOpCG; size : tcgsize;src,dst: tregister;shuffle : pmmshuffle); virtual;
           procedure a_opmm_ref_reg(list: TAsmList; Op: TOpCG; size : tcgsize;const ref: treference; reg: tregister;shuffle : pmmshuffle); virtual;
           procedure a_opmm_loc_reg(list: TAsmList; Op: TOpCG; size : tcgsize;const loc: tlocation; reg: tregister;shuffle : pmmshuffle); virtual;
@@ -577,10 +577,10 @@ unit cgobj;
         procedure a_op64_ref_subsetref(list : TAsmList; Op : TOpCG; size : TCGSize; const ref: treference; const sref: tsubsetreference);
         procedure a_op64_subsetref_subsetref(list : TAsmList; Op : TOpCG; size : TCGSize; const ssref,dsref: tsubsetreference);
 
-        procedure a_param64_reg(list : TAsmList;reg64 : tregister64;const loc : TCGPara);virtual;abstract;
-        procedure a_param64_const(list : TAsmList;value : int64;const loc : TCGPara);virtual;abstract;
-        procedure a_param64_ref(list : TAsmList;const r : treference;const loc : TCGPara);virtual;abstract;
-        procedure a_param64_loc(list : TAsmList;const l : tlocation;const loc : TCGPara);virtual;abstract;
+        procedure a_load64_reg_cgpara(list : TAsmList;reg64 : tregister64;const loc : TCGPara);virtual;abstract;
+        procedure a_load64_const_cgpara(list : TAsmList;value : int64;const loc : TCGPara);virtual;abstract;
+        procedure a_load64_ref_cgpara(list : TAsmList;const r : treference;const loc : TCGPara);virtual;abstract;
+        procedure a_load64_loc_cgpara(list : TAsmList;const l : tlocation;const loc : TCGPara);virtual;abstract;
 
         procedure a_loadmm_intreg64_reg(list: TAsmList; mmsize: tcgsize; intreg: tregister64; mmreg: tregister); virtual;abstract;
         procedure a_loadmm_reg_intreg64(list: TAsmList; mmsize: tcgsize; mmreg: tregister; intreg: tregister64); virtual;abstract;
@@ -875,7 +875,7 @@ implementation
           for better code generation these methods should be overridden
 ******************************************************************************}
 
-    procedure tcg.a_param_reg(list : TAsmList;size : tcgsize;r : tregister;const cgpara : TCGPara);
+    procedure tcg.a_load_reg_cgpara(list : TAsmList;size : tcgsize;r : tregister;const cgpara : TCGPara);
       var
          ref : treference;
       begin
@@ -894,7 +894,7 @@ implementation
       end;
 
 
-    procedure tcg.a_param_const(list : TAsmList;size : tcgsize;a : aint;const cgpara : TCGPara);
+    procedure tcg.a_load_const_cgpara(list : TAsmList;size : tcgsize;a : aint;const cgpara : TCGPara);
       var
          ref : treference;
       begin
@@ -913,7 +913,7 @@ implementation
       end;
 
 
-    procedure tcg.a_param_ref(list : TAsmList;size : tcgsize;const r : treference;const cgpara : TCGPara);
+    procedure tcg.a_load_ref_cgpara(list : TAsmList;size : tcgsize;const r : treference;const cgpara : TCGPara);
       var
          ref : treference;
       begin
@@ -943,24 +943,24 @@ implementation
       end;
 
 
-    procedure tcg.a_param_loc(list : TAsmList;const l:tlocation;const cgpara : TCGPara);
+    procedure tcg.a_load_loc_cgpara(list : TAsmList;const l:tlocation;const cgpara : TCGPara);
       begin
         case l.loc of
           LOC_REGISTER,
           LOC_CREGISTER :
-            a_param_reg(list,l.size,l.register,cgpara);
+            a_load_reg_cgpara(list,l.size,l.register,cgpara);
           LOC_CONSTANT :
-            a_param_const(list,l.size,l.value,cgpara);
+            a_load_const_cgpara(list,l.size,l.value,cgpara);
           LOC_CREFERENCE,
           LOC_REFERENCE :
-            a_param_ref(list,l.size,l.reference,cgpara);
+            a_load_ref_cgpara(list,l.size,l.reference,cgpara);
           else
             internalerror(2002032211);
         end;
       end;
 
 
-    procedure tcg.a_paramaddr_ref(list : TAsmList;const r : treference;const cgpara : TCGPara);
+    procedure tcg.a_loadaddr_ref_cgpara(list : TAsmList;const r : treference;const cgpara : TCGPara);
       var
          hr : tregister;
       begin
@@ -971,7 +971,7 @@ implementation
            begin
              hr:=getaddressregister(list);
              a_loadaddr_ref_reg(list,r,hr);
-             a_param_reg(list,OS_ADDR,hr,cgpara);
+             a_load_reg_cgpara(list,OS_ADDR,hr,cgpara);
            end;
       end;
 
@@ -2599,7 +2599,7 @@ implementation
       end;
 
 
-    procedure tcg.a_paramfpu_reg(list : TAsmList;size : tcgsize;const r : tregister;const cgpara : TCGPara);
+    procedure tcg.a_loadfpu_reg_cgpara(list : TAsmList;size : tcgsize;const r : tregister;const cgpara : TCGPara);
       var
          ref : treference;
       begin
@@ -2620,7 +2620,7 @@ implementation
                 { paramfpu_ref does the check_simpe_location check here if necessary }
                 tg.GetTemp(list,TCGSize2Size[size],TCGSize2Size[size],tt_normal,ref);
                 a_loadfpu_reg_ref(list,size,size,r,ref);
-                a_paramfpu_ref(list,size,ref,cgpara);
+                a_loadfpu_ref_cgpara(list,size,ref,cgpara);
                 tg.Ungettemp(list,ref);
               end;
             else
@@ -2629,7 +2629,7 @@ implementation
       end;
 
 
-    procedure tcg.a_paramfpu_ref(list : TAsmList;size : tcgsize;const ref : treference;const cgpara : TCGPara);
+    procedure tcg.a_loadfpu_ref_cgpara(list : TAsmList;size : tcgsize;const ref : treference;const cgpara : TCGPara);
       var
          href : treference;
       begin
@@ -3028,7 +3028,7 @@ implementation
       end;
 
 
-    procedure tcg.a_parammm_reg(list: TAsmList; size: tcgsize; reg: tregister;const cgpara : TCGPara;shuffle : pmmshuffle);
+    procedure tcg.a_loadmm_reg_cgpara(list: TAsmList; size: tcgsize; reg: tregister;const cgpara : TCGPara;shuffle : pmmshuffle);
       var
         href  : treference;
 {$ifndef cpu64bitalu}
@@ -3101,7 +3101,7 @@ implementation
       end;
 
 
-    procedure tcg.a_parammm_ref(list: TAsmList; size: tcgsize;const ref: treference;const cgpara : TCGPara;shuffle : pmmshuffle);
+    procedure tcg.a_loadmm_ref_cgpara(list: TAsmList; size: tcgsize;const ref: treference;const cgpara : TCGPara;shuffle : pmmshuffle);
       var
          hr : tregister;
          hs : tmmshuffle;
@@ -3113,20 +3113,20 @@ implementation
            begin
              hs:=shuffle^;
              removeshuffles(hs);
-             a_parammm_reg(list,cgpara.location^.size,hr,cgpara,@hs);
+             a_loadmm_reg_cgpara(list,cgpara.location^.size,hr,cgpara,@hs);
            end
          else
-           a_parammm_reg(list,cgpara.location^.size,hr,cgpara,shuffle);
+           a_loadmm_reg_cgpara(list,cgpara.location^.size,hr,cgpara,shuffle);
       end;
 
 
-    procedure tcg.a_parammm_loc(list: TAsmList;const loc: tlocation; const cgpara : TCGPara;shuffle : pmmshuffle);
+    procedure tcg.a_loadmm_loc_cgpara(list: TAsmList;const loc: tlocation; const cgpara : TCGPara;shuffle : pmmshuffle);
       begin
         case loc.loc of
           LOC_MMREGISTER,LOC_CMMREGISTER:
-            a_parammm_reg(list,loc.size,loc.register,cgpara,shuffle);
+            a_loadmm_reg_cgpara(list,loc.size,loc.register,cgpara,shuffle);
           LOC_REFERENCE,LOC_CREFERENCE:
-            a_parammm_ref(list,loc.size,loc.reference,cgpara,shuffle);
+            a_loadmm_ref_cgpara(list,loc.size,loc.reference,cgpara,shuffle);
           else
             internalerror(200310123);
         end;
@@ -3231,11 +3231,11 @@ implementation
         paramanager.getintparaloc(pocall_default,2,cgpara2);
         paramanager.getintparaloc(pocall_default,3,cgpara3);
         paramanager.allocparaloc(list,cgpara3);
-        a_paramaddr_ref(list,dest,cgpara3);
+        a_loadaddr_ref_cgpara(list,dest,cgpara3);
         paramanager.allocparaloc(list,cgpara2);
-        a_paramaddr_ref(list,source,cgpara2);
+        a_loadaddr_ref_cgpara(list,source,cgpara2);
         paramanager.allocparaloc(list,cgpara1);
-        a_param_const(list,OS_INT,len,cgpara1);
+        a_load_const_cgpara(list,OS_INT,len,cgpara1);
         paramanager.freeparaloc(list,cgpara3);
         paramanager.freeparaloc(list,cgpara2);
         paramanager.freeparaloc(list,cgpara1);
@@ -3257,9 +3257,9 @@ implementation
         paramanager.getintparaloc(pocall_default,1,cgpara1);
         paramanager.getintparaloc(pocall_default,2,cgpara2);
         paramanager.allocparaloc(list,cgpara2);
-        a_paramaddr_ref(list,dest,cgpara2);
+        a_loadaddr_ref_cgpara(list,dest,cgpara2);
         paramanager.allocparaloc(list,cgpara1);
-        a_paramaddr_ref(list,source,cgpara1);
+        a_loadaddr_ref_cgpara(list,source,cgpara1);
         paramanager.freeparaloc(list,cgpara2);
         paramanager.freeparaloc(list,cgpara1);
         allocallcpuregisters(list);
@@ -3299,10 +3299,10 @@ implementation
             { widestrings aren't ref. counted on all platforms so we need the address
               to create a real copy }
             if is_widestring(t) then
-              a_paramaddr_ref(list,ref,cgpara1)
+              a_loadaddr_ref_cgpara(list,ref,cgpara1)
             else
               { these functions get the pointer by value }
-              a_param_ref(list,OS_ADDR,ref,cgpara1);
+              a_load_ref_cgpara(list,OS_ADDR,ref,cgpara1);
             paramanager.freeparaloc(list,cgpara1);
             allocallcpuregisters(list);
             a_call_name(list,incrfunc,false);
@@ -3312,9 +3312,9 @@ implementation
           begin
             reference_reset_symbol(href,RTTIWriter.get_rtti_label(t,initrtti),0,sizeof(pint));
             paramanager.allocparaloc(list,cgpara2);
-            a_paramaddr_ref(list,href,cgpara2);
+            a_loadaddr_ref_cgpara(list,href,cgpara2);
             paramanager.allocparaloc(list,cgpara1);
-            a_paramaddr_ref(list,ref,cgpara1);
+            a_loadaddr_ref_cgpara(list,ref,cgpara1);
             paramanager.freeparaloc(list,cgpara1);
             paramanager.freeparaloc(list,cgpara2);
             allocallcpuregisters(list);
@@ -3368,11 +3368,11 @@ implementation
             if needrtti then
               begin
                 paramanager.allocparaloc(list,cgpara2);
-                a_param_reg(list,OS_ADDR,tempreg2,cgpara2);
+                a_load_reg_cgpara(list,OS_ADDR,tempreg2,cgpara2);
                 paramanager.freeparaloc(list,cgpara2);
               end;
             paramanager.allocparaloc(list,cgpara1);
-            a_param_reg(list,OS_ADDR,tempreg1,cgpara1);
+            a_load_reg_cgpara(list,OS_ADDR,tempreg1,cgpara1);
             paramanager.freeparaloc(list,cgpara1);
             allocallcpuregisters(list);
             a_call_name(list,decrfunc,false);
@@ -3382,9 +3382,9 @@ implementation
           begin
             reference_reset_symbol(href,RTTIWriter.get_rtti_label(t,initrtti),0,sizeof(pint));
             paramanager.allocparaloc(list,cgpara2);
-            a_paramaddr_ref(list,href,cgpara2);
+            a_loadaddr_ref_cgpara(list,href,cgpara2);
             paramanager.allocparaloc(list,cgpara1);
-            a_paramaddr_ref(list,ref,cgpara1);
+            a_loadaddr_ref_cgpara(list,ref,cgpara1);
             paramanager.freeparaloc(list,cgpara1);
             paramanager.freeparaloc(list,cgpara2);
             allocallcpuregisters(list);
@@ -3415,9 +3415,9 @@ implementation
            begin
               reference_reset_symbol(href,RTTIWriter.get_rtti_label(t,initrtti),0,sizeof(pint));
               paramanager.allocparaloc(list,cgpara2);
-              a_paramaddr_ref(list,href,cgpara2);
+              a_loadaddr_ref_cgpara(list,href,cgpara2);
               paramanager.allocparaloc(list,cgpara1);
-              a_paramaddr_ref(list,ref,cgpara1);
+              a_loadaddr_ref_cgpara(list,ref,cgpara1);
               paramanager.freeparaloc(list,cgpara1);
               paramanager.freeparaloc(list,cgpara2);
               allocallcpuregisters(list);
@@ -3450,9 +3450,9 @@ implementation
            begin
               reference_reset_symbol(href,RTTIWriter.get_rtti_label(t,initrtti),0,sizeof(pint));
               paramanager.allocparaloc(list,cgpara2);
-              a_paramaddr_ref(list,href,cgpara2);
+              a_loadaddr_ref_cgpara(list,href,cgpara2);
               paramanager.allocparaloc(list,cgpara1);
-              a_paramaddr_ref(list,ref,cgpara1);
+              a_loadaddr_ref_cgpara(list,ref,cgpara1);
               paramanager.freeparaloc(list,cgpara1);
               paramanager.freeparaloc(list,cgpara2);
               allocallcpuregisters(list);
@@ -3686,7 +3686,7 @@ implementation
            cgpara1.init;
            paramanager.getintparaloc(pocall_default,1,cgpara1);
            paramanager.allocparaloc(list,cgpara1);
-           a_param_const(list,OS_INT,210,cgpara1);
+           a_load_const_cgpara(list,OS_INT,210,cgpara1);
            paramanager.freeparaloc(list,cgpara1);
            a_call_name(list,'FPC_HANDLEERROR',false);
            a_label(list,oklabel);
@@ -3708,9 +3708,9 @@ implementation
          begin
            reference_reset_symbol(hrefvmt,current_asmdata.RefAsmSymbol(objdef.vmt_mangledname),0,sizeof(pint));
            paramanager.allocparaloc(list,cgpara2);
-           a_paramaddr_ref(list,hrefvmt,cgpara2);
+           a_loadaddr_ref_cgpara(list,hrefvmt,cgpara2);
            paramanager.allocparaloc(list,cgpara1);
-           a_param_reg(list,OS_ADDR,reg,cgpara1);
+           a_load_reg_cgpara(list,OS_ADDR,reg,cgpara1);
            paramanager.freeparaloc(list,cgpara1);
            paramanager.freeparaloc(list,cgpara2);
            allocallcpuregisters(list);
@@ -3721,7 +3721,7 @@ implementation
          if (cs_check_range in current_settings.localswitches) then
           begin
             paramanager.allocparaloc(list,cgpara1);
-            a_param_reg(list,OS_ADDR,reg,cgpara1);
+            a_load_reg_cgpara(list,OS_ADDR,reg,cgpara1);
             paramanager.freeparaloc(list,cgpara1);
             allocallcpuregisters(list);
             a_call_name(list,'FPC_CHECK_OBJECT',false);
@@ -3767,7 +3767,7 @@ implementation
         cgpara1.init;
         paramanager.getintparaloc(pocall_default,1,cgpara1);
         paramanager.allocparaloc(list,cgpara1);
-        a_param_reg(list,OS_INT,sizereg,cgpara1);
+        a_load_reg_cgpara(list,OS_INT,sizereg,cgpara1);
         paramanager.freeparaloc(list,cgpara1);
         allocallcpuregisters(list);
         a_call_name(list,'FPC_GETMEM',false);
@@ -3785,13 +3785,13 @@ implementation
         paramanager.getintparaloc(pocall_default,3,cgpara3);
         { load size }
         paramanager.allocparaloc(list,cgpara3);
-        a_param_reg(list,OS_INT,sizereg,cgpara3);
+        a_load_reg_cgpara(list,OS_INT,sizereg,cgpara3);
         { load destination }
         paramanager.allocparaloc(list,cgpara2);
-        a_param_reg(list,OS_ADDR,destreg,cgpara2);
+        a_load_reg_cgpara(list,OS_ADDR,destreg,cgpara2);
         { load source }
         paramanager.allocparaloc(list,cgpara1);
-        a_param_reg(list,OS_ADDR,sourcereg,cgpara1);
+        a_load_reg_cgpara(list,OS_ADDR,sourcereg,cgpara1);
         paramanager.freeparaloc(list,cgpara3);
         paramanager.freeparaloc(list,cgpara2);
         paramanager.freeparaloc(list,cgpara1);
@@ -3813,7 +3813,7 @@ implementation
         paramanager.getintparaloc(pocall_default,1,cgpara1);
         { load source }
         paramanager.allocparaloc(list,cgpara1);
-        a_param_loc(list,l,cgpara1);
+        a_load_loc_cgpara(list,l,cgpara1);
         paramanager.freeparaloc(list,cgpara1);
         allocallcpuregisters(list);
         a_call_name(list,'FPC_FREEMEM',false);

compiler/i386/cgcpu.pas

@@ -39,10 +39,10 @@ unit cgcpu;
         procedure do_register_allocation(list:TAsmList;headertai:tai);override;
 
         { passing parameter using push instead of mov }
-        procedure a_param_reg(list : TAsmList;size : tcgsize;r : tregister;const cgpara : tcgpara);override;
-        procedure a_param_const(list : TAsmList;size : tcgsize;a : aint;const cgpara : tcgpara);override;
-        procedure a_param_ref(list : TAsmList;size : tcgsize;const r : treference;const cgpara : tcgpara);override;
-        procedure a_paramaddr_ref(list : TAsmList;const r : treference;const cgpara : tcgpara);override;
+        procedure a_load_reg_cgpara(list : TAsmList;size : tcgsize;r : tregister;const cgpara : tcgpara);override;
+        procedure a_load_const_cgpara(list : TAsmList;size : tcgsize;a : aint;const cgpara : tcgpara);override;
+        procedure a_load_ref_cgpara(list : TAsmList;size : tcgsize;const r : treference;const cgpara : tcgpara);override;
+        procedure a_loadaddr_ref_cgpara(list : TAsmList;const r : treference;const cgpara : tcgpara);override;
 
         procedure g_proc_exit(list : TAsmList;parasize:longint;nostackframe:boolean);override;
         procedure g_copyvaluepara_openarray(list : TAsmList;const ref:treference;const lenloc:tlocation;elesize:aint;destreg:tregister);override;
@@ -108,7 +108,7 @@ unit cgcpu;
       end;
 
 
-    procedure tcg386.a_param_reg(list : TAsmList;size : tcgsize;r : tregister;const cgpara : tcgpara);
+    procedure tcg386.a_load_reg_cgpara(list : TAsmList;size : tcgsize;r : tregister;const cgpara : tcgpara);
       var
         pushsize : tcgsize;
       begin
@@ -123,11 +123,11 @@ unit cgcpu;
             list.concat(taicpu.op_reg(A_PUSH,tcgsize2opsize[pushsize],makeregsize(list,r,pushsize)));
           end
         else
-          inherited a_param_reg(list,size,r,cgpara);
+          inherited a_load_reg_cgpara(list,size,r,cgpara);
       end;
 
 
-    procedure tcg386.a_param_const(list : TAsmList;size : tcgsize;a : aint;const cgpara : tcgpara);
+    procedure tcg386.a_load_const_cgpara(list : TAsmList;size : tcgsize;a : aint;const cgpara : tcgpara);
       var
         pushsize : tcgsize;
       begin
@@ -141,11 +141,11 @@ unit cgcpu;
             list.concat(taicpu.op_const(A_PUSH,tcgsize2opsize[pushsize],a));
           end
         else
-          inherited a_param_const(list,size,a,cgpara);
+          inherited a_load_const_cgpara(list,size,a,cgpara);
       end;
 
 
-    procedure tcg386.a_param_ref(list : TAsmList;size : tcgsize;const r : treference;const cgpara : tcgpara);
+    procedure tcg386.a_load_ref_cgpara(list : TAsmList;size : tcgsize;const r : treference;const cgpara : tcgpara);
 
         procedure pushdata(paraloc:pcgparalocation;ofs:aint);
         var
@@ -211,11 +211,11 @@ unit cgcpu;
               end
           end
         else
-          inherited a_param_ref(list,size,r,cgpara);
+          inherited a_load_ref_cgpara(list,size,r,cgpara);
       end;
 
 
-    procedure tcg386.a_paramaddr_ref(list : TAsmList;const r : treference;const cgpara : tcgpara);
+    procedure tcg386.a_loadaddr_ref_cgpara(list : TAsmList;const r : treference;const cgpara : tcgpara);
       var
         tmpreg : tregister;
         opsize : topsize;
@@ -249,7 +249,7 @@ unit cgcpu;
                   end;
               end
             else
-              inherited a_paramaddr_ref(list,r,cgpara);
+              inherited a_loadaddr_ref_cgpara(list,r,cgpara);
           end;
       end;
 

compiler/m68k/cgcpu.pas

@@ -43,10 +43,10 @@ unit cgcpu;
         procedure init_register_allocators;override;
         procedure done_register_allocators;override;
 
-        procedure a_param_reg(list : TAsmList;size : tcgsize;r : tregister;const cgpara : tcgpara);override;
-        procedure a_param_const(list : TAsmList;size : tcgsize;a : aint;const cgpara : tcgpara);override;
-        procedure a_param_ref(list : TAsmList;size : tcgsize;const r : treference;const cgpara : tcgpara);override;
-        procedure a_paramaddr_ref(list : TAsmList;const r : treference;const cgpara : tcgpara);override;
+        procedure a_load_reg_cgpara(list : TAsmList;size : tcgsize;r : tregister;const cgpara : tcgpara);override;
+        procedure a_load_const_cgpara(list : TAsmList;size : tcgsize;a : aint;const cgpara : tcgpara);override;
+        procedure a_load_ref_cgpara(list : TAsmList;size : tcgsize;const r : treference;const cgpara : tcgpara);override;
+        procedure a_loadaddr_ref_cgpara(list : TAsmList;const r : treference;const cgpara : tcgpara);override;
 
         procedure a_call_name(list : TAsmList;const s : string; weak: boolean);override;
         procedure a_call_reg(list : TAsmList;reg : tregister);override;
@@ -67,7 +67,7 @@ unit cgcpu;
         procedure a_loadmm_reg_reg(list: TAsmList;fromsize,tosize : tcgsize; reg1, reg2: tregister;shuffle : pmmshuffle); override;
         procedure a_loadmm_ref_reg(list: TAsmList;fromsize,tosize : tcgsize; const ref: treference; reg: tregister;shuffle : pmmshuffle); override;
         procedure a_loadmm_reg_ref(list: TAsmList;fromsize,tosize : tcgsize; reg: tregister; const ref: treference;shuffle : pmmshuffle); override;
-        procedure a_parammm_reg(list: TAsmList; size: tcgsize; reg: tregister;const locpara : TCGPara;shuffle : pmmshuffle); override;
+        procedure a_loadmm_reg_cgpara(list: TAsmList; size: tcgsize; reg: tregister;const locpara : TCGPara;shuffle : pmmshuffle); override;
 
         procedure a_op_const_reg(list : TAsmList; Op: TOpCG; size: tcgsize; a: aint; reg: TRegister); override;
 //        procedure a_op_const_ref(list : TAsmList; Op: TOpCG; size: TCGSize; a: aint; const ref: TReference); override;
@@ -237,13 +237,13 @@ unit cgcpu;
       end;
 
 
-    procedure tcg68k.a_param_reg(list : TAsmList;size : tcgsize;r : tregister;const cgpara : tcgpara);
+    procedure tcg68k.a_load_reg_cgpara(list : TAsmList;size : tcgsize;r : tregister;const cgpara : tcgpara);
       var
         pushsize : tcgsize;
         ref : treference;
       begin
 {$ifdef DEBUG_CHARLIE}
-//        writeln('a_param_reg');
+//        writeln('a_load_reg');_cgpara
 {$endif DEBUG_CHARLIE}
         { it's probably necessary to port this from x86 later, or provide an m68k solution (KB) }
 { TODO: FIX ME! check_register_size()}
@@ -261,17 +261,17 @@ unit cgcpu;
             list.concat(taicpu.op_reg_ref(A_MOVE,tcgsize2opsize[pushsize],makeregsize(list,r,pushsize),ref));
           end
         else
-          inherited a_param_reg(list,size,r,cgpara);
+          inherited a_load_reg_cgpara(list,size,r,cgpara);
       end;
 
 
-    procedure tcg68k.a_param_const(list : TAsmList;size : tcgsize;a : aint;const cgpara : tcgpara);
+    procedure tcg68k.a_load_const_cgpara(list : TAsmList;size : tcgsize;a : aint;const cgpara : tcgpara);
       var
         pushsize : tcgsize;
         ref : treference;
       begin
 {$ifdef DEBUG_CHARLIE}
-//        writeln('a_param_const');
+//        writeln('a_load_const');_cgpara
 {$endif DEBUG_CHARLIE}
         if use_push(cgpara) then
           begin
@@ -286,11 +286,11 @@ unit cgcpu;
             list.concat(taicpu.op_const_ref(A_MOVE,tcgsize2opsize[pushsize],a,ref));
           end
         else
-          inherited a_param_const(list,size,a,cgpara);
+          inherited a_load_const_cgpara(list,size,a,cgpara);
       end;
 
 
-    procedure tcg68k.a_param_ref(list : TAsmList;size : tcgsize;const r : treference;const cgpara : tcgpara);
+    procedure tcg68k.a_load_ref_cgpara(list : TAsmList;size : tcgsize;const r : treference;const cgpara : tcgpara);
 
         procedure pushdata(paraloc:pcgparalocation;ofs:aint);
         var
@@ -339,7 +339,7 @@ unit cgcpu;
         href : treference;
       begin
 {$ifdef DEBUG_CHARLIE}
-//        writeln('a_param_ref');
+//        writeln('a_load_ref');_cgpara
 {$endif DEBUG_CHARLIE}
 
         { cgpara.size=OS_NO requires a copy on the stack }
@@ -364,17 +364,17 @@ unit cgcpu;
               end
           end
         else
-          inherited a_param_ref(list,size,r,cgpara);
+          inherited a_load_ref_cgpara(list,size,r,cgpara);
       end;
 
 
-    procedure tcg68k.a_paramaddr_ref(list : TAsmList;const r : treference;const cgpara : tcgpara);
+    procedure tcg68k.a_loadaddr_ref_cgpara(list : TAsmList;const r : treference;const cgpara : tcgpara);
       var
         tmpreg : tregister;
         opsize : topsize;
       begin
 {$ifdef DEBUG_CHARLIE}
-//        writeln('a_paramaddr_ref');
+//        writeln('a_loadaddr_ref');_cgpara
 {$endif DEBUG_CHARLIE}
         with r do
           begin
@@ -406,7 +406,7 @@ unit cgcpu;
                   end;
               end
             else
-              inherited a_paramaddr_ref(list,r,cgpara);
+              inherited a_loadaddr_ref_cgpara(list,r,cgpara);
           end;
       end;
 
@@ -658,7 +658,7 @@ unit cgcpu;
       end;
 
 
-    procedure tcg68k.a_parammm_reg(list: TAsmList; size: tcgsize; reg: tregister;const locpara : TCGPara;shuffle : pmmshuffle);
+    procedure tcg68k.a_loadmm_reg_cgpara(list: TAsmList; size: tcgsize; reg: tregister;const locpara : TCGPara;shuffle : pmmshuffle);
       begin
         internalerror(20020729);
       end;

compiler/m68k/n68kmat.pas

@@ -152,7 +152,7 @@ implementation
          { compare against zero, if not zero continue }
          cg.a_cmp_const_reg_label(current_asmdata.CurrAsmList,OS_S32,OC_NE,0,denum,continuelabel);
 //       paraloc1.init;
-//         cg.a_param_const(current_asmdata.CurrAsmList,OS_S32,200,paramanager.getintparaloc(pocall_default,1,paraloc1));
+//         cg.a_load_const_cgpara(current_asmdata.CurrAsmList,OS_S32,200,paramanager.getintparaloc(pocall_default,1,paraloc1));
 
          cg.a_call_name(current_asmdata.CurrAsmList,'FPC_HANDLEERROR',false);
          cg.a_label(current_asmdata.CurrAsmList, continuelabel);
@@ -199,7 +199,7 @@ implementation
          current_asmdata.getjumplabel(continuelabel);
          { compare against zero, if not zero continue }
          cg.a_cmp_const_reg_label(current_asmdata.CurrAsmList,OS_S32,OC_NE,0,denum,continuelabel);
-//         cg.a_param_const(current_asmdata.CurrAsmList, OS_S32,200,paramanager.getintparaloc(pocall_default,1));
+//         cg.a_load_const_cgpara(current_asmdata.CurrAsmList, OS_S32,200,paramanager.getintparaloc(pocall_default,1));
          cg.a_call_name(current_asmdata.CurrAsmList,'FPC_HANDLEERROR',false);
          cg.a_label(current_asmdata.CurrAsmList, continuelabel);
 

compiler/mips/cgcpu.pas

@@ -47,11 +47,11 @@ type
     procedure handle_reg_const_reg(list: tasmlist; op: Tasmop; src: tregister; a: aint; dst: tregister);
 
     { parameter }
-    procedure a_param_const(list: tasmlist; size: tcgsize; a: aint; const paraloc: TCGPara); override;
-    procedure a_param_ref(list: tasmlist; sz: tcgsize; const r: TReference; const paraloc: TCGPara); override;
-    procedure a_paramaddr_ref(list: tasmlist; const r: TReference; const paraloc: TCGPara); override;
-    procedure a_paramfpu_reg(list: tasmlist; size: tcgsize; const r: tregister; const paraloc: TCGPara); override;
-    procedure a_paramfpu_ref(list: tasmlist; size: tcgsize; const ref: treference; const paraloc: TCGPara); override;
+    procedure a_load_const_cgpara(list: tasmlist; size: tcgsize; a: aint; const paraloc: TCGPara); override;
+    procedure a_load_ref_cgpara(list: tasmlist; sz: tcgsize; const r: TReference; const paraloc: TCGPara); override;
+    procedure a_loadaddr_ref_cgpara(list: tasmlist; const r: TReference; const paraloc: TCGPara); override;
+    procedure a_loadfpu_reg_cgpara(list: tasmlist; size: tcgsize; const r: tregister; const paraloc: TCGPara); override;
+    procedure a_loadfpu_ref_cgpara(list: tasmlist; size: tcgsize; const ref: treference; const paraloc: TCGPara); override;
     procedure a_call_name(list: tasmlist; const s: string; weak : boolean); override;
     procedure a_call_reg(list: tasmlist; Reg: TRegister); override;
     { General purpose instructions }
@@ -92,7 +92,7 @@ type
   public
     procedure a_load64_reg_ref(list: tasmlist; reg: tregister64; const ref: treference); override;
     procedure a_load64_ref_reg(list: tasmlist; const ref: treference; reg: tregister64); override;
-    procedure a_param64_ref(list: tasmlist; const r: treference; const paraloc: tcgpara); override;
+    procedure a_load64_ref_cgpara(list: tasmlist; const r: treference; const paraloc: tcgpara); override;
     procedure a_op64_reg_reg(list: tasmlist; op: TOpCG; size: tcgsize; regsrc, regdst: TRegister64); override;
     procedure a_op64_const_reg(list: tasmlist; op: TOpCG; size: tcgsize; Value: int64; regdst: TRegister64); override;
     procedure a_op64_const_reg_reg(list: tasmlist; op: TOpCG; size: tcgsize; Value: int64; regsrc, regdst: tregister64); override;
@@ -540,7 +540,7 @@ begin
 end;
 
 
-procedure TCgMPSel.a_param_const(list: tasmlist; size: tcgsize; a: aint; const paraloc: TCGPara);
+procedure TCgMPSel.a_load_const_cgpara(list: tasmlist; size: tcgsize; a: aint; const paraloc: TCGPara);
 var
   Ref: TReference;
 begin
@@ -564,7 +564,7 @@ begin
 end;
 
 
-procedure TCgMPSel.a_param_ref(list: tasmlist; sz: TCgSize; const r: TReference; const paraloc: TCGPara);
+procedure TCgMPSel.a_load_ref_cgpara(list: tasmlist; sz: TCgSize; const r: TReference; const paraloc: TCGPara);
 var
   ref:    treference;
   tmpreg: TRegister;
@@ -594,7 +594,7 @@ begin
 end;
 
 
-procedure TCgMPSel.a_paramaddr_ref(list: tasmlist; const r: TReference; const paraloc: TCGPara);
+procedure TCgMPSel.a_loadaddr_ref_cgpara(list: tasmlist; const r: TReference; const paraloc: TCGPara);
 var
   Ref:    TReference;
   TmpReg: TRegister;
@@ -621,7 +621,7 @@ begin
 end;
 
 
-procedure TCgMPSel.a_paramfpu_ref(list: tasmlist; size: tcgsize; const ref: treference; const paraloc: TCGPara);
+procedure TCgMPSel.a_loadfpu_ref_cgpara(list: tasmlist; size: tcgsize; const ref: treference; const paraloc: TCGPara);
 var
   href, href2: treference;
   hloc: pcgparalocation;
@@ -647,13 +647,13 @@ begin
 end;
 
 
-procedure TCgMPSel.a_paramfpu_reg(list: tasmlist; size: tcgsize; const r: tregister; const paraloc: TCGPara);
+procedure TCgMPSel.a_loadfpu_reg_cgpara(list: tasmlist; size: tcgsize; const r: tregister; const paraloc: TCGPara);
 var
   href: treference;
 begin
   tg.GetTemp(list, TCGSize2Size[size], sizeof(aint), tt_normal, href);
   a_loadfpu_reg_ref(list, size, size, r, href);
-  a_paramfpu_ref(list, size, href, paraloc);
+  a_loadfpu_ref_cgpara(list, size, href, paraloc);
   tg.Ungettemp(list, href);
 end;
 
@@ -1468,11 +1468,11 @@ begin
   paramanager.getintparaloc(pocall_default, 2, paraloc2);
   paramanager.getintparaloc(pocall_default, 3, paraloc3);
   paramanager.allocparaloc(list, paraloc3);
-  a_param_const(list, OS_INT, len, paraloc3);
+  a_load_const_cgpara(list, OS_INT, len, paraloc3);
   paramanager.allocparaloc(list, paraloc2);
-  a_paramaddr_ref(list, dest, paraloc2);
+  a_loadaddr_ref_cgpara(list, dest, paraloc2);
   paramanager.allocparaloc(list, paraloc2);
-  a_paramaddr_ref(list, Source, paraloc1);
+  a_loadaddr_ref_cgpara(list, Source, paraloc1);
   paramanager.freeparaloc(list, paraloc3);
   paramanager.freeparaloc(list, paraloc2);
   paramanager.freeparaloc(list, paraloc1);
@@ -1720,7 +1720,7 @@ begin
 end;
 
 
-procedure TCg64MPSel.a_param64_ref(list: tasmlist; const r: treference; const paraloc: tcgpara);
+procedure TCg64MPSel.a_load64_ref_cgpara(list: tasmlist; const r: treference; const paraloc: tcgpara);
 var
   hreg64: tregister64;
 begin
@@ -1729,7 +1729,7 @@ begin
   hreg64.reglo := cg.GetIntRegister(list, OS_S32);
   hreg64.reghi := cg.GetIntRegister(list, OS_S32);
   a_load64_ref_reg(list, r, hreg64);
-  a_param64_reg(list, hreg64, paraloc);
+  a_load64_reg_cgpara(list, hreg64, paraloc);
 end;
 
 

compiler/ncgcal.pas

@@ -114,7 +114,7 @@ implementation
       begin
         if not(left.location.loc in [LOC_CREFERENCE,LOC_REFERENCE]) then
           internalerror(200304235);
-        cg.a_paramaddr_ref(current_asmdata.CurrAsmList,left.location.reference,tempcgpara);
+        cg.a_loadaddr_ref_cgpara(current_asmdata.CurrAsmList,left.location.reference,tempcgpara);
       end;
 
 
@@ -176,7 +176,7 @@ implementation
                  size:=align(left.resultdef.size,tempcgpara.alignment);
                  if (not use_fixed_stack) and
                     (tempcgpara.location^.reference.index=NR_STACK_POINTER_REG) then
-                   cg.a_param_ref(current_asmdata.CurrAsmList,left.location.size,left.location.reference,tempcgpara)
+                   cg.a_load_ref_cgpara(current_asmdata.CurrAsmList,left.location.size,left.location.reference,tempcgpara)
                  else
                    begin
                      reference_reset_base(href,tempcgpara.location^.reference.index,tempcgpara.location^.reference.offset,tempcgpara.alignment);
@@ -197,12 +197,12 @@ implementation
                  LOC_CMMREGISTER,
                  LOC_REGISTER,
                  LOC_CREGISTER :
-                   cg.a_parammm_reg(current_asmdata.CurrAsmList,left.location.size,left.location.register,tempcgpara,mms_movescalar);
+                   cg.a_loadmm_reg_cgpara(current_asmdata.CurrAsmList,left.location.size,left.location.register,tempcgpara,mms_movescalar);
                  LOC_FPUREGISTER,
                  LOC_CFPUREGISTER:
                    begin
                      location_force_fpureg(current_asmdata.CurrAsmList,left.location,false);
-                     cg.a_paramfpu_reg(current_asmdata.CurrAsmList,left.location.size,left.location.register,tempcgpara);
+                     cg.a_loadfpu_reg_cgpara(current_asmdata.CurrAsmList,left.location.size,left.location.register,tempcgpara);
                    end;
                  else
                    internalerror(200204249);
@@ -214,7 +214,7 @@ implementation
                  LOC_CMMREGISTER:
                    begin
                      location_force_mmregscalar(current_asmdata.CurrAsmList,left.location,false);
-                     cg.a_parammm_reg(current_asmdata.CurrAsmList,left.location.size,left.location.register,tempcgpara,mms_movescalar);
+                     cg.a_loadmm_reg_cgpara(current_asmdata.CurrAsmList,left.location.size,left.location.register,tempcgpara,mms_movescalar);
                    end;
 {$ifdef cpu64bitalu}
                  LOC_REGISTER,
@@ -223,7 +223,7 @@ implementation
                      location_force_mem(current_asmdata.CurrAsmList,left.location);
                      { force integer size }
                      left.location.size:=int_cgsize(tcgsize2size[left.location.size]);
-                     cg.a_param_ref(current_asmdata.CurrAsmList,left.location.size,left.location.reference,tempcgpara);
+                     cg.a_load_ref_cgpara(current_asmdata.CurrAsmList,left.location.size,left.location.reference,tempcgpara);
                    end;
 {$endif cpu64bitalu}
 {$ifdef powerpc}
@@ -236,9 +236,9 @@ implementation
                      { force integer size }
                      left.location.size:=int_cgsize(tcgsize2size[left.location.size]);
                      if (left.location.size in [OS_32,OS_S32]) then
-                       cg.a_param_ref(current_asmdata.CurrAsmList,left.location.size,left.location.reference,tempcgpara)
+                       cg.a_load_ref_cgpara(current_asmdata.CurrAsmList,left.location.size,left.location.reference,tempcgpara)
                      else
-                       cg64.a_param64_ref(current_asmdata.CurrAsmList,left.location.reference,tempcgpara);
+                       cg64.a_load64_ref_cgpara(current_asmdata.CurrAsmList,left.location.reference,tempcgpara);
                    end;
 {$endif powerpc}
 {$if defined(sparc) or defined(arm) or defined(m68k)}
@@ -250,7 +250,7 @@ implementation
                  LOC_CREFERENCE,
                  LOC_FPUREGISTER,
                  LOC_CFPUREGISTER:
-                   cg.a_paramfpu_reg(current_asmdata.CurrAsmList,left.location.size,left.location.register,tempcgpara);
+                   cg.a_loadfpu_reg_cgpara(current_asmdata.CurrAsmList,left.location.size,left.location.register,tempcgpara);
                  else
                    internalerror(2002042433);
                end;
@@ -259,14 +259,14 @@ implementation
                case tempcgpara.location^.loc of
                  LOC_MMREGISTER,
                  LOC_CMMREGISTER:
-                   cg.a_parammm_ref(current_asmdata.CurrAsmList,left.location.size,left.location.reference,tempcgpara,mms_movescalar);
+                   cg.a_loadmm_ref_cgpara(current_asmdata.CurrAsmList,left.location.size,left.location.reference,tempcgpara,mms_movescalar);
 {$ifdef cpu64bitalu}
                  LOC_REGISTER,
                  LOC_CREGISTER :
                    begin
                      { force integer size }
                      left.location.size:=int_cgsize(tcgsize2size[left.location.size]);
-                     cg.a_param_ref(current_asmdata.CurrAsmList,left.location.size,left.location.reference,tempcgpara);
+                     cg.a_load_ref_cgpara(current_asmdata.CurrAsmList,left.location.size,left.location.reference,tempcgpara);
                    end;
 {$endif cpu64bitalu}
 {$ifdef powerpc}
@@ -277,9 +277,9 @@ implementation
                      { force integer size }
                      left.location.size:=int_cgsize(tcgsize2size[left.location.size]);
                      if (left.location.size in [OS_32,OS_S32]) then
-                       cg.a_param_ref(current_asmdata.CurrAsmList,left.location.size,left.location.reference,tempcgpara)
+                       cg.a_load_ref_cgpara(current_asmdata.CurrAsmList,left.location.size,left.location.reference,tempcgpara)
                      else
-                       cg64.a_param64_ref(current_asmdata.CurrAsmList,left.location.reference,tempcgpara);
+                       cg64.a_load64_ref_cgpara(current_asmdata.CurrAsmList,left.location.reference,tempcgpara);
                    end;
 {$endif powerpc}
 {$if defined(sparc) or defined(arm) or defined(m68k)}
@@ -291,7 +291,7 @@ implementation
                  LOC_CREFERENCE,
                  LOC_FPUREGISTER,
                  LOC_CFPUREGISTER:
-                   cg.a_paramfpu_ref(current_asmdata.CurrAsmList,left.location.size,left.location.reference,tempcgpara);
+                   cg.a_loadfpu_ref_cgpara(current_asmdata.CurrAsmList,left.location.size,left.location.reference,tempcgpara);
                  else
                    internalerror(2002042431);
                end;
@@ -301,19 +301,19 @@ implementation
 {$ifndef cpu64bitalu}
                  { use cg64 only for int64, not for 8 byte records }
                  if is_64bit(left.resultdef) then
-                   cg64.a_param64_loc(current_asmdata.CurrAsmList,left.location,tempcgpara)
+                   cg64.a_load64_loc_cgpara(current_asmdata.CurrAsmList,left.location,tempcgpara)
                  else
 {$endif not cpu64bitalu}
                    begin
 {$ifndef cpu64bitalu}
-                     { Only a_param_ref supports multiple locations, when the
+                     { Only a_load_ref_cgpara supports multiple locations, when the
                        value is still a const or in a register then write it
                        to a reference first. This situation can be triggered
                        by typecasting an int64 constant to a record of 8 bytes }
                      if left.location.size in [OS_64,OS_S64] then
                        location_force_mem(current_asmdata.CurrAsmList,left.location);
 {$endif not cpu64bitalu}
-                     cg.a_param_loc(current_asmdata.CurrAsmList,left.location,tempcgpara);
+                     cg.a_load_loc_cgpara(current_asmdata.CurrAsmList,left.location,tempcgpara);
                    end;
                end;
              else
@@ -333,25 +333,25 @@ implementation
 {$ifndef cpu64bitalu}
                  { use cg64 only for int64, not for 8 byte records }
                  if is_64bit(left.resultdef) then
-                   cg64.a_param64_loc(current_asmdata.CurrAsmList,left.location,tempcgpara)
+                   cg64.a_load64_loc_cgpara(current_asmdata.CurrAsmList,left.location,tempcgpara)
                  else
 {$endif not cpu64bitalu}
                    begin
 {$ifndef cpu64bitalu}
-                     { Only a_param_ref supports multiple locations, when the
+                     { Only a_load_ref_cgpara supports multiple locations, when the
                        value is still a const or in a register then write it
                        to a reference first. This situation can be triggered
                        by typecasting an int64 constant to a record of 8 bytes }
                      if left.location.size in [OS_64,OS_S64] then
                        location_force_mem(current_asmdata.CurrAsmList,left.location);
 {$endif not cpu64bitalu}
-                     cg.a_param_loc(current_asmdata.CurrAsmList,left.location,tempcgpara);
+                     cg.a_load_loc_cgpara(current_asmdata.CurrAsmList,left.location,tempcgpara);
                    end;
                end;
 {$ifdef SUPPORT_MMX}
              LOC_MMXREGISTER,
              LOC_CMMXREGISTER:
-               cg.a_parammm_reg(current_asmdata.CurrAsmList,OS_M64,left.location.register,tempcgpara,nil);
+               cg.a_loadmm_reg_cgpara(current_asmdata.CurrAsmList,OS_M64,left.location.register,tempcgpara,nil);
 {$endif SUPPORT_MMX}
              else
                internalerror(200204241);
@@ -450,7 +450,7 @@ implementation
                           if (left.location.reference.index<>NR_NO) or
                              (left.location.reference.offset<>0) then
                             internalerror(200410107);
-                          cg.a_param_reg(current_asmdata.CurrAsmList,OS_ADDR,left.location.reference.base,tempcgpara)
+                          cg.a_load_reg_cgpara(current_asmdata.CurrAsmList,OS_ADDR,left.location.reference.base,tempcgpara)
                         end
                       else
                         begin
@@ -1216,7 +1216,7 @@ implementation
 {$ifdef x86_64}
              cgpara.init;
              paramanager.getintparaloc(pocall_default,1,cgpara);
-             cg.a_param_reg(current_asmdata.CurrAsmList,OS_ADDR,NR_RAX,cgpara);
+             cg.a_load_reg_cgpara(current_asmdata.CurrAsmList,OS_ADDR,NR_RAX,cgpara);
              cgpara.done;
 {$endif x86_64}
              cg.allocallcpuregisters(current_asmdata.CurrAsmList);

compiler/ncgflw.pas

@@ -980,12 +980,12 @@ implementation
                   paramanager.allocparaloc(current_asmdata.CurrAsmList,paraloc3);
                   { frame tree }
                   if assigned(third) then
-                    cg.a_param_loc(current_asmdata.CurrAsmList,third.location,paraloc3)
+                    cg.a_load_loc_cgpara(current_asmdata.CurrAsmList,third.location,paraloc3)
                   else
-                    cg.a_param_const(current_asmdata.CurrAsmList,OS_INT,0,paraloc3);
+                    cg.a_load_const_cgpara(current_asmdata.CurrAsmList,OS_INT,0,paraloc3);
                   { push address }
                   paramanager.allocparaloc(current_asmdata.CurrAsmList,paraloc2);
-                  cg.a_param_loc(current_asmdata.CurrAsmList,right.location,paraloc2);
+                  cg.a_load_loc_cgpara(current_asmdata.CurrAsmList,right.location,paraloc2);
                 end
               else
                 begin
@@ -995,16 +995,16 @@ implementation
                    reference_reset_symbol(href2,a,0,1);
                    { push current frame }
                    paramanager.allocparaloc(current_asmdata.CurrAsmList,paraloc3);
-                   cg.a_param_reg(current_asmdata.CurrAsmList,OS_ADDR,NR_FRAME_POINTER_REG,paraloc3);
+                   cg.a_load_reg_cgpara(current_asmdata.CurrAsmList,OS_ADDR,NR_FRAME_POINTER_REG,paraloc3);
                    { push current address }
                    paramanager.allocparaloc(current_asmdata.CurrAsmList,paraloc2);
                    if target_info.system <> system_powerpc_macos then
-                     cg.a_paramaddr_ref(current_asmdata.CurrAsmList,href2,paraloc2)
+                     cg.a_loadaddr_ref_cgpara(current_asmdata.CurrAsmList,href2,paraloc2)
                    else
-                     cg.a_param_const(current_asmdata.CurrAsmList,OS_INT,0,paraloc2);
+                     cg.a_load_const_cgpara(current_asmdata.CurrAsmList,OS_INT,0,paraloc2);
                 end;
               paramanager.allocparaloc(current_asmdata.CurrAsmList,paraloc1);
-              cg.a_param_loc(current_asmdata.CurrAsmList,left.location,paraloc1);
+              cg.a_load_loc_cgpara(current_asmdata.CurrAsmList,left.location,paraloc1);
               paramanager.freeparaloc(current_asmdata.CurrAsmList,paraloc1);
               paramanager.freeparaloc(current_asmdata.CurrAsmList,paraloc2);
               paramanager.freeparaloc(current_asmdata.CurrAsmList,paraloc3);
@@ -1047,7 +1047,7 @@ implementation
          paramanager.getintparaloc(pocall_default,1,paraloc1);
          paramanager.allocparaloc(current_asmdata.CurrAsmList,paraloc1);
          cg.a_reg_dealloc(current_asmdata.CurrAsmList,NR_FUNCTION_RESULT_REG);
-         cg.a_param_reg(current_asmdata.CurrAsmList,OS_ADDR,NR_FUNCTION_RESULT_REG,paraloc1);
+         cg.a_load_reg_cgpara(current_asmdata.CurrAsmList,OS_ADDR,NR_FUNCTION_RESULT_REG,paraloc1);
          paramanager.freeparaloc(current_asmdata.CurrAsmList,paraloc1);
          cg.allocallcpuregisters(current_asmdata.CurrAsmList);
          cg.a_call_name(current_asmdata.CurrAsmList,'FPC_DESTROYEXCEPTION',false);
@@ -1170,7 +1170,7 @@ implementation
               paraloc1.init;
               paramanager.getintparaloc(pocall_default,1,paraloc1);
               paramanager.allocparaloc(current_asmdata.CurrAsmList,paraloc1);
-              cg.a_param_const(current_asmdata.CurrAsmList,OS_ADDR,-1,paraloc1);
+              cg.a_load_const_cgpara(current_asmdata.CurrAsmList,OS_ADDR,-1,paraloc1);
               paramanager.freeparaloc(current_asmdata.CurrAsmList,paraloc1);
               cg.allocallcpuregisters(current_asmdata.CurrAsmList);
               cg.a_call_name(current_asmdata.CurrAsmList,'FPC_CATCHES',false);
@@ -1203,7 +1203,7 @@ implementation
               paramanager.getintparaloc(pocall_default,1,paraloc1);
               cg.a_reg_alloc(current_asmdata.CurrAsmList,NR_FUNCTION_RESULT_REG);
               paramanager.allocparaloc(current_asmdata.CurrAsmList,paraloc1);
-              cg.a_param_reg(current_asmdata.CurrAsmList, OS_ADDR, NR_FUNCTION_RESULT_REG, paraloc1);
+              cg.a_load_reg_cgpara(current_asmdata.CurrAsmList, OS_ADDR, NR_FUNCTION_RESULT_REG, paraloc1);
               paramanager.freeparaloc(current_asmdata.CurrAsmList,paraloc1);
               cg.allocallcpuregisters(current_asmdata.CurrAsmList);
               cg.a_call_name(current_asmdata.CurrAsmList,'FPC_DESTROYEXCEPTION',false);
@@ -1359,7 +1359,7 @@ implementation
          reference_reset_symbol(href2,current_asmdata.RefAsmSymbol(excepttype.vmt_mangledname),0,sizeof(pint));
          paramanager.getintparaloc(pocall_default,1,paraloc1);
          paramanager.allocparaloc(current_asmdata.CurrAsmList,paraloc1);
-         cg.a_paramaddr_ref(current_asmdata.CurrAsmList,href2,paraloc1);
+         cg.a_loadaddr_ref_cgpara(current_asmdata.CurrAsmList,href2,paraloc1);
          paramanager.freeparaloc(current_asmdata.CurrAsmList,paraloc1);
          cg.allocallcpuregisters(current_asmdata.CurrAsmList);
          cg.a_call_name(current_asmdata.CurrAsmList,'FPC_CATCHES',false);
@@ -1432,7 +1432,7 @@ implementation
          paramanager.getintparaloc(pocall_default,1,paraloc1);
          cg.a_reg_dealloc(current_asmdata.CurrAsmList,NR_FUNCTION_RESULT_REG);
          paramanager.allocparaloc(current_asmdata.CurrAsmList,paraloc1);
-         cg.a_param_reg(current_asmdata.CurrAsmList, OS_ADDR, NR_FUNCTION_RESULT_REG, paraloc1);
+         cg.a_load_reg_cgpara(current_asmdata.CurrAsmList, OS_ADDR, NR_FUNCTION_RESULT_REG, paraloc1);
          paramanager.freeparaloc(current_asmdata.CurrAsmList,paraloc1);
          cg.allocallcpuregisters(current_asmdata.CurrAsmList);
          cg.a_call_name(current_asmdata.CurrAsmList,'FPC_DESTROYEXCEPTION',false);

compiler/ncginl.pas

@@ -217,16 +217,16 @@ implementation
           exit;
        { push erroraddr }
        paramanager.allocparaloc(current_asmdata.CurrAsmList,paraloc4);
-       cg.a_param_reg(current_asmdata.CurrAsmList,OS_ADDR,NR_FRAME_POINTER_REG,paraloc4);
+       cg.a_load_reg_cgpara(current_asmdata.CurrAsmList,OS_ADDR,NR_FRAME_POINTER_REG,paraloc4);
        { push lineno }
        paramanager.allocparaloc(current_asmdata.CurrAsmList,paraloc3);
-       cg.a_param_const(current_asmdata.CurrAsmList,OS_INT,current_filepos.line,paraloc3);
+       cg.a_load_const_cgpara(current_asmdata.CurrAsmList,OS_INT,current_filepos.line,paraloc3);
        { push filename }
        paramanager.allocparaloc(current_asmdata.CurrAsmList,paraloc2);
-       cg.a_paramaddr_ref(current_asmdata.CurrAsmList,hp2.location.reference,paraloc2);
+       cg.a_loadaddr_ref_cgpara(current_asmdata.CurrAsmList,hp2.location.reference,paraloc2);
        { push msg }
        paramanager.allocparaloc(current_asmdata.CurrAsmList,paraloc1);
-       cg.a_paramaddr_ref(current_asmdata.CurrAsmList,hp3.location.reference,paraloc1);
+       cg.a_loadaddr_ref_cgpara(current_asmdata.CurrAsmList,hp3.location.reference,paraloc1);
        { call }
        paramanager.freeparaloc(current_asmdata.CurrAsmList,paraloc1);
        paramanager.freeparaloc(current_asmdata.CurrAsmList,paraloc2);

compiler/ncgld.pas

@@ -351,7 +351,7 @@ implementation
                         else
                           reference_reset_symbol(href,current_asmdata.WeakRefAsmSymbol(gvs.mangledname),0,sizeof(pint));
                         paramanager.allocparaloc(current_asmdata.CurrAsmList,paraloc1);
-                        cg.a_param_ref(current_asmdata.CurrAsmList,OS_32,href,paraloc1);
+                        cg.a_load_ref_cgpara(current_asmdata.CurrAsmList,OS_32,href,paraloc1);
                         paramanager.freeparaloc(current_asmdata.CurrAsmList,paraloc1);
                         paraloc1.done;
                         cg.allocallcpuregisters(current_asmdata.CurrAsmList);

compiler/ncgmat.pas

@@ -369,7 +369,7 @@ implementation
                   paraloc1.init;
                   paramanager.getintparaloc(pocall_default,1,paraloc1);
                   paramanager.allocparaloc(current_asmdata.CurrAsmList,paraloc1);
-                  cg.a_param_const(current_asmdata.CurrAsmList,OS_S32,200,paraloc1);
+                  cg.a_load_const_cgpara(current_asmdata.CurrAsmList,OS_S32,200,paraloc1);
                   paramanager.freeparaloc(current_asmdata.CurrAsmList,paraloc1);
                   cg.a_call_name(current_asmdata.CurrAsmList,'FPC_HANDLEERROR',false);
                   paraloc1.done;

compiler/ncgmem.pas

@@ -266,7 +266,7 @@ implementation
             paraloc1.init;
             paramanager.getintparaloc(pocall_default,1,paraloc1);
             paramanager.allocparaloc(current_asmdata.CurrAsmList,paraloc1);
-            cg.a_param_reg(current_asmdata.CurrAsmList, OS_ADDR,location.reference.base,paraloc1);
+            cg.a_load_reg_cgpara(current_asmdata.CurrAsmList, OS_ADDR,location.reference.base,paraloc1);
             paramanager.freeparaloc(current_asmdata.CurrAsmList,paraloc1);
             paraloc1.done;
             cg.allocallcpuregisters(current_asmdata.CurrAsmList);
@@ -333,7 +333,7 @@ implementation
               begin
                 paramanager.getintparaloc(pocall_default,1,paraloc1);
                 paramanager.allocparaloc(current_asmdata.CurrAsmList,paraloc1);
-                cg.a_param_reg(current_asmdata.CurrAsmList, OS_ADDR,location.reference.base,paraloc1);
+                cg.a_load_reg_cgpara(current_asmdata.CurrAsmList, OS_ADDR,location.reference.base,paraloc1);
                 paramanager.freeparaloc(current_asmdata.CurrAsmList,paraloc1);
                 cg.allocallcpuregisters(current_asmdata.CurrAsmList);
                 cg.a_call_name(current_asmdata.CurrAsmList,'FPC_CHECKPOINTER',false);
@@ -352,7 +352,7 @@ implementation
               begin
                 paramanager.getintparaloc(pocall_default,1,paraloc1);
                 paramanager.allocparaloc(current_asmdata.CurrAsmList,paraloc1);
-                cg.a_param_reg(current_asmdata.CurrAsmList, OS_ADDR,location.reference.base,paraloc1);
+                cg.a_load_reg_cgpara(current_asmdata.CurrAsmList, OS_ADDR,location.reference.base,paraloc1);
                 paramanager.freeparaloc(current_asmdata.CurrAsmList,paraloc1);
                 cg.allocallcpuregisters(current_asmdata.CurrAsmList);
                 cg.a_call_name(current_asmdata.CurrAsmList,'FPC_CHECKPOINTER',false);
@@ -686,9 +686,9 @@ implementation
                paramanager.getintparaloc(pocall_default,1,paraloc1);
                paramanager.getintparaloc(pocall_default,2,paraloc2);
                paramanager.allocparaloc(current_asmdata.CurrAsmList,paraloc2);
-               cg.a_param_loc(current_asmdata.CurrAsmList,right.location,paraloc2);
+               cg.a_load_loc_cgpara(current_asmdata.CurrAsmList,right.location,paraloc2);
                paramanager.allocparaloc(current_asmdata.CurrAsmList,paraloc1);
-               cg.a_param_loc(current_asmdata.CurrAsmList,left.location,paraloc1);
+               cg.a_load_loc_cgpara(current_asmdata.CurrAsmList,left.location,paraloc1);
                paramanager.freeparaloc(current_asmdata.CurrAsmList,paraloc1);
                paramanager.freeparaloc(current_asmdata.CurrAsmList,paraloc2);
                cg.allocallcpuregisters(current_asmdata.CurrAsmList);
@@ -772,7 +772,7 @@ implementation
                 begin
                    paramanager.getintparaloc(pocall_default,1,paraloc1);
                    paramanager.allocparaloc(current_asmdata.CurrAsmList,paraloc1);
-                   cg.a_param_reg(current_asmdata.CurrAsmList,OS_ADDR,location.reference.base,paraloc1);
+                   cg.a_load_reg_cgpara(current_asmdata.CurrAsmList,OS_ADDR,location.reference.base,paraloc1);
                    paramanager.freeparaloc(current_asmdata.CurrAsmList,paraloc1);
                    cg.allocallcpuregisters(current_asmdata.CurrAsmList);
                    cg.a_call_name(current_asmdata.CurrAsmList,'FPC_'+upper(tstringdef(left.resultdef).stringtypname)+'_CHECKZERO',false);
@@ -877,20 +877,20 @@ implementation
                               paramanager.getintparaloc(pocall_default,1,paraloc1);
                               paramanager.getintparaloc(pocall_default,2,paraloc2);
                               paramanager.allocparaloc(current_asmdata.CurrAsmList,paraloc2);
-                              cg.a_param_const(current_asmdata.CurrAsmList,OS_INT,tordconstnode(right).value.svalue,paraloc2);
+                              cg.a_load_const_cgpara(current_asmdata.CurrAsmList,OS_INT,tordconstnode(right).value.svalue,paraloc2);
                               href:=location.reference;
                               paramanager.allocparaloc(current_asmdata.CurrAsmList,paraloc1);
                               if not(tf_winlikewidestring in target_info.flags) or
                                  (tstringdef(left.resultdef).stringtype<>st_widestring) then
                                 begin
                                   dec(href.offset,sizeof(pint)-offsetdec);
-                                  cg.a_param_ref(current_asmdata.CurrAsmList,OS_ADDR,href,paraloc1);
+                                  cg.a_load_ref_cgpara(current_asmdata.CurrAsmList,OS_ADDR,href,paraloc1);
                                 end
                               else
                                 begin
                                   { winlike widestrings have a 4 byte length }
                                   dec(href.offset,4-offsetdec);
-                                  cg.a_param_ref(current_asmdata.CurrAsmList,OS_32,href,paraloc1);
+                                  cg.a_load_ref_cgpara(current_asmdata.CurrAsmList,OS_32,href,paraloc1);
                                 end;
                               paramanager.freeparaloc(current_asmdata.CurrAsmList,paraloc1);
                               paramanager.freeparaloc(current_asmdata.CurrAsmList,paraloc2);
@@ -1039,7 +1039,7 @@ implementation
                               paramanager.getintparaloc(pocall_default,1,paraloc1);
                               paramanager.getintparaloc(pocall_default,2,paraloc2);
                               paramanager.allocparaloc(current_asmdata.CurrAsmList,paraloc2);
-                              cg.a_param_reg(current_asmdata.CurrAsmList,OS_INT,right.location.register,paraloc2);
+                              cg.a_load_reg_cgpara(current_asmdata.CurrAsmList,OS_INT,right.location.register,paraloc2);
                               href:=location.reference;
                               dec(href.offset,sizeof(pint)-offsetdec);
 
@@ -1049,13 +1049,13 @@ implementation
                                  (tstringdef(left.resultdef).stringtype<>st_widestring) then
                                 begin
                                   dec(href.offset,sizeof(pint)-offsetdec);
-                                  cg.a_param_ref(current_asmdata.CurrAsmList,OS_ADDR,href,paraloc1);
+                                  cg.a_load_ref_cgpara(current_asmdata.CurrAsmList,OS_ADDR,href,paraloc1);
                                 end
                               else
                                 begin
                                   { winlike widestrings have a 4 byte length }
                                   dec(href.offset,4-offsetdec);
-                                  cg.a_param_ref(current_asmdata.CurrAsmList,OS_32,href,paraloc1);
+                                  cg.a_load_ref_cgpara(current_asmdata.CurrAsmList,OS_32,href,paraloc1);
                                 end;
 
                               paramanager.freeparaloc(current_asmdata.CurrAsmList,paraloc1);

compiler/ncgutil.pas

@@ -408,12 +408,12 @@ implementation
         paramanager.getintparaloc(pocall_default,2,paraloc2);
         paramanager.getintparaloc(pocall_default,3,paraloc3);
         paramanager.allocparaloc(list,paraloc3);
-        cg.a_paramaddr_ref(list,t.envbuf,paraloc3);
+        cg.a_loadaddr_ref_cgpara(list,t.envbuf,paraloc3);
         paramanager.allocparaloc(list,paraloc2);
-        cg.a_paramaddr_ref(list,t.jmpbuf,paraloc2);
+        cg.a_loadaddr_ref_cgpara(list,t.jmpbuf,paraloc2);
         { push type of exceptionframe }
         paramanager.allocparaloc(list,paraloc1);
-        cg.a_param_const(list,OS_S32,1,paraloc1);
+        cg.a_load_const_cgpara(list,OS_S32,1,paraloc1);
         paramanager.freeparaloc(list,paraloc3);
         paramanager.freeparaloc(list,paraloc2);
         paramanager.freeparaloc(list,paraloc1);
@@ -423,7 +423,7 @@ implementation
 
         paramanager.getintparaloc(pocall_default,1,paraloc1);
         paramanager.allocparaloc(list,paraloc1);
-        cg.a_param_reg(list,OS_ADDR,NR_FUNCTION_RESULT_REG,paraloc1);
+        cg.a_load_reg_cgpara(list,OS_ADDR,NR_FUNCTION_RESULT_REG,paraloc1);
         paramanager.freeparaloc(list,paraloc1);
         cg.allocallcpuregisters(list);
         cg.a_call_name(list,'FPC_SETJMP',false);
@@ -2192,7 +2192,7 @@ implementation
         paraloc1.init;
         paramanager.getintparaloc(pocall_default,1,paraloc1);
         paramanager.allocparaloc(list,paraloc1);
-        cg.a_param_const(list,OS_INT,current_procinfo.calc_stackframe_size,paraloc1);
+        cg.a_load_const_cgpara(list,OS_INT,current_procinfo.calc_stackframe_size,paraloc1);
         paramanager.freeparaloc(list,paraloc1);
         paraloc1.done;
       end;

compiler/powerpc/cgcpu.pas

@@ -42,7 +42,7 @@ unit cgcpu;
         { left to right), this allows to move the parameter to    }
         { register, if the cpu supports register calling          }
         { conventions                                             }
-        procedure a_param_ref(list : TAsmList;size : tcgsize;const r : treference;const paraloc : tcgpara);override;
+        procedure a_load_ref_cgpara(list : TAsmList;size : tcgsize;const r : treference;const paraloc : tcgpara);override;
 
 
         procedure a_call_name(list : TAsmList;const s : string; weak: boolean);override;
@@ -184,7 +184,7 @@ const
       end;
 
 
-    procedure tcgppc.a_param_ref(list : TAsmList;size : tcgsize;const r : treference;const paraloc : tcgpara);
+    procedure tcgppc.a_load_ref_cgpara(list : TAsmList;size : tcgsize;const r : treference;const paraloc : tcgpara);
 
       var
         tmpref, ref: treference;
@@ -217,7 +217,7 @@ const
                       dec(tmpref.offset,2);
                     end;
 {$else not cpu64bitaddr}
-{$error add 64 bit support for non power of 2 loads in a_param_ref}
+{$error add 64 bit support for non power of 2 loads in a_load_ref_cgpara}
 {$endif not cpu64bitaddr}
                 end;
               LOC_REFERENCE:

compiler/powerpc64/cgcpu.pas

@@ -42,7 +42,7 @@ type
     { left to right), this allows to move the parameter to    }
     { register, if the cpu supports register calling          }
     { conventions                                             }
-    procedure a_param_ref(list: TAsmList; size: tcgsize; const r: treference;
+    procedure a_load_ref_cgpara(list: TAsmList; size: tcgsize; const r: treference;
       const paraloc: tcgpara); override;
 
     procedure a_call_name(list: TAsmList; const s: string; weak: boolean); override;
@@ -394,7 +394,7 @@ begin
   inherited done_register_allocators;
 end;
 
-procedure tcgppc.a_param_ref(list: TAsmList; size: tcgsize; const r:
+procedure tcgppc.a_load_ref_cgpara(list: TAsmList; size: tcgsize; const r:
   treference; const paraloc: tcgpara);
 
 var

compiler/ppcgen/cgppc.pas

@@ -34,8 +34,8 @@ unit cgppc;
 
     type
       tcgppcgen = class(tcg)
-        procedure a_param_const(list: TAsmList; size: tcgsize; a: aint; const paraloc : tcgpara); override;
-        procedure a_paramaddr_ref(list : TAsmList;const r : treference;const paraloc : tcgpara); override;
+        procedure a_load_const_cgpara(list: TAsmList; size: tcgsize; a: aint; const paraloc : tcgpara); override;
+        procedure a_loadaddr_ref_cgpara(list : TAsmList;const r : treference;const paraloc : tcgpara); override;
 
         procedure a_call_reg(list : TAsmList;reg: tregister); override;
         procedure a_call_ref(list : TAsmList;ref: treference); override;
@@ -157,7 +157,7 @@ unit cgppc;
       end;
 
 
-    procedure tcgppcgen.a_param_const(list: TAsmList; size: tcgsize; a: aint; const
+    procedure tcgppcgen.a_load_const_cgpara(list: TAsmList; size: tcgsize; a: aint; const
       paraloc: tcgpara);
     var
       ref: treference;
@@ -179,7 +179,7 @@ unit cgppc;
     end;
 
 
-    procedure tcgppcgen.a_paramaddr_ref(list : TAsmList;const r : treference;const paraloc : tcgpara);
+    procedure tcgppcgen.a_loadaddr_ref_cgpara(list : TAsmList;const r : treference;const paraloc : tcgpara);
       var
         ref: treference;
         tmpreg: tregister;
@@ -615,7 +615,7 @@ unit cgppc;
         begin
           paraloc1.init;
           paramanager.getintparaloc(pocall_cdecl,1,paraloc1);
-          a_param_reg(list,OS_ADDR,NR_R0,paraloc1);
+          a_load_reg_cgpara(list,OS_ADDR,NR_R0,paraloc1);
           paramanager.freeparaloc(list,paraloc1);
           paraloc1.done;
           allocallcpuregisters(list);

compiler/sparc/cgcpu.pas

@@ -46,11 +46,11 @@ interface
         procedure handle_load_store(list:TAsmList;isstore:boolean;op: tasmop;reg:tregister;ref: treference);
         procedure handle_reg_const_reg(list:TAsmList;op:Tasmop;src:tregister;a:aint;dst:tregister);
         { parameter }
-        procedure a_param_const(list:TAsmList;size:tcgsize;a:aint;const paraloc:TCGPara);override;
-        procedure a_param_ref(list:TAsmList;sz:tcgsize;const r:TReference;const paraloc:TCGPara);override;
-        procedure a_paramaddr_ref(list:TAsmList;const r:TReference;const paraloc:TCGPara);override;
-        procedure a_paramfpu_reg(list : TAsmList;size : tcgsize;const r : tregister;const paraloc : TCGPara);override;
-        procedure a_paramfpu_ref(list : TAsmList;size : tcgsize;const ref : treference;const paraloc : TCGPara);override;
+        procedure a_load_const_cgpara(list:TAsmList;size:tcgsize;a:aint;const paraloc:TCGPara);override;
+        procedure a_load_ref_cgpara(list:TAsmList;sz:tcgsize;const r:TReference;const paraloc:TCGPara);override;
+        procedure a_loadaddr_ref_cgpara(list:TAsmList;const r:TReference;const paraloc:TCGPara);override;
+        procedure a_loadfpu_reg_cgpara(list : TAsmList;size : tcgsize;const r : tregister;const paraloc : TCGPara);override;
+        procedure a_loadfpu_ref_cgpara(list : TAsmList;size : tcgsize;const ref : treference;const paraloc : TCGPara);override;
         procedure a_call_name(list:TAsmList;const s:string; weak: boolean);override;
         procedure a_call_reg(list:TAsmList;Reg:TRegister);override;
         { General purpose instructions }
@@ -100,7 +100,7 @@ interface
       public
         procedure a_load64_reg_ref(list : TAsmList;reg : tregister64;const ref : treference);override;
         procedure a_load64_ref_reg(list : TAsmList;const ref : treference;reg : tregister64);override;
-        procedure a_param64_ref(list : TAsmList;const r : treference;const paraloc : tcgpara);override;
+        procedure a_load64_ref_cgpara(list : TAsmList;const r : treference;const paraloc : tcgpara);override;
         procedure a_op64_reg_reg(list:TAsmList;op:TOpCG;size : tcgsize;regsrc,regdst:TRegister64);override;
         procedure a_op64_const_reg(list:TAsmList;op:TOpCG;size : tcgsize;value:int64;regdst:TRegister64);override;
         procedure a_op64_const_reg_reg(list: TAsmList;op:TOpCG;size : tcgsize;value : int64;regsrc,regdst : tregister64);override;
@@ -322,7 +322,7 @@ implementation
       end;
 
 
-    procedure TCgSparc.a_param_const(list:TAsmList;size:tcgsize;a:aint;const paraloc:TCGPara);
+    procedure TCgSparc.a_load_const_cgpara(list:TAsmList;size:tcgsize;a:aint;const paraloc:TCGPara);
       var
         Ref:TReference;
       begin
@@ -347,7 +347,7 @@ implementation
       end;
 
 
-    procedure TCgSparc.a_param_ref(list:TAsmList;sz:TCgSize;const r:TReference;const paraloc:TCGPara);
+    procedure TCgSparc.a_load_ref_cgpara(list:TAsmList;sz:TCgSize;const r:TReference;const paraloc:TCGPara);
       var
         ref: treference;
         tmpreg:TRegister;
@@ -386,7 +386,7 @@ implementation
       end;
 
 
-    procedure TCgSparc.a_paramaddr_ref(list:TAsmList;const r:TReference;const paraloc:TCGPara);
+    procedure TCgSparc.a_loadaddr_ref_cgpara(list:TAsmList;const r:TReference;const paraloc:TCGPara);
       var
         Ref:TReference;
         TmpReg:TRegister;
@@ -413,7 +413,7 @@ implementation
       end;
 
 
-    procedure tcgsparc.a_paramfpu_ref(list : TAsmList;size : tcgsize;const ref : treference;const paraloc : TCGPara);
+    procedure tcgsparc.a_loadfpu_ref_cgpara(list : TAsmList;size : tcgsize;const ref : treference;const paraloc : TCGPara);
       var
          href,href2 : treference;
          hloc : pcgparalocation;
@@ -439,13 +439,13 @@ implementation
       end;
 
 
-    procedure tcgsparc.a_paramfpu_reg(list : TAsmList;size : tcgsize;const r : tregister;const paraloc : TCGPara);
+    procedure tcgsparc.a_loadfpu_reg_cgpara(list : TAsmList;size : tcgsize;const r : tregister;const paraloc : TCGPara);
       var
         href : treference;
       begin
         tg.GetTemp(list,TCGSize2Size[size],TCGSize2Size[size],tt_normal,href);
         a_loadfpu_reg_ref(list,size,size,r,href);
-        a_paramfpu_ref(list,size,href,paraloc);
+        a_loadfpu_ref_cgpara(list,size,href,paraloc);
         tg.Ungettemp(list,href);
       end;
 
@@ -1161,11 +1161,11 @@ implementation
         paramanager.getintparaloc(pocall_default,2,paraloc2);
         paramanager.getintparaloc(pocall_default,3,paraloc3);
         paramanager.allocparaloc(list,paraloc3);
-        a_param_const(list,OS_INT,len,paraloc3);
+        a_load_const_cgpara(list,OS_INT,len,paraloc3);
         paramanager.allocparaloc(list,paraloc2);
-        a_paramaddr_ref(list,dest,paraloc2);
+        a_loadaddr_ref_cgpara(list,dest,paraloc2);
         paramanager.allocparaloc(list,paraloc2);
-        a_paramaddr_ref(list,source,paraloc1);
+        a_loadaddr_ref_cgpara(list,source,paraloc1);
         paramanager.freeparaloc(list,paraloc3);
         paramanager.freeparaloc(list,paraloc2);
         paramanager.freeparaloc(list,paraloc1);
@@ -1422,7 +1422,7 @@ implementation
       end;
 
 
-    procedure tcg64sparc.a_param64_ref(list : TAsmList;const r : treference;const paraloc : tcgpara);
+    procedure tcg64sparc.a_load64_ref_cgpara(list : TAsmList;const r : treference;const paraloc : tcgpara);
       var
         hreg64 : tregister64;
       begin
@@ -1431,7 +1431,7 @@ implementation
         hreg64.reglo:=cg.GetIntRegister(list,OS_32);
         hreg64.reghi:=cg.GetIntRegister(list,OS_32);
         a_load64_ref_reg(list,r,hreg64);
-        a_param64_reg(list,hreg64,paraloc);
+        a_load64_reg_cgpara(list,hreg64,paraloc);
       end;
 
 

compiler/x86_64/cgcpu.pas

@@ -40,7 +40,7 @@ unit cgcpu;
         procedure g_proc_exit(list : TAsmList;parasize:longint;nostackframe:boolean);override;
         procedure g_intf_wrapper(list: TAsmList; procdef: tprocdef; const labelname: string; ioffset: longint);override;
 
-        procedure a_param_ref(list : TAsmList;size : tcgsize;const r : treference;const paraloc : TCGPara);override;
+        procedure a_load_ref_cgpara(list : TAsmList;size : tcgsize;const r : treference;const paraloc : TCGPara);override;
 
         procedure a_loadmm_intreg_reg(list: TAsmList; fromsize, tosize : tcgsize;intreg, mmreg: tregister; shuffle: pmmshuffle); override;
         procedure a_loadmm_reg_intreg(list: TAsmList; fromsize, tosize : tcgsize;mmreg, intreg: tregister;shuffle : pmmshuffle); override;
@@ -108,7 +108,7 @@ unit cgcpu;
       end;
 
 
-    procedure tcgx86_64.a_param_ref(list : TAsmList;size : tcgsize;const r : treference;const paraloc : TCGPara);
+    procedure tcgx86_64.a_load_ref_cgpara(list : TAsmList;size : tcgsize;const r : treference;const paraloc : TCGPara);
       var
         tmpref, ref: treference;
         location: pcgparalocation;