mirror of
https://gitlab.com/freepascal.org/fpc/source.git
synced 2025-04-12 14:49:33 +02:00
7a0ae38700
getintparaloc + adapted all call sites of getintparaloc. This
led to a number of additional, related changes:
o corrected the type information for some getintparaloc parameters
o don't allocate some intparalocs in cases they aren't used
o changed "const tvardata" parameter into "constref tvardata" for
fpc_variant_copy_overwrite to make pass-by-reference semantics
explicit
o moved a number of routines that now have to call find_system_type()
from cgobj to hlcgobj so that cgobj doesn't have to start depending
on the symtable unit
o added versions of the cpureg alloc/dealloc methods to hlcgobj that
call through to their cgobj counter parts, so we can call save/restore
the cpu registers before/after calling system helpers from hlcgobj
(not implemented in hlcgobj itself, because all basic register
allocator functionality is still part of cgobj/cgcpu)
git-svn-id: trunk@21696 -
278 lines
10 KiB
ObjectPascal
278 lines
10 KiB
ObjectPascal
{
|
||
Copyright (c) 1998-2010 by Florian Klaempfl, Jonas Maebe
|
||
|
||
Calling conventions for the JVM
|
||
|
||
This program is free software; you can redistribute it and/or modify
|
||
it under the terms of the GNU General Public License as published by
|
||
the Free Software Foundation; either version 2 of the License, or
|
||
(at your option) any later version.
|
||
|
||
This program is distributed in the hope that it will be useful,
|
||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||
GNU General Public License for more details.
|
||
|
||
You should have received a copy of the GNU General Public License
|
||
along with this program; if not, write to the Free Software
|
||
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
||
*****************************************************************************}
|
||
unit cpupara;
|
||
|
||
{$i fpcdefs.inc}
|
||
|
||
interface
|
||
|
||
uses
|
||
globtype,
|
||
cclasses,
|
||
aasmtai,aasmdata,
|
||
cpubase,cpuinfo,
|
||
symconst,symbase,symsym,symtype,symdef,paramgr,parabase,cgbase,cgutils;
|
||
|
||
type
|
||
|
||
{ TJVMParaManager }
|
||
|
||
TJVMParaManager=class(TParaManager)
|
||
function push_high_param(varspez:tvarspez;def : tdef;calloption : tproccalloption) : boolean;override;
|
||
function push_addr_param(varspez:tvarspez;def : tdef;calloption : tproccalloption) : boolean;override;
|
||
function push_copyout_param(varspez: tvarspez; def: tdef; calloption: tproccalloption): boolean; override;
|
||
function push_size(varspez: tvarspez; def: tdef; calloption: tproccalloption): longint;override;
|
||
{Returns a structure giving the information on the storage of the parameter
|
||
(which must be an integer parameter)
|
||
@param(nr Parameter number of routine, starting from 1)}
|
||
procedure getintparaloc(calloption : tproccalloption; nr : longint; def : tdef; var cgpara : tcgpara);override;
|
||
function create_paraloc_info(p : TAbstractProcDef; side: tcallercallee):longint;override;
|
||
function create_varargs_paraloc_info(p : tabstractprocdef; varargspara:tvarargsparalist):longint;override;
|
||
function get_funcretloc(p : tabstractprocdef; side: tcallercallee; def: tdef): tcgpara;override;
|
||
function param_use_paraloc(const cgpara: tcgpara): boolean; override;
|
||
function ret_in_param(def: tdef; calloption: tproccalloption): boolean; override;
|
||
function is_stack_paraloc(paraloc: pcgparalocation): boolean;override;
|
||
private
|
||
procedure create_funcretloc_info(p : tabstractprocdef; side: tcallercallee);
|
||
procedure create_paraloc_info_intern(p : tabstractprocdef; side: tcallercallee; paras: tparalist;
|
||
var parasize:longint);
|
||
end;
|
||
|
||
implementation
|
||
|
||
uses
|
||
cutils,verbose,systems,
|
||
defutil,jvmdef,
|
||
aasmcpu,
|
||
hlcgobj;
|
||
|
||
|
||
procedure TJVMParaManager.GetIntParaLoc(calloption : tproccalloption; nr : longint; def : tdef; var cgpara : tcgpara);
|
||
begin
|
||
{ not yet implemented/used }
|
||
internalerror(2010121001);
|
||
end;
|
||
|
||
function TJVMParaManager.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 }
|
||
if not is_open_array(def) then
|
||
result:=inherited
|
||
else
|
||
result:=false;
|
||
end;
|
||
|
||
|
||
{ 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;
|
||
begin
|
||
result:=
|
||
jvmimplicitpointertype(def) or
|
||
((def.typ=formaldef) and
|
||
not(varspez in [vs_var,vs_out]));
|
||
end;
|
||
|
||
|
||
function TJVMParaManager.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 }
|
||
result:=
|
||
(varspez in [vs_var,vs_out,vs_constref]) and
|
||
not jvmimplicitpointertype(def);
|
||
end;
|
||
|
||
|
||
function TJVMParaManager.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
|
||
result:=4
|
||
else
|
||
result:=inherited;
|
||
end;
|
||
|
||
|
||
procedure TJVMParaManager.create_funcretloc_info(p : tabstractprocdef; side: tcallercallee);
|
||
begin
|
||
p.funcretloc[side]:=get_funcretloc(p,side,p.returndef);
|
||
end;
|
||
|
||
|
||
function TJVMParaManager.get_funcretloc(p : tabstractprocdef; side: tcallercallee; def: tdef): tcgpara;
|
||
var
|
||
paraloc : pcgparalocation;
|
||
retcgsize : tcgsize;
|
||
begin
|
||
def:=get_para_push_size(def);
|
||
result.init;
|
||
result.alignment:=get_para_align(p.proccalloption);
|
||
result.def:=def;
|
||
{ void has no location }
|
||
if is_void(def) then
|
||
begin
|
||
paraloc:=result.add_location;
|
||
result.size:=OS_NO;
|
||
result.intsize:=0;
|
||
paraloc^.size:=OS_NO;
|
||
paraloc^.loc:=LOC_VOID;
|
||
exit;
|
||
end;
|
||
{ Constructors return self instead of a boolean }
|
||
if (p.proctypeoption=potype_constructor) then
|
||
begin
|
||
retcgsize:=OS_INT;
|
||
result.intsize:=sizeof(pint);
|
||
end
|
||
else
|
||
begin
|
||
retcgsize:=def_cgsize(def);
|
||
result.intsize:=def.size;
|
||
end;
|
||
result.size:=retcgsize;
|
||
|
||
paraloc:=result.add_location;
|
||
{ all values are returned on the evaluation stack }
|
||
paraloc^.loc:=LOC_REFERENCE;
|
||
paraloc^.reference.index:=NR_EVAL_STACK_BASE;
|
||
paraloc^.reference.offset:=0;
|
||
end;
|
||
|
||
function TJVMParaManager.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; calloption: tproccalloption): boolean;
|
||
begin
|
||
{ not as efficient as returning in param for jvmimplicitpointertypes,
|
||
but in the latter case the routines are harder to use from Java
|
||
(especially for arrays), because the caller then manually has to
|
||
allocate the instance/array of the right size }
|
||
Result:=false;
|
||
end;
|
||
|
||
function TJVMParaManager.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;
|
||
var
|
||
parasize : longint;
|
||
begin
|
||
parasize:=0;
|
||
{ calculate the registers for the normal parameters }
|
||
create_paraloc_info_intern(p,callerside,p.paras,parasize);
|
||
{ append the varargs }
|
||
create_paraloc_info_intern(p,callerside,varargspara,parasize);
|
||
result:=parasize;
|
||
end;
|
||
|
||
|
||
procedure TJVMParaManager.create_paraloc_info_intern(p : tabstractprocdef; side: tcallercallee;paras:tparalist;
|
||
var parasize:longint);
|
||
var
|
||
paraloc : pcgparalocation;
|
||
i : integer;
|
||
hp : tparavarsym;
|
||
paracgsize : tcgsize;
|
||
paraofs : longint;
|
||
paradef : tdef;
|
||
begin
|
||
paraofs:=0;
|
||
for i:=0 to paras.count-1 do
|
||
begin
|
||
hp:=tparavarsym(paras[i]);
|
||
if push_copyout_param(hp.varspez,hp.vardef,p.proccalloption) then
|
||
begin
|
||
{ passed via array reference (instead of creating a new array
|
||
type for every single parameter, use java_jlobject) }
|
||
paracgsize:=OS_ADDR;
|
||
paradef:=java_jlobject;
|
||
end
|
||
else
|
||
begin
|
||
paracgsize:=def_cgsize(hp.vardef);
|
||
if paracgsize=OS_NO then
|
||
paracgsize:=OS_ADDR;
|
||
paradef:=hp.vardef;
|
||
end;
|
||
paradef:=get_para_push_size(paradef);
|
||
hp.paraloc[side].reset;
|
||
hp.paraloc[side].size:=paracgsize;
|
||
hp.paraloc[side].def:=paradef;
|
||
hp.paraloc[side].alignment:=std_param_align;
|
||
hp.paraloc[side].intsize:=tcgsize2size[paracgsize];
|
||
paraloc:=hp.paraloc[side].add_location;
|
||
{ All parameters are passed on the evaluation stack, pushed from
|
||
left to right (including self, if applicable). At the callee side,
|
||
they're available as local variables 0..n-1 (with 64 bit values
|
||
taking up two slots) }
|
||
paraloc^.loc:=LOC_REFERENCE;;
|
||
paraloc^.reference.offset:=paraofs;
|
||
case side of
|
||
callerside:
|
||
begin
|
||
paraloc^.loc:=LOC_REFERENCE;
|
||
{ we use a fake loc_reference to indicate the stack location;
|
||
the offset (set above) will be used by ncal to order the
|
||
parameters so they will be pushed in the right order }
|
||
paraloc^.reference.index:=NR_EVAL_STACK_BASE;
|
||
end;
|
||
calleeside:
|
||
begin
|
||
paraloc^.loc:=LOC_REFERENCE;
|
||
paraloc^.reference.index:=NR_STACK_POINTER_REG;
|
||
end;
|
||
end;
|
||
{ 2 slots for 64 bit integers and floats, 1 slot for the rest }
|
||
if not(is_64bit(paradef) or
|
||
((paradef.typ=floatdef) and
|
||
(tfloatdef(paradef).floattype=s64real))) then
|
||
inc(paraofs)
|
||
else
|
||
inc(paraofs,2);
|
||
end;
|
||
parasize:=paraofs;
|
||
end;
|
||
|
||
|
||
function TJVMParaManager.create_paraloc_info(p : tabstractprocdef; side: tcallercallee):longint;
|
||
var
|
||
parasize : longint;
|
||
begin
|
||
parasize:=0;
|
||
create_paraloc_info_intern(p,side,p.paras,parasize);
|
||
{ Create Function result paraloc }
|
||
create_funcretloc_info(p,side);
|
||
{ We need to return the size allocated on the stack }
|
||
result:=parasize;
|
||
end;
|
||
|
||
|
||
begin
|
||
ParaManager:=TJVMParaManager.create;
|
||
end.
|