paweld/fpc
1
0
Fork 0
mirror of https://gitlab.com/freepascal.org/fpc/source.git synced 2025-08-20 10:09:17 +02:00
Code Issues Packages Projects Releases Wiki Activity

* renamed a_param_* to a_load_*_cgpara

Browse Source 
git-svn-id: trunk@15305 -
This commit is contained in:
Jonas Maebe 2010-05-22 09:07:21 +00:00
parent 537cb9677d
commit 9bc15a5f61
20 changed files with 235 additions and 235 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

24
compiler/arm/cgcpu.pas
View File

@ -40,9 +40,9 @@ unit cgcpu;
{ true, if the next arithmetic operation should modify the flags } { true, if the next arithmetic operation should modify the flags }
cgsetflags : boolean; cgsetflags : boolean;
procedure a_param_const(list : TAsmList;size : tcgsize;a : aint;const paraloc : TCGPara);override; procedure a_load_const_cgpara(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_load_ref_cgpara(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_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_name(list : TAsmList;const s : string; weak: boolean);override;
procedure a_call_reg(list : TAsmList;reg: tregister);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_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_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 } { comparison operations }
procedure a_cmp_const_reg_label(list : TAsmList;size : tcgsize;cmp_op : topcmp;a : aint;reg : tregister; procedure a_cmp_const_reg_label(list : TAsmList;size : tcgsize;cmp_op : topcmp;a : aint;reg : tregister;
l : tasmlabel);override; l : tasmlabel);override;
@ -413,7 +413,7 @@ unit cgcpu;
end; 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 var
ref: treference; ref: treference;
begin begin
@ -434,7 +434,7 @@ unit cgcpu;
end; 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 var
tmpref, ref: treference; tmpref, ref: treference;
location: pcgparalocation; location: pcgparalocation;
@ -482,7 +482,7 @@ unit cgcpu;
end; 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 var
ref: treference; ref: treference;
tmpreg: tregister; tmpreg: tregister;
@ -1227,7 +1227,7 @@ unit cgcpu;
end; 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 var
href,href2 : treference; href,href2 : treference;
hloc : pcgparalocation; hloc : pcgparalocation;
@ -1246,7 +1246,7 @@ unit cgcpu;
a_load_ref_reg(list,OS_32,OS_32,href,hloc^.register); a_load_ref_reg(list,OS_32,OS_32,href,hloc^.register);
OS_64, OS_64,
OS_F64: OS_F64:
cg64.a_param64_ref(list,href,paraloc); cg64.a_load64_ref_cgpara(list,href,paraloc);
else else
a_load_ref_reg(list,hloc^.size,hloc^.size,href,hloc^.register); a_load_ref_reg(list,hloc^.size,hloc^.size,href,hloc^.register);
end; end;
@ -1814,11 +1814,11 @@ unit cgcpu;
paramanager.getintparaloc(pocall_default,2,paraloc2); paramanager.getintparaloc(pocall_default,2,paraloc2);
paramanager.getintparaloc(pocall_default,3,paraloc3); paramanager.getintparaloc(pocall_default,3,paraloc3);
paramanager.allocparaloc(list,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); paramanager.allocparaloc(list,paraloc2);
a_paramaddr_ref(list,dest,paraloc2); a_loadaddr_ref_cgpara(list,dest,paraloc2);
paramanager.allocparaloc(list,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,paraloc3);
paramanager.freeparaloc(list,paraloc2); paramanager.freeparaloc(list,paraloc2);
paramanager.freeparaloc(list,paraloc1); paramanager.freeparaloc(list,paraloc1);

18
compiler/avr/cgcpu.pas
View File

@ -42,9 +42,9 @@ unit cgcpu;
procedure init_register_allocators;override; procedure init_register_allocators;override;
procedure done_register_allocators;override; procedure done_register_allocators;override;
procedure a_param_const(list : TAsmList;size : tcgsize;a : aint;const paraloc : TCGPara);override; procedure a_load_const_cgpara(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_load_ref_cgpara(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_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_name(list : TAsmList;const s : string; weak: boolean);override;
procedure a_call_reg(list : TAsmList;reg: tregister);override; procedure a_call_reg(list : TAsmList;reg: tregister);override;
@ -146,7 +146,7 @@ unit cgcpu;
end; 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 var
ref: treference; ref: treference;
begin begin
@ -167,7 +167,7 @@ unit cgcpu;
end; 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 var
tmpref, ref: treference; tmpref, ref: treference;
location: pcgparalocation; location: pcgparalocation;
@ -208,7 +208,7 @@ unit cgcpu;
end; 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 var
ref: treference; ref: treference;
tmpreg: tregister; tmpreg: tregister;
@ -715,11 +715,11 @@ unit cgcpu;
paramanager.getintparaloc(pocall_default,2,paraloc2); paramanager.getintparaloc(pocall_default,2,paraloc2);
paramanager.getintparaloc(pocall_default,3,paraloc3); paramanager.getintparaloc(pocall_default,3,paraloc3);
paramanager.allocparaloc(list,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); paramanager.allocparaloc(list,paraloc2);
a_paramaddr_ref(list,dest,paraloc2); a_loadaddr_ref_cgpara(list,dest,paraloc2);
paramanager.allocparaloc(list,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,paraloc3);
paramanager.freeparaloc(list,paraloc2); paramanager.freeparaloc(list,paraloc2);
paramanager.freeparaloc(list,paraloc1); paramanager.freeparaloc(list,paraloc1);

34
compiler/cg64f32.pas
View File

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

122
compiler/cgobj.pas
View File

@ -126,7 +126,7 @@ unit cgobj;
@param(r register source of the operand) @param(r register source of the operand)
@param(cgpara where the parameter will be stored) @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. {# Pass a parameter, which is a constant, to a routine.
A generic version is provided. This routine should A generic version is provided. This routine should
@ -137,7 +137,7 @@ unit cgobj;
@param(a value of constant to send) @param(a value of constant to send)
@param(cgpara where the parameter will be stored) @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. {# Pass the value of a parameter, which is located in memory, to a routine.
A generic version is provided. This routine should A generic version is provided. This routine should
@ -148,7 +148,7 @@ unit cgobj;
@param(r Memory reference of value to send) @param(r Memory reference of value to send)
@param(cgpara where the parameter will be stored) @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, {# Pass the value of a parameter, which can be located either in a register or memory location,
to a routine. to a routine.
@ -158,7 +158,7 @@ unit cgobj;
@param(nr parameter number (starting from one) of routine (from left to right)) @param(nr parameter number (starting from one) of routine (from left to right))
@param(cgpara where the parameter will be stored) @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 {# Pass the address of a reference to a routine. This routine
will calculate the address of the reference, and pass this will calculate the address of the reference, and pass this
calculated address as a parameter. calculated address as a parameter.
@ -170,7 +170,7 @@ unit cgobj;
@param(r reference to get address from) @param(r reference to get address from)
@param(nr parameter number (starting from one) of routine (from left to right)) @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. {# Load a cgparaloc into a memory reference.
@ -182,7 +182,7 @@ unit cgobj;
In case this location is also a reference, it is assumed In case this location is also a reference, it is assumed
to be the final part sublocation of the parameter and that it to be the final part sublocation of the parameter and that it
contains all of the "sizeleft" bytes).) 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); 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(regsize the size of the destination register)
@param(paraloc the source parameter sublocation) @param(paraloc the source parameter sublocation)
@param(reg the destination register) @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); 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_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_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_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_loadfpu_reg_cgpara(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_ref_cgpara(list : TAsmList;size : tcgsize;const ref : treference;const cgpara : TCGPara);virtual;
{ vector register move instructions } { vector register move instructions }
procedure a_loadmm_reg_reg(list: TAsmList; fromsize, tosize : tcgsize;reg1, reg2: tregister;shuffle : pmmshuffle); virtual; 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_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_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_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_loadmm_reg_cgpara(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_loadmm_ref_cgpara(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_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_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_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; 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_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_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_load64_reg_cgpara(list : TAsmList;reg64 : tregister64;const loc : TCGPara);virtual;abstract;
procedure a_param64_const(list : TAsmList;value : int64;const loc : TCGPara);virtual;abstract; procedure a_load64_const_cgpara(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_load64_ref_cgpara(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_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_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; 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 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 var
ref : treference; ref : treference;
begin begin
@ -894,7 +894,7 @@ implementation
end; 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 var
ref : treference; ref : treference;
begin begin
@ -913,7 +913,7 @@ implementation
end; 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 var
ref : treference; ref : treference;
begin begin
@ -943,24 +943,24 @@ implementation
end; 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 begin
case l.loc of case l.loc of
LOC_REGISTER, LOC_REGISTER,
LOC_CREGISTER : LOC_CREGISTER :
a_param_reg(list,l.size,l.register,cgpara); a_load_reg_cgpara(list,l.size,l.register,cgpara);
LOC_CONSTANT : LOC_CONSTANT :
a_param_const(list,l.size,l.value,cgpara); a_load_const_cgpara(list,l.size,l.value,cgpara);
LOC_CREFERENCE, LOC_CREFERENCE,
LOC_REFERENCE : LOC_REFERENCE :
a_param_ref(list,l.size,l.reference,cgpara); a_load_ref_cgpara(list,l.size,l.reference,cgpara);
else else
internalerror(2002032211); internalerror(2002032211);
end; end;
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 var
hr : tregister; hr : tregister;
begin begin
@ -971,7 +971,7 @@ implementation
begin begin
hr:=getaddressregister(list); hr:=getaddressregister(list);
a_loadaddr_ref_reg(list,r,hr); 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;
end; end;
@ -2599,7 +2599,7 @@ implementation
end; 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 var
ref : treference; ref : treference;
begin begin
@ -2620,7 +2620,7 @@ implementation
{ paramfpu_ref does the check_simpe_location check here if necessary } { paramfpu_ref does the check_simpe_location check here if necessary }
tg.GetTemp(list,TCGSize2Size[size],TCGSize2Size[size],tt_normal,ref); tg.GetTemp(list,TCGSize2Size[size],TCGSize2Size[size],tt_normal,ref);
a_loadfpu_reg_ref(list,size,size,r,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); tg.Ungettemp(list,ref);
end; end;
else else
@ -2629,7 +2629,7 @@ implementation
end; 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 var
href : treference; href : treference;
begin begin
@ -3028,7 +3028,7 @@ implementation
end; 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 var
href : treference; href : treference;
{$ifndef cpu64bitalu} {$ifndef cpu64bitalu}
@ -3101,7 +3101,7 @@ implementation
end; 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 var
hr : tregister; hr : tregister;
hs : tmmshuffle; hs : tmmshuffle;
@ -3113,20 +3113,20 @@ implementation
begin begin
hs:=shuffle^; hs:=shuffle^;
removeshuffles(hs); removeshuffles(hs);
a_parammm_reg(list,cgpara.location^.size,hr,cgpara,@hs); a_loadmm_reg_cgpara(list,cgpara.location^.size,hr,cgpara,@hs);
end end
else else
a_parammm_reg(list,cgpara.location^.size,hr,cgpara,shuffle); a_loadmm_reg_cgpara(list,cgpara.location^.size,hr,cgpara,shuffle);
end; 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 begin
case loc.loc of case loc.loc of
LOC_MMREGISTER,LOC_CMMREGISTER: 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: 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 else
internalerror(200310123); internalerror(200310123);
end; end;
@ -3231,11 +3231,11 @@ implementation
paramanager.getintparaloc(pocall_default,2,cgpara2); paramanager.getintparaloc(pocall_default,2,cgpara2);
paramanager.getintparaloc(pocall_default,3,cgpara3); paramanager.getintparaloc(pocall_default,3,cgpara3);
paramanager.allocparaloc(list,cgpara3); paramanager.allocparaloc(list,cgpara3);
a_paramaddr_ref(list,dest,cgpara3); a_loadaddr_ref_cgpara(list,dest,cgpara3);
paramanager.allocparaloc(list,cgpara2); paramanager.allocparaloc(list,cgpara2);
a_paramaddr_ref(list,source,cgpara2); a_loadaddr_ref_cgpara(list,source,cgpara2);
paramanager.allocparaloc(list,cgpara1); 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,cgpara3);
paramanager.freeparaloc(list,cgpara2); paramanager.freeparaloc(list,cgpara2);
paramanager.freeparaloc(list,cgpara1); paramanager.freeparaloc(list,cgpara1);
@ -3257,9 +3257,9 @@ implementation
paramanager.getintparaloc(pocall_default,1,cgpara1); paramanager.getintparaloc(pocall_default,1,cgpara1);
paramanager.getintparaloc(pocall_default,2,cgpara2); paramanager.getintparaloc(pocall_default,2,cgpara2);
paramanager.allocparaloc(list,cgpara2); paramanager.allocparaloc(list,cgpara2);
a_paramaddr_ref(list,dest,cgpara2); a_loadaddr_ref_cgpara(list,dest,cgpara2);
paramanager.allocparaloc(list,cgpara1); paramanager.allocparaloc(list,cgpara1);
a_paramaddr_ref(list,source,cgpara1); a_loadaddr_ref_cgpara(list,source,cgpara1);
paramanager.freeparaloc(list,cgpara2); paramanager.freeparaloc(list,cgpara2);
paramanager.freeparaloc(list,cgpara1); paramanager.freeparaloc(list,cgpara1);
allocallcpuregisters(list); allocallcpuregisters(list);
@ -3299,10 +3299,10 @@ implementation
{ widestrings aren't ref. counted on all platforms so we need the address { widestrings aren't ref. counted on all platforms so we need the address
to create a real copy } to create a real copy }
if is_widestring(t) then if is_widestring(t) then
a_paramaddr_ref(list,ref,cgpara1) a_loadaddr_ref_cgpara(list,ref,cgpara1)
else else
{ these functions get the pointer by value } { 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); paramanager.freeparaloc(list,cgpara1);
allocallcpuregisters(list); allocallcpuregisters(list);
a_call_name(list,incrfunc,false); a_call_name(list,incrfunc,false);
@ -3312,9 +3312,9 @@ implementation
begin begin
reference_reset_symbol(href,RTTIWriter.get_rtti_label(t,initrtti),0,sizeof(pint)); reference_reset_symbol(href,RTTIWriter.get_rtti_label(t,initrtti),0,sizeof(pint));
paramanager.allocparaloc(list,cgpara2); paramanager.allocparaloc(list,cgpara2);
a_paramaddr_ref(list,href,cgpara2); a_loadaddr_ref_cgpara(list,href,cgpara2);
paramanager.allocparaloc(list,cgpara1); paramanager.allocparaloc(list,cgpara1);
a_paramaddr_ref(list,ref,cgpara1); a_loadaddr_ref_cgpara(list,ref,cgpara1);
paramanager.freeparaloc(list,cgpara1); paramanager.freeparaloc(list,cgpara1);
paramanager.freeparaloc(list,cgpara2); paramanager.freeparaloc(list,cgpara2);
allocallcpuregisters(list); allocallcpuregisters(list);
@ -3368,11 +3368,11 @@ implementation
if needrtti then if needrtti then
begin begin
paramanager.allocparaloc(list,cgpara2); 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); paramanager.freeparaloc(list,cgpara2);
end; end;
paramanager.allocparaloc(list,cgpara1); 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); paramanager.freeparaloc(list,cgpara1);
allocallcpuregisters(list); allocallcpuregisters(list);
a_call_name(list,decrfunc,false); a_call_name(list,decrfunc,false);
@ -3382,9 +3382,9 @@ implementation
begin begin
reference_reset_symbol(href,RTTIWriter.get_rtti_label(t,initrtti),0,sizeof(pint)); reference_reset_symbol(href,RTTIWriter.get_rtti_label(t,initrtti),0,sizeof(pint));
paramanager.allocparaloc(list,cgpara2); paramanager.allocparaloc(list,cgpara2);
a_paramaddr_ref(list,href,cgpara2); a_loadaddr_ref_cgpara(list,href,cgpara2);
paramanager.allocparaloc(list,cgpara1); paramanager.allocparaloc(list,cgpara1);
a_paramaddr_ref(list,ref,cgpara1); a_loadaddr_ref_cgpara(list,ref,cgpara1);
paramanager.freeparaloc(list,cgpara1); paramanager.freeparaloc(list,cgpara1);
paramanager.freeparaloc(list,cgpara2); paramanager.freeparaloc(list,cgpara2);
allocallcpuregisters(list); allocallcpuregisters(list);
@ -3415,9 +3415,9 @@ implementation
begin begin
reference_reset_symbol(href,RTTIWriter.get_rtti_label(t,initrtti),0,sizeof(pint)); reference_reset_symbol(href,RTTIWriter.get_rtti_label(t,initrtti),0,sizeof(pint));
paramanager.allocparaloc(list,cgpara2); paramanager.allocparaloc(list,cgpara2);
a_paramaddr_ref(list,href,cgpara2); a_loadaddr_ref_cgpara(list,href,cgpara2);
paramanager.allocparaloc(list,cgpara1); paramanager.allocparaloc(list,cgpara1);
a_paramaddr_ref(list,ref,cgpara1); a_loadaddr_ref_cgpara(list,ref,cgpara1);
paramanager.freeparaloc(list,cgpara1); paramanager.freeparaloc(list,cgpara1);
paramanager.freeparaloc(list,cgpara2); paramanager.freeparaloc(list,cgpara2);
allocallcpuregisters(list); allocallcpuregisters(list);
@ -3450,9 +3450,9 @@ implementation
begin begin
reference_reset_symbol(href,RTTIWriter.get_rtti_label(t,initrtti),0,sizeof(pint)); reference_reset_symbol(href,RTTIWriter.get_rtti_label(t,initrtti),0,sizeof(pint));
paramanager.allocparaloc(list,cgpara2); paramanager.allocparaloc(list,cgpara2);
a_paramaddr_ref(list,href,cgpara2); a_loadaddr_ref_cgpara(list,href,cgpara2);
paramanager.allocparaloc(list,cgpara1); paramanager.allocparaloc(list,cgpara1);
a_paramaddr_ref(list,ref,cgpara1); a_loadaddr_ref_cgpara(list,ref,cgpara1);
paramanager.freeparaloc(list,cgpara1); paramanager.freeparaloc(list,cgpara1);
paramanager.freeparaloc(list,cgpara2); paramanager.freeparaloc(list,cgpara2);
allocallcpuregisters(list); allocallcpuregisters(list);
@ -3686,7 +3686,7 @@ implementation
cgpara1.init; cgpara1.init;
paramanager.getintparaloc(pocall_default,1,cgpara1); paramanager.getintparaloc(pocall_default,1,cgpara1);
paramanager.allocparaloc(list,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); paramanager.freeparaloc(list,cgpara1);
a_call_name(list,'FPC_HANDLEERROR',false); a_call_name(list,'FPC_HANDLEERROR',false);
a_label(list,oklabel); a_label(list,oklabel);
@ -3708,9 +3708,9 @@ implementation
begin begin
reference_reset_symbol(hrefvmt,current_asmdata.RefAsmSymbol(objdef.vmt_mangledname),0,sizeof(pint)); reference_reset_symbol(hrefvmt,current_asmdata.RefAsmSymbol(objdef.vmt_mangledname),0,sizeof(pint));
paramanager.allocparaloc(list,cgpara2); paramanager.allocparaloc(list,cgpara2);
a_paramaddr_ref(list,hrefvmt,cgpara2); a_loadaddr_ref_cgpara(list,hrefvmt,cgpara2);
paramanager.allocparaloc(list,cgpara1); 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,cgpara1);
paramanager.freeparaloc(list,cgpara2); paramanager.freeparaloc(list,cgpara2);
allocallcpuregisters(list); allocallcpuregisters(list);
@ -3721,7 +3721,7 @@ implementation
if (cs_check_range in current_settings.localswitches) then if (cs_check_range in current_settings.localswitches) then
begin begin
paramanager.allocparaloc(list,cgpara1); 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,cgpara1);
allocallcpuregisters(list); allocallcpuregisters(list);
a_call_name(list,'FPC_CHECK_OBJECT',false); a_call_name(list,'FPC_CHECK_OBJECT',false);
@ -3767,7 +3767,7 @@ implementation
cgpara1.init; cgpara1.init;
paramanager.getintparaloc(pocall_default,1,cgpara1); paramanager.getintparaloc(pocall_default,1,cgpara1);
paramanager.allocparaloc(list,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); paramanager.freeparaloc(list,cgpara1);
allocallcpuregisters(list); allocallcpuregisters(list);
a_call_name(list,'FPC_GETMEM',false); a_call_name(list,'FPC_GETMEM',false);
@ -3785,13 +3785,13 @@ implementation
paramanager.getintparaloc(pocall_default,3,cgpara3); paramanager.getintparaloc(pocall_default,3,cgpara3);
{ load size } { load size }
paramanager.allocparaloc(list,cgpara3); paramanager.allocparaloc(list,cgpara3);
a_param_reg(list,OS_INT,sizereg,cgpara3); a_load_reg_cgpara(list,OS_INT,sizereg,cgpara3);
{ load destination } { load destination }
paramanager.allocparaloc(list,cgpara2); paramanager.allocparaloc(list,cgpara2);
a_param_reg(list,OS_ADDR,destreg,cgpara2); a_load_reg_cgpara(list,OS_ADDR,destreg,cgpara2);
{ load source } { load source }
paramanager.allocparaloc(list,cgpara1); 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,cgpara3);
paramanager.freeparaloc(list,cgpara2); paramanager.freeparaloc(list,cgpara2);
paramanager.freeparaloc(list,cgpara1); paramanager.freeparaloc(list,cgpara1);
@ -3813,7 +3813,7 @@ implementation
paramanager.getintparaloc(pocall_default,1,cgpara1); paramanager.getintparaloc(pocall_default,1,cgpara1);
{ load source } { load source }
paramanager.allocparaloc(list,cgpara1); paramanager.allocparaloc(list,cgpara1);
a_param_loc(list,l,cgpara1); a_load_loc_cgpara(list,l,cgpara1);
paramanager.freeparaloc(list,cgpara1); paramanager.freeparaloc(list,cgpara1);
allocallcpuregisters(list); allocallcpuregisters(list);
a_call_name(list,'FPC_FREEMEM',false); a_call_name(list,'FPC_FREEMEM',false);

24
compiler/i386/cgcpu.pas
View File

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

36
compiler/m68k/cgcpu.pas
View File

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

4
compiler/m68k/n68kmat.pas
View File

@ -152,7 +152,7 @@ implementation
{ compare against zero, if not zero continue } { 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_cmp_const_reg_label(current_asmdata.CurrAsmList,OS_S32,OC_NE,0,denum,continuelabel);
// paraloc1.init; // 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_call_name(current_asmdata.CurrAsmList,'FPC_HANDLEERROR',false);
cg.a_label(current_asmdata.CurrAsmList, continuelabel); cg.a_label(current_asmdata.CurrAsmList, continuelabel);
@ -199,7 +199,7 @@ implementation
current_asmdata.getjumplabel(continuelabel); current_asmdata.getjumplabel(continuelabel);
{ compare against zero, if not zero continue } { 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_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_call_name(current_asmdata.CurrAsmList,'FPC_HANDLEERROR',false);
cg.a_label(current_asmdata.CurrAsmList, continuelabel); cg.a_label(current_asmdata.CurrAsmList, continuelabel);

34
compiler/mips/cgcpu.pas
View File

@ -47,11 +47,11 @@ type
procedure handle_reg_const_reg(list: tasmlist; op: Tasmop; src: tregister; a: aint; dst: tregister); procedure handle_reg_const_reg(list: tasmlist; op: Tasmop; src: tregister; a: aint; dst: tregister);
{ parameter } { parameter }
procedure a_param_const(list: tasmlist; size: tcgsize; a: aint; const paraloc: TCGPara); override; procedure a_load_const_cgpara(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_load_ref_cgpara(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_loadaddr_ref_cgpara(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_loadfpu_reg_cgpara(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_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_name(list: tasmlist; const s: string; weak : boolean); override;
procedure a_call_reg(list: tasmlist; Reg: TRegister); override; procedure a_call_reg(list: tasmlist; Reg: TRegister); override;
{ General purpose instructions } { General purpose instructions }
@ -92,7 +92,7 @@ type
public public
procedure a_load64_reg_ref(list: tasmlist; reg: tregister64; const ref: treference); override; 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_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_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(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; procedure a_op64_const_reg_reg(list: tasmlist; op: TOpCG; size: tcgsize; Value: int64; regsrc, regdst: tregister64); override;
@ -540,7 +540,7 @@ begin
end; 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 var
Ref: TReference; Ref: TReference;
begin begin
@ -564,7 +564,7 @@ begin
end; 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 var
ref: treference; ref: treference;
tmpreg: TRegister; tmpreg: TRegister;
@ -594,7 +594,7 @@ begin
end; 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 var
Ref: TReference; Ref: TReference;
TmpReg: TRegister; TmpReg: TRegister;
@ -621,7 +621,7 @@ begin
end; 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 var
href, href2: treference; href, href2: treference;
hloc: pcgparalocation; hloc: pcgparalocation;
@ -647,13 +647,13 @@ begin
end; 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 var
href: treference; href: treference;
begin begin
tg.GetTemp(list, TCGSize2Size[size], sizeof(aint), tt_normal, href); tg.GetTemp(list, TCGSize2Size[size], sizeof(aint), tt_normal, href);
a_loadfpu_reg_ref(list, size, size, r, 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); tg.Ungettemp(list, href);
end; end;
@ -1468,11 +1468,11 @@ begin
paramanager.getintparaloc(pocall_default, 2, paraloc2); paramanager.getintparaloc(pocall_default, 2, paraloc2);
paramanager.getintparaloc(pocall_default, 3, paraloc3); paramanager.getintparaloc(pocall_default, 3, paraloc3);
paramanager.allocparaloc(list, 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); paramanager.allocparaloc(list, paraloc2);
a_paramaddr_ref(list, dest, paraloc2); a_loadaddr_ref_cgpara(list, dest, paraloc2);
paramanager.allocparaloc(list, 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, paraloc3);
paramanager.freeparaloc(list, paraloc2); paramanager.freeparaloc(list, paraloc2);
paramanager.freeparaloc(list, paraloc1); paramanager.freeparaloc(list, paraloc1);
@ -1720,7 +1720,7 @@ begin
end; 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 var
hreg64: tregister64; hreg64: tregister64;
begin begin
@ -1729,7 +1729,7 @@ begin
hreg64.reglo := cg.GetIntRegister(list, OS_S32); hreg64.reglo := cg.GetIntRegister(list, OS_S32);
hreg64.reghi := cg.GetIntRegister(list, OS_S32); hreg64.reghi := cg.GetIntRegister(list, OS_S32);
a_load64_ref_reg(list, r, hreg64); a_load64_ref_reg(list, r, hreg64);
a_param64_reg(list, hreg64, paraloc); a_load64_reg_cgpara(list, hreg64, paraloc);
end; end;

46
compiler/ncgcal.pas
View File

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

24
compiler/ncgflw.pas
View File

@ -980,12 +980,12 @@ implementation
paramanager.allocparaloc(current_asmdata.CurrAsmList,paraloc3); paramanager.allocparaloc(current_asmdata.CurrAsmList,paraloc3);
{ frame tree } { frame tree }
if assigned(third) then 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 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 } { push address }
paramanager.allocparaloc(current_asmdata.CurrAsmList,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);
end end
else else
begin begin
@ -995,16 +995,16 @@ implementation
reference_reset_symbol(href2,a,0,1); reference_reset_symbol(href2,a,0,1);
{ push current frame } { push current frame }
paramanager.allocparaloc(current_asmdata.CurrAsmList,paraloc3); 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 } { push current address }
paramanager.allocparaloc(current_asmdata.CurrAsmList,paraloc2); paramanager.allocparaloc(current_asmdata.CurrAsmList,paraloc2);
if target_info.system <> system_powerpc_macos then 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 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; end;
paramanager.allocparaloc(current_asmdata.CurrAsmList,paraloc1); 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,paraloc1);
paramanager.freeparaloc(current_asmdata.CurrAsmList,paraloc2); paramanager.freeparaloc(current_asmdata.CurrAsmList,paraloc2);
paramanager.freeparaloc(current_asmdata.CurrAsmList,paraloc3); paramanager.freeparaloc(current_asmdata.CurrAsmList,paraloc3);
@ -1047,7 +1047,7 @@ implementation
paramanager.getintparaloc(pocall_default,1,paraloc1); paramanager.getintparaloc(pocall_default,1,paraloc1);
paramanager.allocparaloc(current_asmdata.CurrAsmList,paraloc1); paramanager.allocparaloc(current_asmdata.CurrAsmList,paraloc1);
cg.a_reg_dealloc(current_asmdata.CurrAsmList,NR_FUNCTION_RESULT_REG); 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); paramanager.freeparaloc(current_asmdata.CurrAsmList,paraloc1);
cg.allocallcpuregisters(current_asmdata.CurrAsmList); cg.allocallcpuregisters(current_asmdata.CurrAsmList);
cg.a_call_name(current_asmdata.CurrAsmList,'FPC_DESTROYEXCEPTION',false); cg.a_call_name(current_asmdata.CurrAsmList,'FPC_DESTROYEXCEPTION',false);
@ -1170,7 +1170,7 @@ implementation
paraloc1.init; paraloc1.init;
paramanager.getintparaloc(pocall_default,1,paraloc1); paramanager.getintparaloc(pocall_default,1,paraloc1);
paramanager.allocparaloc(current_asmdata.CurrAsmList,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); paramanager.freeparaloc(current_asmdata.CurrAsmList,paraloc1);
cg.allocallcpuregisters(current_asmdata.CurrAsmList); cg.allocallcpuregisters(current_asmdata.CurrAsmList);
cg.a_call_name(current_asmdata.CurrAsmList,'FPC_CATCHES',false); cg.a_call_name(current_asmdata.CurrAsmList,'FPC_CATCHES',false);
@ -1203,7 +1203,7 @@ implementation
paramanager.getintparaloc(pocall_default,1,paraloc1); paramanager.getintparaloc(pocall_default,1,paraloc1);
cg.a_reg_alloc(current_asmdata.CurrAsmList,NR_FUNCTION_RESULT_REG); cg.a_reg_alloc(current_asmdata.CurrAsmList,NR_FUNCTION_RESULT_REG);
paramanager.allocparaloc(current_asmdata.CurrAsmList,paraloc1); 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); paramanager.freeparaloc(current_asmdata.CurrAsmList,paraloc1);
cg.allocallcpuregisters(current_asmdata.CurrAsmList); cg.allocallcpuregisters(current_asmdata.CurrAsmList);
cg.a_call_name(current_asmdata.CurrAsmList,'FPC_DESTROYEXCEPTION',false); 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)); reference_reset_symbol(href2,current_asmdata.RefAsmSymbol(excepttype.vmt_mangledname),0,sizeof(pint));
paramanager.getintparaloc(pocall_default,1,paraloc1); paramanager.getintparaloc(pocall_default,1,paraloc1);
paramanager.allocparaloc(current_asmdata.CurrAsmList,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); paramanager.freeparaloc(current_asmdata.CurrAsmList,paraloc1);
cg.allocallcpuregisters(current_asmdata.CurrAsmList); cg.allocallcpuregisters(current_asmdata.CurrAsmList);
cg.a_call_name(current_asmdata.CurrAsmList,'FPC_CATCHES',false); cg.a_call_name(current_asmdata.CurrAsmList,'FPC_CATCHES',false);
@ -1432,7 +1432,7 @@ implementation
paramanager.getintparaloc(pocall_default,1,paraloc1); paramanager.getintparaloc(pocall_default,1,paraloc1);
cg.a_reg_dealloc(current_asmdata.CurrAsmList,NR_FUNCTION_RESULT_REG); cg.a_reg_dealloc(current_asmdata.CurrAsmList,NR_FUNCTION_RESULT_REG);
paramanager.allocparaloc(current_asmdata.CurrAsmList,paraloc1); 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); paramanager.freeparaloc(current_asmdata.CurrAsmList,paraloc1);
cg.allocallcpuregisters(current_asmdata.CurrAsmList); cg.allocallcpuregisters(current_asmdata.CurrAsmList);
cg.a_call_name(current_asmdata.CurrAsmList,'FPC_DESTROYEXCEPTION',false); cg.a_call_name(current_asmdata.CurrAsmList,'FPC_DESTROYEXCEPTION',false);

8
compiler/ncginl.pas
View File

@ -217,16 +217,16 @@ implementation
exit; exit;
{ push erroraddr } { push erroraddr }
paramanager.allocparaloc(current_asmdata.CurrAsmList,paraloc4); 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 } { push lineno }
paramanager.allocparaloc(current_asmdata.CurrAsmList,paraloc3); 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 } { push filename }
paramanager.allocparaloc(current_asmdata.CurrAsmList,paraloc2); 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 } { push msg }
paramanager.allocparaloc(current_asmdata.CurrAsmList,paraloc1); 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 } { call }
paramanager.freeparaloc(current_asmdata.CurrAsmList,paraloc1); paramanager.freeparaloc(current_asmdata.CurrAsmList,paraloc1);
paramanager.freeparaloc(current_asmdata.CurrAsmList,paraloc2); paramanager.freeparaloc(current_asmdata.CurrAsmList,paraloc2);

2
compiler/ncgld.pas
View File

@ -351,7 +351,7 @@ implementation
else else
reference_reset_symbol(href,current_asmdata.WeakRefAsmSymbol(gvs.mangledname),0,sizeof(pint)); reference_reset_symbol(href,current_asmdata.WeakRefAsmSymbol(gvs.mangledname),0,sizeof(pint));
paramanager.allocparaloc(current_asmdata.CurrAsmList,paraloc1); 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); paramanager.freeparaloc(current_asmdata.CurrAsmList,paraloc1);
paraloc1.done; paraloc1.done;
cg.allocallcpuregisters(current_asmdata.CurrAsmList); cg.allocallcpuregisters(current_asmdata.CurrAsmList);

2
compiler/ncgmat.pas
View File

@ -369,7 +369,7 @@ implementation
paraloc1.init; paraloc1.init;
paramanager.getintparaloc(pocall_default,1,paraloc1); paramanager.getintparaloc(pocall_default,1,paraloc1);
paramanager.allocparaloc(current_asmdata.CurrAsmList,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); paramanager.freeparaloc(current_asmdata.CurrAsmList,paraloc1);
cg.a_call_name(current_asmdata.CurrAsmList,'FPC_HANDLEERROR',false); cg.a_call_name(current_asmdata.CurrAsmList,'FPC_HANDLEERROR',false);
paraloc1.done; paraloc1.done;

24
compiler/ncgmem.pas
View File

@ -266,7 +266,7 @@ implementation
paraloc1.init; paraloc1.init;
paramanager.getintparaloc(pocall_default,1,paraloc1); paramanager.getintparaloc(pocall_default,1,paraloc1);
paramanager.allocparaloc(current_asmdata.CurrAsmList,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); paramanager.freeparaloc(current_asmdata.CurrAsmList,paraloc1);
paraloc1.done; paraloc1.done;
cg.allocallcpuregisters(current_asmdata.CurrAsmList); cg.allocallcpuregisters(current_asmdata.CurrAsmList);
@ -333,7 +333,7 @@ implementation
begin begin
paramanager.getintparaloc(pocall_default,1,paraloc1); paramanager.getintparaloc(pocall_default,1,paraloc1);
paramanager.allocparaloc(current_asmdata.CurrAsmList,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); paramanager.freeparaloc(current_asmdata.CurrAsmList,paraloc1);
cg.allocallcpuregisters(current_asmdata.CurrAsmList); cg.allocallcpuregisters(current_asmdata.CurrAsmList);
cg.a_call_name(current_asmdata.CurrAsmList,'FPC_CHECKPOINTER',false); cg.a_call_name(current_asmdata.CurrAsmList,'FPC_CHECKPOINTER',false);
@ -352,7 +352,7 @@ implementation
begin begin
paramanager.getintparaloc(pocall_default,1,paraloc1); paramanager.getintparaloc(pocall_default,1,paraloc1);
paramanager.allocparaloc(current_asmdata.CurrAsmList,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); paramanager.freeparaloc(current_asmdata.CurrAsmList,paraloc1);
cg.allocallcpuregisters(current_asmdata.CurrAsmList); cg.allocallcpuregisters(current_asmdata.CurrAsmList);
cg.a_call_name(current_asmdata.CurrAsmList,'FPC_CHECKPOINTER',false); 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,1,paraloc1);
paramanager.getintparaloc(pocall_default,2,paraloc2); paramanager.getintparaloc(pocall_default,2,paraloc2);
paramanager.allocparaloc(current_asmdata.CurrAsmList,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); 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,paraloc1);
paramanager.freeparaloc(current_asmdata.CurrAsmList,paraloc2); paramanager.freeparaloc(current_asmdata.CurrAsmList,paraloc2);
cg.allocallcpuregisters(current_asmdata.CurrAsmList); cg.allocallcpuregisters(current_asmdata.CurrAsmList);
@ -772,7 +772,7 @@ implementation
begin begin
paramanager.getintparaloc(pocall_default,1,paraloc1); paramanager.getintparaloc(pocall_default,1,paraloc1);
paramanager.allocparaloc(current_asmdata.CurrAsmList,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); paramanager.freeparaloc(current_asmdata.CurrAsmList,paraloc1);
cg.allocallcpuregisters(current_asmdata.CurrAsmList); cg.allocallcpuregisters(current_asmdata.CurrAsmList);
cg.a_call_name(current_asmdata.CurrAsmList,'FPC_'+upper(tstringdef(left.resultdef).stringtypname)+'_CHECKZERO',false); 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,1,paraloc1);
paramanager.getintparaloc(pocall_default,2,paraloc2); paramanager.getintparaloc(pocall_default,2,paraloc2);
paramanager.allocparaloc(current_asmdata.CurrAsmList,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; href:=location.reference;
paramanager.allocparaloc(current_asmdata.CurrAsmList,paraloc1); paramanager.allocparaloc(current_asmdata.CurrAsmList,paraloc1);
if not(tf_winlikewidestring in target_info.flags) or if not(tf_winlikewidestring in target_info.flags) or
(tstringdef(left.resultdef).stringtype<>st_widestring) then (tstringdef(left.resultdef).stringtype<>st_widestring) then
begin begin
dec(href.offset,sizeof(pint)-offsetdec); 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 end
else else
begin begin
{ winlike widestrings have a 4 byte length } { winlike widestrings have a 4 byte length }
dec(href.offset,4-offsetdec); 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; end;
paramanager.freeparaloc(current_asmdata.CurrAsmList,paraloc1); paramanager.freeparaloc(current_asmdata.CurrAsmList,paraloc1);
paramanager.freeparaloc(current_asmdata.CurrAsmList,paraloc2); paramanager.freeparaloc(current_asmdata.CurrAsmList,paraloc2);
@ -1039,7 +1039,7 @@ implementation
paramanager.getintparaloc(pocall_default,1,paraloc1); paramanager.getintparaloc(pocall_default,1,paraloc1);
paramanager.getintparaloc(pocall_default,2,paraloc2); paramanager.getintparaloc(pocall_default,2,paraloc2);
paramanager.allocparaloc(current_asmdata.CurrAsmList,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; href:=location.reference;
dec(href.offset,sizeof(pint)-offsetdec); dec(href.offset,sizeof(pint)-offsetdec);
@ -1049,13 +1049,13 @@ implementation
(tstringdef(left.resultdef).stringtype<>st_widestring) then (tstringdef(left.resultdef).stringtype<>st_widestring) then
begin begin
dec(href.offset,sizeof(pint)-offsetdec); 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 end
else else
begin begin
{ winlike widestrings have a 4 byte length } { winlike widestrings have a 4 byte length }
dec(href.offset,4-offsetdec); 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; end;
paramanager.freeparaloc(current_asmdata.CurrAsmList,paraloc1); paramanager.freeparaloc(current_asmdata.CurrAsmList,paraloc1);

10
compiler/ncgutil.pas
View File

@ -408,12 +408,12 @@ implementation
paramanager.getintparaloc(pocall_default,2,paraloc2); paramanager.getintparaloc(pocall_default,2,paraloc2);
paramanager.getintparaloc(pocall_default,3,paraloc3); paramanager.getintparaloc(pocall_default,3,paraloc3);
paramanager.allocparaloc(list,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); 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 } { push type of exceptionframe }
paramanager.allocparaloc(list,paraloc1); 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,paraloc3);
paramanager.freeparaloc(list,paraloc2); paramanager.freeparaloc(list,paraloc2);
paramanager.freeparaloc(list,paraloc1); paramanager.freeparaloc(list,paraloc1);
@ -423,7 +423,7 @@ implementation
paramanager.getintparaloc(pocall_default,1,paraloc1); paramanager.getintparaloc(pocall_default,1,paraloc1);
paramanager.allocparaloc(list,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); paramanager.freeparaloc(list,paraloc1);
cg.allocallcpuregisters(list); cg.allocallcpuregisters(list);
cg.a_call_name(list,'FPC_SETJMP',false); cg.a_call_name(list,'FPC_SETJMP',false);
@ -2192,7 +2192,7 @@ implementation
paraloc1.init; paraloc1.init;
paramanager.getintparaloc(pocall_default,1,paraloc1); paramanager.getintparaloc(pocall_default,1,paraloc1);
paramanager.allocparaloc(list,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); paramanager.freeparaloc(list,paraloc1);
paraloc1.done; paraloc1.done;
end; end;

6
compiler/powerpc/cgcpu.pas
View File

@ -42,7 +42,7 @@ unit cgcpu;
{ left to right), this allows to move the parameter to } { left to right), this allows to move the parameter to }
{ register, if the cpu supports register calling } { register, if the cpu supports register calling }
{ conventions } { 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; procedure a_call_name(list : TAsmList;const s : string; weak: boolean);override;
@ -184,7 +184,7 @@ const
end; 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 var
tmpref, ref: treference; tmpref, ref: treference;
@ -217,7 +217,7 @@ const
dec(tmpref.offset,2); dec(tmpref.offset,2);
end; end;
{$else not cpu64bitaddr} {$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} {$endif not cpu64bitaddr}
end; end;
LOC_REFERENCE: LOC_REFERENCE:

4
compiler/powerpc64/cgcpu.pas
View File

@ -42,7 +42,7 @@ type
{ left to right), this allows to move the parameter to } { left to right), this allows to move the parameter to }
{ register, if the cpu supports register calling } { register, if the cpu supports register calling }
{ conventions } { 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; const paraloc: tcgpara); override;
procedure a_call_name(list: TAsmList; const s: string; weak: boolean); override; procedure a_call_name(list: TAsmList; const s: string; weak: boolean); override;
@ -394,7 +394,7 @@ begin
inherited done_register_allocators; inherited done_register_allocators;
end; 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); treference; const paraloc: tcgpara);
var var

10
compiler/ppcgen/cgppc.pas
View File

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

34
compiler/sparc/cgcpu.pas
View File

@ -46,11 +46,11 @@ interface
procedure handle_load_store(list:TAsmList;isstore:boolean;op: tasmop;reg:tregister;ref: treference); 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); procedure handle_reg_const_reg(list:TAsmList;op:Tasmop;src:tregister;a:aint;dst:tregister);
{ parameter } { parameter }
procedure a_param_const(list:TAsmList;size:tcgsize;a:aint;const paraloc:TCGPara);override; procedure a_load_const_cgpara(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_load_ref_cgpara(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_loadaddr_ref_cgpara(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_loadfpu_reg_cgpara(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_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_name(list:TAsmList;const s:string; weak: boolean);override;
procedure a_call_reg(list:TAsmList;Reg:TRegister);override; procedure a_call_reg(list:TAsmList;Reg:TRegister);override;
{ General purpose instructions } { General purpose instructions }
@ -100,7 +100,7 @@ interface
public public
procedure a_load64_reg_ref(list : TAsmList;reg : tregister64;const ref : treference);override; 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_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_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(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; procedure a_op64_const_reg_reg(list: TAsmList;op:TOpCG;size : tcgsize;value : int64;regsrc,regdst : tregister64);override;
@ -322,7 +322,7 @@ implementation
end; 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 var
Ref:TReference; Ref:TReference;
begin begin
@ -347,7 +347,7 @@ implementation
end; 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 var
ref: treference; ref: treference;
tmpreg:TRegister; tmpreg:TRegister;
@ -386,7 +386,7 @@ implementation
end; 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 var
Ref:TReference; Ref:TReference;
TmpReg:TRegister; TmpReg:TRegister;
@ -413,7 +413,7 @@ implementation
end; 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 var
href,href2 : treference; href,href2 : treference;
hloc : pcgparalocation; hloc : pcgparalocation;
@ -439,13 +439,13 @@ implementation
end; 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 var
href : treference; href : treference;
begin begin
tg.GetTemp(list,TCGSize2Size[size],TCGSize2Size[size],tt_normal,href); tg.GetTemp(list,TCGSize2Size[size],TCGSize2Size[size],tt_normal,href);
a_loadfpu_reg_ref(list,size,size,r,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); tg.Ungettemp(list,href);
end; end;
@ -1161,11 +1161,11 @@ implementation
paramanager.getintparaloc(pocall_default,2,paraloc2); paramanager.getintparaloc(pocall_default,2,paraloc2);
paramanager.getintparaloc(pocall_default,3,paraloc3); paramanager.getintparaloc(pocall_default,3,paraloc3);
paramanager.allocparaloc(list,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); paramanager.allocparaloc(list,paraloc2);
a_paramaddr_ref(list,dest,paraloc2); a_loadaddr_ref_cgpara(list,dest,paraloc2);
paramanager.allocparaloc(list,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,paraloc3);
paramanager.freeparaloc(list,paraloc2); paramanager.freeparaloc(list,paraloc2);
paramanager.freeparaloc(list,paraloc1); paramanager.freeparaloc(list,paraloc1);
@ -1422,7 +1422,7 @@ implementation
end; 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 var
hreg64 : tregister64; hreg64 : tregister64;
begin begin
@ -1431,7 +1431,7 @@ implementation
hreg64.reglo:=cg.GetIntRegister(list,OS_32); hreg64.reglo:=cg.GetIntRegister(list,OS_32);
hreg64.reghi:=cg.GetIntRegister(list,OS_32); hreg64.reghi:=cg.GetIntRegister(list,OS_32);
a_load64_ref_reg(list,r,hreg64); a_load64_ref_reg(list,r,hreg64);
a_param64_reg(list,hreg64,paraloc); a_load64_reg_cgpara(list,hreg64,paraloc);
end; end;

4
compiler/x86_64/cgcpu.pas
View File

@ -40,7 +40,7 @@ unit cgcpu;
procedure g_proc_exit(list : TAsmList;parasize:longint;nostackframe:boolean);override; 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 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_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; procedure a_loadmm_reg_intreg(list: TAsmList; fromsize, tosize : tcgsize;mmreg, intreg: tregister;shuffle : pmmshuffle); override;
@ -108,7 +108,7 @@ unit cgcpu;
end; 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 var
tmpref, ref: treference; tmpref, ref: treference;
location: pcgparalocation; location: pcgparalocation;