paweld/fpc
1
0
Fork 0
mirror of https://gitlab.com/freepascal.org/fpc/source.git synced 2025-11-02 06:29:25 +01:00
Code Issues Packages Projects Releases Wiki Activity

* renamed all paramanagers to tcpuparamanager so the llvm paramanager can

Browse Source 
derive from them without ifdefs

git-svn-id: branches/hlcgllvm@26039 -
This commit is contained in:
Jonas Maebe 2013-11-11 11:15:27 +00:00
parent d245228ba6
commit 99de108c68
14 changed files with 174 additions and 174 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

26
compiler/aarch64/cpupara.pas
View File

@ -33,7 +33,7 @@ unit cpupara;
symconst,symbase,symtype,symdef,parabase,paramgr;
type
taarch64paramanager = class(tparamanager)
tcpuparamanager = class(tparamanager)
function get_volatile_registers_int(calloption : tproccalloption):tcpuregisterset;override;
function get_volatile_registers_fpu(calloption : tproccalloption):tcpuregisterset;override;
function get_volatile_registers_mm(calloption : tproccalloption):tcpuregisterset;override;
@ -57,25 +57,25 @@ unit cpupara;
defutil,symsym,symtable;
function taarch64paramanager.get_volatile_registers_int(calloption : tproccalloption):tcpuregisterset;
function tcpuparamanager.get_volatile_registers_int(calloption : tproccalloption):tcpuregisterset;
begin
result:=VOLATILE_INTREGISTERS
end;
function taarch64paramanager.get_volatile_registers_fpu(calloption : tproccalloption):tcpuregisterset;
function tcpuparamanager.get_volatile_registers_fpu(calloption : tproccalloption):tcpuregisterset;
begin
result:=[];
end;
function taarch64paramanager.get_volatile_registers_mm(calloption: tproccalloption): tcpuregisterset;
function tcpuparamanager.get_volatile_registers_mm(calloption: tproccalloption): tcpuregisterset;
begin
result:=VOLATILE_MMREGISTERS;
end;
procedure taarch64paramanager.getintparaloc(pd : tabstractprocdef; nr : longint; var cgpara : tcgpara);
procedure tcpuparamanager.getintparaloc(pd : tabstractprocdef; nr : longint; var cgpara : tcgpara);
var
paraloc : pcgparalocation;
def : tdef;
@ -164,7 +164,7 @@ unit cpupara;
end;
function taarch64paramanager.push_addr_param(varspez:tvarspez;def : tdef;calloption : tproccalloption) : boolean;
function tcpuparamanager.push_addr_param(varspez:tvarspez;def : tdef;calloption : tproccalloption) : boolean;
begin
result:=false;
if varspez in [vs_var,vs_out,vs_constref] then
@ -195,7 +195,7 @@ unit cpupara;
end;
function taarch64paramanager.ret_in_param(def:tdef;pd:tabstractprocdef):boolean;
function tcpuparamanager.ret_in_param(def:tdef;pd:tabstractprocdef):boolean;
var
i: longint;
sym: tsym;
@ -278,7 +278,7 @@ unit cpupara;
end;
procedure taarch64paramanager.init_values(var curintreg, curfloatreg, curmmreg: tsuperregister; var cur_stack_offset: aword; var sparesinglereg: tregister);
procedure tcpuparamanager.init_values(var curintreg, curfloatreg, curmmreg: tsuperregister; var cur_stack_offset: aword; var sparesinglereg: tregister);
begin
curintreg:=RS_R0;
curfloatreg:=RS_F0;
@ -288,7 +288,7 @@ unit cpupara;
end;
function taarch64paramanager.create_paraloc_info_intern(p : tabstractprocdef; side: tcallercallee; paras: tparalist;
function tcpuparamanager.create_paraloc_info_intern(p : tabstractprocdef; side: tcallercallee; paras: tparalist;
var curintreg, curfloatreg, curmmreg: tsuperregister; var cur_stack_offset: aword; var sparesinglereg: tregister; isvariadic: boolean):longint;
var
@ -571,7 +571,7 @@ unit cpupara;
end;
function taarch64paramanager.get_funcretloc(p : tabstractprocdef; side: tcallercallee; forcetempdef: tdef): tcgpara;
function tcpuparamanager.get_funcretloc(p : tabstractprocdef; side: tcallercallee; forcetempdef: tdef): tcgpara;
var
paraloc : pcgparalocation;
retcgsize : tcgsize;
@ -674,7 +674,7 @@ unit cpupara;
end;
function taarch64paramanager.create_paraloc_info(p : tabstractprocdef; side: tcallercallee):longint;
function tcpuparamanager.create_paraloc_info(p : tabstractprocdef; side: tcallercallee):longint;
var
cur_stack_offset: aword;
curintreg, curfloatreg, curmmreg: tsuperregister;
@ -688,7 +688,7 @@ unit cpupara;
end;
function taarch64paramanager.create_varargs_paraloc_info(p : tabstractprocdef; varargspara:tvarargsparalist):longint;
function tcpuparamanager.create_varargs_paraloc_info(p : tabstractprocdef; varargspara:tvarargsparalist):longint;
var
cur_stack_offset: aword;
curintreg, curfloatreg, curmmreg: tsuperregister;
@ -705,5 +705,5 @@ unit cpupara;
end;
begin
paramanager:=taarch64paramanager.create;
paramanager:=tcpuparamanager.create;
end.

10
compiler/alpha/cpupara.pas
View File

@ -31,7 +31,7 @@ unit cpupara;
symconst,symbase,symtype,symdef,paramgr;
type
talphaparamanager = class(tparamanager)
tcpuparamanager = class(tparamanager)
function getintparaloc(nr : longint) : tparalocation;override;
procedure create_param_loc_info(p : tabstractprocdef);override;
function getfuncretparaloc(p : tabstractprocdef) : tparalocation;override;
@ -45,7 +45,7 @@ unit cpupara;
cpuinfo,cginfo,cgbase,
defbase;
function talphaparamanager.getintparaloc(nr : longint) : tparalocation;
function tcpuparamanager.getintparaloc(nr : longint) : tparalocation;
begin
fillchar(result,sizeof(tparalocation),0);
@ -119,7 +119,7 @@ unit cpupara;
end;
end;
procedure talphaparamanager.create_param_loc_info(p : tabstractprocdef);
procedure tcpuparamanager.create_param_loc_info(p : tabstractprocdef);
var
nextintreg,nextfloatreg,nextmmreg : tregister;
@ -246,7 +246,7 @@ unit cpupara;
end;
end;
function talphaparamanager.getfuncretparaloc(p : tabstractprocdef) : tparalocation;
function tcpuparamanager.getfuncretparaloc(p : tabstractprocdef) : tparalocation;
begin
case p.returndef.typ of
orddef,
@ -286,5 +286,5 @@ unit cpupara;
begin
paramanager:=talphaparamanager.create;
paramanager:=tcpuparamanager.create;
end.

26
compiler/arm/cpupara.pas
View File

@ -32,7 +32,7 @@ unit cpupara;
symconst,symtype,symdef,parabase,paramgr;
type
tarmparamanager = class(tparamanager)
tcpuparamanager = class(tparamanager)
function get_volatile_registers_int(calloption : tproccalloption):tcpuregisterset;override;
function get_volatile_registers_fpu(calloption : tproccalloption):tcpuregisterset;override;
function get_volatile_registers_mm(calloption : tproccalloption):tcpuregisterset;override;
@ -57,7 +57,7 @@ unit cpupara;
defutil,symsym,symtable;
function tarmparamanager.get_volatile_registers_int(calloption : tproccalloption):tcpuregisterset;
function tcpuparamanager.get_volatile_registers_int(calloption : tproccalloption):tcpuregisterset;
begin
if (target_info.system<>system_arm_darwin) then
result:=VOLATILE_INTREGISTERS
@ -66,19 +66,19 @@ unit cpupara;
end;
function tarmparamanager.get_volatile_registers_fpu(calloption : tproccalloption):tcpuregisterset;
function tcpuparamanager.get_volatile_registers_fpu(calloption : tproccalloption):tcpuregisterset;
begin
result:=VOLATILE_FPUREGISTERS;
end;
function tarmparamanager.get_volatile_registers_mm(calloption: tproccalloption): tcpuregisterset;
function tcpuparamanager.get_volatile_registers_mm(calloption: tproccalloption): tcpuregisterset;
begin
result:=VOLATILE_MMREGISTERS;
end;
procedure tarmparamanager.getintparaloc(pd : tabstractprocdef; nr : longint; var cgpara : tcgpara);
procedure tcpuparamanager.getintparaloc(pd : tabstractprocdef; nr : longint; var cgpara : tcgpara);
var
paraloc : pcgparalocation;
psym : tparavarsym;
@ -177,7 +177,7 @@ unit cpupara;
end;
function tarmparamanager.push_addr_param(varspez:tvarspez;def : tdef;calloption : tproccalloption) : boolean;
function tcpuparamanager.push_addr_param(varspez:tvarspez;def : tdef;calloption : tproccalloption) : boolean;
begin
result:=false;
if varspez in [vs_var,vs_out,vs_constref] then
@ -208,7 +208,7 @@ unit cpupara;
end;
function tarmparamanager.ret_in_param(def:tdef;pd:tabstractprocdef):boolean;
function tcpuparamanager.ret_in_param(def:tdef;pd:tabstractprocdef):boolean;
var
i: longint;
sym: tsym;
@ -291,7 +291,7 @@ unit cpupara;
end;
procedure tarmparamanager.init_values(p : tabstractprocdef; side: tcallercallee;
procedure tcpuparamanager.init_values(p : tabstractprocdef; side: tcallercallee;
var curintreg, curfloatreg, curmmreg: tsuperregister; var cur_stack_offset: aword; var sparesinglereg: tregister);
begin
curintreg:=RS_R0;
@ -306,7 +306,7 @@ unit cpupara;
end;
function tarmparamanager.create_paraloc_info_intern(p : tabstractprocdef; side: tcallercallee; paras: tparalist;
function tcpuparamanager.create_paraloc_info_intern(p : tabstractprocdef; side: tcallercallee; paras: tparalist;
var curintreg, curfloatreg, curmmreg: tsuperregister; var cur_stack_offset: aword; var sparesinglereg: tregister; isvariadic: boolean):longint;
var
@ -613,7 +613,7 @@ unit cpupara;
end;
function tarmparamanager.get_funcretloc(p : tabstractprocdef; side: tcallercallee; forcetempdef: tdef): tcgpara;
function tcpuparamanager.get_funcretloc(p : tabstractprocdef; side: tcallercallee; forcetempdef: tdef): tcgpara;
var
paraloc : pcgparalocation;
retcgsize : tcgsize;
@ -729,7 +729,7 @@ unit cpupara;
end;
function tarmparamanager.create_paraloc_info(p : tabstractprocdef; side: tcallercallee):longint;
function tcpuparamanager.create_paraloc_info(p : tabstractprocdef; side: tcallercallee):longint;
var
cur_stack_offset: aword;
curintreg, curfloatreg, curmmreg: tsuperregister;
@ -743,7 +743,7 @@ unit cpupara;
end;
function tarmparamanager.create_varargs_paraloc_info(p : tabstractprocdef; varargspara:tvarargsparalist):longint;
function tcpuparamanager.create_varargs_paraloc_info(p : tabstractprocdef; varargspara:tvarargsparalist):longint;
var
cur_stack_offset: aword;
curintreg, curfloatreg, curmmreg: tsuperregister;
@ -760,5 +760,5 @@ unit cpupara;
end;
begin
paramanager:=tarmparamanager.create;
paramanager:=tcpuparamanager.create;
end.

28
compiler/avr/cpupara.pas
View File

@ -33,7 +33,7 @@ unit cpupara;
symconst,symbase,symtype,symdef,parabase,paramgr;
type
tavrparamanager = class(tparamanager)
tcpuparamanager = class(tparamanager)
function get_volatile_registers_int(calloption : tproccalloption):tcpuregisterset;override;
function get_volatile_registers_fpu(calloption : tproccalloption):tcpuregisterset;override;
function push_addr_param(varspez:tvarspez;def : tdef;calloption : tproccalloption) : boolean;override;
@ -56,19 +56,19 @@ unit cpupara;
defutil,symsym;
function tavrparamanager.get_volatile_registers_int(calloption : tproccalloption):tcpuregisterset;
function tcpuparamanager.get_volatile_registers_int(calloption : tproccalloption):tcpuregisterset;
begin
result:=VOLATILE_INTREGISTERS;
end;
function tavrparamanager.get_volatile_registers_fpu(calloption : tproccalloption):tcpuregisterset;
function tcpuparamanager.get_volatile_registers_fpu(calloption : tproccalloption):tcpuregisterset;
begin
result:=VOLATILE_FPUREGISTERS;
end;
procedure tavrparamanager.getintparaloc(pd : tabstractprocdef; nr : longint; var cgpara : tcgpara);
procedure tcpuparamanager.getintparaloc(pd : tabstractprocdef; nr : longint; var cgpara : tcgpara);
var
paraloc : pcgparalocation;
psym: tparavarsym;
@ -156,7 +156,7 @@ unit cpupara;
end;
function tavrparamanager.push_addr_param(varspez:tvarspez;def : tdef;calloption : tproccalloption) : boolean;
function tcpuparamanager.push_addr_param(varspez:tvarspez;def : tdef;calloption : tproccalloption) : boolean;
begin
result:=false;
if varspez in [vs_var,vs_out,vs_constref] then
@ -185,7 +185,7 @@ unit cpupara;
end;
function tavrparamanager.ret_in_param(def:tdef;pd:tabstractprocdef):boolean;
function tcpuparamanager.ret_in_param(def:tdef;pd:tabstractprocdef):boolean;
begin
if handle_common_ret_in_param(def,pd,result) then
exit;
@ -207,7 +207,7 @@ unit cpupara;
end;
procedure tavrparamanager.init_values(var curintreg, curfloatreg, curmmreg: tsuperregister; var cur_stack_offset: aword);
procedure tcpuparamanager.init_values(var curintreg, curfloatreg, curmmreg: tsuperregister; var cur_stack_offset: aword);
begin
curintreg:=RS_R25;
curfloatreg:=RS_INVALID;
@ -216,8 +216,8 @@ unit cpupara;
end;
{ TODO : fix tavrparamanager.create_paraloc_info_intern }
function tavrparamanager.create_paraloc_info_intern(p : tabstractprocdef; side: tcallercallee; paras: tparalist;
{ TODO : fix tcpuparamanager.create_paraloc_info_intern }
function tcpuparamanager.create_paraloc_info_intern(p : tabstractprocdef; side: tcallercallee; paras: tparalist;
var curintreg, curfloatreg, curmmreg: tsuperregister; var cur_stack_offset: aword):longint;
var
@ -415,7 +415,7 @@ unit cpupara;
end;
function tavrparamanager.create_paraloc_info(p : tabstractprocdef; side: tcallercallee):longint;
function tcpuparamanager.create_paraloc_info(p : tabstractprocdef; side: tcallercallee):longint;
var
cur_stack_offset: aword;
curintreg, curfloatreg, curmmreg: tsuperregister;
@ -429,8 +429,8 @@ unit cpupara;
end;
{ TODO : fix tavrparamanager.get_funcretloc }
function tavrparamanager.get_funcretloc(p : tabstractprocdef; side: tcallercallee; forcetempdef: tdef): tcgpara;
{ TODO : fix tcpuparamanager.get_funcretloc }
function tcpuparamanager.get_funcretloc(p : tabstractprocdef; side: tcallercallee; forcetempdef: tdef): tcgpara;
var
retcgsize : tcgsize;
paraloc : pcgparalocation;
@ -504,7 +504,7 @@ unit cpupara;
end;
function tavrparamanager.create_varargs_paraloc_info(p : tabstractprocdef; varargspara:tvarargsparalist):longint;
function tcpuparamanager.create_varargs_paraloc_info(p : tabstractprocdef; varargspara:tvarargsparalist):longint;
var
cur_stack_offset: aword;
curintreg, curfloatreg, curmmreg: tsuperregister;
@ -520,5 +520,5 @@ unit cpupara;
end;
begin
paramanager:=tavrparamanager.create;
paramanager:=tcpuparamanager.create;
end.

34
compiler/i386/cpupara.pas
View File

@ -32,7 +32,7 @@ unit cpupara;
parabase,paramgr;
type
ti386paramanager = class(tparamanager)
tcpuparamanager = class(tparamanager)
function param_use_paraloc(const cgpara:tcgpara):boolean;override;
function ret_in_param(def:tdef;pd:tabstractprocdef):boolean;override;
function push_addr_param(varspez:tvarspez;def : tdef;calloption : tproccalloption) : boolean;override;
@ -68,10 +68,10 @@ unit cpupara;
parasupregs : array[0..2] of tsuperregister = (RS_EAX,RS_EDX,RS_ECX);
{****************************************************************************
TI386PARAMANAGER
tcpuparamanager
****************************************************************************}
function ti386paramanager.param_use_paraloc(const cgpara:tcgpara):boolean;
function tcpuparamanager.param_use_paraloc(const cgpara:tcgpara):boolean;
var
paraloc : pcgparalocation;
begin
@ -92,7 +92,7 @@ unit cpupara;
end;
function ti386paramanager.ret_in_param(def:tdef;pd:tabstractprocdef):boolean;
function tcpuparamanager.ret_in_param(def:tdef;pd:tabstractprocdef):boolean;
var
size: longint;
begin
@ -153,7 +153,7 @@ unit cpupara;
end;
function ti386paramanager.push_addr_param(varspez:tvarspez;def : tdef;calloption : tproccalloption) : boolean;
function tcpuparamanager.push_addr_param(varspez:tvarspez;def : tdef;calloption : tproccalloption) : boolean;
begin
result:=false;
{ var,out,constref always require address }
@ -226,7 +226,7 @@ unit cpupara;
end;
function ti386paramanager.get_para_align(calloption : tproccalloption):byte;
function tcpuparamanager.get_para_align(calloption : tproccalloption):byte;
begin
if calloption=pocall_oldfpccall then
begin
@ -240,7 +240,7 @@ unit cpupara;
end;
function ti386paramanager.get_volatile_registers_int(calloption : tproccalloption):tcpuregisterset;
function tcpuparamanager.get_volatile_registers_int(calloption : tproccalloption):tcpuregisterset;
begin
case calloption of
pocall_internproc :
@ -262,19 +262,19 @@ unit cpupara;
end;
function ti386paramanager.get_volatile_registers_fpu(calloption : tproccalloption):tcpuregisterset;
function tcpuparamanager.get_volatile_registers_fpu(calloption : tproccalloption):tcpuregisterset;
begin
result:=[0..first_fpu_imreg-1];
end;
function ti386paramanager.get_volatile_registers_mm(calloption : tproccalloption):tcpuregisterset;
function tcpuparamanager.get_volatile_registers_mm(calloption : tproccalloption):tcpuregisterset;
begin
result:=[0..first_mm_imreg-1];
end;
procedure ti386paramanager.getintparaloc(pd : tabstractprocdef; nr : longint; var cgpara : tcgpara);
procedure tcpuparamanager.getintparaloc(pd : tabstractprocdef; nr : longint; var cgpara : tcgpara);
var
paraloc : pcgparalocation;
psym: tparavarsym;
@ -321,7 +321,7 @@ unit cpupara;
end;
function ti386paramanager.get_funcretloc(p : tabstractprocdef; side: tcallercallee; forcetempdef: tdef): TCGPara;
function tcpuparamanager.get_funcretloc(p : tabstractprocdef; side: tcallercallee; forcetempdef: tdef): TCGPara;
var
retcgsize : tcgsize;
paraloc : pcgparalocation;
@ -412,7 +412,7 @@ unit cpupara;
end;
procedure ti386paramanager.create_stdcall_paraloc_info(p : tabstractprocdef; side: tcallercallee;paras:tparalist;var parasize:longint);
procedure tcpuparamanager.create_stdcall_paraloc_info(p : tabstractprocdef; side: tcallercallee;paras:tparalist;var parasize:longint);
var
i : integer;
hp : tparavarsym;
@ -561,7 +561,7 @@ unit cpupara;
end;
procedure ti386paramanager.create_register_paraloc_info(p : tabstractprocdef; side: tcallercallee;paras:tparalist;
procedure tcpuparamanager.create_register_paraloc_info(p : tabstractprocdef; side: tcallercallee;paras:tparalist;
var parareg,parasize:longint);
var
hp : tparavarsym;
@ -734,7 +734,7 @@ unit cpupara;
end;
function ti386paramanager.create_paraloc_info(p : tabstractprocdef; side: tcallercallee):longint;
function tcpuparamanager.create_paraloc_info(p : tabstractprocdef; side: tcallercallee):longint;
var
parasize,
parareg : longint;
@ -762,7 +762,7 @@ unit cpupara;
end;
function ti386paramanager.create_varargs_paraloc_info(p : tabstractprocdef; varargspara:tvarargsparalist):longint;
function tcpuparamanager.create_varargs_paraloc_info(p : tabstractprocdef; varargspara:tvarargsparalist):longint;
var
parasize : longint;
begin
@ -775,7 +775,7 @@ unit cpupara;
end;
procedure ti386paramanager.createtempparaloc(list: TAsmList;calloption : tproccalloption;parasym : tparavarsym;can_use_final_stack_loc : boolean;var cgpara:TCGPara);
procedure tcpuparamanager.createtempparaloc(list: TAsmList;calloption : tproccalloption;parasym : tparavarsym;can_use_final_stack_loc : boolean;var cgpara:TCGPara);
begin
{ Never a need for temps when value is pushed (calls inside parameters
will simply allocate even more stack space for their parameters) }
@ -786,5 +786,5 @@ unit cpupara;
begin
paramanager:=ti386paramanager.create;
paramanager:=tcpuparamanager.create;
end.

34
compiler/i8086/cpupara.pas
View File

@ -32,7 +32,7 @@ unit cpupara;
parabase,paramgr;
type
ti8086paramanager = class(tparamanager)
tcpuparamanager = class(tparamanager)
function param_use_paraloc(const cgpara:tcgpara):boolean;override;
function ret_in_param(def:tdef;pd:tabstractprocdef):boolean;override;
function push_addr_param(varspez:tvarspez;def : tdef;calloption : tproccalloption) : boolean;override;
@ -74,10 +74,10 @@ unit cpupara;
parasupregs : array[0..2] of tsuperregister = (RS_AX,RS_DX,RS_CX);
{****************************************************************************
ti8086paramanager
tcpuparamanager
****************************************************************************}
function ti8086paramanager.param_use_paraloc(const cgpara:tcgpara):boolean;
function tcpuparamanager.param_use_paraloc(const cgpara:tcgpara):boolean;
var
paraloc : pcgparalocation;
begin
@ -98,7 +98,7 @@ unit cpupara;
end;
function ti8086paramanager.ret_in_param(def:tdef;pd:tabstractprocdef):boolean;
function tcpuparamanager.ret_in_param(def:tdef;pd:tabstractprocdef):boolean;
var
size: longint;
begin
@ -115,7 +115,7 @@ unit cpupara;
end;
function ti8086paramanager.push_addr_param(varspez:tvarspez;def : tdef;calloption : tproccalloption) : boolean;
function tcpuparamanager.push_addr_param(varspez:tvarspez;def : tdef;calloption : tproccalloption) : boolean;
begin
result:=false;
{ var,out,constref always require address }
@ -188,13 +188,13 @@ unit cpupara;
end;
function ti8086paramanager.get_para_align(calloption : tproccalloption):byte;
function tcpuparamanager.get_para_align(calloption : tproccalloption):byte;
begin
result:=std_param_align;
end;
function ti8086paramanager.get_volatile_registers_int(calloption : tproccalloption):tcpuregisterset;
function tcpuparamanager.get_volatile_registers_int(calloption : tproccalloption):tcpuregisterset;
begin
case calloption of
pocall_internproc :
@ -215,19 +215,19 @@ unit cpupara;
end;
function ti8086paramanager.get_volatile_registers_fpu(calloption : tproccalloption):tcpuregisterset;
function tcpuparamanager.get_volatile_registers_fpu(calloption : tproccalloption):tcpuregisterset;
begin
result:=[0..first_fpu_imreg-1];
end;
function ti8086paramanager.get_volatile_registers_mm(calloption : tproccalloption):tcpuregisterset;
function tcpuparamanager.get_volatile_registers_mm(calloption : tproccalloption):tcpuregisterset;
begin
result:=[0..first_mm_imreg-1];
end;
procedure ti8086paramanager.getintparaloc(pd : tabstractprocdef; nr : longint; var cgpara : tcgpara);
procedure tcpuparamanager.getintparaloc(pd : tabstractprocdef; nr : longint; var cgpara : tcgpara);
var
paraloc : pcgparalocation;
psym: tparavarsym;
@ -274,7 +274,7 @@ unit cpupara;
end;
function ti8086paramanager.get_funcretloc(p : tabstractprocdef; side: tcallercallee; forcetempdef: tdef): TCGPara;
function tcpuparamanager.get_funcretloc(p : tabstractprocdef; side: tcallercallee; forcetempdef: tdef): TCGPara;
var
retcgsize : tcgsize;
paraloc : pcgparalocation;
@ -405,7 +405,7 @@ unit cpupara;
end;
procedure ti8086paramanager.create_stdcall_paraloc_info(p : tabstractprocdef; side: tcallercallee;paras:tparalist;var parasize:longint);
procedure tcpuparamanager.create_stdcall_paraloc_info(p : tabstractprocdef; side: tcallercallee;paras:tparalist;var parasize:longint);
var
i : integer;
hp : tparavarsym;
@ -562,7 +562,7 @@ unit cpupara;
end;
procedure ti8086paramanager.create_register_paraloc_info(p : tabstractprocdef; side: tcallercallee;paras:tparalist;
procedure tcpuparamanager.create_register_paraloc_info(p : tabstractprocdef; side: tcallercallee;paras:tparalist;
var parareg,parasize:longint);
var
hp : tparavarsym;
@ -743,7 +743,7 @@ unit cpupara;
end;
function ti8086paramanager.create_paraloc_info(p : tabstractprocdef; side: tcallercallee):longint;
function tcpuparamanager.create_paraloc_info(p : tabstractprocdef; side: tcallercallee):longint;
var
parasize,
parareg : longint;
@ -771,7 +771,7 @@ unit cpupara;
end;
function ti8086paramanager.create_varargs_paraloc_info(p : tabstractprocdef; varargspara:tvarargsparalist):longint;
function tcpuparamanager.create_varargs_paraloc_info(p : tabstractprocdef; varargspara:tvarargsparalist):longint;
var
parasize : longint;
begin
@ -784,7 +784,7 @@ unit cpupara;
end;
procedure ti8086paramanager.createtempparaloc(list: TAsmList;calloption : tproccalloption;parasym : tparavarsym;can_use_final_stack_loc : boolean;var cgpara:TCGPara);
procedure tcpuparamanager.createtempparaloc(list: TAsmList;calloption : tproccalloption;parasym : tparavarsym;can_use_final_stack_loc : boolean;var cgpara:TCGPara);
begin
{ Never a need for temps when value is pushed (calls inside parameters
will simply allocate even more stack space for their parameters) }
@ -795,5 +795,5 @@ unit cpupara;
begin
paramanager:=ti8086paramanager.create;
paramanager:=tcpuparamanager.create;
end.

32
compiler/jvm/cpupara.pas
View File

@ -32,9 +32,9 @@ interface
type
{ TJVMParaManager }
{ tcpuparamanager }
TJVMParaManager=class(TParaManager)
tcpuparamanager=class(TParaManager)
function push_high_param(varspez:tvarspez;def : tdef;calloption : tproccalloption) : boolean;override;
function keep_para_array_range(varspez: tvarspez; def: tdef; calloption: tproccalloption): boolean; override;
function push_addr_param(varspez:tvarspez;def : tdef;calloption : tproccalloption) : boolean;override;
@ -64,13 +64,13 @@ implementation
hlcgobj;
procedure TJVMParaManager.GetIntParaLoc(pd : tabstractprocdef; nr : longint; var cgpara : tcgpara);
procedure tcpuparamanager.GetIntParaLoc(pd : tabstractprocdef; nr : longint; var cgpara : tcgpara);
begin
{ not yet implemented/used }
internalerror(2010121001);
end;
function TJVMParaManager.push_high_param(varspez: tvarspez; def: tdef; calloption: tproccalloption): boolean;
function tcpuparamanager.push_high_param(varspez: tvarspez; def: tdef; calloption: tproccalloption): boolean;
begin
{ we don't need a separate high parameter, since all arrays in Java
have an implicit associated length }
@ -82,7 +82,7 @@ implementation
end;
function TJVMParaManager.keep_para_array_range(varspez: tvarspez; def: tdef; calloption: tproccalloption): boolean;
function tcpuparamanager.keep_para_array_range(varspez: tvarspez; def: tdef; calloption: tproccalloption): boolean;
begin
{ even though these don't need a high parameter (see push_high_param),
we do have to keep the original parameter's array length because it's
@ -96,7 +96,7 @@ implementation
{ true if a parameter is too large to copy and only the address is pushed }
function TJVMParaManager.push_addr_param(varspez:tvarspez;def : tdef;calloption : tproccalloption) : boolean;
function tcpuparamanager.push_addr_param(varspez:tvarspez;def : tdef;calloption : tproccalloption) : boolean;
begin
result:=
jvmimplicitpointertype(def) or
@ -105,7 +105,7 @@ implementation
end;
function TJVMParaManager.push_copyout_param(varspez: tvarspez; def: tdef; calloption: tproccalloption): boolean;
function tcpuparamanager.push_copyout_param(varspez: tvarspez; def: tdef; calloption: tproccalloption): boolean;
begin
{ in principle also for vs_constref, but since we can't have real
references, that won't make a difference }
@ -115,7 +115,7 @@ implementation
end;
function TJVMParaManager.push_size(varspez: tvarspez; def: tdef; calloption: tproccalloption): longint;
function tcpuparamanager.push_size(varspez: tvarspez; def: tdef; calloption: tproccalloption): longint;
begin
{ all aggregate types are emulated using indirect pointer types }
if def.typ in [arraydef,recorddef,setdef,stringdef] then
@ -125,7 +125,7 @@ implementation
end;
function TJVMParaManager.get_funcretloc(p : tabstractprocdef; side: tcallercallee; forcetempdef: tdef): tcgpara;
function tcpuparamanager.get_funcretloc(p : tabstractprocdef; side: tcallercallee; forcetempdef: tdef): tcgpara;
var
paraloc : pcgparalocation;
retcgsize : tcgsize;
@ -178,13 +178,13 @@ implementation
paraloc^.def:=result.def;
end;
function TJVMParaManager.param_use_paraloc(const cgpara: tcgpara): boolean;
function tcpuparamanager.param_use_paraloc(const cgpara: tcgpara): boolean;
begin
{ all parameters are copied by the VM to local variable locations }
result:=true;
end;
function TJVMParaManager.ret_in_param(def:tdef;pd:tabstractprocdef):boolean;
function tcpuparamanager.ret_in_param(def:tdef;pd:tabstractprocdef):boolean;
begin
{ not as efficient as returning in param for jvmimplicitpointertypes,
but in the latter case the routines are harder to use from Java
@ -193,14 +193,14 @@ implementation
Result:=false;
end;
function TJVMParaManager.is_stack_paraloc(paraloc: pcgparalocation): boolean;
function tcpuparamanager.is_stack_paraloc(paraloc: pcgparalocation): boolean;
begin
{ all parameters are passed on the evaluation stack }
result:=true;
end;
function TJVMParaManager.create_varargs_paraloc_info(p : tabstractprocdef; varargspara:tvarargsparalist):longint;
function tcpuparamanager.create_varargs_paraloc_info(p : tabstractprocdef; varargspara:tvarargsparalist):longint;
var
parasize : longint;
begin
@ -213,7 +213,7 @@ implementation
end;
procedure TJVMParaManager.create_paraloc_info_intern(p : tabstractprocdef; side: tcallercallee;paras:tparalist;
procedure tcpuparamanager.create_paraloc_info_intern(p : tabstractprocdef; side: tcallercallee;paras:tparalist;
var parasize:longint);
var
paraloc : pcgparalocation;
@ -288,7 +288,7 @@ implementation
end;
function TJVMParaManager.create_paraloc_info(p : tabstractprocdef; side: tcallercallee):longint;
function tcpuparamanager.create_paraloc_info(p : tabstractprocdef; side: tcallercallee):longint;
var
parasize : longint;
begin
@ -302,5 +302,5 @@ implementation
begin
ParaManager:=TJVMParaManager.create;
ParaManager:=tcpuparamanager.create;
end.

28
compiler/m68k/cpupara.pas
View File

@ -40,7 +40,7 @@ unit cpupara;
and if the calling conventions for the helper routines of the
rtl are used.
}
tm68kparamanager = class(tparamanager)
tcpuparamanager = class(tparamanager)
procedure getintparaloc(pd : tabstractprocdef; nr : longint; var cgpara : tcgpara);override;
function create_paraloc_info(p : tabstractprocdef; side: tcallercallee):longint;override;
function push_addr_param(varspez:tvarspez;def : tdef;calloption : tproccalloption) : boolean;override;
@ -66,7 +66,7 @@ unit cpupara;
cpuinfo,
defutil;
procedure tm68kparamanager.getintparaloc(pd : tabstractprocdef; nr : longint; var cgpara : tcgpara);
procedure tcpuparamanager.getintparaloc(pd : tabstractprocdef; nr : longint; var cgpara : tcgpara);
var
paraloc : pcgparalocation;
psym: tparavarsym;
@ -158,7 +158,7 @@ unit cpupara;
{ TODO: copied from ppc cg, needs work}
function tm68kparamanager.push_addr_param(varspez:tvarspez;def : tdef;calloption : tproccalloption) : boolean;
function tcpuparamanager.push_addr_param(varspez:tvarspez;def : tdef;calloption : tproccalloption) : boolean;
begin
result:=false;
{ var,out,constref always require address }
@ -189,14 +189,14 @@ unit cpupara;
end;
end;
procedure tm68kparamanager.init_values(var curintreg, curfloatreg: tsuperregister; var cur_stack_offset: aword);
procedure tcpuparamanager.init_values(var curintreg, curfloatreg: tsuperregister; var cur_stack_offset: aword);
begin
cur_stack_offset:=8;
curintreg:=RS_D0;
curfloatreg:=RS_FP0;
end;
function tm68kparamanager.get_funcretloc(p : tabstractprocdef; side: tcallercallee; forcetempdef: tdef): tcgpara;
function tcpuparamanager.get_funcretloc(p : tabstractprocdef; side: tcallercallee; forcetempdef: tdef): tcgpara;
var
paraloc : pcgparalocation;
retcgsize : tcgsize;
@ -250,7 +250,7 @@ unit cpupara;
end;
end;
function tm68kparamanager.create_paraloc_info(p : tabstractprocdef; side: tcallercallee):longint;
function tcpuparamanager.create_paraloc_info(p : tabstractprocdef; side: tcallercallee):longint;
var
cur_stack_offset: aword;
curintreg, curfloatreg: tsuperregister;
@ -262,7 +262,7 @@ unit cpupara;
create_funcretloc_info(p,side);
end;
function tm68kparamanager.create_paraloc_info_intern(p : tabstractprocdef; side: tcallercallee; paras: tparalist;
function tcpuparamanager.create_paraloc_info_intern(p : tabstractprocdef; side: tcallercallee; paras: tparalist;
var curintreg, curfloatreg: tsuperregister; var cur_stack_offset: aword):longint;
var
paraloc : pcgparalocation;
@ -445,7 +445,7 @@ unit cpupara;
end;
}
function tm68kparamanager.parsefuncretloc(p : tabstractprocdef; const s : string) : boolean;
function tcpuparamanager.parsefuncretloc(p : tabstractprocdef; const s : string) : boolean;
begin
result:=false;
case target_info.system of
@ -494,7 +494,7 @@ unit cpupara;
end;
end;
function tm68kparamanager.get_volatile_registers_int(calloption:tproccalloption):tcpuregisterset;
function tcpuparamanager.get_volatile_registers_int(calloption:tproccalloption):tcpuregisterset;
begin
{ d0 and d1 are considered volatile (ToDo: results in "procedure too
complex when compiling unicodedata.pas) }
@ -503,14 +503,14 @@ unit cpupara;
end;
function tm68kparamanager.get_volatile_registers_address(calloption:tproccalloption):tcpuregisterset;
function tcpuparamanager.get_volatile_registers_address(calloption:tproccalloption):tcpuregisterset;
begin
{ a0 and a1 are considered volatile }
Result:=[RS_A0,RS_A1];
end;
function tm68kparamanager.parseparaloc(p : tparavarsym;const s : string) : boolean;
function tcpuparamanager.parseparaloc(p : tparavarsym;const s : string) : boolean;
var
paraloc : pcgparalocation;
begin
@ -570,7 +570,7 @@ unit cpupara;
end;
procedure tm68kparamanager.createtempparaloc(list: TAsmList;calloption : tproccalloption;parasym : tparavarsym;can_use_final_stack_loc : boolean;var cgpara:TCGPara);
procedure tcpuparamanager.createtempparaloc(list: TAsmList;calloption : tproccalloption;parasym : tparavarsym;can_use_final_stack_loc : boolean;var cgpara:TCGPara);
var
paraloc : pcgparalocation;
begin
@ -582,7 +582,7 @@ unit cpupara;
inherited createtempparaloc(list,calloption,parasym,can_use_final_stack_loc,cgpara);
end;
function tm68kparamanager.create_varargs_paraloc_info(p : tabstractprocdef; varargspara:tvarargsparalist):longint;
function tcpuparamanager.create_varargs_paraloc_info(p : tabstractprocdef; varargspara:tvarargsparalist):longint;
var
cur_stack_offset: aword;
curintreg, curfloatreg: tsuperregister;
@ -599,5 +599,5 @@ unit cpupara;
begin
paramanager:=tm68kparamanager.create;
paramanager:=tcpuparamanager.create;
end.

24
compiler/mips/cpupara.pas
View File

@ -67,7 +67,7 @@ interface
parasupregs : tparasupregs = (RS_R4, RS_R5, RS_R6, RS_R7, RS_R8, RS_R9);
type
TMIPSParaManager=class(TParaManager)
tcpuparamanager=class(TParaManager)
function push_addr_param(varspez:tvarspez;def : tdef;calloption : tproccalloption) : boolean;override;
function get_volatile_registers_int(calloption : tproccalloption):TCpuRegisterSet;override;
function get_volatile_registers_fpu(calloption : tproccalloption):TCpuRegisterSet;override;
@ -92,14 +92,14 @@ implementation
function TMIPSParaManager.get_volatile_registers_int(calloption : tproccalloption):TCpuRegisterSet;
function tcpuparamanager.get_volatile_registers_int(calloption : tproccalloption):TCpuRegisterSet;
begin
{ O32 ABI values }
result:=[RS_R1..RS_R15,RS_R24..RS_R25,RS_R31];
end;
function TMIPSParaManager.get_volatile_registers_fpu(calloption : tproccalloption):TCpuRegisterSet;
function tcpuparamanager.get_volatile_registers_fpu(calloption : tproccalloption):TCpuRegisterSet;
begin
{ O32 ABI values }
result:=[RS_F0..RS_F19];
@ -108,14 +108,14 @@ implementation
{ whether "def" must be treated as record when used as function result,
i.e. its address passed in a0 }
function TMIPSParaManager.is_abi_record(def: tdef): boolean;
function tcpuparamanager.is_abi_record(def: tdef): boolean;
begin
result:=(def.typ=recorddef) or
((def.typ=procvardef) and not tprocvardef(def).is_addressonly);
end;
function TMIPSParaManager.param_use_paraloc(const cgpara: tcgpara): boolean;
function tcpuparamanager.param_use_paraloc(const cgpara: tcgpara): boolean;
var
paraloc: pcgparalocation;
begin
@ -127,7 +127,7 @@ implementation
{ true if a parameter is too large to copy and only the address is pushed }
function TMIPSParaManager.push_addr_param(varspez:tvarspez;def : tdef;calloption : tproccalloption) : boolean;
function tcpuparamanager.push_addr_param(varspez:tvarspez;def : tdef;calloption : tproccalloption) : boolean;
begin
result:=false;
{ var,out,constref always require address }
@ -161,7 +161,7 @@ implementation
end;
function TMIPSParaManager.get_funcretloc(p : tabstractprocdef; side: tcallercallee; forcetempdef: tdef): tcgpara;
function tcpuparamanager.get_funcretloc(p : tabstractprocdef; side: tcallercallee; forcetempdef: tdef): tcgpara;
var
paraloc : pcgparalocation;
retcgsize : tcgsize;
@ -234,7 +234,7 @@ implementation
end;
procedure TMIPSParaManager.create_paraloc_info_intern(p : tabstractprocdef; side: tcallercallee;paras:tparalist);
procedure tcpuparamanager.create_paraloc_info_intern(p : tabstractprocdef; side: tcallercallee;paras:tparalist);
var
paraloc : pcgparalocation;
i,j : integer;
@ -373,7 +373,7 @@ implementation
begin
{ This should be the first parameter }
//if (intparareg<>1) then
// Comment(V_Warning,'intparareg should be one for funcret in TMipsParaManager.create_paraloc_info_intern');
// Comment(V_Warning,'intparareg should be one for funcret in tcpuparamanager.create_paraloc_info_intern');
paraloc^.loc:=LOC_REGISTER;
paraloc^.register:=newreg(R_INTREGISTER,parasupregs[0],R_SUBWHOLE);
inc(intparasize,align(tcgsize2size[paraloc^.size],sizeof(aint)));
@ -480,7 +480,7 @@ implementation
end;
function TMIPSParaManager.create_varargs_paraloc_info(p : tabstractprocdef; varargspara:tvarargsparalist):longint;
function tcpuparamanager.create_varargs_paraloc_info(p : tabstractprocdef; varargspara:tvarargsparalist):longint;
begin
intparareg:=0;
intparasize:=0;
@ -501,7 +501,7 @@ implementation
function TMIPSParaManager.create_paraloc_info(p : tabstractprocdef; side: tcallercallee):longint;
function tcpuparamanager.create_paraloc_info(p : tabstractprocdef; side: tcallercallee):longint;
begin
intparareg:=0;
intparasize:=0;
@ -515,5 +515,5 @@ implementation
begin
ParaManager:=TMIPSParaManager.create;
ParaManager:=tcpuparamanager.create;
end.

12
compiler/pdecsub.pas
View File

@ -1788,8 +1788,8 @@ begin
else
Message(parser_e_32bitint_or_pointer_variable_expected);
end;
(paramanager as tm68kparamanager).create_funcretloc_info(pd,calleeside);
(paramanager as tm68kparamanager).create_funcretloc_info(pd,callerside);
(paramanager as tcpuparamanager).create_funcretloc_info(pd,calleeside);
(paramanager as tcpuparamanager).create_funcretloc_info(pd,callerside);
v:=get_intconst;
if (v<low(Tprocdef(pd).extnumber)) or (v>high(Tprocdef(pd).extnumber)) then
@ -1819,8 +1819,8 @@ begin
Message(parser_e_32bitint_or_pointer_variable_expected);
end;
(paramanager as tppcparamanager).create_funcretloc_info(pd,calleeside);
(paramanager as tppcparamanager).create_funcretloc_info(pd,callerside);
(paramanager as tcpuparamanager).create_funcretloc_info(pd,calleeside);
(paramanager as tcpuparamanager).create_funcretloc_info(pd,callerside);
v:=get_intconst;
if (v<low(Tprocdef(pd).extnumber)) or (v>high(Tprocdef(pd).extnumber)) then
@ -1911,8 +1911,8 @@ begin
else
Message(parser_e_32bitint_or_pointer_variable_expected);
end;
(paramanager as tppcparamanager).create_funcretloc_info(pd,calleeside);
(paramanager as tppcparamanager).create_funcretloc_info(pd,callerside);
(paramanager as tcpuparamanager).create_funcretloc_info(pd,calleeside);
(paramanager as tcpuparamanager).create_funcretloc_info(pd,callerside);
v:=get_intconst;
if (v<low(Tprocdef(pd).extnumber)) or (v>high(Tprocdef(pd).extnumber)) then

24
compiler/powerpc/cpupara.pas
View File

@ -32,7 +32,7 @@ unit cpupara;
paramgr,parabase,cgbase,cgutils;
type
tppcparamanager = class(tparamanager)
tcpuparamanager = class(tparamanager)
function get_volatile_registers_int(calloption : tproccalloption):tcpuregisterset;override;
function get_volatile_registers_fpu(calloption : tproccalloption):tcpuregisterset;override;
function push_addr_param(varspez:tvarspez;def : tdef;calloption : tproccalloption) : boolean;override;
@ -56,7 +56,7 @@ unit cpupara;
procinfo,cpupi;
function tppcparamanager.get_volatile_registers_int(calloption : tproccalloption):tcpuregisterset;
function tcpuparamanager.get_volatile_registers_int(calloption : tproccalloption):tcpuregisterset;
begin
if (target_info.system = system_powerpc_darwin) then
result := [RS_R0,RS_R2..RS_R12]
@ -65,7 +65,7 @@ unit cpupara;
end;
function tppcparamanager.get_volatile_registers_fpu(calloption : tproccalloption):tcpuregisterset;
function tcpuparamanager.get_volatile_registers_fpu(calloption : tproccalloption):tcpuregisterset;
begin
case target_info.abi of
abi_powerpc_aix,
@ -77,7 +77,7 @@ unit cpupara;
end;
procedure tppcparamanager.getintparaloc(pd : tabstractprocdef; nr : longint; var cgpara : tcgpara);
procedure tcpuparamanager.getintparaloc(pd : tabstractprocdef; nr : longint; var cgpara : tcgpara);
var
paraloc : pcgparalocation;
psym : tparavarsym;
@ -181,7 +181,7 @@ unit cpupara;
end;
function tppcparamanager.push_addr_param(varspez:tvarspez;def : tdef;calloption : tproccalloption) : boolean;
function tcpuparamanager.push_addr_param(varspez:tvarspez;def : tdef;calloption : tproccalloption) : boolean;
begin
result:=false;
{ var,out,constref always require address }
@ -236,7 +236,7 @@ unit cpupara;
end;
procedure tppcparamanager.init_values(var curintreg, curfloatreg, curmmreg: tsuperregister; var cur_stack_offset: aword);
procedure tcpuparamanager.init_values(var curintreg, curfloatreg, curmmreg: tsuperregister; var cur_stack_offset: aword);
begin
case target_info.abi of
abi_powerpc_aix:
@ -252,7 +252,7 @@ unit cpupara;
end;
function tppcparamanager.get_funcretloc(p : tabstractprocdef; side: tcallercallee; forcetempdef: tdef): tcgpara;
function tcpuparamanager.get_funcretloc(p : tabstractprocdef; side: tcallercallee; forcetempdef: tdef): tcgpara;
var
paraloc : pcgparalocation;
retcgsize : tcgsize;
@ -306,7 +306,7 @@ unit cpupara;
end;
function tppcparamanager.create_paraloc_info(p : tabstractprocdef; side: tcallercallee):longint;
function tcpuparamanager.create_paraloc_info(p : tabstractprocdef; side: tcallercallee):longint;
var
cur_stack_offset: aword;
@ -321,7 +321,7 @@ unit cpupara;
function tppcparamanager.create_paraloc_info_intern(p : tabstractprocdef; side: tcallercallee; paras:tparalist;
function tcpuparamanager.create_paraloc_info_intern(p : tabstractprocdef; side: tcallercallee; paras:tparalist;
var curintreg, curfloatreg, curmmreg: tsuperregister; var cur_stack_offset: aword; varargsparas: boolean):longint;
var
stack_offset: longint;
@ -609,7 +609,7 @@ unit cpupara;
end;
function tppcparamanager.create_varargs_paraloc_info(p : tabstractprocdef; varargspara:tvarargsparalist):longint;
function tcpuparamanager.create_varargs_paraloc_info(p : tabstractprocdef; varargspara:tvarargsparalist):longint;
var
cur_stack_offset: aword;
parasize, l: longint;
@ -654,7 +654,7 @@ unit cpupara;
end;
function tppcparamanager.parseparaloc(p : tparavarsym;const s : string) : boolean;
function tcpuparamanager.parseparaloc(p : tparavarsym;const s : string) : boolean;
var
paraloc : pcgparalocation;
paracgsize : tcgsize;
@ -731,5 +731,5 @@ unit cpupara;
end;
begin
paramanager:=tppcparamanager.create;
paramanager:=tcpuparamanager.create;
end.

24
compiler/powerpc64/cpupara.pas
View File

@ -32,7 +32,7 @@ uses
paramgr, parabase, cgbase, cgutils;
type
tppcparamanager = class(tparamanager)
tcpuparamanager = class(tparamanager)
function get_volatile_registers_int(calloption: tproccalloption):
tcpuregisterset; override;
function get_volatile_registers_fpu(calloption: tproccalloption):
@ -63,7 +63,7 @@ uses
defutil,symtable,
procinfo, cpupi;
function tppcparamanager.get_volatile_registers_int(calloption:
function tcpuparamanager.get_volatile_registers_int(calloption:
tproccalloption): tcpuregisterset;
begin
result := [RS_R0,RS_R3..RS_R12];
@ -71,13 +71,13 @@ begin
include(result,RS_R2);
end;
function tppcparamanager.get_volatile_registers_fpu(calloption:
function tcpuparamanager.get_volatile_registers_fpu(calloption:
tproccalloption): tcpuregisterset;
begin
result := [RS_F0..RS_F13];
end;
procedure tppcparamanager.getintparaloc(pd : tabstractprocdef; nr: longint; var cgpara: tcgpara);
procedure tcpuparamanager.getintparaloc(pd : tabstractprocdef; nr: longint; var cgpara: tcgpara);
var
paraloc: pcgparalocation;
psym: tparavarsym;
@ -160,7 +160,7 @@ begin
end;
end;
function tppcparamanager.push_addr_param(varspez: tvarspez; def: tdef;
function tcpuparamanager.push_addr_param(varspez: tvarspez; def: tdef;
calloption: tproccalloption): boolean;
begin
result := false;
@ -198,7 +198,7 @@ begin
end;
end;
procedure tppcparamanager.init_values(var curintreg, curfloatreg, curmmreg:
procedure tcpuparamanager.init_values(var curintreg, curfloatreg, curmmreg:
tsuperregister; var cur_stack_offset: aword);
begin
{ register parameter save area begins at 48(r2) }
@ -208,7 +208,7 @@ begin
curmmreg := RS_M2;
end;
function tppcparamanager.get_funcretloc(p : tabstractprocdef; side:
function tcpuparamanager.get_funcretloc(p : tabstractprocdef; side:
tcallercallee; forcetempdef: tdef): tcgpara;
var
paraloc : pcgparalocation;
@ -239,7 +239,7 @@ begin
end;
end;
function tppcparamanager.create_paraloc_info(p: tabstractprocdef; side:
function tcpuparamanager.create_paraloc_info(p: tabstractprocdef; side:
tcallercallee): longint;
var
cur_stack_offset: aword;
@ -253,7 +253,7 @@ begin
create_funcretloc_info(p, side);
end;
function tppcparamanager.create_paraloc_info_intern(p: tabstractprocdef; side:
function tcpuparamanager.create_paraloc_info_intern(p: tabstractprocdef; side:
tcallercallee; paras: tparalist;
var curintreg, curfloatreg, curmmreg: tsuperregister; var cur_stack_offset:
aword; isVararg : boolean): longint;
@ -485,7 +485,7 @@ begin
result := stack_offset;
end;
function tppcparamanager.create_varargs_paraloc_info(p: tabstractprocdef;
function tcpuparamanager.create_varargs_paraloc_info(p: tabstractprocdef;
varargspara: tvarargsparalist): longint;
var
cur_stack_offset: aword;
@ -527,7 +527,7 @@ begin
include(varargspara.varargsinfo, va_uses_float_reg);
end;
function tppcparamanager.parseparaloc(p: tparavarsym; const s: string): boolean;
function tcpuparamanager.parseparaloc(p: tparavarsym; const s: string): boolean;
begin
{ not supported/required for PowerPC64-linux target }
internalerror(200404182);
@ -536,6 +536,6 @@ end;
begin
paramanager := tppcparamanager.create;
paramanager := tcpuparamanager.create;
end.

20
compiler/sparc/cpupara.pas
View File

@ -31,7 +31,7 @@ interface
symconst,symbase,symsym,symtype,symdef,paramgr,parabase,cgbase,cgutils;
type
TSparcParaManager=class(TParaManager)
tcpuparamanager=class(TParaManager)
function push_addr_param(varspez:tvarspez;def : tdef;calloption : tproccalloption) : boolean;override;
function get_volatile_registers_int(calloption : tproccalloption):TCpuRegisterSet;override;
function get_volatile_registers_fpu(calloption : tproccalloption):TCpuRegisterSet;override;
@ -62,19 +62,19 @@ implementation
parainsupregs : tparasupregs = (RS_I0,RS_I1,RS_I2,RS_I3,RS_I4,RS_I5);
function TSparcParaManager.get_volatile_registers_int(calloption : tproccalloption):TCpuRegisterSet;
function tcpuparamanager.get_volatile_registers_int(calloption : tproccalloption):TCpuRegisterSet;
begin
result:=[RS_G1,RS_O0,RS_O1,RS_O2,RS_O3,RS_O4,RS_O5,RS_O6,RS_O7];
end;
function tsparcparamanager.get_volatile_registers_fpu(calloption : tproccalloption):TCpuRegisterSet;
function tcpuparamanager.get_volatile_registers_fpu(calloption : tproccalloption):TCpuRegisterSet;
begin
result:=[RS_F0..RS_F31];
end;
procedure TSparcParaManager.GetIntParaLoc(pd : tabstractprocdef; nr : longint; var cgpara : tcgpara);
procedure tcpuparamanager.GetIntParaLoc(pd : tabstractprocdef; nr : longint; var cgpara : tcgpara);
var
paraloc : pcgparalocation;
psym: tparavarsym;
@ -115,7 +115,7 @@ implementation
{ true if a parameter is too large to copy and only the address is pushed }
function tsparcparamanager.push_addr_param(varspez:tvarspez;def : tdef;calloption : tproccalloption) : boolean;
function tcpuparamanager.push_addr_param(varspez:tvarspez;def : tdef;calloption : tproccalloption) : boolean;
begin
result:=false;
{ var,out,constref always require address }
@ -146,7 +146,7 @@ implementation
end;
function tsparcparamanager.get_funcretloc(p : tabstractprocdef; side: tcallercallee; forcetempdef: tdef): tcgpara;
function tcpuparamanager.get_funcretloc(p : tabstractprocdef; side: tcallercallee; forcetempdef: tdef): tcgpara;
var
paraloc : pcgparalocation;
retcgsize : tcgsize;
@ -204,7 +204,7 @@ implementation
end;
procedure tsparcparamanager.create_paraloc_info_intern(p : tabstractprocdef; side: tcallercallee;paras:tparalist;
procedure tcpuparamanager.create_paraloc_info_intern(p : tabstractprocdef; side: tcallercallee;paras:tparalist;
var intparareg,parasize:longint);
var
paraloc : pcgparalocation;
@ -313,7 +313,7 @@ implementation
end;
function TSparcParaManager.create_varargs_paraloc_info(p : tabstractprocdef; varargspara:tvarargsparalist):longint;
function tcpuparamanager.create_varargs_paraloc_info(p : tabstractprocdef; varargspara:tvarargsparalist):longint;
var
intparareg,
parasize : longint;
@ -329,7 +329,7 @@ implementation
function tsparcparamanager.create_paraloc_info(p : tabstractprocdef; side: tcallercallee):longint;
function tcpuparamanager.create_paraloc_info(p : tabstractprocdef; side: tcallercallee):longint;
var
intparareg,
parasize : longint;
@ -345,5 +345,5 @@ implementation
begin
ParaManager:=TSparcParaManager.create;
ParaManager:=tcpuparamanager.create;
end.

26
compiler/x86_64/cpupara.pas
View File

@ -33,7 +33,7 @@ unit cpupara;
parabase,paramgr;
type
tx86_64paramanager = class(tparamanager)
tcpuparamanager = class(tparamanager)
private
procedure create_paraloc_info_intern(p : tabstractprocdef; side: tcallercallee;paras:tparalist;
var intparareg,mmparareg,parasize:longint;varargsparas: boolean);
@ -742,7 +742,7 @@ unit cpupara;
end;
function tx86_64paramanager.ret_in_param(def:tdef;pd:tabstractprocdef):boolean;
function tcpuparamanager.ret_in_param(def:tdef;pd:tabstractprocdef):boolean;
var
classes: tx64paraclasses;
numclasses: longint;
@ -765,7 +765,7 @@ unit cpupara;
end;
function tx86_64paramanager.param_use_paraloc(const cgpara:tcgpara):boolean;
function tcpuparamanager.param_use_paraloc(const cgpara:tcgpara):boolean;
var
paraloc : pcgparalocation;
begin
@ -787,7 +787,7 @@ unit cpupara;
{ true if a parameter is too large to copy and only the address is pushed }
function tx86_64paramanager.push_addr_param(varspez:tvarspez;def : tdef;calloption : tproccalloption) : boolean;
function tcpuparamanager.push_addr_param(varspez:tvarspez;def : tdef;calloption : tproccalloption) : boolean;
var
classes: tx64paraclasses;
numclasses: longint;
@ -865,7 +865,7 @@ unit cpupara;
end;
function tx86_64paramanager.get_volatile_registers_int(calloption : tproccalloption):tcpuregisterset;
function tcpuparamanager.get_volatile_registers_int(calloption : tproccalloption):tcpuregisterset;
begin
if target_info.system=system_x86_64_win64 then
result:=[RS_RAX,RS_RCX,RS_RDX,RS_R8,RS_R9,RS_R10,RS_R11]
@ -874,7 +874,7 @@ unit cpupara;
end;
function tx86_64paramanager.get_volatile_registers_mm(calloption : tproccalloption):tcpuregisterset;
function tcpuparamanager.get_volatile_registers_mm(calloption : tproccalloption):tcpuregisterset;
begin
if target_info.system=system_x86_64_win64 then
result:=[RS_XMM0..RS_XMM5]
@ -883,13 +883,13 @@ unit cpupara;
end;
function tx86_64paramanager.get_volatile_registers_fpu(calloption : tproccalloption):tcpuregisterset;
function tcpuparamanager.get_volatile_registers_fpu(calloption : tproccalloption):tcpuregisterset;
begin
result:=[RS_ST0..RS_ST7];
end;
procedure tx86_64paramanager.getintparaloc(pd : tabstractprocdef; nr : longint; var cgpara : tcgpara);
procedure tcpuparamanager.getintparaloc(pd : tabstractprocdef; nr : longint; var cgpara : tcgpara);
var
paraloc : pcgparalocation;
psym : tparavarsym;
@ -945,7 +945,7 @@ unit cpupara;
end;
function tx86_64paramanager.get_funcretloc(p : tabstractprocdef; side: tcallercallee; forcetempdef: tdef): tcgpara;
function tcpuparamanager.get_funcretloc(p : tabstractprocdef; side: tcallercallee; forcetempdef: tdef): tcgpara;
const
intretregs: array[0..1] of tregister = (NR_FUNCTION_RETURN_REG,NR_FUNCTION_RETURN_REG_HIGH);
mmretregs: array[0..1] of tregister = (NR_MM_RESULT_REG,NR_MM_RESULT_REG_HIGH);
@ -1093,7 +1093,7 @@ unit cpupara;
end;
procedure tx86_64paramanager.create_paraloc_info_intern(p : tabstractprocdef; side: tcallercallee;paras:tparalist;
procedure tcpuparamanager.create_paraloc_info_intern(p : tabstractprocdef; side: tcallercallee;paras:tparalist;
var intparareg,mmparareg,parasize:longint;varargsparas: boolean);
var
hp : tparavarsym;
@ -1363,7 +1363,7 @@ unit cpupara;
end;
function tx86_64paramanager.create_varargs_paraloc_info(p : tabstractprocdef; varargspara:tvarargsparalist):longint;
function tcpuparamanager.create_varargs_paraloc_info(p : tabstractprocdef; varargspara:tvarargsparalist):longint;
var
intparareg,mmparareg,
parasize : longint;
@ -1384,7 +1384,7 @@ unit cpupara;
end;
function tx86_64paramanager.create_paraloc_info(p : tabstractprocdef; side: tcallercallee):longint;
function tcpuparamanager.create_paraloc_info(p : tabstractprocdef; side: tcallercallee):longint;
var
intparareg,mmparareg,
parasize : longint;
@ -1404,5 +1404,5 @@ unit cpupara;
begin
paramanager:=tx86_64paramanager.create;
paramanager:=tcpuparamanager.create;
end.