* Use dynamic arrays instead of getmem for spill temp

compiler/jvm/rgcpu.pas

@@ -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;
 

compiler/rgobj.pas

@@ -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;
 
 

compiler/wasm32/rgcpu.pas

@@ -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);