paweld/fpc
1
0
Fork 0
mirror of https://gitlab.com/freepascal.org/fpc/source.git synced 2025-04-15 15:19:25 +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 }
cgsetflags : boolean;
procedure a_param_const(list : TAsmList;size : tcgsize;a : aint;const paraloc : TCGPara);override;
procedure a_param_ref(list : TAsmList;size : tcgsize;const r : treference;const paraloc : TCGPara);override;
procedure a_paramaddr_ref(list : TAsmList;const r : treference;const paraloc : TCGPara);override;
procedure a_load_const_cgpara(list : TAsmList;size : tcgsize;a : aint;const paraloc : TCGPara);override;
procedure a_load_ref_cgpara(list : TAsmList;size : tcgsize;const r : treference;const paraloc : TCGPara);override;
procedure a_loadaddr_ref_cgpara(list : TAsmList;const r : treference;const paraloc : TCGPara);override;
procedure a_call_name(list : TAsmList;const s : string; weak: boolean);override;
procedure a_call_reg(list : TAsmList;reg: tregister);override;
@ -69,7 +69,7 @@ unit cgcpu;
procedure a_loadfpu_ref_reg(list: TAsmList; fromsize, tosize: tcgsize; const ref: treference; reg: tregister); override;
procedure a_loadfpu_reg_ref(list: TAsmList; fromsize, tosize: tcgsize; reg: tregister; const ref: treference); override;
procedure a_paramfpu_ref(list : TAsmList;size : tcgsize;const ref : treference;const paraloc : TCGPara);override;
procedure a_loadfpu_ref_cgpara(list : TAsmList;size : tcgsize;const ref : treference;const paraloc : TCGPara);override;
{ comparison operations }
procedure a_cmp_const_reg_label(list : TAsmList;size : tcgsize;cmp_op : topcmp;a : aint;reg : tregister;
l : tasmlabel);override;
@ -413,7 +413,7 @@ unit cgcpu;
end;
procedure tcgarm.a_param_const(list : TAsmList;size : tcgsize;a : aint;const paraloc : TCGPara);
procedure tcgarm.a_load_const_cgpara(list : TAsmList;size : tcgsize;a : aint;const paraloc : TCGPara);
var
ref: treference;
begin
@ -434,7 +434,7 @@ unit cgcpu;
end;
procedure tcgarm.a_param_ref(list : TAsmList;size : tcgsize;const r : treference;const paraloc : TCGPara);
procedure tcgarm.a_load_ref_cgpara(list : TAsmList;size : tcgsize;const r : treference;const paraloc : TCGPara);
var
tmpref, ref: treference;
location: pcgparalocation;
@ -482,7 +482,7 @@ unit cgcpu;
end;
procedure tcgarm.a_paramaddr_ref(list : TAsmList;const r : treference;const paraloc : TCGPara);
procedure tcgarm.a_loadaddr_ref_cgpara(list : TAsmList;const r : treference;const paraloc : TCGPara);
var
ref: treference;
tmpreg: tregister;
@ -1227,7 +1227,7 @@ unit cgcpu;
end;
procedure tcgarm.a_paramfpu_ref(list : TAsmList;size : tcgsize;const ref : treference;const paraloc : TCGPara);
procedure tcgarm.a_loadfpu_ref_cgpara(list : TAsmList;size : tcgsize;const ref : treference;const paraloc : TCGPara);
var
href,href2 : treference;
hloc : pcgparalocation;
@ -1246,7 +1246,7 @@ unit cgcpu;
a_load_ref_reg(list,OS_32,OS_32,href,hloc^.register);
OS_64,
OS_F64:
cg64.a_param64_ref(list,href,paraloc);
cg64.a_load64_ref_cgpara(list,href,paraloc);
else
a_load_ref_reg(list,hloc^.size,hloc^.size,href,hloc^.register);
end;
@ -1814,11 +1814,11 @@ unit cgcpu;
paramanager.getintparaloc(pocall_default,2,paraloc2);
paramanager.getintparaloc(pocall_default,3,paraloc3);
paramanager.allocparaloc(list,paraloc3);
a_param_const(list,OS_INT,len,paraloc3);
a_load_const_cgpara(list,OS_INT,len,paraloc3);
paramanager.allocparaloc(list,paraloc2);
a_paramaddr_ref(list,dest,paraloc2);
a_loadaddr_ref_cgpara(list,dest,paraloc2);
paramanager.allocparaloc(list,paraloc2);
a_paramaddr_ref(list,source,paraloc1);
a_loadaddr_ref_cgpara(list,source,paraloc1);
paramanager.freeparaloc(list,paraloc3);
paramanager.freeparaloc(list,paraloc2);
paramanager.freeparaloc(list,paraloc1);

18
compiler/avr/cgcpu.pas
View File

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

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

122
compiler/cgobj.pas
View File

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

24
compiler/i386/cgcpu.pas
View File

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

36
compiler/m68k/cgcpu.pas
View File

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

4
compiler/m68k/n68kmat.pas
View File

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

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

46
compiler/ncgcal.pas
View File

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

24
compiler/ncgflw.pas
View File

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

8
compiler/ncginl.pas
View File

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

2
compiler/ncgld.pas
View File

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

2
compiler/ncgmat.pas
View File

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

24
compiler/ncgmem.pas
View File

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

10
compiler/ncgutil.pas
View File

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

6
compiler/powerpc/cgcpu.pas
View File

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

4
compiler/powerpc64/cgcpu.pas
View File

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

10
compiler/ppcgen/cgppc.pas
View File

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

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

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_intf_wrapper(list: TAsmList; procdef: tprocdef; const labelname: string; ioffset: longint);override;
procedure a_param_ref(list : TAsmList;size : tcgsize;const r : treference;const paraloc : TCGPara);override;
procedure a_load_ref_cgpara(list : TAsmList;size : tcgsize;const r : treference;const paraloc : TCGPara);override;
procedure a_loadmm_intreg_reg(list: TAsmList; fromsize, tosize : tcgsize;intreg, mmreg: tregister; shuffle: pmmshuffle); override;
procedure a_loadmm_reg_intreg(list: TAsmList; fromsize, tosize : tcgsize;mmreg, intreg: tregister;shuffle : pmmshuffle); override;
@ -108,7 +108,7 @@ unit cgcpu;
end;
procedure tcgx86_64.a_param_ref(list : TAsmList;size : tcgsize;const r : treference;const paraloc : TCGPara);
procedure tcgx86_64.a_load_ref_cgpara(list : TAsmList;size : tcgsize;const r : treference;const paraloc : TCGPara);
var
tmpref, ref: treference;
location: pcgparalocation;