mirror of
https://gitlab.com/freepascal.org/fpc/source.git
synced 2025-04-07 06:28:55 +02:00
765 lines
29 KiB
ObjectPascal
765 lines
29 KiB
ObjectPascal
{
|
|
Copyright (c) 2002 by Florian Klaempfl
|
|
|
|
PowerPC 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.
|
|
****************************************************************************
|
|
}
|
|
unit cpupara;
|
|
|
|
{$i fpcdefs.inc}
|
|
|
|
interface
|
|
|
|
uses
|
|
globtype,
|
|
aasmtai,aasmdata,
|
|
cpubase,
|
|
symconst,symtype,symdef,symsym,
|
|
paramgr,parabase,cgbase,cgutils;
|
|
|
|
type
|
|
tcpuparamanager = class(tparamanager)
|
|
function get_volatile_registers_int(calloption : tproccalloption):tcpuregisterset;override;
|
|
function get_volatile_registers_fpu(calloption : tproccalloption):tcpuregisterset;override;
|
|
function get_saved_registers_int(calloption : tproccalloption):tcpuregisterarray;override;
|
|
function push_addr_param(varspez:tvarspez;def : tdef;calloption : tproccalloption) : boolean;override;
|
|
|
|
procedure getcgtempparaloc(list: TAsmList; pd : tabstractprocdef; nr : longint; var cgpara : tcgpara);override;
|
|
function create_paraloc_info(p : tabstractprocdef; side: tcallercallee):longint;override;
|
|
function create_varargs_paraloc_info(p : tabstractprocdef; side: tcallercallee; 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);
|
|
function create_paraloc_info_intern(p : tabstractprocdef; side: tcallercallee; paras:tparalist;
|
|
var curintreg, curfloatreg, curmmreg: tsuperregister; var cur_stack_offset: aword; varargsparas: boolean):longint;
|
|
function parseparaloc(p : tparavarsym;const s : string) : boolean;override;
|
|
end;
|
|
|
|
implementation
|
|
|
|
uses
|
|
verbose,systems,
|
|
defutil,symtable,
|
|
procinfo,cpupi;
|
|
|
|
|
|
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]
|
|
else
|
|
result := [RS_R0,RS_R3..RS_R12];
|
|
end;
|
|
|
|
|
|
function tcpuparamanager.get_volatile_registers_fpu(calloption : tproccalloption):tcpuregisterset;
|
|
begin
|
|
case target_info.abi of
|
|
abi_powerpc_aix,
|
|
abi_powerpc_darwin,
|
|
abi_powerpc_sysv:
|
|
result := [RS_F0..RS_F13];
|
|
else
|
|
internalerror(2003091401);
|
|
end;
|
|
end;
|
|
|
|
|
|
function tcpuparamanager.get_saved_registers_int(calloption : tproccalloption):tcpuregisterarray;
|
|
const
|
|
saved_regs : tcpuregisterarray = (
|
|
RS_R13,RS_R14,RS_R15,RS_R16,RS_R17,RS_R18,RS_R19,
|
|
RS_R20,RS_R21,RS_R22,RS_R23,RS_R24,RS_R25,RS_R26,RS_R27,RS_R28,RS_R29,
|
|
RS_R30,RS_R31
|
|
);
|
|
begin
|
|
result:=saved_regs;
|
|
end;
|
|
|
|
|
|
procedure tcpuparamanager.getcgtempparaloc(list: TAsmList; pd : tabstractprocdef; nr : longint; var cgpara : tcgpara);
|
|
var
|
|
paraloc : pcgparalocation;
|
|
psym : tparavarsym;
|
|
pdef : tdef;
|
|
begin
|
|
psym:=tparavarsym(pd.paras[nr-1]);
|
|
pdef:=psym.vardef;
|
|
if push_addr_param(psym.varspez,pdef,pd.proccalloption) then
|
|
pdef:=cpointerdef.getreusable_no_free(pdef);
|
|
cgpara.reset;
|
|
cgpara.size:=def_cgsize(pdef);
|
|
cgpara.intsize:=tcgsize2size[cgpara.size];
|
|
cgpara.alignment:=get_para_align(pd.proccalloption);
|
|
cgpara.def:=pdef;
|
|
paraloc:=cgpara.add_location;
|
|
with paraloc^ do
|
|
begin
|
|
size:=def_cgsize(pdef);
|
|
def:=pdef;
|
|
if (nr<=8) then
|
|
begin
|
|
if nr=0 then
|
|
internalerror(200309271);
|
|
loc:=LOC_REGISTER;
|
|
register:=newreg(R_INTREGISTER,RS_R2+nr,R_SUBWHOLE);
|
|
end
|
|
else
|
|
begin
|
|
loc:=LOC_REFERENCE;
|
|
paraloc^.reference.index:=NR_STACK_POINTER_REG;
|
|
if not(target_info.abi in [abi_powerpc_aix,abi_powerpc_darwin]) then
|
|
reference.offset:=sizeof(pint)*(nr-8)
|
|
else
|
|
reference.offset:=sizeof(pint)*(nr);
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
|
|
|
|
function getparaloc(p : tdef) : 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:
|
|
result:=LOC_REGISTER;
|
|
floatdef:
|
|
result:=LOC_FPUREGISTER;
|
|
enumdef:
|
|
result:=LOC_REGISTER;
|
|
pointerdef:
|
|
result:=LOC_REGISTER;
|
|
formaldef:
|
|
result:=LOC_REGISTER;
|
|
classrefdef:
|
|
result:=LOC_REGISTER;
|
|
procvardef:
|
|
if (target_info.abi in [abi_powerpc_aix,abi_powerpc_darwin]) or
|
|
(p.size = sizeof(pint)) then
|
|
result:=LOC_REGISTER
|
|
else
|
|
result:=LOC_REFERENCE;
|
|
recorddef:
|
|
if not(target_info.system in systems_aix) and
|
|
(not(target_info.abi in [abi_powerpc_aix,abi_powerpc_darwin]) or
|
|
((p.size >= 3) and
|
|
((p.size mod 4) <> 0))) then
|
|
result:=LOC_REFERENCE
|
|
else
|
|
result:=LOC_REGISTER;
|
|
objectdef:
|
|
if is_object(p) then
|
|
result:=LOC_REFERENCE
|
|
else
|
|
result:=LOC_REGISTER;
|
|
stringdef:
|
|
if is_shortstring(p) or is_longstring(p) then
|
|
result:=LOC_REFERENCE
|
|
else
|
|
result:=LOC_REGISTER;
|
|
filedef:
|
|
result:=LOC_REGISTER;
|
|
arraydef:
|
|
if is_dynamic_array(p) then
|
|
getparaloc:=LOC_REGISTER
|
|
else
|
|
result:=LOC_REFERENCE;
|
|
setdef:
|
|
if is_smallset(p) then
|
|
result:=LOC_REGISTER
|
|
else
|
|
result:=LOC_REFERENCE;
|
|
variantdef:
|
|
result:=LOC_REFERENCE;
|
|
{ avoid problems with errornous definitions }
|
|
errordef:
|
|
result:=LOC_REGISTER;
|
|
else
|
|
internalerror(2002071001);
|
|
end;
|
|
end;
|
|
|
|
|
|
function tcpuparamanager.push_addr_param(varspez:tvarspez;def : tdef;calloption : tproccalloption) : boolean;
|
|
begin
|
|
result:=false;
|
|
{ var,out,constref always require address }
|
|
if varspez in [vs_var,vs_out,vs_constref] then
|
|
begin
|
|
result:=true;
|
|
exit;
|
|
end;
|
|
case def.typ of
|
|
variantdef,
|
|
formaldef :
|
|
result:=true;
|
|
{ regular procvars must be passed by value, because you cannot pass
|
|
the address of a local stack location when calling e.g.
|
|
pthread_create with the address of a function (first of all it
|
|
expects the address of the function to execute and not the address
|
|
of a memory location containing that address, and secondly if you
|
|
first store the address on the stack and then pass the address of
|
|
this stack location, then this stack location may no longer be
|
|
valid when the newly started thread accesses it.
|
|
|
|
However, for "procedure of object" we must use the same calling
|
|
convention as for "8 byte record" due to the need for
|
|
interchangeability with the TMethod record type.
|
|
}
|
|
procvardef :
|
|
result:=
|
|
not(target_info.abi in [abi_powerpc_aix,abi_powerpc_darwin]) and
|
|
(def.size <> sizeof(pint));
|
|
recorddef :
|
|
result :=
|
|
not(target_info.abi in [abi_powerpc_aix,abi_powerpc_darwin]) or
|
|
((varspez = vs_const) and
|
|
((calloption = pocall_mwpascal) or
|
|
(not (calloption in cdecl_pocalls) and
|
|
(def.size > 8)
|
|
)
|
|
)
|
|
);
|
|
arraydef:
|
|
result:=(tarraydef(def).highrange>=tarraydef(def).lowrange) or
|
|
is_open_array(def) or
|
|
is_array_of_const(def) or
|
|
is_array_constructor(def);
|
|
objectdef :
|
|
result:=is_object(def);
|
|
setdef :
|
|
result:=not is_smallset(def);
|
|
stringdef :
|
|
result:=tstringdef(def).stringtype in [st_shortstring,st_longstring];
|
|
else
|
|
;
|
|
end;
|
|
end;
|
|
|
|
|
|
procedure tcpuparamanager.init_values(var curintreg, curfloatreg, curmmreg: tsuperregister; var cur_stack_offset: aword);
|
|
begin
|
|
case target_info.abi of
|
|
abi_powerpc_aix,
|
|
abi_powerpc_darwin:
|
|
cur_stack_offset:=24;
|
|
abi_powerpc_sysv:
|
|
cur_stack_offset:=8;
|
|
else
|
|
internalerror(2003051901);
|
|
end;
|
|
curintreg:=RS_R3;
|
|
curfloatreg:=RS_F1;
|
|
curmmreg:=RS_M1;
|
|
end;
|
|
|
|
|
|
function tcpuparamanager.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
|
|
paraloc^.loc:=LOC_FPUREGISTER;
|
|
paraloc^.register:=NR_FPU_RESULT_REG;
|
|
paraloc^.size:=retcgsize;
|
|
paraloc^.def:=result.def;
|
|
end
|
|
else
|
|
{ Return in register }
|
|
begin
|
|
if retcgsize in [OS_64,OS_S64] then
|
|
begin
|
|
{ low 32bits }
|
|
paraloc^.loc:=LOC_REGISTER;
|
|
if side=callerside then
|
|
paraloc^.register:=NR_FUNCTION_RESULT64_HIGH_REG
|
|
else
|
|
paraloc^.register:=NR_FUNCTION_RETURN64_HIGH_REG;
|
|
paraloc^.size:=OS_32;
|
|
paraloc^.def:=u32inttype;
|
|
{ high 32bits }
|
|
paraloc:=result.add_location;
|
|
paraloc^.loc:=LOC_REGISTER;
|
|
if side=callerside then
|
|
paraloc^.register:=NR_FUNCTION_RESULT64_LOW_REG
|
|
else
|
|
paraloc^.register:=NR_FUNCTION_RETURN64_LOW_REG;
|
|
paraloc^.size:=OS_32;
|
|
paraloc^.def:=u32inttype;
|
|
end
|
|
else
|
|
begin
|
|
paraloc^.loc:=LOC_REGISTER;
|
|
if side=callerside then
|
|
paraloc^.register:=newreg(R_INTREGISTER,RS_FUNCTION_RESULT_REG,cgsize2subreg(R_INTREGISTER,retcgsize))
|
|
else
|
|
paraloc^.register:=newreg(R_INTREGISTER,RS_FUNCTION_RETURN_REG,cgsize2subreg(R_INTREGISTER,retcgsize));
|
|
paraloc^.size:=retcgsize;
|
|
paraloc^.def:=result.def;
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
|
|
function tcpuparamanager.create_paraloc_info(p : tabstractprocdef; side: tcallercallee):longint;
|
|
|
|
var
|
|
cur_stack_offset: aword;
|
|
curintreg, curfloatreg, curmmreg: tsuperregister;
|
|
begin
|
|
init_values(curintreg,curfloatreg,curmmreg,cur_stack_offset);
|
|
|
|
result := create_paraloc_info_intern(p,side,p.paras,curintreg,curfloatreg,curmmreg,cur_stack_offset,false);
|
|
|
|
create_funcretloc_info(p,side);
|
|
end;
|
|
|
|
|
|
|
|
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;
|
|
paralen: aint;
|
|
nextintreg,nextfloatreg,nextmmreg, maxfpureg : tsuperregister;
|
|
locdef,
|
|
fdef,
|
|
paradef : tdef;
|
|
paraloc : pcgparalocation;
|
|
i : integer;
|
|
hp : tparavarsym;
|
|
loc : tcgloc;
|
|
paracgsize: tcgsize;
|
|
firstparaloc: boolean;
|
|
|
|
begin
|
|
{$ifdef extdebug}
|
|
if po_explicitparaloc in p.procoptions then
|
|
internalerror(200411141);
|
|
{$endif extdebug}
|
|
|
|
result:=0;
|
|
nextintreg := curintreg;
|
|
nextfloatreg := curfloatreg;
|
|
nextmmreg := curmmreg;
|
|
stack_offset := cur_stack_offset;
|
|
case target_info.abi of
|
|
abi_powerpc_aix,
|
|
abi_powerpc_darwin:
|
|
maxfpureg := RS_F13;
|
|
abi_powerpc_sysv:
|
|
maxfpureg := RS_F8;
|
|
else internalerror(2004070912);
|
|
end;
|
|
|
|
for i:=0 to paras.count-1 do
|
|
begin
|
|
hp:=tparavarsym(paras[i]);
|
|
paradef := hp.vardef;
|
|
{ Syscall for Morphos can have already a paraloc set }
|
|
if (vo_has_explicit_paraloc in hp.varoptions) then
|
|
continue;
|
|
|
|
hp.paraloc[side].reset;
|
|
{ currently only support C-style array of const }
|
|
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;
|
|
paraloc^.def:=voidpointertype;
|
|
break;
|
|
end;
|
|
|
|
if push_addr_param(hp.varspez,paradef,p.proccalloption) then
|
|
begin
|
|
paradef:=cpointerdef.getreusable_no_free(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)];
|
|
if (target_info.abi in [abi_powerpc_aix,abi_powerpc_darwin]) and
|
|
(paradef.typ = recorddef) and
|
|
(hp.varspez in [vs_value,vs_const]) then
|
|
begin
|
|
{ if a record has only one field and that field is }
|
|
{ non-composite (not array or record), it must be }
|
|
{ passed according to the rules of that type. }
|
|
if tabstractrecordsymtable(tabstractrecorddef(paradef).symtable).has_single_field(fdef) and
|
|
((fdef.typ=floatdef) or
|
|
((target_info.system=system_powerpc_darwin) and
|
|
(fdef.typ in [orddef,enumdef]))) then
|
|
begin
|
|
paradef:=fdef;
|
|
paracgsize:=def_cgsize(paradef);
|
|
end
|
|
else
|
|
begin
|
|
paracgsize := int_cgsize(paralen);
|
|
end;
|
|
end
|
|
else
|
|
begin
|
|
paracgsize:=def_cgsize(paradef);
|
|
{ for things like formaldef }
|
|
if (paracgsize=OS_NO) then
|
|
begin
|
|
paracgsize:=OS_ADDR;
|
|
paralen := tcgsize2size[OS_ADDR];
|
|
end;
|
|
end
|
|
end;
|
|
|
|
loc := getparaloc(paradef);
|
|
if varargsparas and
|
|
(target_info.abi in [abi_powerpc_aix,abi_powerpc_darwin]) and
|
|
(paradef.typ = floatdef) then
|
|
begin
|
|
loc := LOC_REGISTER;
|
|
if paracgsize=OS_F64 then
|
|
begin
|
|
paracgsize:=OS_64;
|
|
paradef:=u64inttype;
|
|
end
|
|
else
|
|
begin
|
|
paracgsize:=OS_32;
|
|
paradef:=u32inttype;
|
|
end;
|
|
end;
|
|
|
|
hp.paraloc[side].alignment:=std_param_align;
|
|
hp.paraloc[side].size:=paracgsize;
|
|
hp.paraloc[side].intsize:=paralen;
|
|
hp.paraloc[side].def:=paradef;
|
|
{$ifndef cpu64bitaddr}
|
|
if (target_info.abi=abi_powerpc_sysv) and
|
|
is_64bit(paradef) and
|
|
odd(nextintreg-RS_R3) then
|
|
inc(nextintreg);
|
|
{$endif not cpu64bitaddr}
|
|
if (paralen = 0) then
|
|
if (paradef.typ = recorddef) then
|
|
begin
|
|
paraloc:=hp.paraloc[side].add_location;
|
|
paraloc^.loc := LOC_VOID;
|
|
end
|
|
else
|
|
internalerror(2005011310);
|
|
locdef:=paradef;
|
|
firstparaloc:=true;
|
|
{ can become < 0 for e.g. 3-byte records }
|
|
while (paralen > 0) do
|
|
begin
|
|
paraloc:=hp.paraloc[side].add_location;
|
|
{ In case of po_delphi_nested_cc, the parent frame pointer
|
|
is always passed on the stack. }
|
|
if (loc = LOC_REGISTER) and
|
|
(nextintreg <= RS_R10) and
|
|
(not(vo_is_parentfp in hp.varoptions) or
|
|
not(po_delphi_nested_cc in p.procoptions)) then
|
|
begin
|
|
paraloc^.loc := loc;
|
|
{ make sure we don't lose whether or not the type is signed }
|
|
if (paradef.typ<>orddef) then
|
|
begin
|
|
paracgsize:=int_cgsize(paralen);
|
|
locdef:=get_paraloc_def(paradef,paralen,firstparaloc);
|
|
end;
|
|
if (paracgsize in [OS_NO,OS_64,OS_S64,OS_128,OS_S128]) then
|
|
begin
|
|
paraloc^.size:=OS_INT;
|
|
paraloc^.def:=u32inttype;
|
|
end
|
|
else
|
|
begin
|
|
paraloc^.size:=paracgsize;
|
|
paraloc^.def:=locdef;
|
|
end;
|
|
{ aix requires that record data stored in parameter
|
|
registers is left-aligned }
|
|
if (target_info.system in systems_aix) and
|
|
(paradef.typ = recorddef) and
|
|
(paralen < sizeof(aint)) then
|
|
begin
|
|
paraloc^.shiftval := (sizeof(aint)-paralen)*(-8);
|
|
paraloc^.size := OS_INT;
|
|
paraloc^.def := u32inttype;
|
|
end;
|
|
paraloc^.register:=newreg(R_INTREGISTER,nextintreg,R_SUBNONE);
|
|
inc(nextintreg);
|
|
dec(paralen,tcgsize2size[paraloc^.size]);
|
|
if target_info.abi in [abi_powerpc_aix,abi_powerpc_darwin] then
|
|
inc(stack_offset,align(tcgsize2size[paraloc^.size],4));
|
|
end
|
|
else if (loc = LOC_FPUREGISTER) and
|
|
(nextfloatreg <= maxfpureg) then
|
|
begin
|
|
paraloc^.loc:=loc;
|
|
paraloc^.size := paracgsize;
|
|
paraloc^.def := paradef;
|
|
paraloc^.register:=newreg(R_FPUREGISTER,nextfloatreg,R_SUBWHOLE);
|
|
inc(nextfloatreg);
|
|
dec(paralen,tcgsize2size[paraloc^.size]);
|
|
{ if nextfpureg > maxfpureg, all intregs are already used, since there }
|
|
{ are less of those available for parameter passing in the AIX abi }
|
|
if target_info.abi in [abi_powerpc_aix,abi_powerpc_darwin] then
|
|
{$ifndef cpu64bitaddr}
|
|
if (paracgsize = OS_F32) then
|
|
begin
|
|
inc(stack_offset,4);
|
|
if (nextintreg < RS_R11) then
|
|
inc(nextintreg);
|
|
end
|
|
else
|
|
begin
|
|
inc(stack_offset,8);
|
|
if (nextintreg < RS_R10) then
|
|
inc(nextintreg,2)
|
|
else
|
|
nextintreg := RS_R11;
|
|
end;
|
|
{$else not cpu64bitaddr}
|
|
begin
|
|
inc(stack_offset,tcgsize2size[paracgsize]);
|
|
if (nextintreg < RS_R11) then
|
|
inc(nextintreg);
|
|
end;
|
|
{$endif not cpu64bitaddr}
|
|
end
|
|
else { LOC_REFERENCE }
|
|
begin
|
|
paraloc^.loc:=LOC_REFERENCE;
|
|
case loc of
|
|
LOC_FPUREGISTER:
|
|
begin
|
|
paraloc^.size:=int_float_cgsize(paralen);
|
|
case paraloc^.size of
|
|
OS_F32: paraloc^.def:=s32floattype;
|
|
OS_F64: paraloc^.def:=s64floattype;
|
|
else
|
|
internalerror(2013060124);
|
|
end;
|
|
end;
|
|
LOC_REGISTER,
|
|
LOC_REFERENCE:
|
|
begin
|
|
paraloc^.size:=int_cgsize(paralen);
|
|
if paraloc^.size<>OS_NO then
|
|
paraloc^.def:=cgsize_orddef(paraloc^.size)
|
|
else
|
|
paraloc^.def:=carraydef.getreusable_no_free(u8inttype,paralen);
|
|
end;
|
|
else
|
|
internalerror(2006011101);
|
|
end;
|
|
if (side = callerside) then
|
|
paraloc^.reference.index:=NR_STACK_POINTER_REG
|
|
else
|
|
begin
|
|
paraloc^.reference.index:=NR_R12;
|
|
|
|
{ create_paraloc_info_intern might be also called when being outside of
|
|
code generation so current_procinfo might be not set }
|
|
if assigned(current_procinfo) then
|
|
tcpuprocinfo(current_procinfo).needs_frame_pointer := true;
|
|
end;
|
|
|
|
if not((target_info.system in systems_aix) and
|
|
(paradef.typ=recorddef)) and
|
|
(target_info.abi in [abi_powerpc_aix,abi_powerpc_darwin]) and
|
|
(hp.paraloc[side].intsize < 3) then
|
|
paraloc^.reference.offset:=stack_offset+(4-paralen)
|
|
else
|
|
paraloc^.reference.offset:=stack_offset;
|
|
|
|
inc(stack_offset,align(paralen,4));
|
|
while (paralen > 0) and
|
|
(nextintreg < RS_R11) do
|
|
begin
|
|
inc(nextintreg);
|
|
dec(paralen,sizeof(pint));
|
|
end;
|
|
paralen := 0;
|
|
end;
|
|
firstparaloc:=false;
|
|
end;
|
|
end;
|
|
curintreg:=nextintreg;
|
|
curfloatreg:=nextfloatreg;
|
|
curmmreg:=nextmmreg;
|
|
cur_stack_offset:=stack_offset;
|
|
result:=stack_offset;
|
|
end;
|
|
|
|
|
|
function tcpuparamanager.create_varargs_paraloc_info(p : tabstractprocdef; side: tcallercallee; varargspara:tvarargsparalist):longint;
|
|
var
|
|
cur_stack_offset: aword;
|
|
curintreg, firstfloatreg, curfloatreg, curmmreg: tsuperregister;
|
|
begin
|
|
init_values(curintreg,curfloatreg,curmmreg,cur_stack_offset);
|
|
firstfloatreg:=curfloatreg;
|
|
|
|
result:=create_paraloc_info_intern(p,side,p.paras,curintreg,curfloatreg,curmmreg,cur_stack_offset, false);
|
|
if (p.proccalloption in cstylearrayofconst) then
|
|
{ just continue loading the parameters in the registers }
|
|
begin
|
|
if assigned(varargspara) then
|
|
begin
|
|
if side=callerside then
|
|
result:=create_paraloc_info_intern(p,side,varargspara,curintreg,curfloatreg,curmmreg,cur_stack_offset,true)
|
|
else
|
|
internalerror(2019021921);
|
|
end;
|
|
{ varargs routines have to reserve at least 32 bytes for the AIX abi }
|
|
if (target_info.abi in [abi_powerpc_aix,abi_powerpc_darwin]) and
|
|
(result < 32) then
|
|
result := 32;
|
|
end
|
|
else
|
|
internalerror(2019021710);
|
|
if curfloatreg<>firstfloatreg then
|
|
include(varargspara.varargsinfo,va_uses_float_reg);
|
|
create_funcretloc_info(p,side);
|
|
end;
|
|
|
|
|
|
function tcpuparamanager.parseparaloc(p : tparavarsym;const s : string) : boolean;
|
|
var
|
|
paraloc : pcgparalocation;
|
|
paracgsize : tcgsize;
|
|
offset_lo: aint;
|
|
offset_hi: aint;
|
|
|
|
function parse68kregname(idx: longint): longint;
|
|
begin
|
|
result:=-1;
|
|
if (lowercase(s[idx]) = 'd') and (s[idx+1] in ['0'..'7']) then
|
|
result:=(ord(s[idx+1]) - ord('0')) * sizeof(pint)
|
|
else if (lowercase(s[idx]) = 'a') and (s[idx+1] in ['0'..'6']) then
|
|
result:=(ord(s[idx+1]) - ord('0') + 8) * sizeof(pint);
|
|
end;
|
|
|
|
begin
|
|
result:=false;
|
|
offset_hi:=-1;
|
|
offset_lo:=-1;
|
|
case target_info.system of
|
|
system_powerpc_morphos:
|
|
begin
|
|
paracgsize:=def_cgsize(p.vardef);
|
|
p.paraloc[callerside].alignment:=4;
|
|
p.paraloc[callerside].size:=paracgsize;
|
|
p.paraloc[callerside].intsize:=tcgsize2size[paracgsize];
|
|
paraloc:=p.paraloc[callerside].add_location;
|
|
|
|
{ The OS side should be zero extended and the entire "virtual"
|
|
68k register should be overwritten. This is what the C ppcinline
|
|
macros do as well, by casting all arguments to ULONG. A call
|
|
which breaks w/o this is for example exec/RawPutChar (KB) }
|
|
paraloc^.size:=OS_ADDR;
|
|
paraloc^.def:=p.vardef;
|
|
|
|
{ convert virtual 68k reg patterns into offsets }
|
|
case length(s) of
|
|
2: begin
|
|
{ single register }
|
|
offset_lo:=parse68kregname(1);
|
|
if offset_lo<0 then
|
|
message(parser_e_illegal_explicit_paraloc);
|
|
|
|
if tcgsize2size[paracgsize]>4 then
|
|
message(parser_e_location_size_too_small);
|
|
|
|
paraloc^.loc:=LOC_REFERENCE;
|
|
paraloc^.reference.index:=newreg(R_INTREGISTER,RS_R2,R_SUBWHOLE);
|
|
paraloc^.reference.offset:=offset_lo;
|
|
end;
|
|
5: begin
|
|
{ 64bit register pair, used by AmiSSL 68k for example }
|
|
offset_hi:=parse68kregname(1);
|
|
offset_lo:=parse68kregname(4);
|
|
|
|
if (not (s[3] in [':','-'])) or
|
|
(offset_lo<0) or (offset_hi<0) then
|
|
message(parser_e_illegal_explicit_paraloc);
|
|
|
|
if offset_lo>=(8*sizeof(pint)) then
|
|
message(parser_e_location_regpair_only_data);
|
|
|
|
if (offset_lo-offset_hi)<>4 then
|
|
message(parser_e_location_regpair_only_consecutive);
|
|
|
|
if tcgsize2size[paracgsize]<=4 then
|
|
message(parser_e_location_size_too_large);
|
|
|
|
if tcgsize2size[paracgsize]>8 then
|
|
message(parser_e_location_size_too_small);
|
|
|
|
paraloc^.loc:=LOC_REFERENCE;
|
|
paraloc^.reference.index:=newreg(R_INTREGISTER,RS_R2,R_SUBWHOLE);
|
|
paraloc^.reference.offset:=offset_hi;
|
|
paraloc^.size:=OS_64;
|
|
end;
|
|
else
|
|
begin
|
|
{ 'R12' is special, used internally to support regbase and nobase
|
|
calling convention }
|
|
if lowercase(s)='r12' then
|
|
begin
|
|
paraloc^.loc:=LOC_REGISTER;
|
|
paraloc^.register:=NR_R12;
|
|
end
|
|
else
|
|
exit; { error, cannot parse }
|
|
end;
|
|
end;
|
|
|
|
{ copy to callee side }
|
|
p.paraloc[calleeside].add_location^:=paraloc^;
|
|
end;
|
|
else
|
|
internalerror(200404182);
|
|
end;
|
|
result:=true;
|
|
end;
|
|
|
|
begin
|
|
paramanager:=tcpuparamanager.create;
|
|
end.
|