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

* Use dynamic arrays instead of getmem for spill temp

Browse Source
This commit is contained in:
Michaël Van Canneyt 2025-03-18 08:55:09 +01:00
parent b67e6ed75e
commit be1fedb2ec
3 changed files with 42 additions and 43 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
compiler/jvm/rgcpu.pas
View File

@ -32,7 +32,7 @@ unit rgcpu;
rgobj;
type
tspilltemps = array[tregistertype] of ^Tspill_temp_list;
tspilltemps = array[tregistertype] of Tspill_temp_list;
{ trgcpu }
@ -67,7 +67,7 @@ implementation
if instr.oper[l]^.typ=top_reg then
begin
reg:=instr.oper[l]^.reg;
instr.loadref(l,spilltemps[getregtype(reg)]^[getsupreg(reg)]);
instr.loadref(l,spilltemps[getregtype(reg)][getsupreg(reg)]);
end;
end;
@ -350,8 +350,8 @@ implementation
{ remove some simple useless store/load sequences }
remove_dummy_load_stores(list,headertai);
{ allocate room to store the virtual register -> temp mapping }
spill_temps[R_INTREGISTER]:=allocmem(sizeof(treference)*intrg.maxreg);
spill_temps[R_FPUREGISTER]:=allocmem(sizeof(treference)*fprg.maxreg);
setlength(spill_temps[R_INTREGISTER],intrg.maxreg);
setlength(spill_temps[R_FPUREGISTER],fprg.maxreg);
{ List to insert temp allocations into }
templist:=TAsmList.create;
{ allocate/replace all registers }
@ -385,10 +385,10 @@ implementation
ra_alloc :
tg.gettemp(templist,
size,1,
tt_regallocator,spill_temps[getregtype(reg)]^[getsupreg(reg)]);
tt_regallocator,spill_temps[getregtype(reg)][getsupreg(reg)]);
ra_dealloc :
begin
tg.ungettemp(templist,spill_temps[getregtype(reg)]^[getsupreg(reg)]);
tg.ungettemp(templist,spill_temps[getregtype(reg)][getsupreg(reg)]);
{ don't invalidate the temp reference, may still be used one instruction
later }
end;
@ -413,8 +413,8 @@ implementation
end;
p:=Tai(p.next);
end;
freemem(spill_temps[R_INTREGISTER]);
freemem(spill_temps[R_FPUREGISTER]);
spill_temps[R_INTREGISTER]:=nil;
spill_temps[R_FPUREGISTER]:=nil;
templist.free;
end;

45
compiler/rgobj.pas
View File

@ -123,7 +123,8 @@ unit rgobj;
total_interferences : longint;
real_reg_interferences: word;
end;
Preginfo=^TReginfo;
// Preginfo=^TReginfo;
TReginfoArray = Array of TReginfo;
tspillreginfo = record
{ a single register may appear more than once in an instruction,
@ -141,8 +142,9 @@ unit rgobj;
spillreginfo: array[0..3] of tspillreginfo;
end;
Pspill_temp_list=^Tspill_temp_list;
Tspill_temp_list=array[tsuperregister] of Treference;
// Pspill_temp_list=^Tspill_temp_list;
Tspill_temp_list = array of Treference;
{ used to store where a register is spilled and what interferences it has at the point of being spilled }
tspillinfo = record
@ -229,10 +231,10 @@ unit rgobj;
const spilltemplist:Tspill_temp_list): boolean;virtual;
procedure insert_regalloc_info_all(list:TAsmList);
procedure determine_spill_registers(list:TAsmList;headertail:tai); virtual;
procedure get_spill_temp(list:TAsmlist;spill_temps: Pspill_temp_list; supreg: tsuperregister);virtual;
procedure get_spill_temp(list:TAsmlist;spill_temps: Tspill_temp_list; supreg: tsuperregister);virtual;
strict protected
{ Highest register allocated until now.}
reginfo : PReginfo;
reginfo : TReginfoArray;
usable_registers_cnt : word;
private
int_live_range_direction: TRADirection;
@ -455,7 +457,7 @@ unit rgobj;
moveins_id_counter:=0;
worklist_moves:=Tlinkedlist.create;
move_garbage:=TLinkedList.Create;
reginfo:=allocmem(first_imaginary*sizeof(treginfo));
SetLength(reginfo,first_imaginary);
for i:=0 to first_imaginary-1 do
begin
reginfo[i].degree:=high(tsuperregister);
@ -513,7 +515,6 @@ unit rgobj;
if movelist<>nil then
dispose(movelist);
end;
freemem(reginfo);
reginfo:=nil;
end;
end;
@ -539,9 +540,7 @@ unit rgobj;
if maxreginfoinc<256 then
maxreginfoinc:=maxreginfoinc*2;
end;
reallocmem(reginfo,maxreginfo*sizeof(treginfo));
{ Do we really need it to clear it ? At least for 1.0.x (PFV) }
fillchar(reginfo[oldmaxreginfo],(maxreginfo-oldmaxreginfo)*sizeof(treginfo),0);
SetLength(reginfo,maxreginfo);
end;
reginfo[result].subreg:=subreg;
end;
@ -1991,7 +1990,7 @@ unit rgobj;
end;
procedure trgobj.get_spill_temp(list: TAsmlist; spill_temps: Pspill_temp_list; supreg: tsuperregister);
procedure trgobj.get_spill_temp(list: TAsmlist; spill_temps: Tspill_temp_list; supreg: tsuperregister);
var
size: ptrint;
begin
@ -2007,7 +2006,7 @@ unit rgobj;
size:=tcgsize2size[reg_cgsize(newreg(regtype,supreg,reginfo[supreg].subreg))];
tg.gettemp(list,
size,size,
tt_noreuse,spill_temps^[supreg]);
tt_noreuse,spill_temps[supreg]);
end;
@ -2416,7 +2415,7 @@ unit rgobj;
t : tsuperregister;
p : Tai;
regs_to_spill_set:Tsuperregisterset;
spill_temps : ^Tspill_temp_list;
spill_temps : Tspill_temp_list;
supreg,x,y : tsuperregister;
templist : TAsmList;
j : Longint;
@ -2429,7 +2428,7 @@ unit rgobj;
sort_spillednodes;
for i:=first_imaginary to maxreg-1 do
exclude(reginfo[i].flags,ri_selected);
spill_temps:=allocmem(sizeof(treference)*maxreg);
SetLength(spill_temps,maxreg);
supregset_reset(regs_to_spill_set,false,$ffff);
{$ifdef DEBUG_SPILLCOALESCE}
@ -2464,7 +2463,7 @@ unit rgobj;
getnewspillloc:=not (ri_has_initial_loc in reginfo[t].flags);
if not getnewspillloc then
spill_temps^[t]:=spillinfo[t].spilllocation;
spill_temps[t]:=spillinfo[t].spilllocation;
{ check if we can "coalesce" spilled nodes. To do so, it is required that they do not
interfere but are connected by a move instruction
@ -2481,7 +2480,7 @@ unit rgobj;
(spillinfo[get_alias(y)].spilled) and
not(spillinfo[get_alias(y)].interferences[0,t]) then
begin
spill_temps^[t]:=spillinfo[get_alias(y)].spilllocation;
spill_temps[t]:=spillinfo[get_alias(y)].spilllocation;
{$ifdef DEBUG_SPILLCOALESCE}
writeln('trgobj.spill_registers: Spill coalesce ',t,' to ',y);
{$endif DEBUG_SPILLCOALESCE}
@ -2495,7 +2494,7 @@ unit rgobj;
{$ifdef DEBUG_SPILLCOALESCE}
writeln('trgobj.spill_registers: Spill coalesce ',t,' to ',x);
{$endif DEBUG_SPILLCOALESCE}
spill_temps^[t]:=spillinfo[get_alias(x)].spilllocation;
spill_temps[t]:=spillinfo[get_alias(x)].spilllocation;
getnewspillloc:=false;
break;
end;
@ -2505,13 +2504,13 @@ unit rgobj;
get_spill_temp(templist,spill_temps,t);
{$ifdef DEBUG_SPILLCOALESCE}
writeln('trgobj.spill_registers: Spill temp: ',getsupreg(spill_temps^[t].base),'+',spill_temps^[t].offset);
writeln('trgobj.spill_registers: Spill temp: ',getsupreg(spill_temps[t].base),'+',spill_temps[t].offset);
{$endif DEBUG_SPILLCOALESCE}
{ set spilled only as soon as a temp is assigned, else a mov iregX,iregX results in a spill coalesce with itself }
spillinfo[t].spilled:=true;
spillinfo[t].spilllocation:=spill_temps^[t];
spillinfo[t].spilllocation:=spill_temps[t];
end;
list.insertlistafter(headertai,templist);
templist.free;
@ -2566,7 +2565,7 @@ unit rgobj;
begin
// writeln(gas_op2str[tai_cpu_abstract_sym(p).opcode]);
current_filepos:=fileinfo;
if instr_spill_register(list,tai_cpu_abstract_sym(p),regs_to_spill_set,spill_temps^) then
if instr_spill_register(list,tai_cpu_abstract_sym(p),regs_to_spill_set,spill_temps) then
spill_registers:=true;
end;
else
@ -2580,10 +2579,10 @@ unit rgobj;
for i:=0 to length-1 do
begin
j:=buf[i];
if tg.istemp(spill_temps^[j]) then
tg.ungettemp(list,spill_temps^[j]);
if tg.istemp(spill_temps[j]) then
tg.ungettemp(list,spill_temps[j]);
end;
freemem(spill_temps);
spill_temps:=nil;
end;

24
compiler/wasm32/rgcpu.pas
View File

@ -33,7 +33,7 @@ unit rgcpu;
rgobj;
type
tspilltemps = array[tregistertype] of ^Tspill_temp_list;
tspilltemps = array[tregistertype] of Tspill_temp_list;
{ trgcpu }
@ -69,7 +69,7 @@ implementation
if (instr.oper[l]^.typ=top_reg) and (instr.oper[l]^.reg<>NR_LOCAL_FRAME_POINTER_REG) then
begin
reg:=instr.oper[l]^.reg;
instr.loadref(l,spilltemps[getregtype(reg)]^[getsupreg(reg)]);
instr.loadref(l,spilltemps[getregtype(reg)][getsupreg(reg)]);
end;
end;
@ -366,10 +366,10 @@ implementation
{ remove some simple useless store/load sequences }
remove_dummy_load_stores(list,headertai);
{ allocate room to store the virtual register -> temp mapping }
spill_temps[R_INTREGISTER]:=allocmem(sizeof(treference)*intrg.maxreg);
spill_temps[R_FPUREGISTER]:=allocmem(sizeof(treference)*fprg.maxreg);
spill_temps[R_FUNCREFREGISTER]:=allocmem(sizeof(treference)*frrg.maxreg);
spill_temps[R_EXTERNREFREGISTER]:=allocmem(sizeof(treference)*errg.maxreg);
SetLength(spill_temps[R_INTREGISTER],intrg.maxreg);
SetLength(spill_temps[R_FPUREGISTER],fprg.maxreg);
SetLength(spill_temps[R_FUNCREFREGISTER],frrg.maxreg);
SetLength(spill_temps[R_EXTERNREFREGISTER],errg.maxreg);
{ List to insert temp allocations into }
templist:=TAsmList.create;
{ }
@ -437,10 +437,10 @@ implementation
ra_alloc :
tg.gethltemp(templist,def,
size,
tt_regallocator,spill_temps[getregtype(ra.reg)]^[getsupreg(ra.reg)]);
tt_regallocator,spill_temps[getregtype(ra.reg)][getsupreg(ra.reg)]);
ra_dealloc :
begin
tg.ungettemp(templist,spill_temps[getregtype(ra.reg)]^[getsupreg(ra.reg)]);
tg.ungettemp(templist,spill_temps[getregtype(ra.reg)][getsupreg(ra.reg)]);
{ don't invalidate the temp reference, may still be used one instruction
later }
end;
@ -465,10 +465,10 @@ implementation
end;
if templist.count>0 then
list.insertListBefore(nil, templist);
freemem(spill_temps[R_INTREGISTER]);
freemem(spill_temps[R_FPUREGISTER]);
freemem(spill_temps[R_FUNCREFREGISTER]);
freemem(spill_temps[R_EXTERNREFREGISTER]);
spill_temps[R_INTREGISTER]:=Nil;
spill_temps[R_FPUREGISTER]:=Nil;
spill_temps[R_FUNCREFREGISTER]:=Nil;
spill_temps[R_EXTERNREFREGISTER]:=Nil;
templist.free;
{ Not needed anymore }
wasmfuncreftype.owner.deletedef(wasmfuncreftype);