paweld/fpc
1
0
Fork 0
mirror of https://gitlab.com/freepascal.org/fpc/source.git synced 2025-10-30 17:51:32 +01:00
Code Issues Packages Projects Releases Wiki Activity

+ started cpupara for aarch64

Browse Source 
git-svn-id: trunk@23029 -
This commit is contained in:
florian 2012-11-18 20:42:11 +00:00
parent 5640b654c9
commit 2aaa7514f4
2 changed files with 706 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
.gitattributes vendored
View File

@ -19,6 +19,7 @@ compiler/aarch64/aoptcpub.pas svneol=native#text/plain
compiler/aarch64/aoptcpud.pas svneol=native#text/plain compiler/aarch64/aoptcpud.pas svneol=native#text/plain
compiler/aarch64/cpubase.pas svneol=native#text/plain compiler/aarch64/cpubase.pas svneol=native#text/plain
compiler/aarch64/cpuinfo.pas svneol=native#text/plain compiler/aarch64/cpuinfo.pas svneol=native#text/plain
compiler/aarch64/cpupara.pas svneol=native#text/plain
compiler/aarch64/itcpugas.pas svneol=native#text/plain compiler/aarch64/itcpugas.pas svneol=native#text/plain
compiler/aarch64/ra64con.inc svneol=native#text/plain compiler/aarch64/ra64con.inc svneol=native#text/plain
compiler/aarch64/ra64dwa.inc svneol=native#text/plain compiler/aarch64/ra64dwa.inc svneol=native#text/plain

705
compiler/aarch64/cpupara.pas Normal file
View File

@ -0,0 +1,705 @@
{
Copyright (c) 2003-2012 by Florian Klaempfl and others
AArch64 specific calling conventions
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.
****************************************************************************
}
{ AArch64 specific calling conventions are handled by this unit
}
unit cpupara;
{$i fpcdefs.inc}
interface
uses
globtype,globals,
aasmtai,aasmdata,
cpuinfo,cpubase,cgbase,cgutils,
symconst,symbase,symtype,symdef,parabase,paramgr;
type
taarch64paramanager = 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;
function push_addr_param(varspez:tvarspez;def : tdef;calloption : tproccalloption) : boolean;override;
function ret_in_param(def : tdef;calloption : tproccalloption) : boolean;override;
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; forcetempdef: tdef): tcgpara;override;
private
procedure init_values(var curintreg, curfloatreg, curmmreg: tsuperregister; var cur_stack_offset: aword; var sparesinglereg: tregister);
function 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;
end;
implementation
uses
verbose,systems,cutils,
rgobj,
defutil,symsym,symtable;
function taarch64paramanager.get_volatile_registers_int(calloption : tproccalloption):tcpuregisterset;
begin
result:=VOLATILE_INTREGISTERS
end;
function taarch64paramanager.get_volatile_registers_fpu(calloption : tproccalloption):tcpuregisterset;
begin
result:=[];
end;
function taarch64paramanager.get_volatile_registers_mm(calloption: tproccalloption): tcpuregisterset;
begin
result:=VOLATILE_MMREGISTERS;
end;
procedure taarch64paramanager.getintparaloc(calloption : tproccalloption; nr : longint; def : tdef; var cgpara : tcgpara);
var
paraloc : pcgparalocation;
begin
if nr<1 then
internalerror(2002070801);
cgpara.reset;
cgpara.size:=def_cgsize(def);
cgpara.intsize:=tcgsize2size[cgpara.size];
cgpara.alignment:=std_param_align;
cgpara.def:=def;
paraloc:=cgpara.add_location;
with paraloc^ do
begin
size:=OS_INT;
{ the four first parameters are passed into registers }
if nr<=8 then
begin
loc:=LOC_REGISTER;
register:=newreg(R_INTREGISTER,RS_X0+nr-1,R_SUBWHOLE);
end
else
begin
{ the other parameters are passed on the stack }
loc:=LOC_REFERENCE;
reference.index:=NR_STACK_POINTER_REG;
reference.offset:=(nr-9)*8;
end;
end;
end;
function Is_HFA(p : tdef) : boolean;
begin
result:=false;
end;
function getparaloc(calloption : tproccalloption; p : tdef; isvariadic: boolean) : tcgloc;
begin
{ Later, the LOC_REFERENCE is in most cases changed into LOC_REGISTER
if push_addr_param for the def is true
}
case p.typ of
orddef:
getparaloc:=LOC_REGISTER;
floatdef:
getparaloc:=LOC_MMREGISTER
enumdef:
getparaloc:=LOC_REGISTER;
pointerdef:
getparaloc:=LOC_REGISTER;
formaldef:
getparaloc:=LOC_REGISTER;
classrefdef:
getparaloc:=LOC_REGISTER;
recorddef:
getparaloc:=LOC_REGISTER;
objectdef:
getparaloc:=LOC_REGISTER;
stringdef:
if is_shortstring(p) or is_longstring(p) then
getparaloc:=LOC_REFERENCE
else
getparaloc:=LOC_REGISTER;
procvardef:
getparaloc:=LOC_REGISTER;
filedef:
getparaloc:=LOC_REGISTER;
arraydef:
getparaloc:=LOC_REFERENCE;
setdef:
if is_smallset(p) then
getparaloc:=LOC_REGISTER
else
getparaloc:=LOC_REFERENCE;
variantdef:
getparaloc:=LOC_REGISTER;
{ avoid problems with errornous definitions }
errordef:
getparaloc:=LOC_REGISTER;
else
internalerror(2002071001);
end;
end;
function taarch64paramanager.push_addr_param(varspez:tvarspez;def : tdef;calloption : tproccalloption) : boolean;
begin
result:=false;
if varspez in [vs_var,vs_out,vs_constref] then
begin
result:=true;
exit;
end;
case def.typ of
objectdef:
result:=not(Is_HFA(def) and (is_object(def) and ((varspez=vs_const) or (def.size=0));
recorddef:
{ note: should this ever be changed, make sure that const records
are always passed by reference for calloption=pocall_mwpascal }
result:=(varspez=vs_const) or (def.size=0);
variantdef,
formaldef:
result:=true;
arraydef:
result:=(tarraydef(def).highrange>=tarraydef(def).lowrange) or
is_open_array(def) or
is_array_of_const(def) or
is_array_constructor(def);
setdef :
result:=def.size>16;
stringdef :
result:=tstringdef(def).stringtype in [st_shortstring,st_longstring];
end;
end;
function taarch64paramanager.ret_in_param(def : tdef;calloption : tproccalloption) : boolean;
var
i: longint;
sym: tsym;
fpufield: boolean;
begin
case def.typ of
recorddef:
begin
result:=def.size>4;
if not result and
(target_info.abi in [abi_default,abi_armeb]) then
begin
{ in case of the old ARM abi (APCS), a struct is returned in
a register only if it is simple. And what is a (non-)simple
struct:
"A non-simple type is any non-floating-point type of size
greater than one word (including structures containing only
floating-point fields), and certain single-word structured
types."
(-- ARM APCS documentation)
So only floating point types or more than one word ->
definitely non-simple (more than one word is already
checked above). This includes unions/variant records with
overlaid floating point and integer fields.
Smaller than one word struct types are simple if they are
"integer-like", and:
"A structure is termed integer-like if its size is less than
or equal to one word, and the offset of each of its
addressable subfields is zero."
(-- ARM APCS documentation)
An "addressable subfield" is a field of which you can take
the address, which in practive means any non-bitfield.
In Pascal, there is no way to express the difference that
you can have in C between "char" and "int :8". In this
context, we use the fake distinction that a type defined
inside the record itself (such as "a: 0..255;") indicates
a bitpacked field while a field using a different type
(such as "a: byte;") is not.
}
for i:=0 to trecorddef(def).symtable.SymList.count-1 do
begin
sym:=tsym(trecorddef(def).symtable.SymList[i]);
if sym.typ<>fieldvarsym then
continue;
{ bitfield -> ignore }
if (trecordsymtable(trecorddef(def).symtable).usefieldalignment=bit_alignment) and
(tfieldvarsym(sym).vardef.typ in [orddef,enumdef]) and
(tfieldvarsym(sym).vardef.owner.defowner=def) then
continue;
{ all other fields must be at offset zero }
if tfieldvarsym(sym).fieldoffset<>0 then
begin
result:=true;
exit;
end;
{ floating point field -> also by reference }
if tfieldvarsym(sym).vardef.typ=floatdef then
begin
result:=true;
exit;
end;
end;
end;
end;
procvardef:
if not tprocvardef(def).is_addressonly then
result:=true
else
result:=false
else
result:=inherited ret_in_param(def,calloption);
end;
end;
procedure taarch64paramanager.init_values(var curintreg, curfloatreg, curmmreg: tsuperregister; var cur_stack_offset: aword; var sparesinglereg: tregister);
begin
curintreg:=RS_R0;
curfloatreg:=RS_F0;
curmmreg:=RS_D0;
cur_stack_offset:=0;
sparesinglereg := NR_NO;
end;
function taarch64paramanager.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
nextintreg,nextfloatreg,nextmmreg : tsuperregister;
paradef : tdef;
paraloc : pcgparalocation;
stack_offset : aword;
hp : tparavarsym;
loc : tcgloc;
paracgsize : tcgsize;
paralen : longint;
i : integer;
firstparaloc: boolean;
procedure assignintreg;
begin
{ In case of po_delphi_nested_cc, the parent frame pointer
is always passed on the stack. }
if (nextintreg<=RS_R3) and
(not(vo_is_parentfp in hp.varoptions) or
not(po_delphi_nested_cc in p.procoptions)) then
begin
paraloc^.loc:=LOC_REGISTER;
paraloc^.register:=newreg(R_INTREGISTER,nextintreg,R_SUBWHOLE);
inc(nextintreg);
end
else
begin
paraloc^.loc:=LOC_REFERENCE;
paraloc^.reference.index:=NR_STACK_POINTER_REG;
paraloc^.reference.offset:=stack_offset;
inc(stack_offset,4);
end;
end;
begin
result:=0;
nextintreg:=curintreg;
nextfloatreg:=curfloatreg;
nextmmreg:=curmmreg;
stack_offset:=cur_stack_offset;
for i:=0 to paras.count-1 do
begin
hp:=tparavarsym(paras[i]);
paradef:=hp.vardef;
hp.paraloc[side].reset;
{ currently only support C-style array of const,
there should be no location assigned to the vararg array itself }
if (p.proccalloption in cstylearrayofconst) and
is_array_of_const(paradef) then
begin
paraloc:=hp.paraloc[side].add_location;
{ hack: the paraloc must be valid, but is not actually used }
paraloc^.loc:=LOC_REGISTER;
paraloc^.register:=NR_R0;
paraloc^.size:=OS_ADDR;
break;
end;
if push_addr_param(hp.varspez,paradef,p.proccalloption) then
begin
paradef:=getpointerdef(paradef);
loc:=LOC_REGISTER;
paracgsize := OS_ADDR;
paralen := tcgsize2size[OS_ADDR];
end
else
begin
if not is_special_array(paradef) then
paralen := paradef.size
else
paralen := tcgsize2size[def_cgsize(paradef)];
loc := getparaloc(p.proccalloption,paradef,isvariadic);
if (paradef.typ in [objectdef,arraydef,recorddef]) and
not is_special_array(paradef) and
(hp.varspez in [vs_value,vs_const]) then
paracgsize := int_cgsize(paralen)
else
begin
paracgsize:=def_cgsize(paradef);
{ for things like formaldef }
if (paracgsize=OS_NO) then
begin
paracgsize:=OS_ADDR;
paralen:=tcgsize2size[OS_ADDR];
paradef:=voidpointertype;
end;
end
end;
hp.paraloc[side].size:=paracgsize;
hp.paraloc[side].Alignment:=std_param_align;
hp.paraloc[side].intsize:=paralen;
hp.paraloc[side].def:=paradef;
firstparaloc:=true;
{$ifdef EXTDEBUG}
if paralen=0 then
internalerror(200410311);
{$endif EXTDEBUG}
while paralen>0 do
begin
paraloc:=hp.paraloc[side].add_location;
if (loc=LOC_REGISTER) and (paracgsize in [OS_F32,OS_F64,OS_F80]) then
case paracgsize of
OS_F32:
paraloc^.size:=OS_32;
OS_F64:
paraloc^.size:=OS_32;
else
internalerror(2005082901);
end
else if (paracgsize in [OS_NO,OS_64,OS_S64]) then
paraloc^.size := OS_32
else
paraloc^.size:=paracgsize;
case loc of
LOC_REGISTER:
begin
{ align registers for eabi }
if (target_info.abi in [abi_eabi,abi_eabihf]) and
firstparaloc and
(paradef.alignment=8) then
begin
if (nextintreg in [RS_R1,RS_R3]) then
inc(nextintreg)
else if nextintreg>RS_R3 then
stack_offset:=align(stack_offset,8);
end;
{ this is not abi compliant
why? (FK) }
if nextintreg<=RS_R3 then
begin
paraloc^.loc:=LOC_REGISTER;
paraloc^.register:=newreg(R_INTREGISTER,nextintreg,R_SUBWHOLE);
inc(nextintreg);
end
else
begin
{ LOC_REFERENCE always contains everything that's left }
paraloc^.loc:=LOC_REFERENCE;
paraloc^.size:=int_cgsize(paralen);
if (side=callerside) then
paraloc^.reference.index:=NR_STACK_POINTER_REG;
paraloc^.reference.offset:=stack_offset;
inc(stack_offset,align(paralen,4));
paralen:=0;
end;
end;
LOC_FPUREGISTER:
begin
if nextfloatreg<=RS_F3 then
begin
paraloc^.loc:=LOC_FPUREGISTER;
paraloc^.register:=newreg(R_FPUREGISTER,nextfloatreg,R_SUBWHOLE);
inc(nextfloatreg);
end
else
begin
paraloc^.loc:=LOC_REFERENCE;
paraloc^.reference.index:=NR_STACK_POINTER_REG;
paraloc^.reference.offset:=stack_offset;
case paraloc^.size of
OS_F32:
inc(stack_offset,4);
OS_F64:
inc(stack_offset,8);
OS_F80:
inc(stack_offset,10);
OS_F128:
inc(stack_offset,16);
else
internalerror(200403201);
end;
end;
end;
LOC_MMREGISTER:
begin
if (nextmmreg<=RS_D7) or
((paraloc^.size = OS_F32) and
(sparesinglereg<>NR_NO)) then
begin
paraloc^.loc:=LOC_MMREGISTER;
case paraloc^.size of
OS_F32:
if sparesinglereg = NR_NO then
begin
paraloc^.register:=newreg(R_MMREGISTER,nextmmreg,R_SUBFS);
sparesinglereg:=newreg(R_MMREGISTER,nextmmreg-RS_S0+RS_S1,R_SUBFS);
inc(nextmmreg);
end
else
begin
paraloc^.register:=sparesinglereg;
sparesinglereg := NR_NO;
end;
OS_F64:
begin
paraloc^.register:=newreg(R_MMREGISTER,nextmmreg,R_SUBFD);
inc(nextmmreg);
end;
else
internalerror(2012031601);
end;
end
else
begin
{ once a floating point parameters has been placed
on the stack we must not pass any more in vfp regs
even if there is a single precision register still
free}
sparesinglereg := NR_NO;
{ LOC_REFERENCE always contains everything that's left }
paraloc^.loc:=LOC_REFERENCE;
paraloc^.size:=int_cgsize(paralen);
if (side=callerside) then
paraloc^.reference.index:=NR_STACK_POINTER_REG;
paraloc^.reference.offset:=stack_offset;
inc(stack_offset,align(paralen,4));
paralen:=0;
end;
end;
LOC_REFERENCE:
begin
if push_addr_param(hp.varspez,paradef,p.proccalloption) then
begin
paraloc^.size:=OS_ADDR;
assignintreg
end
else
begin
{ align stack for eabi }
if (target_info.abi in [abi_eabi,abi_eabihf]) and
firstparaloc and
(paradef.alignment=8) then
stack_offset:=align(stack_offset,8);
paraloc^.size:=paracgsize;
paraloc^.loc:=LOC_REFERENCE;
paraloc^.reference.index:=NR_STACK_POINTER_REG;
paraloc^.reference.offset:=stack_offset;
inc(stack_offset,align(paralen,4));
paralen:=0
end;
end;
else
internalerror(2002071002);
end;
if side=calleeside then
begin
if paraloc^.loc=LOC_REFERENCE then
begin
paraloc^.reference.index:=NR_FRAME_POINTER_REG;
{ on non-Darwin, the framepointer contains the value
of the stack pointer on entry. On Darwin, the
framepointer points to the previously saved
framepointer (which is followed only by the saved
return address -> framepointer + 4 = stack pointer
on entry }
if not(target_info.system in systems_darwin) then
inc(paraloc^.reference.offset,4)
else
inc(paraloc^.reference.offset,8);
end;
end;
dec(paralen,tcgsize2size[paraloc^.size]);
firstparaloc:=false
end;
end;
curintreg:=nextintreg;
curfloatreg:=nextfloatreg;
curmmreg:=nextmmreg;
cur_stack_offset:=stack_offset;
result:=cur_stack_offset;
end;
function taarch64paramanager.get_funcretloc(p : tabstractprocdef; side: tcallercallee; forcetempdef: tdef): tcgpara;
var
paraloc : pcgparalocation;
retcgsize : tcgsize;
begin
if set_common_funcretloc_info(p,forcetempdef,retcgsize,result) then
exit;
paraloc:=result.add_location;
{ Return in FPU register? }
if result.def.typ=floatdef then
begin
if target_info.abi = abi_eabihf then
begin
paraloc^.loc:=LOC_MMREGISTER;
case retcgsize of
OS_64,
OS_F64:
begin
paraloc^.register:=NR_MM_RESULT_REG;
end;
OS_32,
OS_F32:
begin
paraloc^.register:=NR_S0;
end;
else
internalerror(2012032501);
end;
paraloc^.size:=retcgsize;
end
else if (p.proccalloption in [pocall_softfloat]) or
(cs_fp_emulation in current_settings.moduleswitches) or
(current_settings.fputype in [fpu_vfpv2,fpu_vfpv3,fpu_vfpv3_d16,fpu_fpv4_s16]) then
begin
case retcgsize of
OS_64,
OS_F64:
begin
paraloc^.loc:=LOC_REGISTER;
if target_info.endian = endian_big then
paraloc^.register:=NR_FUNCTION_RESULT64_HIGH_REG
else
paraloc^.register:=NR_FUNCTION_RESULT64_LOW_REG;
paraloc^.size:=OS_32;
paraloc:=result.add_location;
paraloc^.loc:=LOC_REGISTER;
if target_info.endian = endian_big then
paraloc^.register:=NR_FUNCTION_RESULT64_LOW_REG
else
paraloc^.register:=NR_FUNCTION_RESULT64_HIGH_REG;
paraloc^.size:=OS_32;
end;
OS_32,
OS_F32:
begin
paraloc^.loc:=LOC_REGISTER;
paraloc^.register:=NR_FUNCTION_RETURN_REG;
paraloc^.size:=OS_32;
end;
else
internalerror(2005082603);
end;
end
else
begin
paraloc^.loc:=LOC_FPUREGISTER;
paraloc^.register:=NR_FPU_RESULT_REG;
paraloc^.size:=retcgsize;
end;
end
{ Return in register }
else
begin
if retcgsize in [OS_64,OS_S64] then
begin
paraloc^.loc:=LOC_REGISTER;
if target_info.endian = endian_big then
paraloc^.register:=NR_FUNCTION_RESULT64_HIGH_REG
else
paraloc^.register:=NR_FUNCTION_RESULT64_LOW_REG;
paraloc^.size:=OS_32;
paraloc:=result.add_location;
paraloc^.loc:=LOC_REGISTER;
if target_info.endian = endian_big then
paraloc^.register:=NR_FUNCTION_RESULT64_LOW_REG
else
paraloc^.register:=NR_FUNCTION_RESULT64_HIGH_REG;
paraloc^.size:=OS_32;
end
else
begin
paraloc^.loc:=LOC_REGISTER;
paraloc^.register:=NR_FUNCTION_RETURN_REG;
if (result.intsize<>3) then
paraloc^.size:=retcgsize
else
paraloc^.size:=OS_32;
end;
end;
end;
function taarch64paramanager.create_paraloc_info(p : tabstractprocdef; side: tcallercallee):longint;
var
cur_stack_offset: aword;
curintreg, curfloatreg, curmmreg: tsuperregister;
sparesinglereg:tregister;
begin
init_values(curintreg,curfloatreg,curmmreg,cur_stack_offset,sparesinglereg);
result:=create_paraloc_info_intern(p,side,p.paras,curintreg,curfloatreg,curmmreg,cur_stack_offset,sparesinglereg,false);
create_funcretloc_info(p,side);
end;
function taarch64paramanager.create_varargs_paraloc_info(p : tabstractprocdef; varargspara:tvarargsparalist):longint;
var
cur_stack_offset: aword;
curintreg, curfloatreg, curmmreg: tsuperregister;
sparesinglereg:tregister;
begin
init_values(curintreg,curfloatreg,curmmreg,cur_stack_offset,sparesinglereg);
result:=create_paraloc_info_intern(p,callerside,p.paras,curintreg,curfloatreg,curmmreg,cur_stack_offset,sparesinglereg,true);
if (p.proccalloption in cstylearrayofconst) then
{ just continue loading the parameters in the registers }
result:=create_paraloc_info_intern(p,callerside,varargspara,curintreg,curfloatreg,curmmreg,cur_stack_offset,sparesinglereg,true)
else
internalerror(200410231);
end;
begin
paramanager:=taarch64paramanager.create;
end.