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

+ jvm parameter manager: on the caller side, all arguments are pushed

Browse Source 
on the evaluation stack, while on the callee side they are placed
    in local variables 1..n
   o the jvm only supports call-by-value. call-by-reference parameters
     will have to be emulated at a higher level
   o similarly, ret_in_param() always returns false
   o all function results are returned on the evaluation stack (both
     on the caller and callee side)

git-svn-id: branches/jvmbackend@18306 -
This commit is contained in:
Jonas Maebe 2011-08-20 07:37:12 +00:00
parent 05b919b821
commit 72fc911dcf
2 changed files with 203 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
.gitattributes vendored
View File

@ -210,6 +210,7 @@ compiler/jvm/aasmcpu.pas svneol=native#text/plain
compiler/jvm/cgcpu.pas svneol=native#text/plain
compiler/jvm/cpubase.pas svneol=native#text/plain
compiler/jvm/cpuinfo.pas svneol=native#text/plain
compiler/jvm/cpupara.pas svneol=native#text/plain
compiler/jvm/jvmreg.dat svneol=native#text/plain
compiler/jvm/rjvmcon.inc svneol=native#text/plain
compiler/jvm/rjvmnor.inc svneol=native#text/plain

202
compiler/jvm/cpupara.pas Normal file
View File

@ -0,0 +1,202 @@
{
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_addr_param(varspez:tvarspez;def : tdef;calloption : tproccalloption) : boolean;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;var cgpara : TCGPara);override;
function create_paraloc_info(p : TAbstractProcDef; side: tcallercallee):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;
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,
cgobj;
procedure TJVMParaManager.GetIntParaLoc(calloption : tproccalloption; nr : longint;var cgpara : tcgpara);
begin
{ don't know whether it's an actual integer or a pointer (necessary for cgpara.def) }
internalerror(2010121001);
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
{ call by reference does not exist in Java bytecode }
result:=false;
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
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
Result:=false;
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;
begin
paraofs:=0;
for i:=0 to paras.count-1 do
begin
hp:=tparavarsym(paras[i]);
paracgsize:=def_cgsize(hp.vardef);
if paracgsize=OS_NO then
paracgsize:=OS_ADDR;
hp.paraloc[side].reset;
hp.paraloc[side].size:=paracgsize;
hp.paraloc[side].def:=hp.vardef;
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(hp.vardef) or
((hp.vardef.typ=floatdef) and
(tfloatdef(hp.vardef).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.