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

45
compiler/rgobj.pas
View File

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

24
compiler/wasm32/rgcpu.pas
View File

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