paweld/fpc
1
0
Fork 0
mirror of https://gitlab.com/freepascal.org/fpc/source.git synced 2025-04-16 02:40:26 +02:00
Code Issues Packages Projects Releases Wiki Activity

* always specify an explicit alignment for tgobj.gettemp (so e.g.

Browse Source 
shortstring temps don't get maximum alignment)
  * changed some gettemptyed() calls into gettemp() calls (gettemptyped
    means that this temp can only be used for temps of that type,
    which is necessary for refcounted types but not for floats)

git-svn-id: trunk@12036 -
This commit is contained in:
Jonas Maebe 2008-11-08 22:20:47 +00:00
parent 334379f844
commit 718694d1d6
19 changed files with 64 additions and 52 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
compiler/cgobj.pas
View File

@ -2534,7 +2534,7 @@ implementation
LOC_REGISTER,LOC_CREGISTER:
begin
{ paramfpu_ref does the check_simpe_location check here if necessary }
tg.GetTemp(list,TCGSize2Size[size],tt_normal,ref);
tg.GetTemp(list,TCGSize2Size[size],TCGSize2Size[size],tt_normal,ref);
a_loadfpu_reg_ref(list,size,size,r,ref);
a_paramfpu_ref(list,size,ref,cgpara);
tg.Ungettemp(list,ref);
@ -3670,7 +3670,7 @@ implementation
if size>0 then
begin
tg.GetTemp(list,size,tt_noreuse,current_procinfo.save_regs_ref);
tg.GetTemp(list,size,sizeof(aint),tt_noreuse,current_procinfo.save_regs_ref);
include(current_procinfo.flags,pi_has_saved_regs);
{ Copy registers to temp }

3
compiler/globals.pas
View File

@ -265,7 +265,8 @@ interface
{ Memory sizes }
heapsize,
stacksize,
jmp_buf_size : longint;
jmp_buf_size,
jmp_buf_align : longint;
{$Ifdef EXTDEBUG}
{ parameter switches }

2
compiler/ncgbas.pas
View File

@ -429,7 +429,7 @@ interface
else
begin
location_reset(tempinfo^.location,LOC_REFERENCE,def_cgsize(tempinfo^.typedef));
tg.GetTemp(current_asmdata.CurrAsmList,size,tempinfo^.temptype,tempinfo^.location.reference);
tg.GetTemp(current_asmdata.CurrAsmList,size,tempinfo^.typedef.alignment,tempinfo^.temptype,tempinfo^.location.reference);
end;
include(tempinfo^.flags,ti_valid);
end;

2
compiler/ncgcal.pas
View File

@ -555,7 +555,7 @@ implementation
structs with up to 16 bytes are returned in registers }
if cgsize in [OS_128,OS_S128] then
begin
tg.GetTemp(current_asmdata.CurrAsmList,16,tt_normal,ref);
tg.GetTemp(current_asmdata.CurrAsmList,16,8,tt_normal,ref);
location_reset(location,LOC_REFERENCE,OS_NO);
location.reference:=ref;
cg.a_load_reg_ref(current_asmdata.CurrAsmList,OS_64,OS_64,procdefinition.funcretloc[callerside].register,ref);

6
compiler/ncgcnv.pas
View File

@ -243,7 +243,7 @@ interface
case tstringdef(resultdef).stringtype of
st_shortstring :
begin
tg.GetTemp(current_asmdata.CurrAsmList,256,tt_normal,location.reference);
tg.GetTemp(current_asmdata.CurrAsmList,256,1,tt_normal,location.reference);
cg.a_load_loc_ref(current_asmdata.CurrAsmList,left.location.size,left.location,
location.reference);
location_freetemp(current_asmdata.CurrAsmList,left.location);
@ -272,7 +272,7 @@ interface
if (left.location.loc in [LOC_CREFERENCE,LOC_REFERENCE]) then
location_force_fpureg(current_asmdata.CurrAsmList,left.location,false);
{ round them down to the proper precision }
tg.gettemp(current_asmdata.currasmlist,resultdef.size,tt_normal,tr);
tg.gettemp(current_asmdata.currasmlist,resultdef.size,resultdef.alignment,tt_normal,tr);
cg.a_loadfpu_reg_ref(current_asmdata.CurrAsmList,left.location.size,location.size,left.location.register,tr);
location_reset(left.location,LOC_REFERENCE,location.size);
left.location.reference:=tr;
@ -368,7 +368,7 @@ interface
var r:Treference;
begin
tg.gettemp(current_asmdata.currasmlist,2*sizeof(puint),tt_normal,r);
tg.gettemp(current_asmdata.currasmlist,2*sizeof(puint),sizeof(puint),tt_normal,r);
location_reset(location,LOC_REFERENCE,OS_NO);
location.reference:=r;
cg.a_load_const_ref(current_asmdata.currasmlist,OS_ADDR,0,r);

2
compiler/ncgflw.pas
View File

@ -1323,7 +1323,7 @@ implementation
end
else
begin
tg.GetTemp(current_asmdata.CurrAsmList,sizeof(pint),tt_normal,exceptref);
tg.GetTemp(current_asmdata.CurrAsmList,sizeof(pint),sizeof(pint),tt_normal,exceptref);
cg.a_load_reg_ref(current_asmdata.CurrAsmList,OS_ADDR,OS_ADDR,NR_FUNCTION_RESULT_REG,exceptref);
end;

33
compiler/ncgld.pas
View File

@ -432,7 +432,7 @@ implementation
{$else}
internalerror(20020520);
{$endif} {$endif}
tg.GetTemp(current_asmdata.CurrAsmList,2*sizeof(pint),tt_normal,location.reference);
tg.GetTemp(current_asmdata.CurrAsmList,2*sizeof(pint),sizeof(pint),tt_normal,location.reference);
secondpass(left);
{ load class instance/classrefdef address }
@ -757,7 +757,7 @@ implementation
{ convert an extended into a double/single, since sse }
{ doesn't support extended) }
r:=cg.getfpuregister(current_asmdata.CurrAsmList,right.location.size);
tg.gettemp(current_asmdata.CurrAsmList,left.resultdef.size,tt_normal,href);
tg.gettemp(current_asmdata.CurrAsmList,left.resultdef.size,left.resultdef.alignment,tt_normal,href);
cg.a_loadfpu_ref_reg(current_asmdata.CurrAsmList,right.location.size,right.location.size,right.location.reference,r);
cg.a_loadfpu_reg_ref(current_asmdata.CurrAsmList,right.location.size,left.location.size,r,href);
if releaseright then
@ -834,7 +834,7 @@ implementation
begin
{ perform size conversion if needed (the mm-code cannot convert an }
{ extended into a double/single, since sse doesn't support extended) }
tg.gettemp(current_asmdata.CurrAsmList,left.resultdef.size,tt_normal,href);
tg.gettemp(current_asmdata.CurrAsmList,left.resultdef.size,left.resultdef.alignment,tt_normal,href);
cg.a_loadfpu_reg_ref(current_asmdata.CurrAsmList,right.location.size,left.location.size,right.location.register,href);
location_reset(right.location,LOC_REFERENCE,left.location.size);
right.location.reference:=href;
@ -951,31 +951,38 @@ implementation
hp : tarrayconstructornode;
href : treference;
lt : tdef;
vaddr : boolean;
vtype : longint;
freetemp,
dovariant : boolean;
elesize : longint;
tmpreg : tregister;
paraloc : tcgparalocation;
otlabel,
oflabel : tasmlabel;
vtype : longint;
elesize,
elealign : longint;
tmpreg : tregister;
vaddr : boolean;
freetemp,
dovariant : boolean;
begin
if is_packed_array(resultdef) then
internalerror(200608042);
dovariant:=(nf_forcevaria in flags) or is_variant_array(resultdef);
if dovariant then
elesize:=sizeof(pint)+sizeof(pint)
begin
elesize:=sizeof(pint)+sizeof(pint);
elealign:=sizeof(pint);
end
else
elesize:=tarraydef(resultdef).elesize;
begin
elesize:=tarraydef(resultdef).elesize;
elealign:=tarraydef(resultdef).elementdef.alignment;
end;
location_reset(location,LOC_CREFERENCE,OS_NO);
fillchar(paraloc,sizeof(paraloc),0);
{ Allocate always a temp, also if no elements are required, to
be sure that location is valid (PFV) }
if tarraydef(resultdef).highrange=-1 then
tg.GetTemp(current_asmdata.CurrAsmList,elesize,tt_normal,location.reference)
tg.GetTemp(current_asmdata.CurrAsmList,elesize,elealign,tt_normal,location.reference)
else
tg.GetTemp(current_asmdata.CurrAsmList,(tarraydef(resultdef).highrange+1)*elesize,tt_normal,location.reference);
tg.GetTemp(current_asmdata.CurrAsmList,(tarraydef(resultdef).highrange+1)*elesize,resultdef.alignment,tt_normal,location.reference);
href:=location.reference;
{ Process nodes in array constructor }
hp:=self;

2
compiler/ncgmat.pas
View File

@ -149,7 +149,7 @@ implementation
{ get a temporary memory reference to store the floating
point value
}
tg.gettemp(current_asmdata.CurrAsmList,tcgsize2size[_size],tt_normal,href);
tg.gettemp(current_asmdata.CurrAsmList,tcgsize2size[_size],tcgsize2size[_size],tt_normal,href);
{ store the floating point value in the temporary memory area }
cg.a_loadfpu_reg_ref(current_asmdata.CurrAsmList,_size,_size,r,href);
{ only single and double ieee are supported, for little endian

2
compiler/ncgopt.pas
View File

@ -90,7 +90,7 @@ begin
if not(tg.istemp(left.location.reference) and
(tg.sizeoftemp(current_asmdata.CurrAsmList,left.location.reference) = 256)) then
begin
tg.Gettemp(current_asmdata.CurrAsmList,256,tt_normal,href);
tg.Gettemp(current_asmdata.CurrAsmList,256,1,tt_normal,href);
cg.g_copyshortstring(current_asmdata.CurrAsmList,left.location.reference,href,255);
location_freetemp(current_asmdata.CurrAsmList,left.location);
{ return temp reference }

21
compiler/ncgutil.pas
View File

@ -361,10 +361,11 @@ implementation
begin
srsym:=search_system_type('JMP_BUF');
jmp_buf_size:=srsym.typedef.size;
jmp_buf_align:=srsym.typedef.alignment;
end;
tg.GetTemp(list,EXCEPT_BUF_SIZE,tt_persistent,t.envbuf);
tg.GetTemp(list,jmp_buf_size,tt_persistent,t.jmpbuf);
tg.GetTemp(list,sizeof(pint),tt_persistent,t.reasonbuf);
tg.GetTemp(list,EXCEPT_BUF_SIZE,sizeof(pint),tt_persistent,t.envbuf);
tg.GetTemp(list,jmp_buf_size,jmp_buf_align,tt_persistent,t.jmpbuf);
tg.GetTemp(list,sizeof(pint),sizeof(pint),tt_persistent,t.reasonbuf);
end;
@ -682,7 +683,7 @@ implementation
{ if it's in an mm register, store to memory first }
if (l.loc in [LOC_MMREGISTER,LOC_CMMREGISTER]) then
begin
tg.GetTemp(list,tcgsize2size[l.size],tt_normal,href);
tg.GetTemp(list,tcgsize2size[l.size],tcgsize2size[l.size],tt_normal,href);
cg.a_loadmm_reg_ref(list,l.size,l.size,l.register,href,mms_movescalar);
location_reset(l,LOC_REFERENCE,l.size);
l.reference:=href;
@ -707,7 +708,7 @@ implementation
{ if it's in an fpu register, store to memory first }
if (l.loc in [LOC_FPUREGISTER,LOC_CFPUREGISTER]) then
begin
tg.GetTemp(list,tcgsize2size[l.size],tt_normal,href);
tg.GetTemp(list,tcgsize2size[l.size],tcgsize2size[l.size],tt_normal,href);
cg.a_loadfpu_reg_ref(list,l.size,l.size,l.register,href);
location_reset(l,LOC_REFERENCE,l.size);
l.reference:=href;
@ -771,7 +772,7 @@ implementation
LOC_FPUREGISTER,
LOC_CFPUREGISTER :
begin
tg.GetTemp(list,TCGSize2Size[l.size],tt_normal,r);
tg.GetTemp(list,TCGSize2Size[l.size],TCGSize2Size[l.size],tt_normal,r);
cg.a_loadfpu_reg_ref(list,l.size,l.size,l.register,r);
location_reset(l,LOC_REFERENCE,l.size);
l.reference:=r;
@ -779,7 +780,7 @@ implementation
LOC_MMREGISTER,
LOC_CMMREGISTER:
begin
tg.GetTemp(list,TCGSize2Size[l.size],tt_normal,r);
tg.GetTemp(list,TCGSize2Size[l.size],TCGSize2Size[l.size],tt_normal,r);
cg.a_loadmm_reg_ref(list,l.size,l.size,l.register,r,mms_movescalar);
location_reset(l,LOC_REFERENCE,l.size);
l.reference:=r;
@ -788,7 +789,7 @@ implementation
LOC_REGISTER,
LOC_CREGISTER :
begin
tg.GetTemp(list,TCGSize2Size[l.size],tt_normal,r);
tg.GetTemp(list,TCGSize2Size[l.size],TCGSize2Size[l.size],tt_normal,r);
{$ifndef cpu64bitalu}
if l.size in [OS_64,OS_S64] then
cg64.a_load64_loc_ref(list,l,r)
@ -803,7 +804,7 @@ implementation
LOC_SUBSETREF,
LOC_CSUBSETREF:
begin
tg.GetTemp(list,TCGSize2Size[l.size],tt_normal,r);
tg.GetTemp(list,TCGSize2Size[l.size],TCGSize2Size[l.size],tt_normal,r);
cg.a_load_loc_ref(list,l.size,l,r);
location_reset(l,LOC_REFERENCE,l.size);
l.reference:=r;
@ -1828,7 +1829,7 @@ implementation
{ Arm and Sparc passes floats in int registers, when loading to fpu register
we need a temp }
sizeleft := TCGSize2Size[currpara.initialloc.size];
tg.GetTemp(list,sizeleft,tt_normal,tempref);
tg.GetTemp(list,sizeleft,sizeleft,tt_normal,tempref);
href:=tempref;
while assigned(paraloc) do
begin

2
compiler/paramgr.pas
View File

@ -340,7 +340,7 @@ implementation
newparaloc^.register:=cg.getmmregister(list,paraloc^.size);
LOC_REFERENCE :
begin
tg.gettemp(list,len,tt_persistent,href);
tg.gettemp(list,len,cgpara.alignment,tt_persistent,href);
newparaloc^.reference.index:=href.base;
newparaloc^.reference.offset:=href.offset;
end;

2
compiler/powerpc/nppccnv.pas
View File

@ -144,7 +144,7 @@ implementation
{ stw R3,disp+4(R1) # store lower half }
{ lfd FR1,disp(R1) # float load double of value }
{ fsub FR1,FR1,FR2 # subtract 0x4330000000000000 }
tg.Gettemp(current_asmdata.CurrAsmList,8,tt_normal,ref);
tg.Gettemp(current_asmdata.CurrAsmList,8,8,tt_normal,ref);
signed := is_signed(left.resultdef);

4
compiler/powerpc64/nppccnv.pas
View File

@ -125,7 +125,7 @@ begin
{ fcfid frD,frD # point integer (no round) }
{ fmadd frD,frC,frT1,frD # (2^32)*high + low }
{ # (only add can round) }
tg.Gettemp(current_asmdata.CurrAsmList, 8, tt_normal, disp);
tg.Gettemp(current_asmdata.CurrAsmList, 8, 8, tt_normal, disp);
{ do the signed case for everything but 64 bit unsigned integers }
signed := (left.location.size <> OS_64);
@ -143,7 +143,7 @@ begin
internalerror(200110011);
// allocate second temp memory
tg.Gettemp(current_asmdata.CurrAsmList, 8, tt_normal, disp2);
tg.Gettemp(current_asmdata.CurrAsmList, 8, 8, tt_normal, disp2);
end;
if not(left.location.loc in [LOC_REGISTER,LOC_CREGISTER,LOC_REFERENCE,LOC_CREFERENCE]) then

6
compiler/rgobj.pas
View File

@ -1718,6 +1718,7 @@ unit rgobj;
spill_temps : ^Tspill_temp_list;
supreg : tsuperregister;
templist : TAsmList;
size: ptrint;
begin
spill_registers:=false;
live_registers.clear;
@ -1739,9 +1740,10 @@ unit rgobj;
{Get a temp for the spilled register, the size must at least equal a complete register,
take also care of the fact that subreg can be larger than a single register like doubles
that occupy 2 registers }
size:=max(tcgsize2size[reg_cgsize(newreg(regtype,t,R_SUBWHOLE))],
tcgsize2size[reg_cgsize(newreg(regtype,t,reginfo[t].subreg))]);
tg.gettemp(templist,
max(tcgsize2size[reg_cgsize(newreg(regtype,t,R_SUBWHOLE))],
tcgsize2size[reg_cgsize(newreg(regtype,t,reginfo[t].subreg))]),
size,size,
tt_noreuse,spill_temps^[t]);
end;
list.insertlistafter(headertai,templist);

2
compiler/sparc/cgcpu.pas
View File

@ -423,7 +423,7 @@ implementation
var
href : treference;
begin
tg.GetTemp(list,TCGSize2Size[size],tt_normal,href);
tg.GetTemp(list,TCGSize2Size[size],TCGSize2Size[size],tt_normal,href);
a_loadfpu_reg_ref(list,size,size,r,href);
a_paramfpu_ref(list,size,href,paraloc);
tg.Ungettemp(list,href);

9
compiler/tgobj.pas
View File

@ -80,7 +80,7 @@ unit tgobj;
}
procedure setfirsttemp(l : longint);
procedure gettemp(list: TAsmList; size : longint;temptype:ttemptype;out ref : treference);
procedure gettemp(list: TAsmList; size, alignment : longint;temptype:ttemptype;out ref : treference);
procedure gettemptyped(list: TAsmList; def:tdef;temptype:ttemptype;out ref : treference);
procedure ungettemp(list: TAsmList; const ref : treference);
@ -491,17 +491,17 @@ implementation
end;
procedure ttgobj.gettemp(list: TAsmList; size : longint;temptype:ttemptype;out ref : treference);
procedure ttgobj.gettemp(list: TAsmList; size, alignment : longint;temptype:ttemptype;out ref : treference);
var
varalign : shortint;
begin
varalign:=size_2_align(size);
varalign:=used_align(varalign,current_settings.alignment.localalignmin,current_settings.alignment.localalignmax);
varalign:=used_align(alignment,current_settings.alignment.localalignmin,current_settings.alignment.localalignmax);
{ can't use reference_reset_base, because that will let tgobj depend
on cgobj (PFV) }
fillchar(ref,sizeof(ref),0);
ref.base:=current_procinfo.framepointer;
ref.offset:=alloctemp(list,size,varalign,temptype,nil);
ref.alignment:=varalign;
end;
@ -516,6 +516,7 @@ implementation
fillchar(ref,sizeof(ref),0);
ref.base:=current_procinfo.framepointer;
ref.offset:=alloctemp(list,def.size,varalign,temptype,def);
ref.alignment:=varalign;
end;

2
compiler/x86/cgx86.pas
View File

@ -946,7 +946,7 @@ unit cgx86;
(tosize<fromsize) then
begin
{ can't round down to lower precision in x87 :/ }
tg.gettemp(list,tcgsize2size[tosize],tt_normal,href);
tg.gettemp(list,tcgsize2size[tosize],tcgsize2size[tosize],tt_normal,href);
a_loadfpu_reg_ref(list,fromsize,tosize,NR_ST,href);
a_loadfpu_ref_reg(list,tosize,tosize,href,NR_ST);
tg.ungettemp(list,href);

2
compiler/x86/nx86cnv.pas
View File

@ -305,7 +305,7 @@ implementation
make it 64bits }
if (torddef(left.resultdef).ordtype=u32bit) then
begin
tg.GetTemp(current_asmdata.CurrAsmList,8,tt_normal,href);
tg.GetTemp(current_asmdata.CurrAsmList,8,8,tt_normal,href);
location_freetemp(current_asmdata.CurrAsmList,left.location);
cg.a_load_ref_ref(current_asmdata.CurrAsmList,left.location.size,OS_32,left.location.reference,href);
inc(href.offset,4);

10
compiler/x86/nx86inl.pas
View File

@ -268,7 +268,7 @@ implementation
begin
load_fpu_location;
location_reset(location,LOC_REFERENCE,OS_S64);
tg.GetTempTyped(current_asmdata.CurrAsmList,resultdef,tt_normal,location.reference);
tg.GetTemp(current_asmdata.CurrAsmList,resultdef.size,resultdef.alignment,tt_normal,location.reference);
emit_ref(A_FISTP,S_IQ,location.reference);
emit_none(A_FWAIT,S_NO);
end;
@ -303,20 +303,20 @@ implementation
begin
load_fpu_location;
location_reset(location,LOC_REFERENCE,OS_S64);
tg.GetTempTyped(current_asmdata.CurrAsmList,resultdef,tt_normal,location.reference);
tg.GetTemp(current_asmdata.CurrAsmList,resultdef.size,resultdef.alignment,tt_normal,location.reference);
emit_ref(A_FISTTP,S_IQ,location.reference);
end
else
begin
tg.GetTemp(current_asmdata.CurrAsmList,2,tt_normal,oldcw);
tg.GetTemp(current_asmdata.CurrAsmList,2,tt_normal,newcw);
tg.GetTemp(current_asmdata.CurrAsmList,2,2,tt_normal,oldcw);
tg.GetTemp(current_asmdata.CurrAsmList,2,2,tt_normal,newcw);
emit_ref(A_FNSTCW,S_NO,newcw);
emit_ref(A_FNSTCW,S_NO,oldcw);
emit_const_ref(A_OR,S_W,$0f00,newcw);
load_fpu_location;
emit_ref(A_FLDCW,S_NO,newcw);
location_reset(location,LOC_REFERENCE,OS_S64);
tg.GetTempTyped(current_asmdata.CurrAsmList,resultdef,tt_normal,location.reference);
tg.GetTemp(current_asmdata.CurrAsmList,resultdef.size,resultdef.alignment,tt_normal,location.reference);
emit_ref(A_FISTP,S_IQ,location.reference);
emit_ref(A_FLDCW,S_NO,oldcw);
emit_none(A_FWAIT,S_NO);