* Register allocator splitted, ans abstract now

compiler/cg64f32.pas

@@ -173,7 +173,7 @@ unit cg64f32;
         tmpref := ref;
         if (tmpref.base=reg.reglo) then
          begin
-           tmpreg:=rg.getaddressregister(list);
+           tmpreg:=cg.getaddressregister(list);
            got_scratch:=true;
            cg.a_load_reg_reg(list,OS_ADDR,OS_ADDR,tmpref.base,tmpreg);
            tmpref.base:=tmpreg;
@@ -184,7 +184,7 @@ unit cg64f32;
          { implementation FK                                              }
          if (tmpref.index=reg.reglo) then
           begin
-            tmpreg:=rg.getaddressregister(list);
+            tmpreg:=cg.getaddressregister(list);
             got_scratch:=true;
             cg.a_load_reg_reg(list,OS_ADDR,OS_ADDR,tmpref.index,tmpreg);
             tmpref.index:=tmpreg;
@@ -198,7 +198,7 @@ unit cg64f32;
           end;
         cg.a_load_ref_reg(list,OS_32,OS_32,tmpref,reg.reghi);
         if got_scratch then
-          rg.ungetregisterint(list,tmpreg);
+          cg.ungetregister(list,tmpreg);
       end;
 
 
@@ -206,10 +206,10 @@ unit cg64f32;
 
       begin
         if delete then
-          rg.ungetregisterint(list,regsrc.reglo);
+          cg.ungetregister(list,regsrc.reglo);
         cg.a_load_reg_reg(list,OS_32,OS_32,regsrc.reglo,regdst.reglo);
         if delete then
-          rg.ungetregisterint(list,regsrc.reghi);
+          cg.ungetregister(list,regsrc.reghi);
         cg.a_load_reg_reg(list,OS_32,OS_32,regsrc.reghi,regdst.reghi);
       end;
 
@@ -415,12 +415,12 @@ unit cg64f32;
       var
         tempreg: tregister64;
       begin
-        tempreg.reghi:=rg.getregisterint(list,OS_INT);
-        tempreg.reglo:=rg.getregisterint(list,OS_INT);
+        tempreg.reghi:=cg.getintregister(list,OS_INT);
+        tempreg.reglo:=cg.getintregister(list,OS_INT);
         a_load64_ref_reg(list,ref,tempreg,false);
         a_op64_reg_reg(list,op,tempreg,reg);
-        rg.ungetregisterint(list,tempreg.reglo);
-        rg.ungetregisterint(list,tempreg.reghi);
+        cg.ungetregister(list,tempreg.reglo);
+        cg.ungetregister(list,tempreg.reghi);
       end;
 
 
@@ -428,13 +428,13 @@ unit cg64f32;
       var
         tempreg: tregister64;
       begin
-        tempreg.reghi:=rg.getregisterint(list,OS_INT);
-        tempreg.reglo:=rg.getregisterint(list,OS_INT);
+        tempreg.reghi:=cg.getintregister(list,OS_INT);
+        tempreg.reglo:=cg.getintregister(list,OS_INT);
         a_load64_ref_reg(list,ref,tempreg,false);
         a_op64_reg_reg(list,op,reg,tempreg);
         a_load64_reg_ref(list,tempreg,ref);
-        rg.ungetregisterint(list,tempreg.reglo);
-        rg.ungetregisterint(list,tempreg.reghi);
+        cg.ungetregister(list,tempreg.reglo);
+        cg.ungetregister(list,tempreg.reghi);
       end;
 
 
@@ -442,13 +442,13 @@ unit cg64f32;
       var
         tempreg: tregister64;
       begin
-        tempreg.reghi:=rg.getregisterint(list,OS_INT);
-        tempreg.reglo:=rg.getregisterint(list,OS_INT);
+        tempreg.reghi:=cg.getintregister(list,OS_INT);
+        tempreg.reglo:=cg.getintregister(list,OS_INT);
         a_load64_ref_reg(list,ref,tempreg,false);
         a_op64_const_reg(list,op,value,tempreg);
         a_load64_reg_ref(list,tempreg,ref);
-        rg.ungetregisterint(list,tempreg.reglo);
-        rg.ungetregisterint(list,tempreg.reghi);
+        cg.ungetregister(list,tempreg.reglo);
+        cg.ungetregister(list,tempreg.reghi);
       end;
 
 
@@ -537,7 +537,7 @@ unit cg64f32;
                end
              else
                begin
-                 hreg:=rg.getregisterint(list,OS_INT);
+                 hreg:=cg.getintregister(list,OS_INT);
                  got_scratch := true;
                  a_load64high_ref_reg(list,l.reference,hreg);
                end;
@@ -554,7 +554,7 @@ unit cg64f32;
                end;
              { !!! freeing of register should happen directly after compare! (JM) }
              if got_scratch then
-               rg.ungetregisterint(list,hreg);
+               cg.ungetregister(list,hreg);
              { For all other values we have a range check error }
              cg.a_call_name(list,'FPC_RANGEERROR');
 
@@ -583,7 +583,7 @@ unit cg64f32;
                    end
                  else
                    begin
-                     hreg:=rg.getregisterint(list,OS_INT);
+                     hreg:=cg.getintregister(list,OS_INT);
                      got_scratch := true;
                      a_load64low_ref_reg(list,l.reference,hreg);
                    end;
@@ -592,7 +592,7 @@ unit cg64f32;
                  cg.a_cmp_const_reg_label(list,OS_32,OC_LT,0,hreg,neglabel);
                  { !!! freeing of register should happen directly after compare! (JM) }
                  if got_scratch then
-                   rg.ungetregisterint(list,hreg);
+                   cg.ungetregister(list,hreg);
 
                  cg.a_call_name(list,'FPC_RANGEERROR');
 
@@ -636,7 +636,7 @@ unit cg64f32;
                  end
                else
                  begin
-                   hreg:=rg.getregisterint(list,OS_INT);
+                   hreg:=cg.getintregister(list,OS_INT);
                    got_scratch := true;
 
                    opsize := def_cgsize(fromdef);
@@ -650,7 +650,7 @@ unit cg64f32;
 
                { !!! freeing of register should happen directly after compare! (JM) }
                if got_scratch then
-                 rg.ungetregisterint(list,hreg);
+                 cg.ungetregister(list,hreg);
                cg.a_call_name(list,'FPC_RANGEERROR');
                cg.a_label(list,poslabel);
              end;
@@ -761,7 +761,10 @@ begin
 end.
 {
   $Log$
-  Revision 1.50  2003-10-01 20:34:48  peter
+  Revision 1.51  2003-10-09 21:31:37  daniel
+    * Register allocator splitted, ans abstract now
+
+  Revision 1.50  2003/10/01 20:34:48  peter
     * procinfo unit contains tprocinfo
     * cginfo renamed to cgbase
     * moved cgmessage to verbose

compiler/cgbase.pas

@@ -124,7 +124,8 @@ interface
         R_SUBH,    { = 2; 8 bits, Like AH }
         R_SUBW,    { = 3; 16 bits, Like AX }
         R_SUBD,    { = 4; 32 bits, Like EAX }
-        R_SUBQ     { = 5; 64 bits, Like RAX }
+        R_SUBQ,    { = 5; 64 bits, Like RAX }
+        R_SUBF64   { = 6; 64 bits float that allocates 2 FPU registers }
       );
 
       TSuperRegister = type byte;
@@ -370,7 +371,10 @@ implementation
 end.
 {
   $Log$
-  Revision 1.67  2003-10-01 20:34:48  peter
+  Revision 1.68  2003-10-09 21:31:37  daniel
+    * Register allocator splitted, ans abstract now
+
+  Revision 1.67  2003/10/01 20:34:48  peter
     * procinfo unit contains tprocinfo
     * cginfo renamed to cgbase
     * moved cgmessage to verbose

compiler/cgobj.pas

@@ -60,14 +60,41 @@ unit cgobj;
        }
        tcg = class
           alignment : talignment;
+          t_times:cardinal;
           {************************************************}
           {                 basic routines                 }
           constructor create;
 
+          {# Initialize the register allocators needed for the codegenerator.}
           procedure init_register_allocators;virtual;abstract;
+          {# Clean up the register allocators needed for the codegenerator.}
           procedure done_register_allocators;virtual;abstract;
 
-          { returns the tcgsize corresponding with the size of reg }
+          {# Gets a register suitable to do integer operations on.}
+          function getintregister(list:Taasmoutput;size:Tcgsize):Tregister;virtual;abstract;
+          {# Gets a register suitable to do integer operations on.}
+          function getaddressregister(list:Taasmoutput):Tregister;virtual;abstract;
+          function getfpuregister(list:Taasmoutput;size:Tcgsize):Tregister;virtual;abstract;
+          function getabtregister(list:Taasmoutput;size:Tcgsize):Tregister;virtual;abstract;
+          {Does the generic cg need SIMD registers, like getmmxregister? Or should
+           the cpu specific child cg object have such a method?}
+          procedure ungetregister(list:Taasmoutput;r:Tregister);virtual;abstract;
+          procedure ungetreference(list:Taasmoutput;const r:Treference);virtual;abstract;
+
+          procedure add_move_instruction(instr:Taicpu);virtual;abstract;
+
+          {# Get a specific register.}
+          procedure getexplicitregister(list:Taasmoutput;r:Tregister);virtual;abstract;
+          {# Get multiple registers specified.}
+          procedure allocexplicitregisters(list:Taasmoutput;rt:Tregistertype;r:Tsuperregisterset);virtual;abstract;
+          {# Free multiple registers specified.}
+          procedure deallocexplicitregisters(list:Taasmoutput;rt:Tregistertype;r:Tsuperregisterset);virtual;abstract;
+
+          procedure do_register_allocation(list:Taasmoutput;headertai:tai);virtual;abstract;
+
+          function makeregsize(reg:Tregister;size:Tcgsize):Tregister;
+
+          {# Returns the tcgsize corresponding with the size of reg.}
           class function reg_cgsize(const reg: tregister) : tcgsize; virtual;
 
           {# Emit a label to the instruction stream. }
@@ -392,14 +419,14 @@ unit cgobj;
 
              @param(usedinproc Registers which are used in the code of this routine)
           }
-          procedure g_save_standard_registers(list:Taasmoutput;usedinproc:Tsuperregisterset);virtual;abstract;
+          procedure g_save_standard_registers(list:Taasmoutput);virtual;abstract;
           {# This routine is called when generating the code for the exit point
              of a routine. It should restore all registers which were previously
              saved in @var(g_save_standard_registers).
 
              @param(usedinproc Registers which are used in the code of this routine)
           }
-          procedure g_restore_standard_registers(list:Taasmoutput;usedinproc:Tsuperregisterset);virtual;abstract;
+          procedure g_restore_standard_registers(list:Taasmoutput);virtual;abstract;
           procedure g_save_all_registers(list : taasmoutput);virtual;abstract;
           procedure g_restore_all_registers(list : taasmoutput;accused,acchiused:boolean);virtual;abstract;
        end;
@@ -492,8 +519,18 @@ implementation
 
     constructor tcg.create;
 
-      begin
-      end;
+    begin
+    end;
+
+    function Tcg.makeregsize(reg:Tregister;size:Tcgsize):Tregister;
+
+    var subreg:Tsubregister;
+
+    begin
+      subreg:=cgsize2subreg(size);
+      result:=reg;
+      setsubreg(result,subreg);
+    end;
 
     procedure tcg.a_reg_alloc(list : taasmoutput;r : tregister);
 
@@ -543,20 +580,20 @@ implementation
          hr : tregister;
 
       begin
-         hr:=rg.getregisterint(list,size);
+         hr:=getintregister(list,size);
          a_load_const_reg(list,size,a,hr);
          a_param_reg(list,size,hr,locpara);
-         rg.ungetregisterint(list,hr);
+         ungetregister(list,hr);
       end;
 
     procedure tcg.a_param_ref(list : taasmoutput;size : tcgsize;const r : treference;const locpara : tparalocation);
       var
          hr : tregister;
       begin
-         hr:=rg.getregisterint(list,size);
+         hr:=getintregister(list,size);
          a_load_ref_reg(list,size,size,r,hr);
          a_param_reg(list,size,hr,locpara);
-         rg.ungetregisterint(list,hr);
+         ungetregister(list,hr);
       end;
 
 
@@ -581,10 +618,10 @@ implementation
       var
          hr : tregister;
       begin
-         hr:=rg.getaddressregister(list);
+         hr:=getaddressregister(list);
          a_loadaddr_ref_reg(list,r,hr);
          a_param_reg(list,OS_ADDR,hr,locpara);
-         rg.ungetregisterint(list,hr);
+         ungetregister(list,hr);
       end;
 
 
@@ -595,7 +632,7 @@ implementation
          if not(locpara.loc in [LOC_REFERENCE,LOC_CREFERENCE]) then
            internalerror(2003010901);
          reference_reset_base(ref,locpara.reference.index,locpara.reference.offset);
-         cg.g_concatcopy(list,r,ref,size,false,false);
+         g_concatcopy(list,r,ref,size,false,false);
       end;
 
 
@@ -608,25 +645,25 @@ implementation
               if (locpara.size in [OS_S64,OS_64]) then
                 begin
 {$ifdef cpu64bit}
-                  rg.ungetregisterint(list,locpara.register64);
+                  ungetregisterint(list,locpara.register64);
 {$else cpu64bit}
-                  rg.getexplicitregisterint(list,locpara.registerlow);
-                  rg.getexplicitregisterint(list,locpara.registerhigh);
-                  rg.ungetregisterint(list,locpara.registerlow);
-                  rg.ungetregisterint(list,locpara.registerhigh);
+                  getexplicitregister(list,locpara.registerlow);
+                  getexplicitregister(list,locpara.registerhigh);
+                  ungetregister(list,locpara.registerlow);
+                  ungetregister(list,locpara.registerhigh);
 {$endif cpu64bit}
                   cg64.a_load64_reg_ref(list,locpara.register64,ref)
                 end
               else
                 begin
-                  rg.getexplicitregisterint(list,locpara.register);
-                  rg.ungetregisterint(list,locpara.register);
-                  cg.a_load_reg_ref(list,locpara.size,locpara.size,locpara.register,ref);
+                  getexplicitregister(list,locpara.register);
+                  ungetregister(list,locpara.register);
+                  a_load_reg_ref(list,locpara.size,locpara.size,locpara.register,ref);
                 end;
             end;
           LOC_FPUREGISTER,
           LOC_CFPUREGISTER:
-            cg.a_loadfpu_reg_ref(list,locpara.size,locpara.register,ref);
+            a_loadfpu_reg_ref(list,locpara.size,locpara.register,ref);
           else
             internalerror(2002081302);
         end;
@@ -643,23 +680,23 @@ implementation
             begin
               if not(locpara.size in [OS_S64,OS_64]) then
                 begin
-                  rg.getexplicitregisterint(list,locpara.register);
-                  rg.ungetregisterint(list,locpara.register);
-                  rg.getexplicitregisterint(list,reg);
-                  cg.a_load_reg_reg(list,locpara.size,locpara.size,locpara.register,reg)
+                  getexplicitregister(list,locpara.register);
+                  ungetregister(list,locpara.register);
+                  getexplicitregister(list,reg);
+                  a_load_reg_reg(list,locpara.size,locpara.size,locpara.register,reg)
                 end
               else
                 internalerror(2003053011);
             end;
           LOC_CFPUREGISTER,
           LOC_FPUREGISTER:
-            cg.a_loadfpu_reg_reg(list,locpara.size,locpara.register,reg);
+            a_loadfpu_reg_reg(list,locpara.size,locpara.register,reg);
           LOC_REFERENCE,
           LOC_CREFERENCE:
             begin
               reference_reset_base(href,locpara.reference.index,locpara.reference.offset);
-              rg.getexplicitregisterint(list,reg);
-              cg.a_load_ref_reg(list,locpara.size,locpara.size,href,reg);
+              getexplicitregister(list,reg);
+              a_load_ref_reg(list,locpara.size,locpara.size,href,reg);
             end;
           else
             internalerror(2003053010);
@@ -678,10 +715,10 @@ implementation
         { verify if we have the same reference }
         if references_equal(sref,dref) then
           exit;
-        tmpreg:=rg.getregisterint(list,tosize);
+        tmpreg:=getintregister(list,tosize);
         a_load_ref_reg(list,fromsize,tosize,sref,tmpreg);
         a_load_reg_ref(list,tosize,tosize,tmpreg,dref);
-        rg.ungetregisterint(list,tmpreg);
+        ungetregister(list,tmpreg);
       end;
 
 
@@ -689,10 +726,10 @@ implementation
       var
         tmpreg: tregister;
       begin
-        tmpreg:=rg.getregisterint(list,size);
+        tmpreg:=getintregister(list,size);
         a_load_const_reg(list,size,a,tmpreg);
         a_load_reg_ref(list,size,size,tmpreg,ref);
-        rg.ungetregisterint(list,tmpreg);
+        ungetregister(list,tmpreg);
       end;
 
 
@@ -856,10 +893,10 @@ implementation
       var
          hr : tregister;
       begin
-         hr:=rg.getregisterfpu(list,size);
+         hr:=getfpuregister(list,size);
          a_loadfpu_ref_reg(list,size,ref,hr);
          a_paramfpu_reg(list,size,hr,locpara);
-         rg.ungetregisterfpu(list,hr,size);
+         ungetregister(list,hr);
       end;
 
 
@@ -869,11 +906,11 @@ implementation
         tmpreg: tregister;
 
       begin
-        tmpreg:=rg.getregisterint(list,size);
+        tmpreg:=getintregister(list,size);
         a_load_ref_reg(list,size,size,ref,tmpreg);
         a_op_const_reg(list,op,size,a,tmpreg);
         a_load_reg_ref(list,size,size,tmpreg,ref);
-        rg.ungetregisterint(list,tmpreg);
+        ungetregister(list,tmpreg);
       end;
 
 
@@ -897,11 +934,11 @@ implementation
         tmpreg: tregister;
 
       begin
-        tmpreg:=rg.getregisterint(list,size);
+        tmpreg:=getintregister(list,size);
         a_load_ref_reg(list,size,size,ref,tmpreg);
         a_op_reg_reg(list,op,size,reg,tmpreg);
         a_load_reg_ref(list,size,size,tmpreg,ref);
-        rg.ungetregisterint(list,tmpreg);
+        ungetregister(list,tmpreg);
       end;
 
 
@@ -920,10 +957,10 @@ implementation
             end;
           else
             begin
-              tmpreg:=rg.getregisterint(list,size);
+              tmpreg:=getintregister(list,size);
               a_load_ref_reg(list,size,size,ref,tmpreg);
               a_op_reg_reg(list,op,size,tmpreg,reg);
-              rg.ungetregisterint(list,tmpreg);
+              ungetregister(list,tmpreg);
             end;
         end;
       end;
@@ -954,22 +991,23 @@ implementation
             a_op_ref_reg(list,op,loc.size,ref,loc.register);
           LOC_REFERENCE,LOC_CREFERENCE:
             begin
-              tmpreg:=rg.getregisterint(list,loc.size);
+              tmpreg:=getintregister(list,loc.size);
               a_load_ref_reg(list,loc.size,loc.size,ref,tmpreg);
               a_op_reg_ref(list,op,loc.size,tmpreg,loc.reference);
-              rg.ungetregisterint(list,tmpreg);
+              ungetregister(list,tmpreg);
             end;
           else
             internalerror(200109061);
         end;
       end;
 
-    procedure tcg.a_op_const_reg_reg(list: taasmoutput; op: TOpCg;
-        size: tcgsize; a: aword; src, dst: tregister);
-      begin
-        a_load_reg_reg(list,size,size,src,dst);
-        a_op_const_reg(list,op,size,a,dst);
-      end;
+    procedure Tcg.a_op_const_reg_reg(list:Taasmoutput;op:Topcg;size:Tcgsize;
+                                     a:aword;src,dst:Tregister);
+
+    begin
+      a_load_reg_reg(list,size,size,src,dst);
+      a_op_const_reg(list,op,size,a,dst);
+    end;
 
     procedure tcg.a_op_reg_reg_reg(list: taasmoutput; op: TOpCg;
         size: tcgsize; src1, src2, dst: tregister);
@@ -983,11 +1021,11 @@ implementation
           end
         else
           begin
-            tmpreg := rg.getregisterint(list,size);
+            tmpreg:=cg.getintregister(list,size);
             a_load_reg_reg(list,size,size,src2,tmpreg);
             a_op_reg_reg(list,op,size,src1,tmpreg);
             a_load_reg_reg(list,size,size,tmpreg,dst);
-            rg.ungetregisterint(list,tmpreg);
+            ungetregister(list,tmpreg);
           end;
       end;
 
@@ -1000,10 +1038,10 @@ implementation
         tmpreg: tregister;
 
       begin
-        tmpreg:=rg.getregisterint(list,size);
+        tmpreg:=getintregister(list,size);
         a_load_ref_reg(list,size,size,ref,tmpreg);
         a_cmp_const_reg_label(list,size,cmp_op,a,tmpreg,l);
-        rg.ungetregisterint(list,tmpreg);
+        ungetregister(list,tmpreg);
       end;
 
     procedure tcg.a_cmp_const_loc_label(list : taasmoutput;size : tcgsize;cmp_op : topcmp;a : aword;const loc : tlocation;
@@ -1026,10 +1064,10 @@ implementation
         tmpreg: tregister;
 
       begin
-        tmpreg:=rg.getregisterint(list,size);
+        tmpreg:=getintregister(list,size);
         a_load_ref_reg(list,size,size,ref,tmpreg);
         a_cmp_reg_reg_label(list,size,cmp_op,tmpreg,reg,l);
-        rg.ungetregisterint(list,tmpreg);
+        ungetregister(list,tmpreg);
       end;
 
     procedure tcg.a_cmp_loc_reg_label(list : taasmoutput;size : tcgsize;cmp_op : topcmp; const loc: tlocation; reg : tregister; l : tasmlabel);
@@ -1061,10 +1099,10 @@ implementation
             a_cmp_ref_reg_label(list,size,cmp_op,ref,loc.register,l);
           LOC_REFERENCE,LOC_CREFERENCE:
             begin
-              tmpreg := rg.getregisterint(list,size);
+              tmpreg:=getintregister(list,size);
               a_load_ref_reg(list,size,size,loc.reference,tmpreg);
               a_cmp_ref_reg_label(list,size,cmp_op,ref,tmpreg,l);
-              rg.ungetregisterint(list,tmpreg);
+              ungetregister(list,tmpreg);
             end
           else
             internalerror(200109061);
@@ -1102,9 +1140,9 @@ implementation
         paramanager.freeparaloc(list,paraloc3);
         paramanager.freeparaloc(list,paraloc2);
         paramanager.freeparaloc(list,paraloc1);
-        rg.allocexplicitregistersint(list,paramanager.get_volatile_registers_int(pocall_default));
+        allocexplicitregisters(list,R_INTREGISTER,paramanager.get_volatile_registers_int(pocall_default));
         a_call_name(list,'FPC_SHORTSTR_ASSIGN');
-        rg.deallocexplicitregistersint(list,paramanager.get_volatile_registers_int(pocall_default));
+        deallocexplicitregisters(list,R_INTREGISTER,paramanager.get_volatile_registers_int(pocall_default));
       end;
 
 
@@ -1135,9 +1173,9 @@ implementation
             paramanager.allocparaloc(list,paraloc1);
             a_param_ref(list,OS_ADDR,ref,paraloc1);
             paramanager.freeparaloc(list,paraloc1);
-            rg.allocexplicitregistersint(list,paramanager.get_volatile_registers_int(pocall_default));
+            allocexplicitregisters(list,R_INTREGISTER,paramanager.get_volatile_registers_int(pocall_default));
             a_call_name(list,incrfunc);
-            rg.deallocexplicitregistersint(list,paramanager.get_volatile_registers_int(pocall_default));
+            deallocexplicitregisters(list,R_INTREGISTER,paramanager.get_volatile_registers_int(pocall_default));
           end
          else
           begin
@@ -1151,9 +1189,9 @@ implementation
               a_paramaddr_ref(list,ref,paraloc1);
             paramanager.freeparaloc(list,paraloc1);
             paramanager.freeparaloc(list,paraloc2);
-            rg.allocexplicitregistersint(list,paramanager.get_volatile_registers_int(pocall_default));
+            allocexplicitregisters(list,R_INTREGISTER,paramanager.get_volatile_registers_int(pocall_default));
             a_call_name(list,'FPC_ADDREF');
-            rg.deallocexplicitregistersint(list,paramanager.get_volatile_registers_int(pocall_default));
+            deallocexplicitregisters(list,R_INTREGISTER,paramanager.get_volatile_registers_int(pocall_default));
          end;
       end;
 
@@ -1198,9 +1236,9 @@ implementation
             paramanager.freeparaloc(list,paraloc1);
             if needrtti then
               paramanager.freeparaloc(list,paraloc2);
-            rg.allocexplicitregistersint(list,paramanager.get_volatile_registers_int(pocall_default));
+            allocexplicitregisters(list,R_INTREGISTER,paramanager.get_volatile_registers_int(pocall_default));
             a_call_name(list,decrfunc);
-            rg.deallocexplicitregistersint(list,paramanager.get_volatile_registers_int(pocall_default));
+            deallocexplicitregisters(list,R_INTREGISTER,paramanager.get_volatile_registers_int(pocall_default));
           end
          else
           begin
@@ -1214,9 +1252,9 @@ implementation
               a_paramaddr_ref(list,ref,paraloc1);
             paramanager.freeparaloc(list,paraloc1);
             paramanager.freeparaloc(list,paraloc2);
-            rg.allocexplicitregistersint(list,paramanager.get_volatile_registers_int(pocall_default));
+            allocexplicitregisters(list,R_INTREGISTER,paramanager.get_volatile_registers_int(pocall_default));
             a_call_name(list,'FPC_DECREF');
-            rg.deallocexplicitregistersint(list,paramanager.get_volatile_registers_int(pocall_default));
+            deallocexplicitregisters(list,R_INTREGISTER,paramanager.get_volatile_registers_int(pocall_default));
          end;
       end;
 
@@ -1244,9 +1282,9 @@ implementation
                 a_paramaddr_ref(list,ref,paraloc1);
               paramanager.freeparaloc(list,paraloc1);
               paramanager.freeparaloc(list,paraloc2);
-              rg.allocexplicitregistersint(list,paramanager.get_volatile_registers_int(pocall_default));
+              allocexplicitregisters(list,R_INTREGISTER,paramanager.get_volatile_registers_int(pocall_default));
               a_call_name(list,'FPC_INITIALIZE');
-              rg.deallocexplicitregistersint(list,paramanager.get_volatile_registers_int(pocall_default));
+              deallocexplicitregisters(list,R_INTREGISTER,paramanager.get_volatile_registers_int(pocall_default));
            end;
       end;
 
@@ -1274,9 +1312,9 @@ implementation
                 a_paramaddr_ref(list,ref,paraloc1);
               paramanager.freeparaloc(list,paraloc1);
               paramanager.freeparaloc(list,paraloc2);
-              rg.allocexplicitregistersint(list,paramanager.get_volatile_registers_int(pocall_default));
+              allocexplicitregisters(list,R_INTREGISTER,paramanager.get_volatile_registers_int(pocall_default));
               a_call_name(list,'FPC_FINALIZE');
-              rg.deallocexplicitregistersint(list,paramanager.get_volatile_registers_int(pocall_default));
+              deallocexplicitregisters(list,R_INTREGISTER,paramanager.get_volatile_registers_int(pocall_default));
            end;
       end;
 
@@ -1379,13 +1417,13 @@ implementation
               if lto < 0 then
                 lto := 0;
             end;
-        hreg:=rg.getregisterint(list,OS_INT);
+        hreg:=getintregister(list,OS_INT);
         a_load_loc_reg(list,OS_INT,l,hreg);
         a_op_const_reg(list,OP_SUB,OS_INT,aword(lto),hreg);
         objectlibrary.getlabel(neglabel);
         a_cmp_const_reg_label(list,OS_INT,OC_BE,aword(hto-lto),hreg,neglabel);
         { !!! should happen right after the compare (JM) }
-        rg.ungetregisterint(list,hreg);
+        ungetregister(list,hreg);
         a_call_name(list,'FPC_RANGEERROR');
         a_label(list,neglabel);
       end;
@@ -1409,10 +1447,10 @@ implementation
       var
         tmpreg : tregister;
       begin
-        tmpreg:=rg.getregisterint(list,size);
+        tmpreg:=getintregister(list,size);
         g_flags2reg(list,size,f,tmpreg);
         a_load_reg_ref(list,size,size,tmpreg,ref);
-        rg.ungetregisterint(list,tmpreg);
+        ungetregister(list,tmpreg);
       end;
 
 
@@ -1526,7 +1564,10 @@ finalization
 end.
 {
   $Log$
-  Revision 1.126  2003-10-01 20:34:48  peter
+  Revision 1.127  2003-10-09 21:31:37  daniel
+    * Register allocator splitted, ans abstract now
+
+  Revision 1.126  2003/10/01 20:34:48  peter
     * procinfo unit contains tprocinfo
     * cginfo renamed to cgbase
     * moved cgmessage to verbose

compiler/i386/n386add.pas

@@ -61,7 +61,7 @@ interface
       aasmbase,aasmtai,aasmcpu,defutil,htypechk,
       cgbase,pass_2,regvars,
       ncon,nset,
-      cga,ncgutil,tgobj,rgobj,cgobj,cg64f32,rgcpu;
+      cga,cgx86,ncgutil,tgobj,rgobj,cgobj,cg64f32,rgcpu;
 
 {*****************************************************************************
                                   Helpers
@@ -222,11 +222,11 @@ interface
             begin
               if extra_not then
                 emit_reg(A_NOT,opsize,left.location.register);
-              r:=rg.getregisterint(exprasmlist,OS_INT);
+              r:=cg.getintregister(exprasmlist,OS_INT);
               cg.a_load_loc_reg(exprasmlist,OS_INT,right.location,r);
               emit_reg_reg(op,opsize,left.location.register,r);
               emit_reg_reg(A_MOV,opsize,r,left.location.register);
-              rg.ungetregisterint(exprasmlist,r);
+              cg.ungetregister(exprasmlist,r);
             end
            else
             begin
@@ -266,11 +266,11 @@ interface
                  begin
                    if extra_not then
                      begin
-                        r:=rg.getregisterint(exprasmlist,OS_INT);
+                        r:=cg.getintregister(exprasmlist,OS_INT);
                         cg.a_load_loc_reg(exprasmlist,OS_INT,right.location,r);
                         emit_reg(A_NOT,S_L,r);
                         emit_reg_reg(A_AND,S_L,r,left.location.register);
-                        rg.ungetregisterint(exprasmlist,r);
+                        cg.ungetregister(exprasmlist,r);
                      end
                    else
                      begin
@@ -292,7 +292,7 @@ interface
               if unsigned then
                 cg.a_jmp_flags(exprasmlist,F_AE,hl4)
               else
-                cg.a_jmp_flags(exprasmlist,F_GE,hl4);
+                cg.a_jmp_flags(exprasmlist,F_NO,hl4);
               cg.a_call_name(exprasmlist,'FPC_OVERFLOW');
               cg.a_label(exprasmlist,hl4);
             end;
@@ -352,7 +352,7 @@ interface
                        location_release(exprasmlist,left.location);
                        if paraloc2.loc=LOC_REGISTER then
                          begin
-                           hregister2:=rg.getaddressregister(exprasmlist);
+                           hregister2:=cg.getaddressregister(exprasmlist);
                            cg.a_loadaddr_ref_reg(exprasmlist,left.location.reference,hregister2);
                          end
                        else
@@ -364,7 +364,7 @@ interface
                        location_release(exprasmlist,right.location);
                        if paraloc1.loc=LOC_REGISTER then
                          begin
-                           hregister1:=rg.getaddressregister(exprasmlist);
+                           hregister1:=cg.getaddressregister(exprasmlist);
                            cg.a_loadaddr_ref_reg(exprasmlist,right.location.reference,hregister1);
                          end
                        else
@@ -375,21 +375,21 @@ interface
                        { push parameters }
                        if paraloc1.loc=LOC_REGISTER then
                          begin
-                           rg.ungetregisterint(exprasmlist,hregister2);
+                           cg.ungetregister(exprasmlist,hregister2);
                            paramanager.allocparaloc(exprasmlist,paraloc2);
                            cg.a_param_reg(exprasmlist,OS_ADDR,hregister2,paraloc2);
                          end;
                        if paraloc2.loc=LOC_REGISTER then
                          begin
-                           rg.ungetregisterint(exprasmlist,hregister1);
+                           cg.ungetregister(exprasmlist,hregister1);
                            paramanager.allocparaloc(exprasmlist,paraloc1);
                            cg.a_param_reg(exprasmlist,OS_ADDR,hregister1,paraloc1);
                          end;
                        paramanager.freeparaloc(exprasmlist,paraloc1);
                        paramanager.freeparaloc(exprasmlist,paraloc2);
-                       rg.allocexplicitregistersint(exprasmlist,paramanager.get_volatile_registers_int(pocall_default));
+                       cg.allocexplicitregisters(exprasmlist,R_INTREGISTER,paramanager.get_volatile_registers_int(pocall_default));
                        cg.a_call_name(exprasmlist,'FPC_SHORTSTR_COMPARE');
-                       rg.deallocexplicitregistersint(exprasmlist,paramanager.get_volatile_registers_int(pocall_default));
+                       cg.deallocexplicitregisters(exprasmlist,R_INTREGISTER,paramanager.get_volatile_registers_int(pocall_default));
                        location_freetemp(exprasmlist,left.location);
                        location_freetemp(exprasmlist,right.location);
                      end;
@@ -631,21 +631,22 @@ interface
         if op<>A_FCOMPP then
           begin
              emit_reg_reg(op,S_NO,NR_ST,NR_ST1);
-             dec(trgcpu(rg).fpuvaroffset);
+             tcgx86(cg).dec_fpu_stack;
           end
         else
           begin
              emit_none(op,S_NO);
-             dec(trgcpu(rg).fpuvaroffset,2);
+             tcgx86(cg).dec_fpu_stack;
+             tcgx86(cg).dec_fpu_stack;
           end;
 
         { on comparison load flags }
         if cmpop then
          begin
-           r:=rg.getexplicitregisterint(exprasmlist,NR_AX);
-           emit_reg(A_FNSTSW,S_NO,r);
+           cg.getexplicitregister(exprasmlist,NR_AX);
+           emit_reg(A_FNSTSW,S_NO,NR_AX);
            emit_none(A_SAHF,S_NO);
-           rg.ungetregisterint(exprasmlist,r);
+           cg.ungetregister(exprasmlist,NR_AX);
            if nf_swaped in flags then
             begin
               case nodetype of
@@ -930,8 +931,8 @@ interface
               if not((left.location.loc=LOC_CREGISTER) and cmpop) then
                begin
                  delete:=left.location.loc<>LOC_CREGISTER;
-                 hregister:=rg.getregisterint(exprasmlist,OS_INT);
-                 hregister2:=rg.getregisterint(exprasmlist,OS_INT);
+                 hregister:=cg.getintregister(exprasmlist,OS_INT);
+                 hregister2:=cg.getintregister(exprasmlist,OS_INT);
                  cg64.a_load64_loc_reg(exprasmlist,left.location,joinreg64(hregister,hregister2),delete);
                  location_reset(left.location,LOC_REGISTER,OS_64);
                  left.location.registerlow:=hregister;
@@ -977,7 +978,7 @@ interface
            { right.location<>LOC_REGISTER }
            if (nodetype=subn) and (nf_swaped in flags) then
             begin
-              r:=rg.getregisterint(exprasmlist,OS_INT);
+              r:=cg.getintregister(exprasmlist,OS_INT);
               cg64.a_load64low_loc_reg(exprasmlist,right.location,r);
               emit_reg_reg(op1,opsize,left.location.registerlow,r);
               emit_reg_reg(A_MOV,opsize,r,left.location.registerlow);
@@ -985,7 +986,7 @@ interface
               { the carry flag is still ok }
               emit_reg_reg(op2,opsize,left.location.registerhigh,r);
               emit_reg_reg(A_MOV,opsize,r,left.location.registerhigh);
-              rg.ungetregisterint(exprasmlist,r);
+              cg.ungetregister(exprasmlist,r);
               if right.location.loc<>LOC_CREGISTER then
                begin
                  location_freetemp(exprasmlist,right.location);
@@ -1057,7 +1058,7 @@ interface
               if unsigned then
                cg.a_jmp_flags(exprasmlist,F_AE,hl4)
               else
-               cg.a_jmp_flags(exprasmlist,F_GE,hl4);
+               cg.a_jmp_flags(exprasmlist,F_NO,hl4);
               cg.a_call_name(exprasmlist,'FPC_OVERFLOW');
               cg.a_label(exprasmlist,hl4);
             end;
@@ -1084,6 +1085,7 @@ interface
         mmxbase    : tmmxtype;
         r,hregister  : tregister;
       begin
+      (*
         pass_left_and_right(pushedfpu);
 
         cmpop:=false;
@@ -1252,6 +1254,7 @@ interface
            location_release(exprasmlist,left.location);
          end;
         set_result_location(cmpop,true);
+        *)
       end;
 {$endif SUPPORT_MMX}
 
@@ -1268,25 +1271,25 @@ interface
       location_reset(location,LOC_REGISTER,OS_INT);
       {Get a temp register and load the left value into it
        and free the location.}
-      r:=rg.getregisterint(exprasmlist,OS_INT);
+      r:=cg.getintregister(exprasmlist,OS_INT);
       cg.a_load_loc_reg(exprasmlist,OS_INT,left.location,r);
       location_release(exprasmlist,left.location);
       {Allocate EAX.}
-      rg.getexplicitregisterint(exprasmlist,NR_EAX);
+      cg.getexplicitregister(exprasmlist,NR_EAX);
       {Load the right value.}
       cg.a_load_loc_reg(exprasmlist,OS_INT,right.location,NR_EAX);
       location_release(exprasmlist,right.location);
       {The mul instruction frees register r.}
-      rg.ungetregisterint(exprasmlist,r);
+      cg.ungetregister(exprasmlist,r);
       {Also allocate EDX, since it is also modified by a mul (JM).}
-      rg.getexplicitregisterint(exprasmlist,NR_EDX);
+      cg.getexplicitregister(exprasmlist,NR_EDX);
       emit_reg(A_MUL,S_L,r);
       {Free EDX}
-      rg.ungetregisterint(exprasmlist,NR_EDX);
+      cg.ungetregister(exprasmlist,NR_EDX);
       {Free EAX}
-      rg.ungetregisterint(exprasmlist,NR_EAX);
+      cg.ungetregister(exprasmlist,NR_EAX);
       {Allocate a new register and store the result in EAX in it.}
-      location.register:=rg.getregisterint(exprasmlist,OS_INT);
+      location.register:=cg.getintregister(exprasmlist,OS_INT);
       emit_reg_reg(A_MOV,S_L,NR_EAX,location.register);
       location_freetemp(exprasmlist,left.location);
       location_freetemp(exprasmlist,right.location);
@@ -1489,7 +1492,10 @@ begin
 end.
 {
   $Log$
-  Revision 1.81  2003-10-08 09:13:16  florian
+  Revision 1.82  2003-10-09 21:31:37  daniel
+    * Register allocator splitted, ans abstract now
+
+  Revision 1.81  2003/10/08 09:13:16  florian
     * fixed full bool evalution and bool xor, if the left or right side have LOC_JUMP
 
   Revision 1.80  2003/10/01 20:34:49  peter

compiler/i386/n386cal.pas

@@ -136,9 +136,9 @@ implementation
         { better than an add on all processors }
         if pop_size=4 then
           begin
-            hreg:=rg.getregisterint(exprasmlist,OS_INT);
+            hreg:=cg.getintregister(exprasmlist,OS_INT);
             exprasmlist.concat(taicpu.op_reg(A_POP,S_L,hreg));
-            rg.ungetregisterint(exprasmlist,hreg);
+            cg.ungetregister(exprasmlist,hreg);
           end
         { the pentium has two pipes and pop reg is pairable }
         { but the registers must be different!        }
@@ -147,12 +147,12 @@ implementation
              not(cs_littlesize in aktglobalswitches) and
              (aktoptprocessor=ClassP5) then
             begin
-               hreg:=rg.getregisterint(exprasmlist,OS_INT);
+               hreg:=cg.getintregister(exprasmlist,OS_INT);
                exprasmlist.concat(taicpu.op_reg(A_POP,S_L,hreg));
-               rg.ungetregisterint(exprasmlist,hreg);
-               hreg:=rg.getregisterint(exprasmlist,OS_INT);
+               cg.ungetregister(exprasmlist,hreg);
+               hreg:=cg.getintregister(exprasmlist,OS_INT);
                exprasmlist.concat(taicpu.op_reg(A_POP,S_L,hreg));
-               rg.ungetregisterint(exprasmlist,hreg);
+               cg.ungetregister(exprasmlist,hreg);
             end
         else
           if pop_size<>0 then
@@ -170,7 +170,10 @@ begin
 end.
 {
   $Log$
-  Revision 1.96  2003-10-01 20:34:49  peter
+  Revision 1.97  2003-10-09 21:31:37  daniel
+    * Register allocator splitted, ans abstract now
+
+  Revision 1.96  2003/10/01 20:34:49  peter
     * procinfo unit contains tprocinfo
     * cginfo renamed to cgbase
     * moved cgmessage to verbose

compiler/i386/n386cnv.pas

@@ -67,7 +67,7 @@ implementation
       cgbase,pass_2,
       ncon,ncal,ncnv,
       cpubase,
-      cgobj,cga,tgobj,rgobj,rgcpu,ncgutil;
+      cgobj,cga,cgx86,tgobj,rgobj,rgcpu,ncgutil;
 
 
     function ti386typeconvnode.first_int_to_real : tnode;
@@ -112,7 +112,7 @@ implementation
                    hregister:=left.location.register;
                  else
                    begin
-                     hregister:=rg.getregisterint(exprasmlist,OS_32);
+                     hregister:=cg.getintregister(exprasmlist,OS_32);
                      freereg:=true;
                      cg.a_load_reg_reg(exprasmlist,left.location.size,OS_32,left.location.register,hregister);
                    end;
@@ -121,7 +121,7 @@ implementation
            LOC_REFERENCE,
            LOC_CREFERENCE :
              begin
-               hregister:=rg.getregisterint(exprasmlist,OS_INT);
+               hregister:=cg.getintregister(exprasmlist,OS_INT);
                freereg:=true;
                if left.location.size in [OS_64,OS_S64] then
                 begin
@@ -143,7 +143,7 @@ implementation
          { for 64 bit integers, the high dword is already pushed }
          exprasmlist.concat(taicpu.op_reg(A_PUSH,S_L,hregister));
          if freereg then
-           rg.ungetregisterint(exprasmlist,hregister);
+           cg.ungetregister(exprasmlist,hregister);
          reference_reset_base(href,NR_ESP,0);
          case torddef(left.resulttype.def).typ of
            u32bit:
@@ -164,12 +164,12 @@ implementation
                 { if it is 1 then we add $80000000 000000000 }
                 { as double                                  }
                 inc(href.offset,4);
-                hregister:=rg.getregisterint(exprasmlist,OS_32);
+                hregister:=cg.getintregister(exprasmlist,OS_32);
                 cg.a_load_ref_reg(exprasmlist,OS_INT,OS_INT,href,hregister);
                 reference_reset_base(href,NR_ESP,4);
                 emit_const_ref(A_AND,S_L,$7fffffff,href);
                 emit_const_reg(A_TEST,S_L,longint($80000000),hregister);
-                rg.ungetregisterint(exprasmlist,hregister);
+                cg.ungetregister(exprasmlist,hregister);
                 reference_reset_base(href,NR_ESP,0);
                 emit_ref(A_FILD,S_IQ,href);
                 objectlibrary.getdatalabel(l1);
@@ -187,12 +187,12 @@ implementation
            else
              begin
                 emit_ref(A_FILD,S_IL,href);
-                hregister:=rg.getregisterint(exprasmlist,OS_32);
+                hregister:=cg.getintregister(exprasmlist,OS_32);
                 emit_reg(A_POP,S_L,hregister);
-                rg.ungetregisterint(exprasmlist,hregister);
+                cg.ungetregister(exprasmlist,hregister);
              end;
          end;
-         inc(trgcpu(rg).fpuvaroffset);
+         tcgx86(cg).inc_fpu_stack;
          location.register:=NR_ST;
       end;
 
@@ -209,7 +209,7 @@ implementation
           r^.base:=p^.location.register
          else
            begin
-              rg.getexplicitregisterint(exprasmlist,R_EDI);
+              cg.getexplicitregister(exprasmlist,R_EDI);
               emit_mov_loc_reg(p^.location,R_EDI);
               r^.base:=R_EDI;
            end;
@@ -332,7 +332,10 @@ begin
 end.
 {
   $Log$
-  Revision 1.65  2003-10-01 20:34:49  peter
+  Revision 1.66  2003-10-09 21:31:37  daniel
+    * Register allocator splitted, ans abstract now
+
+  Revision 1.65  2003/10/01 20:34:49  peter
     * procinfo unit contains tprocinfo
     * cginfo renamed to cgbase
     * moved cgmessage to verbose

compiler/i386/n386con.pas

@@ -41,7 +41,7 @@ implementation
       systems,globtype,globals,
       defutil,
       cpubase,
-      cga,cgbase,rgobj,rgcpu;
+      cga,cgx86,cgobj,cgbase,rgobj,rgcpu;
 
 {*****************************************************************************
                            TI386REALCONSTNODE
@@ -69,14 +69,14 @@ implementation
                   emit_none(A_FLD1,S_NO);
                   location_reset(location,LOC_FPUREGISTER,def_cgsize(resulttype.def));
                   location.register:=NR_ST;
-                  inc(trgcpu(rg).fpuvaroffset);
+                  tcgx86(cg).inc_fpu_stack;
                end
              else if (value_real=0.0) then
                begin
                   emit_none(A_FLDZ,S_NO);
                   location_reset(location,LOC_FPUREGISTER,def_cgsize(resulttype.def));
                   location.register:=NR_ST;
-                  inc(trgcpu(rg).fpuvaroffset);
+                  tcgx86(cg).inc_fpu_stack;
                end
             else
               inherited pass_2;
@@ -91,7 +91,10 @@ begin
 end.
 {
   $Log$
-  Revision 1.22  2003-10-01 20:34:49  peter
+  Revision 1.23  2003-10-09 21:31:37  daniel
+    * Register allocator splitted, ans abstract now
+
+  Revision 1.22  2003/10/01 20:34:49  peter
     * procinfo unit contains tprocinfo
     * cginfo renamed to cgbase
     * moved cgmessage to verbose

compiler/i386/n386inl.pas

@@ -67,7 +67,7 @@ implementation
       cgbase,pass_2,
       cpubase,paramgr,
       nbas,ncon,ncal,ncnv,nld,
-      cga,tgobj,ncgutil,cgobj,rgobj,rgcpu;
+      cga,cgx86,tgobj,ncgutil,cgobj,rgobj,rgcpu;
 
 
 {*****************************************************************************
@@ -164,7 +164,7 @@ implementation
        begin
          location_reset(location,LOC_FPUREGISTER,def_cgsize(resulttype.def));
          emit_none(A_FLDPI,S_NO);
-         inc(trgcpu(rg).fpuvaroffset);
+         tcgx86(cg).inc_fpu_stack;
          location.register:=NR_FPU_RESULT_REG;
        end;
 
@@ -301,11 +301,11 @@ implementation
                 { need a cmp and jmp, but this should be done by the         }
                 { type cast code which does range checking if necessary (FK) }
                 begin
-                  hregister:=rg.makeregsize(Tcallparanode(Tcallparanode(left).right).left.location.register,OS_INT);
+                  hregister:=cg.makeregsize(Tcallparanode(Tcallparanode(left).right).left.location.register,OS_INT);
                 end
               else
                 begin
-                  hregister:=rg.getregisterint(exprasmlist,OS_INT);
+                  hregister:=cg.getintregister(exprasmlist,OS_INT);
                 end;
               location_release(exprasmlist,tcallparanode(tcallparanode(left).right).left.location);
               cg.a_load_loc_reg(exprasmlist,OS_INT,tcallparanode(tcallparanode(left).right).left.location,hregister);
@@ -313,7 +313,7 @@ implementation
                 emit_reg_ref(asmop,S_L,hregister,tcallparanode(left).left.location.reference)
               else
                 emit_reg_reg(asmop,S_L,hregister,tcallparanode(left).left.location.register);
-              rg.ungetregisterint(exprasmlist,hregister);
+              cg.ungetregister(exprasmlist,hregister);
               location_release(exprasmlist,Tcallparanode(left).left.location);
             end;
         end;
@@ -324,7 +324,10 @@ begin
 end.
 {
   $Log$
-  Revision 1.68  2003-10-01 20:34:49  peter
+  Revision 1.69  2003-10-09 21:31:37  daniel
+    * Register allocator splitted, ans abstract now
+
+  Revision 1.68  2003/10/01 20:34:49  peter
     * procinfo unit contains tprocinfo
     * cginfo renamed to cgbase
     * moved cgmessage to verbose

compiler/i386/n386mat.pas

@@ -108,7 +108,7 @@ implementation
                   comp.compilers (JM) }
                 begin
                   { no jumps, but more operations }
-                  hreg2:=rg.getregisterint(exprasmlist,OS_INT);
+                  hreg2:=cg.getintregister(exprasmlist,OS_INT);
                   emit_reg_reg(A_MOV,S_L,hreg1,hreg2);
                   {If the left value is signed, hreg2=$ffffffff, otherwise 0.}
                   emit_const_reg(A_SAR,S_L,31,hreg2);
@@ -117,7 +117,7 @@ implementation
                   { add to the left value }
                   emit_reg_reg(A_ADD,S_L,hreg2,hreg1);
                   { release EDX if we used it }
-                  rg.ungetregisterint(exprasmlist,hreg2);
+                  cg.ungetregister(exprasmlist,hreg2);
                   { do the shift }
                   emit_const_reg(A_SAR,S_L,power,hreg1);
                 end
@@ -142,10 +142,10 @@ implementation
       else
         begin
           {Bring denominator to a register.}
-          rg.ungetregisterint(exprasmlist,hreg1);
-          rg.getexplicitregisterint(exprasmlist,NR_EAX);
+          cg.ungetregister(exprasmlist,hreg1);
+          cg.getexplicitregister(exprasmlist,NR_EAX);
           emit_reg_reg(A_MOV,S_L,hreg1,NR_EAX);
-          rg.getexplicitregisterint(exprasmlist,NR_EDX);
+          cg.getexplicitregister(exprasmlist,NR_EDX);
           {Sign extension depends on the left type.}
           if torddef(left.resulttype.def).typ=u32bit then
             emit_reg_reg(A_XOR,S_L,NR_EDX,NR_EDX)
@@ -164,9 +164,9 @@ implementation
             emit_reg(op,S_L,right.location.register)
           else
             begin
-              hreg1:=rg.getregisterint(exprasmlist,right.location.size);
+              hreg1:=cg.getintregister(exprasmlist,right.location.size);
               cg.a_load_loc_reg(exprasmlist,OS_32,right.location,hreg1);
-              rg.ungetregisterint(exprasmlist,hreg1);
+              cg.ungetregister(exprasmlist,hreg1);
               emit_reg(op,S_L,hreg1);
             end;
           location_release(exprasmlist,right.location);
@@ -174,16 +174,16 @@ implementation
           {Copy the result into a new register. Release EAX & EDX.}
           if nodetype=divn then
             begin
-              rg.ungetregisterint(exprasmlist,NR_EDX);
-              rg.ungetregisterint(exprasmlist,NR_EAX);
-              location.register:=rg.getregisterint(exprasmlist,OS_INT);
+              cg.ungetregister(exprasmlist,NR_EDX);
+              cg.ungetregister(exprasmlist,NR_EAX);
+              location.register:=cg.getintregister(exprasmlist,OS_INT);
               emit_reg_reg(A_MOV,S_L,NR_EAX,location.register);
             end
           else
             begin
-              rg.ungetregisterint(exprasmlist,NR_EAX);
-              rg.ungetregisterint(exprasmlist,NR_EDX);
-              location.register:=rg.getregisterint(exprasmlist,OS_INT);
+              cg.ungetregister(exprasmlist,NR_EAX);
+              cg.ungetregister(exprasmlist,NR_EDX);
+              location.register:=cg.getintregister(exprasmlist,OS_INT);
               emit_reg_reg(A_MOV,S_L,NR_EDX,location.register);
             end;
         end;
@@ -203,7 +203,7 @@ implementation
 
     procedure ti386shlshrnode.pass_2;
 
-    var hregister2,hregisterhigh,hregisterlow:Tregister;
+    var hregisterhigh,hregisterlow:Tregister;
         op:Tasmop;
         l1,l2,l3:Tasmlabel;
 
@@ -272,8 +272,8 @@ implementation
           else
             begin
               { load right operators in a register }
-              hregister2:=rg.getexplicitregisterint(exprasmlist,NR_ECX);
-              cg.a_load_loc_reg(exprasmlist,OS_32,right.location,hregister2);
+              cg.getexplicitregister(exprasmlist,NR_ECX);
+              cg.a_load_loc_reg(exprasmlist,OS_32,right.location,NR_ECX);
               if right.location.loc<>LOC_CREGISTER then
                 location_release(exprasmlist,right.location);
 
@@ -286,15 +286,15 @@ implementation
               objectlibrary.getlabel(l1);
               objectlibrary.getlabel(l2);
               objectlibrary.getlabel(l3);
-              emit_const_reg(A_CMP,S_L,64,hregister2);
+              emit_const_reg(A_CMP,S_L,64,NR_ECX);
               cg.a_jmp_flags(exprasmlist,F_L,l1);
               emit_reg_reg(A_XOR,S_L,hregisterlow,hregisterlow);
               emit_reg_reg(A_XOR,S_L,hregisterhigh,hregisterhigh);
               cg.a_jmp_always(exprasmlist,l3);
               cg.a_label(exprasmlist,l1);
-              emit_const_reg(A_CMP,S_L,32,hregister2);
+              emit_const_reg(A_CMP,S_L,32,NR_ECX);
               cg.a_jmp_flags(exprasmlist,F_L,l2);
-              emit_const_reg(A_SUB,S_L,32,hregister2);
+              emit_const_reg(A_SUB,S_L,32,NR_ECX);
               if nodetype=shln then
                 begin
                   emit_reg_reg(A_SHL,S_L,NR_CL,hregisterlow);
@@ -317,7 +317,7 @@ implementation
                 end;
               cg.a_label(exprasmlist,l3);
 
-              rg.ungetregisterint(exprasmlist,hregister2);
+              cg.ungetregister(exprasmlist,NR_ECX);
               location.registerlow:=hregisterlow;
               location.registerhigh:=hregisterhigh;
             end;
@@ -337,12 +337,12 @@ implementation
               { load right operators in a ECX }
               if right.location.loc<>LOC_CREGISTER then
                 location_release(exprasmlist,right.location);
-              hregister2:=rg.getexplicitregisterint(exprasmlist,NR_ECX);
-              cg.a_load_loc_reg(exprasmlist,OS_32,right.location,hregister2);
+              cg.getexplicitregister(exprasmlist,NR_ECX);
+              cg.a_load_loc_reg(exprasmlist,OS_32,right.location,NR_ECX);
 
               { right operand is in ECX }
+              cg.ungetregister(exprasmlist,NR_ECX);
               emit_reg_reg(op,S_L,NR_CL,location.register);
-              rg.ungetregisterint(exprasmlist,hregister2);
             end;
         end;
     end;
@@ -388,6 +388,7 @@ implementation
       var
         op : tasmop;
       begin
+      (*
         secondpass(left);
         location_reset(location,LOC_MMXREGISTER,OS_NO);
         case left.location.loc of
@@ -435,6 +436,7 @@ implementation
           end;
         emit_reg_reg(op,S_NO,location.register,NR_MM7);
         emit_reg_reg(A_MOVQ,S_NO,NR_MM7,location.register);
+        *)
       end;
 {$endif SUPPORT_MMX}
 
@@ -528,9 +530,10 @@ implementation
     var r:Tregister;
 
     begin
+    (*
       secondpass(left);
       location_reset(location,LOC_MMXREGISTER,OS_NO);
-      r:=rg.getregisterint(exprasmlist,OS_INT);
+      r:=cg.getintregister(exprasmlist,OS_INT);
       emit_const_reg(A_MOV,S_L,longint($ffffffff),r);
       { load operand }
       case left.location.loc of
@@ -558,6 +561,7 @@ implementation
       emit_const_reg(A_PSLLQ,S_NO,32,NR_MM7);
       { higher 32 bit }
       emit_reg_reg(A_PXOR,S_D,NR_MM7,location.register);
+      *)
     end;
 {$endif SUPPORT_MMX}
 
@@ -569,7 +573,10 @@ begin
 end.
 {
   $Log$
-  Revision 1.63  2003-10-01 20:34:49  peter
+  Revision 1.64  2003-10-09 21:31:37  daniel
+    * Register allocator splitted, ans abstract now
+
+  Revision 1.63  2003/10/01 20:34:49  peter
     * procinfo unit contains tprocinfo
     * cginfo renamed to cgbase
     * moved cgmessage to verbose

compiler/i386/n386mem.pas

@@ -107,7 +107,7 @@ implementation
           end
          else
           begin
-            rg.ungetregisterint(exprasmlist,location.reference.base);
+            cg.ungetregister(exprasmlist,location.reference.base);
             cg.a_loadaddr_ref_reg(exprasmlist,location.reference,location.reference.index);
             reference_reset_base(location.reference,location.reference.index,0);
           end;
@@ -142,7 +142,10 @@ begin
 end.
 {
   $Log$
-  Revision 1.56  2003-10-01 20:34:49  peter
+  Revision 1.57  2003-10-09 21:31:37  daniel
+    * Register allocator splitted, ans abstract now
+
+  Revision 1.56  2003/10/01 20:34:49  peter
     * procinfo unit contains tprocinfo
     * cginfo renamed to cgbase
     * moved cgmessage to verbose

compiler/i386/n386set.pas

@@ -214,7 +214,7 @@ implementation
                { use the register as base in a reference (JM)                }
                if ranges then
                  begin
-                   pleftreg:=rg.makeregsize(left.location.register,OS_INT);
+                   pleftreg:=cg.makeregsize(left.location.register,OS_INT);
                    cg.a_load_reg_reg(exprasmlist,left.location.size,OS_INT,left.location.register,pleftreg);
                    if opsize<>OS_INT then
                      cg.a_op_const_reg(exprasmlist,OP_AND,OS_INT,255,pleftreg);
@@ -224,14 +224,14 @@ implementation
                  { otherwise simply use the lower 8 bits (no "and" }
                  { necessary this way) (JM)                        }
                  begin
-                   pleftreg:=rg.makeregsize(left.location.register,OS_8);
+                   pleftreg:=cg.makeregsize(left.location.register,OS_8);
                    opsize := OS_8;
                  end;
              end
             else
              begin
                { load the value in a register }
-               pleftreg:=rg.getregisterint(exprasmlist,OS_INT);
+               pleftreg:=cg.getintregister(exprasmlist,OS_INT);
                opsize:=OS_INT;
                cg.a_load_ref_reg(exprasmlist,OS_8,OS_INT,left.location.reference,pleftreg);
                location_release(exprasmlist,left.location);
@@ -269,8 +269,8 @@ implementation
                       { move and substract in one instruction with LEA)    }
                       if (left.location.loc = LOC_CREGISTER) then
                         begin
-                          rg.ungetregister(exprasmlist,pleftreg);
-                          r:=rg.getregisterint(exprasmlist,OS_INT);
+                          cg.ungetregister(exprasmlist,pleftreg);
+                          r:=cg.getintregister(exprasmlist,OS_INT);
                           reference_reset_base(href,pleftreg,-setparts[i].start);
                           cg.a_loadaddr_ref_reg(exprasmlist,href,r);
                           { only now change pleftreg since previous value is }
@@ -322,9 +322,9 @@ implementation
              right.location.reference.symbol:=nil;
              { Now place the end label }
              cg.a_label(exprasmlist,l);
-             rg.ungetregisterint(exprasmlist,pleftreg);
+             cg.ungetregister(exprasmlist,pleftreg);
              if r<>NR_NO then
-              rg.ungetregisterint(exprasmlist,r);
+              cg.ungetregister(exprasmlist,r);
           end
          else
           begin
@@ -361,7 +361,7 @@ implementation
                      LOC_REGISTER,
                      LOC_CREGISTER:
                        begin
-                          hr:=rg.makeregsize(left.location.register,OS_INT);
+                          hr:=cg.makeregsize(left.location.register,OS_INT);
                           cg.a_load_reg_reg(exprasmlist,left.location.size,OS_INT,left.location.register,hr);
                        end;
                   else
@@ -369,7 +369,7 @@ implementation
                       { the set element isn't never samller than a byte  }
                       { and because it's a small set we need only 5 bits }
                       { but 8 bits are easier to load               }
-                      hr:=rg.getregisterint(exprasmlist,OS_INT);
+                      hr:=cg.getintregister(exprasmlist,OS_INT);
                       cg.a_load_ref_reg(exprasmlist,OS_8,OS_INT,left.location.reference,hr);
                       location_release(exprasmlist,left.location);
                     end;
@@ -381,16 +381,16 @@ implementation
                           begin
                             emit_reg_reg(A_BT,S_L,hr,
                               right.location.register);
-                            rg.ungetregisterint(exprasmlist,right.location.register);
+                            cg.ungetregister(exprasmlist,right.location.register);
                           end;
                    LOC_CONSTANT :
                        begin
                        { We have to load the value into a register because
                          btl does not accept values only refs or regs (PFV) }
-                         hr2:=rg.getregisterint(exprasmlist,OS_INT);
+                         hr2:=cg.getintregister(exprasmlist,OS_INT);
                          cg.a_load_const_reg(exprasmlist,OS_INT,right.location.value,hr2);
                          emit_reg_reg(A_BT,S_L,hr,hr2);
-                         rg.ungetregisterint(exprasmlist,hr2);
+                         cg.ungetregister(exprasmlist,hr2);
                        end;
                    LOC_CREFERENCE,
                    LOC_REFERENCE :
@@ -402,7 +402,7 @@ implementation
                        internalerror(2002032210);
                   end;
                   { simply to indicate EDI is deallocated here too (JM) }
-                  rg.ungetregisterint(exprasmlist,hr);
+                  cg.ungetregister(exprasmlist,hr);
                   location.resflags:=F_C;
                 end;
              end
@@ -422,7 +422,7 @@ implementation
                      LOC_REGISTER,
                      LOC_CREGISTER:
                        begin
-                          hr:=rg.makeregsize(left.location.register,OS_INT);
+                          hr:=cg.makeregsize(left.location.register,OS_INT);
                           cg.a_load_reg_reg(exprasmlist,left.location.size,OS_INT,left.location.register,hr);
                           cg.a_cmp_const_reg_label(exprasmlist,OS_INT,OC_BE,31,hr,l);
                         { reset carry flag }
@@ -431,10 +431,10 @@ implementation
                           cg.a_label(exprasmlist,l);
                         { We have to load the value into a register because
                           btl does not accept values only refs or regs (PFV) }
-                          hr2:=rg.getregisterint(exprasmlist,OS_INT);
+                          hr2:=cg.getintregister(exprasmlist,OS_INT);
                           cg.a_load_const_reg(exprasmlist,OS_INT,right.location.value,hr2);
                           emit_reg_reg(A_BT,S_L,hr,hr2);
-                          rg.ungetregisterint(exprasmlist,hr2);
+                          cg.ungetregister(exprasmlist,hr2);
                        end;
                   else
                     begin
@@ -456,14 +456,14 @@ implementation
                        cg.a_jmp_always(exprasmlist,l2);
                        cg.a_label(exprasmlist,l);
                        location_release(exprasmlist,left.location);
-                       hr:=rg.getregisterint(exprasmlist,OS_INT);
+                       hr:=cg.getintregister(exprasmlist,OS_INT);
                        cg.a_load_ref_reg(exprasmlist,OS_INT,OS_INT,left.location.reference,hr);
                        { We have to load the value into a register because
                          btl does not accept values only refs or regs (PFV) }
-                       hr2:=rg.getregisterint(exprasmlist,OS_INT);
+                       hr2:=cg.getintregister(exprasmlist,OS_INT);
                        cg.a_load_const_reg(exprasmlist,OS_INT,right.location.value,hr2);
                        emit_reg_reg(A_BT,S_L,hr,hr2);
-                       rg.ungetregisterint(exprasmlist,hr2);
+                       cg.ungetregister(exprasmlist,hr2);
                     end;
                   end;
                   cg.a_label(exprasmlist,l2);
@@ -480,14 +480,14 @@ implementation
                else
                 begin
                   if (left.location.loc in [LOC_REGISTER,LOC_CREGISTER]) then
-                    pleftreg:=rg.makeregsize(left.location.register,OS_INT)
+                    pleftreg:=cg.makeregsize(left.location.register,OS_INT)
                   else
-                    pleftreg:=rg.getregisterint(exprasmlist,OS_INT);
+                    pleftreg:=cg.getintregister(exprasmlist,OS_INT);
                   cg.a_load_loc_reg(exprasmlist,OS_INT,left.location,pleftreg);
                   location_freetemp(exprasmlist,left.location);
                   location_release(exprasmlist,left.location);
                   emit_reg_ref(A_BT,S_L,pleftreg,right.location.reference);
-                  rg.ungetregisterint(exprasmlist,pleftreg);
+                  cg.ungetregister(exprasmlist,pleftreg);
                   location_release(exprasmlist,right.location);
                   { tg.ungetiftemp(exprasmlist,right.location.reference) happens below }
                   location.resflags:=F_C;
@@ -559,7 +559,7 @@ implementation
           end;
         objectlibrary.getlabel(table);
         { make it a 32bit register }
-        indexreg:=rg.makeregsize(hregister,OS_INT);
+        indexreg:=cg.makeregsize(hregister,OS_INT);
         cg.a_load_reg_reg(exprasmlist,opsize,OS_INT,hregister,indexreg);
         { create reference }
         reference_reset_symbol(href,table,0);
@@ -672,7 +672,10 @@ begin
 end.
 {
   $Log$
-  Revision 1.67  2003-10-01 20:34:49  peter
+  Revision 1.68  2003-10-09 21:31:37  daniel
+    * Register allocator splitted, ans abstract now
+
+  Revision 1.67  2003/10/01 20:34:49  peter
     * procinfo unit contains tprocinfo
     * cginfo renamed to cgbase
     * moved cgmessage to verbose

compiler/i386/rgcpu.pas

@@ -35,21 +35,23 @@ unit rgcpu;
       cclasses,globtype,cgbase,rgobj;
 
     type
-       trgcpu = class(trgobj)
-          fpuvaroffset : byte;
-
-          { to keep the same allocation order as with the old routines }
+       Tregisterallocatorcpu = class(Tregisterallocator)
           procedure add_constraints(reg:Tregister);override;
+       end;
+
+
+       Trgcpu = class(Trgobj)
+          fpuvaroffset : byte;
 
           function getregisterfpu(list: taasmoutput;size:TCGSize) : tregister; override;
-          procedure ungetregisterfpu(list: taasmoutput; r : tregister;size:TCGSize); override;
+          procedure ungetregisterfpu(list: taasmoutput; r : tregister); override;
 
           {# Returns a subset register of the register r with the specified size.
              WARNING: There is no clearing of the upper parts of the register,
              if a 8-bit / 16-bit register is converted to a 32-bit register.
              It is up to the code generator to correctly zero fill the register
           }
-          function makeregsize(reg: tregister; size: tcgsize): tregister; override;
+{          function makeregsize(reg: tregister; size: tcgsize): tregister; override;}
 
           { pushes and restores registers }
 {$ifdef SUPPORT_MMX}
@@ -74,18 +76,17 @@ unit rgcpu;
          function correct_fpuregister(r : tregister;ofs : byte) : tregister;
        end;
 
-
   implementation
 
     uses
        systems,
        globals,verbose;
 
-{************************************************************************}
-{                               trgcpu                                   }
-{************************************************************************}
+{************************************************************************
+                          tregisterallocatorcpu
+*************************************************************************}
 
-    procedure Trgcpu.add_constraints(reg:Tregister);
+    procedure Tregisterallocatorcpu.add_constraints(reg:Tregister);
     var
       supreg : tsuperregister;
     begin
@@ -100,6 +101,10 @@ unit rgcpu;
     end;
 
 
+{************************************************************************
+                                   trgcpu
+*************************************************************************}
+
     function trgcpu.getregisterfpu(list: taasmoutput;size: TCGSize) : tregister;
 
       begin
@@ -109,7 +114,7 @@ unit rgcpu;
       end;
 
 
-    procedure trgcpu.ungetregisterfpu(list : taasmoutput; r : tregister;size:TCGSize);
+    procedure trgcpu.ungetregisterfpu(list : taasmoutput; r : tregister);
 
       begin
         { nothing to do, fpu stack management is handled by the load/ }
@@ -226,7 +231,7 @@ unit rgcpu;
         setsupreg(correct_fpuregister,ofs);
      end;
 
-
+(*
     function trgcpu.makeregsize(reg: tregister; size: tcgsize): tregister;
       var
         subreg : tsubregister;
@@ -238,11 +243,14 @@ unit rgcpu;
         setsubreg(result,subreg);
         add_constraints(result);
       end;
-
+*)
 end.
 {
   $Log$
-  Revision 1.36  2003-10-01 20:34:49  peter
+  Revision 1.37  2003-10-09 21:31:37  daniel
+    * Register allocator splitted, ans abstract now
+
+  Revision 1.36  2003/10/01 20:34:49  peter
     * procinfo unit contains tprocinfo
     * cginfo renamed to cgbase
     * moved cgmessage to verbose

compiler/ncal.pas

@@ -187,8 +187,8 @@ implementation
       symconst,paramgr,defutil,defcmp,
       htypechk,pass_1,
       ncnv,nld,ninl,nadd,ncon,nmem,
-      rgobj,
-      cgbase,procinfo
+      nutils,procinfo,
+      tgobj,cgbase
       ;
 
 type
@@ -2365,7 +2365,6 @@ type
               { procedure does a call }
               if not (block_type in [bt_const,bt_type]) then
                 include(current_procinfo.flags,pi_do_call);
-              rg.incrementotherregisterpushed(all_otherregisters);
            end
          else
          { not a procedure variable }
@@ -2399,8 +2398,6 @@ type
                     include(current_procinfo.flags,pi_do_call);
                 end;
 
-             { It doesn't hurt to calculate it already though :) (JM) }
-             rg.incrementotherregisterpushed(tprocdef(procdefinition).usedotherregisters);
            end;
 
          { get a register for the return value }
@@ -2615,7 +2612,10 @@ begin
 end.
 {
   $Log$
-  Revision 1.194  2003-10-09 15:00:13  florian
+  Revision 1.195  2003-10-09 21:31:37  daniel
+    * Register allocator splitted, ans abstract now
+
+  Revision 1.194  2003/10/09 15:00:13  florian
     * fixed constructor call in class methods
 
   Revision 1.193  2003/10/08 19:19:45  peter

compiler/ncgbas.pas

@@ -180,7 +180,7 @@ interface
            end;
 
          { Allocate registers used in the assembler block }
-         rg.allocexplicitregistersint(exprasmlist,used_regs_int);
+         cg.allocexplicitregisters(exprasmlist,R_INTREGISTER,used_regs_int);
 
          if (current_procinfo.procdef.proccalloption=pocall_inline) then
            begin
@@ -265,7 +265,7 @@ interface
            end;
 
          { Release register used in the assembler block }
-         rg.deallocexplicitregistersint(exprasmlist,used_regs_int);
+         cg.deallocexplicitregisters(exprasmlist,R_INTREGISTER,used_regs_int);
        end;
 
 
@@ -372,7 +372,10 @@ begin
 end.
 {
   $Log$
-  Revision 1.42  2003-10-07 18:18:16  peter
+  Revision 1.43  2003-10-09 21:31:37  daniel
+    * Register allocator splitted, ans abstract now
+
+  Revision 1.42  2003/10/07 18:18:16  peter
     * fix register calling for assembler procedures
     * fix result loading for assembler procedures
 

compiler/ncgcal.pas

@@ -89,7 +89,7 @@ implementation
       cpuinfo,aasmbase,aasmtai,
       nbas,nmem,nld,ncnv,
 {$ifdef x86}
-      cga,
+      cga,cgx86,
 {$endif x86}
       ncgutil,cgobj,tgobj,
       rgobj,rgcpu,
@@ -428,7 +428,7 @@ implementation
             is_widestring(resulttype.def) then
           begin
             { the FUNCTION_RESULT_REG is already allocated }
-            rg.ungetregisterint(exprasmlist,NR_FUNCTION_RESULT_REG);
+            cg.ungetregister(exprasmlist,NR_FUNCTION_RESULT_REG);
             if not assigned(funcretnode) then
               begin
                 location_reset(location,LOC_CREFERENCE,OS_ADDR);
@@ -437,7 +437,7 @@ implementation
               end
             else
               begin
-                hregister := rg.getaddressregister(exprasmlist);
+                hregister := cg.getaddressregister(exprasmlist);
                 cg.a_load_reg_reg(exprasmlist,OS_ADDR,OS_ADDR,NR_FUNCTION_RESULT_REG,hregister);
                 { in case of a regular funcretnode with ret_in_param, the }
                 { original funcretnode isn't touched -> make sure it's    }
@@ -448,7 +448,7 @@ implementation
                 tempnode.free;
                 cg.g_decrrefcount(exprasmlist,resulttype.def,location.reference, false);
                 cg.a_load_reg_ref(exprasmlist,OS_ADDR,OS_ADDR,hregister,location.reference);
-                rg.ungetregisterint(exprasmlist,hregister);
+                cg.ungetregister(exprasmlist,hregister);
              end;
           end
         else
@@ -465,9 +465,9 @@ implementation
 {$endif cpufpemu}
                   location.register:=NR_FPU_RESULT_REG;
 {$ifdef x86}
-                inc(trgcpu(rg).fpuvaroffset);
+                tcgx86(cg).inc_fpu_stack;
 {$else x86}
-                hregister := rg.getregisterfpu(exprasmlist,location.size);
+                hregister := cg.getfputregister(exprasmlist,location.size);
                 cg.a_loadfpu_reg_reg(exprasmlist,location.size,location.register,hregister);
                 location.register := hregister;
 {$endif x86}
@@ -485,11 +485,11 @@ implementation
                         FUNCTION_RESULT_REG/FUNCTION_RESULTHIGH_REG, so no move is necessary.}
                       { the FUNCTION_RESULT_LOW_REG/FUNCTION_RESULT_HIGH_REG
                         are already allocated }
-                      rg.ungetregisterint(exprasmlist,NR_FUNCTION_RESULT64_LOW_REG);
-                      location.registerlow:=rg.getregisterint(exprasmlist,OS_INT);
+                      cg.ungetregister(exprasmlist,NR_FUNCTION_RESULT64_LOW_REG);
+                      location.registerlow:=cg.getintregister(exprasmlist,OS_INT);
                       cg.a_load_reg_reg(exprasmlist,OS_32,OS_32,NR_FUNCTION_RESULT64_LOW_REG,location.registerlow);
-                      rg.ungetregisterint(exprasmlist,NR_FUNCTION_RESULT64_HIGH_REG);
-                      location.registerhigh:=rg.getregisterint(exprasmlist,OS_INT);
+                      cg.ungetregister(exprasmlist,NR_FUNCTION_RESULT64_HIGH_REG);
+                      location.registerhigh:=cg.getintregister(exprasmlist,OS_INT);
                       cg.a_load_reg_reg(exprasmlist,OS_32,OS_32,NR_FUNCTION_RESULT64_HIGH_REG,location.registerhigh);
                     end
                    else
@@ -498,11 +498,11 @@ implementation
                       {Move the function result to a free register, preferably the
                        FUNCTION_RESULT_REG, so no move is necessary.}
                       { the FUNCTION_RESULT_REG is already allocated }
-                      rg.ungetregisterint(exprasmlist,NR_FUNCTION_RESULT_REG);
+                      cg.ungetregister(exprasmlist,NR_FUNCTION_RESULT_REG);
                       { change register size after the unget because the
                       getregister was done for the full register }
-                      location.register:=rg.getregisterint(exprasmlist,cgsize);
-                      cg.a_load_reg_reg(exprasmlist,cgsize,cgsize,rg.makeregsize(NR_FUNCTION_RESULT_REG,cgsize),location.register);
+                      location.register:=cg.getintregister(exprasmlist,cgsize);
+                      cg.a_load_reg_reg(exprasmlist,cgsize,cgsize,cg.makeregsize(NR_FUNCTION_RESULT_REG,cgsize),location.register);
                     end;
                  end
                 else
@@ -524,12 +524,12 @@ implementation
 {$ifndef cpu64bit}
               if cgsize in [OS_64,OS_S64] then
                 begin
-                  rg.ungetregisterint(exprasmlist,NR_FUNCTION_RESULT64_LOW_REG);
-                  rg.ungetregisterint(exprasmlist,NR_FUNCTION_RESULT64_HIGH_REG);
+                  cg.ungetregister(exprasmlist,NR_FUNCTION_RESULT64_LOW_REG);
+                  cg.ungetregister(exprasmlist,NR_FUNCTION_RESULT64_HIGH_REG);
                 end
               else
 {$endif cpu64bit}
-                rg.ungetregisterint(exprasmlist,NR_FUNCTION_RESULT_REG);
+                cg.ungetregister(exprasmlist,NR_FUNCTION_RESULT_REG);
             location_reset(location,LOC_VOID,OS_NO);
           end;
       end;
@@ -572,7 +572,6 @@ implementation
     procedure tcgcallnode.normal_pass_2;
       var
          regs_to_push_other : totherregisterset;
-         unusedstate: pointer;
          regs_to_alloc,regs_to_free:Tsuperregisterset;
          pushedother : tpushedsavedother;
          oldpushedparasize : longint;
@@ -651,8 +650,6 @@ implementation
          if assigned(varargsparas) then
            paramanager.create_varargs_paraloc_info(procdefinition,varargsparas);
 
-         rg.saveunusedstate(unusedstate);
-
          if not assigned(funcretnode) then
            begin
              { if we allocate the temp. location for ansi- or widestrings }
@@ -692,7 +689,8 @@ implementation
           end;
 
          { Save registers destroyed by the call }
-         rg.saveusedotherregisters(exprasmlist,pushedother,regs_to_push_other);
+         {$warning fime saveusedotherregisters.}
+{         cg.saveusedotherregisters(exprasmlist,pushedother,regs_to_push_other);}
 
          { Initialize for pushing the parameters }
          oldpushedparasize:=pushedparasize;
@@ -731,8 +729,8 @@ implementation
                     not(is_cppclass(tprocdef(procdefinition)._class)) then
                    cg.g_maybe_testvmt(exprasmlist,methodpointer.location.register,tprocdef(procdefinition)._class);
                end;
-
-              rg.saveotherregvars(exprasmlist,regs_to_push_other);
+               {$warning fixme regvars}
+{              rg.saveotherregvars(exprasmlist,regs_to_push_other);}
 
               if (po_virtualmethod in procdefinition.procoptions) and
                  assigned(methodpointer) then
@@ -740,8 +738,8 @@ implementation
                    vmtreg:=methodpointer.location.register;
 
                    { release self }
-                   rg.ungetaddressregister(exprasmlist,vmtreg);
-                   pvreg:=rg.getabtregisterint(exprasmlist,OS_ADDR);
+                   cg.ungetregister(exprasmlist,vmtreg);
+                   pvreg:=cg.getabtregister(exprasmlist,OS_ADDR);
                    reference_reset_base(href,vmtreg,
                       tprocdef(procdefinition)._class.vmtmethodoffset(tprocdef(procdefinition).extnumber));
                    cg.a_load_ref_reg(exprasmlist,OS_ADDR,OS_ADDR,href,pvreg);
@@ -752,12 +750,12 @@ implementation
                      pushparas;
 
                    { Release register containing procvar }
-                   rg.ungetregisterint(exprasmlist,pvreg);
+                   cg.ungetregister(exprasmlist,pvreg);
 
                    { free the resources allocated for the parameters }
                    freeparas;
 
-                   rg.allocexplicitregistersint(exprasmlist,regs_to_alloc);
+                   cg.allocexplicitregisters(exprasmlist,R_INTREGISTER,regs_to_alloc);
 
                    { call method }
                    cg.a_call_reg(exprasmlist,pvreg);
@@ -772,7 +770,7 @@ implementation
                   { free the resources allocated for the parameters }
                   freeparas;
 
-                  rg.allocexplicitregistersint(exprasmlist,regs_to_alloc);
+                  cg.allocexplicitregisters(exprasmlist,R_INTREGISTER,regs_to_alloc);
                   { Calling interrupt from the same code requires some
                     extra code }
                   if (po_interrupt in procdefinition.procoptions) then
@@ -786,7 +784,7 @@ implementation
               secondpass(right);
 
               location_release(exprasmlist,right.location);
-              pvreg:=rg.getabtregisterint(exprasmlist,OS_ADDR);
+              pvreg:=cg.getabtregister(exprasmlist,OS_ADDR);
               { Only load OS_ADDR from the reference }
               if right.location.loc in [LOC_REFERENCE,LOC_CREFERENCE] then
                 cg.a_load_ref_reg(exprasmlist,OS_ADDR,OS_ADDR,right.location.reference,pvreg)
@@ -800,19 +798,19 @@ implementation
                 pushparas;
 
               { Release register containing procvar }
-              rg.ungetregisterint(exprasmlist,pvreg);
+              cg.ungetregister(exprasmlist,pvreg);
 
               { free the resources allocated for the parameters }
               freeparas;
 
-              rg.allocexplicitregistersint(exprasmlist,regs_to_alloc);
+              cg.allocexplicitregisters(exprasmlist,R_INTREGISTER,regs_to_alloc);
 
               { Calling interrupt from the same code requires some
                 extra code }
               if (po_interrupt in procdefinition.procoptions) then
                 extra_interrupt_code;
-
-              rg.saveotherregvars(exprasmlist,ALL_OTHERREGISTERS);
+              {$warning fixme regvars.}
+{              rg.saveotherregvars(exprasmlist,ALL_OTHERREGISTERS);}
               cg.a_call_reg(exprasmlist,pvreg);
            end;
 
@@ -836,10 +834,6 @@ implementation
 
          { Restore }
          pushedparasize:=oldpushedparasize;
-         rg.restoreunusedstate(unusedstate);
-{$ifdef TEMPREGDEBUG}
-         testregisters32;
-{$endif TEMPREGDEBUG}
 
          { Release registers, but not the registers that contain the
            function result }
@@ -861,7 +855,7 @@ implementation
                  end;
              end;
            end;
-         rg.deallocexplicitregistersint(exprasmlist,regs_to_free);
+         cg.deallocexplicitregisters(exprasmlist,R_INTREGISTER,regs_to_free);
 
          { handle function results }
          if (not is_void(resulttype.def)) then
@@ -877,13 +871,14 @@ implementation
             (right=nil) and
             not(po_virtualmethod in procdefinition.procoptions) then
            begin
-              rg.allocexplicitregistersint(exprasmlist,paramanager.get_volatile_registers_int(pocall_default));
+              cg.allocexplicitregisters(exprasmlist,R_INTREGISTER,paramanager.get_volatile_registers_int(pocall_default));
               cg.a_call_name(exprasmlist,'FPC_IOCHECK');
-              rg.deallocexplicitregistersint(exprasmlist,paramanager.get_volatile_registers_int(pocall_default));
+              cg.deallocexplicitregisters(exprasmlist,R_INTREGISTER,paramanager.get_volatile_registers_int(pocall_default));
            end;
 
          { restore registers }
-         rg.restoreusedotherregisters(exprasmlist,pushedother);
+         {$warnig fixme restoreusedotherregisters}
+{         rg.restoreusedotherregisters(exprasmlist,pushedother);}
 
          { release temps of paras }
          release_para_temps;
@@ -904,10 +899,6 @@ implementation
 {$ifdef x86}
                   { release FPU stack }
                   emit_reg(A_FSTP,S_NO,NR_FPU_RESULT_REG);
-                  {
-                    dec(trgcpu(rg).fpuvaroffset);
-                    do NOT decrement as the increment before
-                    is not called for unused results PM }
 {$endif x86}
                 end;
            end;
@@ -977,8 +968,6 @@ implementation
            end;
 {$endif GDB}
 
-         rg.saveunusedstate(unusedstate);
-
          { if we allocate the temp. location for ansi- or widestrings }
          { already here, we avoid later a push/pop                    }
          if is_widestring(resulttype.def) then
@@ -1039,9 +1028,9 @@ implementation
             (right=nil) and
             not(po_virtualmethod in procdefinition.procoptions) then
            begin
-              rg.allocexplicitregistersint(exprasmlist,paramanager.get_volatile_registers_int(pocall_default));
+              cg.allocexplicitregisters(exprasmlist,R_INTREGISTER,paramanager.get_volatile_registers_int(pocall_default));
               cg.a_call_name(exprasmlist,'FPC_IOCHECK');
-              rg.deallocexplicitregistersint(exprasmlist,paramanager.get_volatile_registers_int(pocall_default));
+              cg.deallocexplicitregisters(exprasmlist,R_INTREGISTER,paramanager.get_volatile_registers_int(pocall_default));
            end;
 
          { release temps of paras }
@@ -1064,10 +1053,6 @@ implementation
 {$ifdef x86}
                   { release FPU stack }
                   emit_reg(A_FSTP,S_NO,NR_FPU_RESULT_REG);
-                  {
-                    dec(trgcpu(rg).fpuvaroffset);
-                    do NOT decrement as the increment before
-                    is not called for unused results PM }
 {$endif x86}
                 end;
            end;
@@ -1099,12 +1084,6 @@ implementation
          { restore }
          current_procinfo:=oldprocinfo;
          inlining_procedure:=oldinlining_procedure;
-
-         { reallocate the registers used for the current procedure's regvars, }
-         { since they may have been used and then deallocated in the inlined  }
-         { procedure (JM)                                                     }
-//         if assigned(current_procinfo.procdef.regvarinfo) then
-//           rg.restoreStateAfterInline(oldregstate);
       end;
 
 
@@ -1123,7 +1102,10 @@ begin
 end.
 {
   $Log$
-  Revision 1.126  2003-10-07 15:17:07  peter
+  Revision 1.127  2003-10-09 21:31:37  daniel
+    * Register allocator splitted, ans abstract now
+
+  Revision 1.126  2003/10/07 15:17:07  peter
     * inline supported again, LOC_REFERENCEs are used to pass the
       parameters
     * inlineparasymtable,inlinelocalsymtable removed

compiler/ncgcnv.pas

@@ -127,7 +127,7 @@ interface
            st_shortstring :
              begin
                inc(left.location.reference.offset);
-               location.register:=rg.getaddressregister(exprasmlist);
+               location.register:=cg.getaddressregister(exprasmlist);
                cg.a_loadaddr_ref_reg(exprasmlist,left.location.reference,location.register);
              end;
            st_ansistring :
@@ -137,12 +137,12 @@ interface
                 begin
                   reference_reset(hr);
                   hr.symbol:=objectlibrary.newasmsymboldata('FPC_EMPTYCHAR');
-                  location.register:=rg.getaddressregister(exprasmlist);
+                  location.register:=cg.getaddressregister(exprasmlist);
                   cg.a_loadaddr_ref_reg(exprasmlist,hr,location.register);
                 end
                else
                 begin
-                  location.register:=rg.getaddressregister(exprasmlist);
+                  location.register:=cg.getaddressregister(exprasmlist);
                   cg.a_load_ref_reg(exprasmlist,OS_ADDR,OS_ADDR,left.location.reference,location.register);
                 end;
              end;
@@ -158,12 +158,12 @@ interface
                 begin
                   reference_reset(hr);
                   hr.symbol:=objectlibrary.newasmsymboldata('FPC_EMPTYCHAR');
-                  location.register:=rg.getaddressregister(exprasmlist);
+                  location.register:=cg.getaddressregister(exprasmlist);
                   cg.a_loadaddr_ref_reg(exprasmlist,hr,location.register);
                 end
                else
                 begin
-                  location.register:=rg.getregisterint(exprasmlist,OS_INT);
+                  location.register:=cg.getintregister(exprasmlist,OS_INT);
 {$ifdef fpc}
 {$warning Todo: convert widestrings to ascii when typecasting them to pchars}
 {$endif}
@@ -203,7 +203,7 @@ interface
       begin
          location_release(exprasmlist,left.location);
          location_reset(location,LOC_REGISTER,OS_ADDR);
-         location.register:=rg.getaddressregister(exprasmlist);
+         location.register:=cg.getaddressregister(exprasmlist);
          cg.a_loadaddr_ref_reg(exprasmlist,left.location.reference,location.register);
       end;
 
@@ -215,7 +215,8 @@ interface
         case left.location.loc of
           LOC_REGISTER :
             begin
-              if not rg.isaddressregister(left.location.register) then
+            {$ifdef cpu_uses_separate_address_registers}
+              if getregtype(left.location.register)<>R_ADDRESSREGISTER then
                 begin
                   location_release(exprasmlist,left.location);
                   location.reference.base:=rg.getaddressregister(exprasmlist);
@@ -223,11 +224,12 @@ interface
                           left.location.register,location.reference.base);
                 end
               else
+            {$endif}
                 location.reference.base := left.location.register;
             end;
           LOC_CREGISTER :
             begin
-              location.reference.base:=rg.getaddressregister(exprasmlist);
+              location.reference.base:=cg.getaddressregister(exprasmlist);
               cg.a_load_reg_reg(exprasmlist,OS_ADDR,OS_ADDR,left.location.register,
                 location.reference.base);
             end;
@@ -235,7 +237,7 @@ interface
           LOC_CREFERENCE :
             begin
               location_release(exprasmlist,left.location);
-              location.reference.base:=rg.getaddressregister(exprasmlist);
+              location.reference.base:=cg.getaddressregister(exprasmlist);
               cg.a_load_ref_reg(exprasmlist,OS_ADDR,OS_ADDR,left.location.reference,
                 location.reference.base);
               location_freetemp(exprasmlist,left.location);
@@ -274,13 +276,13 @@ interface
               begin
                 location_copy(location,left.location);
                 location.size:=def_cgsize(resulttype.def);
-                exit;
+                exit
               end;
             LOC_CREFERENCE,
             LOC_REFERENCE:
               begin
                  location_release(exprasmlist,left.location);
-                 location.register:=rg.getregisterfpu(exprasmlist,left.location.size);
+                 location.register:=cg.getfpuregister(exprasmlist,left.location.size);
                  cg.a_loadfpu_loc_reg(exprasmlist,left.location,location.register);
                  location_freetemp(exprasmlist,left.location);
               end;
@@ -311,7 +313,7 @@ interface
           begin
              location_release(exprasmlist,left.location);
              location_reset(location,LOC_REGISTER,OS_ADDR);
-             location.register:=rg.getaddressregister(exprasmlist);
+             location.register:=cg.getaddressregister(exprasmlist);
              cg.a_loadaddr_ref_reg(exprasmlist,left.location.reference,location.register);
           end;
       end;
@@ -364,20 +366,22 @@ interface
          case left.location.loc of
             LOC_CREGISTER,LOC_REGISTER:
               begin
-                 if not rg.isaddressregister(left.location.register) then
+               {$ifdef cpu_uses_separate_address_registers}
+                 if getregtype(left.location.register)<>R_ADDRESSREGISTER then
                    begin
                      location_release(exprasmlist,left.location);
-                     location.register:=rg.getaddressregister(exprasmlist);
+                     location.register:=cg.getaddressregister(exprasmlist);
                      cg.a_load_reg_reg(exprasmlist,OS_ADDR,OS_ADDR,
                               left.location.register,location.register);
                    end
                  else
+               {$endif}
                     location.register := left.location.register;
               end;
             LOC_CREFERENCE,LOC_REFERENCE:
               begin
                 location_release(exprasmlist,left.location);
-                location.register:=rg.getaddressregister(exprasmlist);
+                location.register:=cg.getaddressregister(exprasmlist);
                 cg.a_load_ref_reg(exprasmlist,OS_ADDR,OS_ADDR,left.location.reference,location.register);
                 location_freetemp(exprasmlist,left.location);
               end;
@@ -403,13 +407,13 @@ interface
             LOC_REFERENCE:
               begin
                  location_release(exprasmlist,left.location);
-                 location.register:=rg.getaddressregister(exprasmlist);
+                 location.register:=cg.getaddressregister(exprasmlist);
                  cg.a_load_ref_reg(exprasmlist,OS_ADDR,OS_ADDR,left.location.reference,location.register);
                  location_freetemp(exprasmlist,left.location);
               end;
             LOC_CREGISTER:
               begin
-                 location.register:=rg.getaddressregister(exprasmlist);
+                 location.register:=cg.getaddressregister(exprasmlist);
                  cg.a_load_reg_reg(exprasmlist,OS_ADDR,OS_ADDR,left.location.register,location.register);
               end;
             LOC_REGISTER:
@@ -511,7 +515,10 @@ end.
 
 {
   $Log$
-  Revision 1.47  2003-10-01 20:34:48  peter
+  Revision 1.48  2003-10-09 21:31:37  daniel
+    * Register allocator splitted, ans abstract now
+
+  Revision 1.47  2003/10/01 20:34:48  peter
     * procinfo unit contains tprocinfo
     * cginfo renamed to cgbase
     * moved cgmessage to verbose

compiler/ncgflw.pas

@@ -210,8 +210,8 @@ implementation
 {$ifdef i386}
          if cs_regvars in aktglobalswitches then
            begin
-             org_regvar_loaded_int := rg.regvar_loaded_int;
-             org_regvar_loaded_other := rg.regvar_loaded_other;
+{             org_regvar_loaded_int := rg.regvar_loaded_int;
+             org_regvar_loaded_other := rg.regvar_loaded_other;}
            end;
 {$endif i386}
 
@@ -226,12 +226,12 @@ implementation
          { loaded regvar state and create new clean ones                 }
          if cs_regvars in aktglobalswitches then
            begin
-             then_regvar_loaded_int := rg.regvar_loaded_int;
+{             then_regvar_loaded_int := rg.regvar_loaded_int;
              then_regvar_loaded_other := rg.regvar_loaded_other;
              rg.regvar_loaded_int := org_regvar_loaded_int;
              rg.regvar_loaded_other := org_regvar_loaded_other;
              then_list := exprasmlist;
-             exprasmlist := taasmoutput.create;
+             exprasmlist := taasmoutput.create;}
            end;
 {$endif i386}
 
@@ -259,8 +259,8 @@ implementation
               { and loaded regvar state and create a new clean list       }
               if cs_regvars in aktglobalswitches then
                 begin
-                  else_regvar_loaded_int := rg.regvar_loaded_int;
-                  else_regvar_loaded_other := rg.regvar_loaded_other;
+{                  else_regvar_loaded_int := rg.regvar_loaded_int;
+                  else_regvar_loaded_other := rg.regvar_loaded_other;}
                   else_list := exprasmlist;
                   exprasmlist := taasmoutput.create;
                 end;
@@ -273,8 +273,8 @@ implementation
 {$ifdef i386}
               if cs_regvars in aktglobalswitches then
                 begin
-                  else_regvar_loaded_int := rg.regvar_loaded_int;
-                  else_regvar_loaded_other := rg.regvar_loaded_other;
+{                  else_regvar_loaded_int := rg.regvar_loaded_int;
+                  else_regvar_loaded_other := rg.regvar_loaded_other;}
                   else_list := exprasmlist;
                   exprasmlist := taasmoutput.create;
                 end;
@@ -372,7 +372,7 @@ implementation
                  (right.location.loc=LOC_CREGISTER) then
                 begin
                    cg.a_load_reg_ref(exprasmlist,opsize,opsize,right.location.register,temp1);
-                   rg.ungetregisterint(exprasmlist,right.location.register);
+                   cg.ungetregister(exprasmlist,right.location.register);
                  end
               else
                 cg.g_concatcopy(exprasmlist,right.location.reference,temp1,
@@ -825,16 +825,16 @@ implementation
               paramanager.freeparaloc(exprasmlist,paraloc1);
               paramanager.freeparaloc(exprasmlist,paraloc2);
               paramanager.freeparaloc(exprasmlist,paraloc3);
-              rg.allocexplicitregistersint(exprasmlist,paramanager.get_volatile_registers_int(pocall_default));
+              cg.allocexplicitregisters(exprasmlist,R_INTREGISTER,paramanager.get_volatile_registers_int(pocall_default));
               cg.a_call_name(exprasmlist,'FPC_RAISEEXCEPTION');
-              rg.deallocexplicitregistersint(exprasmlist,paramanager.get_volatile_registers_int(pocall_default));
+              cg.deallocexplicitregisters(exprasmlist,R_INTREGISTER,paramanager.get_volatile_registers_int(pocall_default));
            end
          else
            begin
-              rg.allocexplicitregistersint(exprasmlist,paramanager.get_volatile_registers_int(pocall_default));
+              cg.allocexplicitregisters(exprasmlist,R_INTREGISTER,paramanager.get_volatile_registers_int(pocall_default));
               cg.a_call_name(exprasmlist,'FPC_POPADDRSTACK');
               cg.a_call_name(exprasmlist,'FPC_RERAISE');
-              rg.deallocexplicitregistersint(exprasmlist,paramanager.get_volatile_registers_int(pocall_default));
+              cg.deallocexplicitregisters(exprasmlist,R_INTREGISTER,paramanager.get_volatile_registers_int(pocall_default));
            end;
        end;
 
@@ -873,16 +873,16 @@ implementation
       var
         paraloc1 : tparalocation;
       begin
-         rg.allocexplicitregistersint(exprasmlist,paramanager.get_volatile_registers_int(pocall_default));
+         cg.allocexplicitregisters(exprasmlist,R_INTREGISTER,paramanager.get_volatile_registers_int(pocall_default));
          cg.a_call_name(exprasmlist,'FPC_POPOBJECTSTACK');
-         rg.deallocexplicitregistersint(exprasmlist,paramanager.get_volatile_registers_int(pocall_default));
+         cg.deallocexplicitregisters(exprasmlist,R_INTREGISTER,paramanager.get_volatile_registers_int(pocall_default));
          paraloc1:=paramanager.getintparaloc(pocall_default,1);
          paramanager.allocparaloc(exprasmlist,paraloc1);
          cg.a_param_reg(exprasmlist,OS_ADDR,NR_FUNCTION_RESULT_REG,paraloc1);
          paramanager.freeparaloc(exprasmlist,paraloc1);
-         rg.allocexplicitregistersint(exprasmlist,paramanager.get_volatile_registers_int(pocall_default));
+         cg.allocexplicitregisters(exprasmlist,R_INTREGISTER,paramanager.get_volatile_registers_int(pocall_default));
          cg.a_call_name(exprasmlist,'FPC_DESTROYEXCEPTION');
-         rg.deallocexplicitregistersint(exprasmlist,paramanager.get_volatile_registers_int(pocall_default));
+         cg.deallocexplicitregisters(exprasmlist,R_INTREGISTER,paramanager.get_volatile_registers_int(pocall_default));
       end;
 
 
@@ -989,9 +989,9 @@ implementation
               paramanager.allocparaloc(exprasmlist,paraloc1);
               cg.a_param_const(exprasmlist,OS_ADDR,aword(-1),paraloc1);
               paramanager.freeparaloc(exprasmlist,paraloc1);
-              rg.allocexplicitregistersint(exprasmlist,paramanager.get_volatile_registers_int(pocall_default));
+              cg.allocexplicitregisters(exprasmlist,R_INTREGISTER,paramanager.get_volatile_registers_int(pocall_default));
               cg.a_call_name(exprasmlist,'FPC_CATCHES');
-              rg.deallocexplicitregistersint(exprasmlist,paramanager.get_volatile_registers_int(pocall_default));
+              cg.deallocexplicitregisters(exprasmlist,R_INTREGISTER,paramanager.get_volatile_registers_int(pocall_default));
 
               { the destruction of the exception object must be also }
               { guarded by an exception frame                        }
@@ -1009,17 +1009,17 @@ implementation
 
               try_free_exception(exprasmlist,tempbuf,tempaddr,href,0,doobjectdestroy,false);
 
-              rg.allocexplicitregistersint(exprasmlist,paramanager.get_volatile_registers_int(pocall_default));
+              cg.allocexplicitregisters(exprasmlist,R_INTREGISTER,paramanager.get_volatile_registers_int(pocall_default));
               cg.a_call_name(exprasmlist,'FPC_POPSECONDOBJECTSTACK');
-              rg.deallocexplicitregistersint(exprasmlist,paramanager.get_volatile_registers_int(pocall_default));
+              cg.deallocexplicitregisters(exprasmlist,R_INTREGISTER,paramanager.get_volatile_registers_int(pocall_default));
 
               paraloc1:=paramanager.getintparaloc(pocall_default,1);
               paramanager.allocparaloc(exprasmlist,paraloc1);
               cg.a_param_reg(exprasmlist, OS_ADDR, NR_FUNCTION_RESULT_REG, paraloc1);
               paramanager.freeparaloc(exprasmlist,paraloc1);
-              rg.allocexplicitregistersint(exprasmlist,paramanager.get_volatile_registers_int(pocall_default));
+              cg.allocexplicitregisters(exprasmlist,R_INTREGISTER,paramanager.get_volatile_registers_int(pocall_default));
               cg.a_call_name(exprasmlist,'FPC_DESTROYEXCEPTION');
-              rg.deallocexplicitregistersint(exprasmlist,paramanager.get_volatile_registers_int(pocall_default));
+              cg.deallocexplicitregisters(exprasmlist,R_INTREGISTER,paramanager.get_volatile_registers_int(pocall_default));
               { we don't need to restore esi here because reraise never }
               { returns                                                 }
               cg.a_call_name(exprasmlist,'FPC_RERAISE');
@@ -1040,9 +1040,9 @@ implementation
               cg.a_label(exprasmlist,exitexceptlabel);
               { we must also destroy the address frame which guards }
               { exception object                                    }
-              rg.allocexplicitregistersint(exprasmlist,paramanager.get_volatile_registers_int(pocall_default));
+              cg.allocexplicitregisters(exprasmlist,R_INTREGISTER,paramanager.get_volatile_registers_int(pocall_default));
               cg.a_call_name(exprasmlist,'FPC_POPADDRSTACK');
-              rg.deallocexplicitregistersint(exprasmlist,paramanager.get_volatile_registers_int(pocall_default));
+              cg.deallocexplicitregisters(exprasmlist,R_INTREGISTER,paramanager.get_volatile_registers_int(pocall_default));
               cg.g_exception_reason_load(exprasmlist,href);
               cleanupobjectstack;
               cg.a_jmp_always(exprasmlist,oldaktexitlabel);
@@ -1053,9 +1053,9 @@ implementation
               cg.a_label(exprasmlist,breakexceptlabel);
               { we must also destroy the address frame which guards }
               { exception object                                    }
-              rg.allocexplicitregistersint(exprasmlist,paramanager.get_volatile_registers_int(pocall_default));
+              cg.allocexplicitregisters(exprasmlist,R_INTREGISTER,paramanager.get_volatile_registers_int(pocall_default));
               cg.a_call_name(exprasmlist,'FPC_POPADDRSTACK');
-              rg.deallocexplicitregistersint(exprasmlist,paramanager.get_volatile_registers_int(pocall_default));
+              cg.deallocexplicitregisters(exprasmlist,R_INTREGISTER,paramanager.get_volatile_registers_int(pocall_default));
               cg.g_exception_reason_load(exprasmlist,href);
               cleanupobjectstack;
               cg.a_jmp_always(exprasmlist,oldaktbreaklabel);
@@ -1066,9 +1066,9 @@ implementation
               cg.a_label(exprasmlist,continueexceptlabel);
               { we must also destroy the address frame which guards }
               { exception object                                    }
-              rg.allocexplicitregistersint(exprasmlist,paramanager.get_volatile_registers_int(pocall_default));
+              cg.allocexplicitregisters(exprasmlist,R_INTREGISTER,paramanager.get_volatile_registers_int(pocall_default));
               cg.a_call_name(exprasmlist,'FPC_POPADDRSTACK');
-              rg.deallocexplicitregistersint(exprasmlist,paramanager.get_volatile_registers_int(pocall_default));
+              cg.deallocexplicitregisters(exprasmlist,R_INTREGISTER,paramanager.get_volatile_registers_int(pocall_default));
               cg.g_exception_reason_load(exprasmlist,href);
               cleanupobjectstack;
               cg.a_jmp_always(exprasmlist,oldaktcontinuelabel);
@@ -1078,9 +1078,9 @@ implementation
            begin
               { do some magic for exit in the try block }
               cg.a_label(exprasmlist,exittrylabel);
-              rg.allocexplicitregistersint(exprasmlist,paramanager.get_volatile_registers_int(pocall_default));
+              cg.allocexplicitregisters(exprasmlist,R_INTREGISTER,paramanager.get_volatile_registers_int(pocall_default));
               cg.a_call_name(exprasmlist,'FPC_POPADDRSTACK');
-              rg.deallocexplicitregistersint(exprasmlist,paramanager.get_volatile_registers_int(pocall_default));
+              cg.deallocexplicitregisters(exprasmlist,R_INTREGISTER,paramanager.get_volatile_registers_int(pocall_default));
               cg.g_exception_reason_load(exprasmlist,href);
               cg.a_jmp_always(exprasmlist,oldaktexitlabel);
            end;
@@ -1088,9 +1088,9 @@ implementation
          if fc_break in tryflowcontrol then
            begin
               cg.a_label(exprasmlist,breaktrylabel);
-              rg.allocexplicitregistersint(exprasmlist,paramanager.get_volatile_registers_int(pocall_default));
+              cg.allocexplicitregisters(exprasmlist,R_INTREGISTER,paramanager.get_volatile_registers_int(pocall_default));
               cg.a_call_name(exprasmlist,'FPC_POPADDRSTACK');
-              rg.deallocexplicitregistersint(exprasmlist,paramanager.get_volatile_registers_int(pocall_default));
+              cg.deallocexplicitregisters(exprasmlist,R_INTREGISTER,paramanager.get_volatile_registers_int(pocall_default));
               cg.g_exception_reason_load(exprasmlist,href);
               cg.a_jmp_always(exprasmlist,oldaktbreaklabel);
            end;
@@ -1098,9 +1098,9 @@ implementation
          if fc_continue in tryflowcontrol then
            begin
               cg.a_label(exprasmlist,continuetrylabel);
-              rg.allocexplicitregistersint(exprasmlist,paramanager.get_volatile_registers_int(pocall_default));
+              cg.allocexplicitregisters(exprasmlist,R_INTREGISTER,paramanager.get_volatile_registers_int(pocall_default));
               cg.a_call_name(exprasmlist,'FPC_POPADDRSTACK');
-              rg.deallocexplicitregistersint(exprasmlist,paramanager.get_volatile_registers_int(pocall_default));
+              cg.deallocexplicitregisters(exprasmlist,R_INTREGISTER,paramanager.get_volatile_registers_int(pocall_default));
               cg.g_exception_reason_load(exprasmlist,href);
               cg.a_jmp_always(exprasmlist,oldaktcontinuelabel);
            end;
@@ -1154,9 +1154,9 @@ implementation
          paramanager.allocparaloc(exprasmlist,paraloc1);
          cg.a_paramaddr_ref(exprasmlist,href2,paraloc1);
          paramanager.freeparaloc(exprasmlist,paraloc1);
-         rg.allocexplicitregistersint(exprasmlist,paramanager.get_volatile_registers_int(pocall_default));
+         cg.allocexplicitregisters(exprasmlist,R_INTREGISTER,paramanager.get_volatile_registers_int(pocall_default));
          cg.a_call_name(exprasmlist,'FPC_CATCHES');
-         rg.deallocexplicitregistersint(exprasmlist,paramanager.get_volatile_registers_int(pocall_default));
+         cg.deallocexplicitregisters(exprasmlist,R_INTREGISTER,paramanager.get_volatile_registers_int(pocall_default));
 
          { is it this catch? No. go to next onlabel }
          cg.a_cmp_const_reg_label(exprasmlist,OS_ADDR,OC_EQ,0,NR_FUNCTION_RESULT_REG,nextonlabel);
@@ -1206,16 +1206,16 @@ implementation
 
          try_free_exception(exprasmlist,tempbuf,tempaddr,href,0,doobjectdestroy,false);
 
-         rg.allocexplicitregistersint(exprasmlist,paramanager.get_volatile_registers_int(pocall_default));
+         cg.allocexplicitregisters(exprasmlist,R_INTREGISTER,paramanager.get_volatile_registers_int(pocall_default));
          cg.a_call_name(exprasmlist,'FPC_POPSECONDOBJECTSTACK');
-         rg.deallocexplicitregistersint(exprasmlist,paramanager.get_volatile_registers_int(pocall_default));
+         cg.deallocexplicitregisters(exprasmlist,R_INTREGISTER,paramanager.get_volatile_registers_int(pocall_default));
          paraloc1:=paramanager.getintparaloc(pocall_default,1);
          paramanager.allocparaloc(exprasmlist,paraloc1);
          cg.a_param_reg(exprasmlist, OS_ADDR, NR_FUNCTION_RESULT_REG, paraloc1);
          paramanager.freeparaloc(exprasmlist,paraloc1);
-         rg.allocexplicitregistersint(exprasmlist,paramanager.get_volatile_registers_int(pocall_default));
+         cg.allocexplicitregisters(exprasmlist,R_INTREGISTER,paramanager.get_volatile_registers_int(pocall_default));
          cg.a_call_name(exprasmlist,'FPC_DESTROYEXCEPTION');
-         rg.deallocexplicitregistersint(exprasmlist,paramanager.get_volatile_registers_int(pocall_default));
+         cg.deallocexplicitregisters(exprasmlist,R_INTREGISTER,paramanager.get_volatile_registers_int(pocall_default));
          { we don't need to restore esi here because reraise never }
          { returns                                                 }
          cg.a_call_name(exprasmlist,'FPC_RERAISE');
@@ -1444,7 +1444,10 @@ begin
 end.
 {
   $Log$
-  Revision 1.82  2003-10-01 20:34:48  peter
+  Revision 1.83  2003-10-09 21:31:37  daniel
+    * Register allocator splitted, ans abstract now
+
+  Revision 1.82  2003/10/01 20:34:48  peter
     * procinfo unit contains tprocinfo
     * cginfo renamed to cgbase
     * moved cgmessage to verbose

compiler/ncginl.pas

@@ -211,9 +211,9 @@ implementation
        paramanager.freeparaloc(exprasmlist,paraloc2);
        paramanager.freeparaloc(exprasmlist,paraloc3);
        paramanager.freeparaloc(exprasmlist,paraloc4);
-       rg.allocexplicitregistersint(exprasmlist,paramanager.get_volatile_registers_int(pocall_default));
+       cg.allocexplicitregisters(exprasmlist,R_INTREGISTER,paramanager.get_volatile_registers_int(pocall_default));
        cg.a_call_name(exprasmlist,'FPC_ASSERT');
-       rg.deallocexplicitregistersint(exprasmlist,paramanager.get_volatile_registers_int(pocall_default));
+       cg.deallocexplicitregisters(exprasmlist,R_INTREGISTER,paramanager.get_volatile_registers_int(pocall_default));
        cg.a_label(exprasmlist,truelabel);
        truelabel:=otlabel;
        falselabel:=oflabel;
@@ -235,7 +235,7 @@ implementation
         { for both cases load vmt }
         if left.nodetype=typen then
           begin
-            hregister:=rg.getaddressregister(exprasmlist);
+            hregister:=cg.getaddressregister(exprasmlist);
             reference_reset_symbol(href,objectlibrary.newasmsymboldata(tobjectdef(left.resulttype.def).vmt_mangledname),0);
             cg.a_loadaddr_ref_reg(exprasmlist,href,hregister);
           end
@@ -243,7 +243,7 @@ implementation
           begin
             secondpass(left);
             location_release(exprasmlist,left.location);
-            hregister:=rg.getaddressregister(exprasmlist);
+            hregister:=cg.getaddressregister(exprasmlist);
 
             { handle self inside a method of a class }
             case left.location.loc of
@@ -288,8 +288,8 @@ implementation
         if inlinenumber=in_sizeof_x then
            begin
              reference_reset_base(href,hregister,0);
-             rg.ungetaddressregister(exprasmlist,hregister);
-             hregister:=rg.getregisterint(exprasmlist,OS_INT);
+             cg.ungetregister(exprasmlist,hregister);
+             hregister:=cg.getintregister(exprasmlist,OS_INT);
              cg.a_load_ref_reg(exprasmlist,OS_INT,OS_INT,href,hregister);
            end;
         location.register:=hregister;
@@ -366,7 +366,7 @@ implementation
        const
          addsubop:array[in_inc_x..in_dec_x] of TOpCG=(OP_ADD,OP_SUB);
         var
-         addvalue : longint;
+         addvalue : TConstExprInt;
          addconstant : boolean;
          hregisterhi,
          hregister : tregister;
@@ -447,7 +447,7 @@ implementation
          href : treference;
         begin
           location_reset(location,LOC_REGISTER,OS_ADDR);
-          location.register:=rg.getaddressregister(exprasmlist);
+          location.register:=cg.getaddressregister(exprasmlist);
           reference_reset_symbol(href,tstoreddef(left.resulttype.def).get_rtti_label(fullrtti),0);
           cg.a_loadaddr_ref_reg(exprasmlist,href,location.register);
         end;
@@ -509,8 +509,8 @@ implementation
               secondpass(tcallparanode(tcallparanode(left).right).left);
 
               { bitnumber - which must be loaded into register }
-              hregister:=rg.getregisterint(exprasmlist,OS_INT);
-              hregister2 := rg.getregisterint(exprasmlist,OS_INT);
+              hregister:=cg.getintregister(exprasmlist,OS_INT);
+              hregister2:=cg.getintregister(exprasmlist,OS_INT);
 
               case tcallparanode(tcallparanode(left).right).left.location.loc of
                  LOC_CREGISTER,
@@ -572,7 +572,7 @@ implementation
 
                   cg.a_op_const_reg_reg(exprasmlist, OP_SHR, OS_32, 5, hregister,hregister2);
                   cg.a_op_const_reg(exprasmlist, OP_SHL, OS_32, 2, hregister2);
-                  addrreg:=rg.getaddressregister(exprasmlist);
+                  addrreg:=cg.getaddressregister(exprasmlist);
                   { calculate the correct address of the operand }
                   cg.a_loadaddr_ref_reg(exprasmlist, tcallparanode(left).left.location.reference,addrreg);
                   cg.a_op_reg_reg(exprasmlist, OP_ADD, OS_INT, hregister2, addrreg);
@@ -594,10 +594,10 @@ implementation
                          cg.a_op_reg_reg(exprasmlist, OP_NOT, OS_32, hregister2, hregister2);
                          cg.a_op_reg_ref(exprasmlist, OP_AND, OS_32, hregister2, href);
                        end;
-                  rg.ungetregisterint(exprasmlist,addrreg);
+                  cg.ungetregister(exprasmlist,addrreg);
                 end;
-                rg.ungetregisterint(exprasmlist,hregister);
-                rg.ungetregisterint(exprasmlist,hregister2);
+                cg.ungetregister(exprasmlist,hregister);
+                cg.ungetregister(exprasmlist,hregister2);
             end;
         end;
 
@@ -656,7 +656,10 @@ end.
 
 {
   $Log$
-  Revision 1.45  2003-10-08 19:19:45  peter
+  Revision 1.46  2003-10-09 21:31:37  daniel
+    * Register allocator splitted, ans abstract now
+
+  Revision 1.45  2003/10/08 19:19:45  peter
     * set_varstate cleanup
 
   Revision 1.44  2003/10/05 21:21:52  peter

compiler/ncgld.pas

@@ -115,7 +115,7 @@ implementation
                   { DLL variable }
                   else if (vo_is_dll_var in tvarsym(symtableentry).varoptions) then
                     begin
-                       hregister:=rg.getaddressregister(exprasmlist);
+                       hregister:=cg.getaddressregister(exprasmlist);
                        location.reference.symbol:=objectlibrary.newasmsymboldata(tvarsym(symtableentry).mangledname);
                        cg.a_load_ref_reg(exprasmlist,OS_ADDR,OS_ADDR,location.reference,hregister);
                        reference_reset_base(location.reference,hregister,0);
@@ -142,25 +142,25 @@ implementation
                        objectlibrary.getlabel(endrelocatelab);
                        { make sure hregister can't allocate the register necessary for the parameter }
                        paraloc1:=paramanager.getintparaloc(pocall_default,1);
-                       hregister:=rg.getaddressregister(exprasmlist);
+                       hregister:=cg.getaddressregister(exprasmlist);
                        reference_reset_symbol(href,objectlibrary.newasmsymboldata('FPC_THREADVAR_RELOCATE'),0);
                        cg.a_load_ref_reg(exprasmlist,OS_ADDR,OS_ADDR,href,hregister);
-                       rg.ungetregisterint(exprasmlist,hregister);
+                       cg.ungetregister(exprasmlist,hregister);
                        cg.a_cmp_const_reg_label(exprasmlist,OS_ADDR,OC_EQ,0,hregister,norelocatelab);
                        { don't save the allocated register else the result will be destroyed later }
                        reference_reset_symbol(href,objectlibrary.newasmsymboldata(tvarsym(symtableentry).mangledname),0);
                        paramanager.allocparaloc(exprasmlist,paraloc1);
                        cg.a_param_ref(exprasmlist,OS_ADDR,href,paraloc1);
                        paramanager.freeparaloc(exprasmlist,paraloc1);
-                       r:=rg.getabtregisterint(exprasmlist,OS_ADDR);
-                       rg.ungetregisterint(exprasmlist,r);
+                       r:=cg.getabtregister(exprasmlist,OS_ADDR);
+                       cg.ungetregister(exprasmlist,r);
                        cg.a_load_reg_reg(exprasmlist,OS_ADDR,OS_ADDR,hregister,r);
-                       rg.allocexplicitregistersint(exprasmlist,paramanager.get_volatile_registers_int(pocall_default));
+                       cg.allocexplicitregisters(exprasmlist,R_INTREGISTER,paramanager.get_volatile_registers_int(pocall_default));
                        cg.a_call_reg(exprasmlist,r);
-                       rg.deallocexplicitregistersint(exprasmlist,paramanager.get_volatile_registers_int(pocall_default));
-                       r:=rg.getexplicitregisterint(exprasmlist,NR_FUNCTION_RESULT_REG);
-                       rg.ungetregisterint(exprasmlist,r);
-                       hregister:=rg.getaddressregister(exprasmlist);
+                       cg.deallocexplicitregisters(exprasmlist,R_INTREGISTER,paramanager.get_volatile_registers_int(pocall_default));
+                       cg.getexplicitregister(exprasmlist,NR_FUNCTION_RESULT_REG);
+                       cg.ungetregister(exprasmlist,NR_FUNCTION_RESULT_REG);
+                       hregister:=cg.getaddressregister(exprasmlist);
                        cg.a_load_reg_reg(exprasmlist,OS_INT,OS_ADDR,r,hregister);
                        cg.a_jmp_always(exprasmlist,endrelocatelab);
                        cg.a_label(exprasmlist,norelocatelab);
@@ -188,8 +188,9 @@ implementation
                   { normal variable }
                   else
                     begin
+                       {$warning fixme regvars}
                        { in case it is a register variable: }
-                       if tvarsym(symtableentry).localloc.loc=LOC_REGISTER then
+{                       if tvarsym(symtableentry).localloc.loc=LOC_REGISTER then
                          begin
                             case getregtype(tvarsym(symtableentry).localloc.register) of
                               R_FPUREGISTER :
@@ -212,7 +213,7 @@ implementation
                                 internalerror(200301172);
                             end;
                          end
-                       else
+                       else}
                          begin
                            case symtabletype of
                               localsymtable,
@@ -250,7 +251,7 @@ implementation
                      paramanager.push_addr_param(tvarsym(symtableentry).varspez,tvarsym(symtableentry).vartype.def,tprocdef(symtable.defowner).proccalloption) then
                     begin
                       if hregister=NR_NO then
-                        hregister:=rg.getaddressregister(exprasmlist);
+                        hregister:=cg.getaddressregister(exprasmlist);
                       { we need to load only an address }
                       location.size:=OS_ADDR;
                       cg.a_load_loc_reg(exprasmlist,location.size,location,hregister);
@@ -292,7 +293,7 @@ implementation
                          LOC_REFERENCE:
                            begin
                               location_release(exprasmlist,left.location);
-                              hregister:=rg.getaddressregister(exprasmlist);
+                              hregister:=cg.getaddressregister(exprasmlist);
                               if is_class_or_interface(left.resulttype.def) then
                                 cg.a_load_ref_reg(exprasmlist,OS_ADDR,OS_ADDR,left.location.reference,hregister)
                               else
@@ -314,7 +315,7 @@ implementation
                           { load vmt pointer }
                           reference_reset_base(href,hregister,0);
                           reference_release(exprasmlist,href);
-                          hregister:=rg.getaddressregister(exprasmlist);
+                          hregister:=cg.getaddressregister(exprasmlist);
                           cg.a_load_ref_reg(exprasmlist,OS_ADDR,OS_ADDR,href,hregister);
 
 
@@ -323,22 +324,22 @@ implementation
                           reference_release(exprasmlist,href);
 
                           { load method address }
-                          hregister:=rg.getaddressregister(exprasmlist);
+                          hregister:=cg.getaddressregister(exprasmlist);
                           cg.a_load_ref_reg(exprasmlist,OS_ADDR,OS_ADDR,href,hregister);
                           { ... and store it }
                           cg.a_load_reg_ref(exprasmlist,OS_ADDR,OS_ADDR,hregister,location.reference);
-                          rg.ungetaddressregister(exprasmlist,hregister);
+                          cg.ungetregister(exprasmlist,hregister);
                         end
                       else
                         begin
                           { we don't use the hregister }
-                          rg.ungetregisterint(exprasmlist,hregister);
+                          cg.ungetregister(exprasmlist,hregister);
                           { load address of the function }
                           reference_reset_symbol(href,objectlibrary.newasmsymbol(procdef.mangledname),0);
-                          hregister:=rg.getaddressregister(exprasmlist);
+                          hregister:=cg.getaddressregister(exprasmlist);
                           cg.a_loadaddr_ref_reg(exprasmlist,href,hregister);
                           cg.a_load_reg_ref(exprasmlist,OS_ADDR,OS_ADDR,hregister,location.reference);
-                          rg.ungetregisterint(exprasmlist,hregister);
+                          cg.ungetregister(exprasmlist,hregister);
                         end;
                     end
                   else
@@ -506,7 +507,7 @@ implementation
                       LOC_REGISTER,
                       LOC_CREGISTER :
                         begin
-                          r:=rg.makeregsize(right.location.register,OS_8);
+                          r:=cg.makeregsize(right.location.register,OS_8);
                           cg.a_load_reg_ref(exprasmlist,OS_8,OS_8,r,href);
                         end;
                       LOC_REFERENCE,
@@ -816,9 +817,9 @@ implementation
                   begin
                     location_force_mem(exprasmlist,hp.left.location);
                     location_release(exprasmlist,hp.left.location);
-                    tmpreg:=rg.getaddressregister(exprasmlist);
+                    tmpreg:=cg.getaddressregister(exprasmlist);
                     cg.a_loadaddr_ref_reg(exprasmlist,hp.left.location.reference,tmpreg);
-                    rg.ungetregisterint(exprasmlist,tmpreg);
+                    cg.ungetregister(exprasmlist,tmpreg);
                     cg.a_load_reg_ref(exprasmlist,OS_ADDR,OS_ADDR,tmpreg,href);
                     if freetemp then
                       location_freetemp(exprasmlist,hp.left.location);
@@ -883,7 +884,10 @@ begin
 end.
 {
   $Log$
-  Revision 1.91  2003-10-07 15:17:07  peter
+  Revision 1.92  2003-10-09 21:31:37  daniel
+    * Register allocator splitted, ans abstract now
+
+  Revision 1.91  2003/10/07 15:17:07  peter
     * inline supported again, LOC_REFERENCEs are used to pass the
       parameters
     * inlineparasymtable,inlinelocalsymtable removed

compiler/ncgmat.pas

@@ -153,7 +153,7 @@ implementation
         else
         if _size <> OS_F32 then
            internalerror(20020814);
-        hreg := rg.getregisterint(exprasmlist,OS_32);
+        hreg := cg.getintregister(exprasmlist,OS_32);
         { load value }
         cg.a_load_ref_reg(exprasmlist,OS_32,OS_32,href,hreg);
         { bitwise complement copied value }
@@ -162,7 +162,7 @@ implementation
         cg.a_op_const_reg(exprasmlist,OP_AND,OS_32,aword($80000000),hreg);
         { or with value in reference memory }
         cg.a_op_reg_ref(exprasmlist,OP_OR,OS_32,hreg,href);
-        rg.ungetregisterint(exprasmlist,hreg);
+        cg.ungetregister(exprasmlist,hreg);
         { store the floating point value in the temporary memory area }
         if _size = OS_F64 then
           begin
@@ -196,7 +196,7 @@ implementation
           LOC_CREFERENCE :
             begin
               reference_release(exprasmlist,left.location.reference);
-              location.register:=rg.getregisterfpu(exprasmlist,location.size);
+              location.register:=cg.getfpuregister(exprasmlist,location.size);
               cg.a_loadfpu_ref_reg(exprasmlist,
                  def_cgsize(left.resulttype.def),
                  left.location.reference,location.register);
@@ -209,7 +209,7 @@ implementation
             end;
           LOC_CFPUREGISTER:
             begin
-               location.register:=rg.getregisterfpu(exprasmlist,location.size);
+               location.register:=cg.getfpuregister(exprasmlist,location.size);
                cg.a_loadfpu_reg_reg(exprasmlist,left.location.size,left.location.register,location.register);
                emit_float_sign_change(location.register,def_cgsize(left.resulttype.def));
             end;
@@ -321,7 +321,7 @@ implementation
                   { hdenom is always free, it's }
                   { only used for temporary }
                   { purposes                }
-                  hdenom := rg.getregisterint(exprasmlist,OS_INT);
+                  hdenom := cg.getintregister(exprasmlist,OS_INT);
                   if right.location.loc<>LOC_CREGISTER then
                    location_release(exprasmlist,right.location);
                   cg.a_load_loc_reg(exprasmlist,right.location.size,right.location,hdenom);
@@ -431,7 +431,7 @@ implementation
                 begin
                   if right.location.loc<>LOC_CREGISTER then
                    location_release(exprasmlist,right.location);
-                  hcountreg:=rg.getregisterint(exprasmlist,OS_INT);
+                  hcountreg:=cg.getintregister(exprasmlist,OS_INT);
                   freescratch := true;
                   cg.a_load_loc_reg(exprasmlist,right.location.size,right.location,hcountreg);
                 end
@@ -439,7 +439,7 @@ implementation
                 hcountreg:=right.location.register;
               cg.a_op_reg_reg(exprasmlist,op,OS_INT,hcountreg,location.register);
               if freescratch then
-                rg.ungetregisterint(exprasmlist,hcountreg);
+                cg.ungetregister(exprasmlist,hcountreg);
            end;
       end;
 
@@ -502,7 +502,10 @@ begin
 end.
 {
   $Log$
-  Revision 1.19  2003-10-01 20:34:48  peter
+  Revision 1.20  2003-10-09 21:31:37  daniel
+    * Register allocator splitted, ans abstract now
+
+  Revision 1.19  2003/10/01 20:34:48  peter
     * procinfo unit contains tprocinfo
     * cginfo renamed to cgbase
     * moved cgmessage to verbose

compiler/ncgmem.pas

@@ -119,7 +119,7 @@ implementation
                   LOC_REFERENCE:
                     begin
                        location_release(exprasmlist,left.location);
-                       reference_reset_base(href,rg.getaddressregister(exprasmlist),tobjectdef(left.resulttype.def).vmt_offset);
+                       reference_reset_base(href,cg.getaddressregister(exprasmlist),tobjectdef(left.resulttype.def).vmt_offset);
                        cg.a_loadaddr_ref_reg(exprasmlist,left.location.reference,href.base);
                     end;
                   else
@@ -131,13 +131,15 @@ implementation
                case left.location.loc of
                   LOC_REGISTER:
                     begin
-                      if not rg.isaddressregister(left.location.register) then
+                    {$ifdef cpu_uses_separate_address_registers}
+                      if getregtype(left.location.register)<>R_ADDRESSREGISTER then
                         begin
                           location_release(exprasmlist,left.location);
-                          reference_reset_base(href,rg.getaddressregister(exprasmlist),tobjectdef(left.resulttype.def).vmt_offset);
+                          reference_reset_base(href,cg.getaddressregister(exprasmlist),tobjectdef(left.resulttype.def).vmt_offset);
                           cg.a_load_reg_reg(exprasmlist,OS_ADDR,OS_ADDR,left.location.register,href.base);
                         end
                       else
+                    {$endif}
                         reference_reset_base(href,left.location.register,tobjectdef(left.resulttype.def).vmt_offset);
                     end;
                   LOC_CREGISTER,
@@ -145,7 +147,7 @@ implementation
                   LOC_REFERENCE:
                     begin
                        location_release(exprasmlist,left.location);
-                       reference_reset_base(href,rg.getaddressregister(exprasmlist),tobjectdef(left.resulttype.def).vmt_offset);
+                       reference_reset_base(href,cg.getaddressregister(exprasmlist),tobjectdef(left.resulttype.def).vmt_offset);
                        cg.a_load_loc_reg(exprasmlist,OS_ADDR,left.location,href.base);
                     end;
                   else
@@ -153,7 +155,7 @@ implementation
                end;
              end;
             reference_release(exprasmlist,href);
-            location.register:=rg.getaddressregister(exprasmlist);
+            location.register:=cg.getaddressregister(exprasmlist);
             cg.g_maybe_testself(exprasmlist,href.base);
             cg.a_load_ref_reg(exprasmlist,OS_ADDR,OS_ADDR,href,location.register);
           end
@@ -161,7 +163,7 @@ implementation
           begin
             reference_reset_symbol(href,
               objectlibrary.newasmsymboldata(tobjectdef(tclassrefdef(resulttype.def).pointertype.def).vmt_mangledname),0);
-            location.register:=rg.getaddressregister(exprasmlist);
+            location.register:=cg.getaddressregister(exprasmlist);
             cg.a_loadaddr_ref_reg(exprasmlist,href,location.register);
           end;
       end;
@@ -186,7 +188,7 @@ implementation
           begin
             currpi:=current_procinfo;
             location_reset(location,LOC_REGISTER,OS_ADDR);
-            location.register:=rg.getaddressregister(exprasmlist);
+            location.register:=cg.getaddressregister(exprasmlist);
             { load framepointer of current proc }
             hsym:=tvarsym(currpi.procdef.parast.search('parentfp'));
             if not assigned(hsym) then
@@ -234,7 +236,7 @@ implementation
 
          location_release(exprasmlist,left.location);
          location_reset(location,LOC_REGISTER,OS_ADDR);
-         location.register:=rg.getaddressregister(exprasmlist);
+         location.register:=cg.getaddressregister(exprasmlist);
          { @ on a procvar means returning an address to the procedure that
            is stored in it }
          if (m_tp_procvar in aktmodeswitches) and
@@ -261,14 +263,16 @@ implementation
          case left.location.loc of
             LOC_REGISTER:
               begin
-                if not rg.isaddressregister(left.location.register) then
+              {$ifdef cpu_uses_separate_address_registers}
+                if getregtype(left.location.register)<>R_ADDRESSREGISTER then
                   begin
                     location_release(exprasmlist,left.location);
-                    location.reference.base := rg.getaddressregister(exprasmlist);
+                    location.reference.base := cg.getaddressregister(exprasmlist);
                     cg.a_load_reg_reg(exprasmlist,OS_ADDR,OS_ADDR,left.location.register,
                       location.reference.base);
                   end
                 else
+              {$endif}
                   location.reference.base := left.location.register;
               end;
             LOC_CREGISTER,
@@ -276,7 +280,7 @@ implementation
             LOC_REFERENCE:
               begin
                  location_release(exprasmlist,left.location);
-                 location.reference.base:=rg.getaddressregister(exprasmlist);
+                 location.reference.base:=cg.getaddressregister(exprasmlist);
                  cg.a_load_loc_reg(exprasmlist,OS_ADDR,left.location,location.reference.base);
               end;
          end;
@@ -314,7 +318,8 @@ implementation
                 LOC_CREGISTER,
                 LOC_REGISTER:
                   begin
-                    if not rg.isaddressregister(left.location.register) then
+                  {$ifdef cpu_uses_separate_address_registers}
+                    if getregtype(left.location.register)<>R_ADDRESSREGISTER then
                       begin
                         location_release(exprasmlist,left.location);
                         location.reference.base:=rg.getaddressregister(exprasmlist);
@@ -322,13 +327,14 @@ implementation
                           left.location.register,location.reference.base);
                       end
                     else
+                  {$endif}
                       location.reference.base := left.location.register;
                   end;
                 LOC_CREFERENCE,
                 LOC_REFERENCE:
                   begin
                      location_release(exprasmlist,left.location);
-                     location.reference.base:=rg.getaddressregister(exprasmlist);
+                     location.reference.base:=cg.getaddressregister(exprasmlist);
                      cg.a_load_loc_reg(exprasmlist,OS_ADDR,left.location,location.reference.base);
                   end;
              end;
@@ -478,8 +484,8 @@ implementation
           end
          else
           begin
-            rg.ungetreference(exprasmlist,location.reference);
-            hreg := rg.getaddressregister(exprasmlist);
+            cg.ungetreference(exprasmlist,location.reference);
+            hreg := cg.getaddressregister(exprasmlist);
             cg.a_loadaddr_ref_reg(exprasmlist,location.reference,hreg);
             reference_reset_base(location.reference,hreg,0);
             { insert new index register }
@@ -526,7 +532,7 @@ implementation
                  hreg:=right.location.register
                else
                  begin
-                   hreg:=rg.getregisterint(exprasmlist,OS_INT);
+                   hreg:=cg.getintregister(exprasmlist,OS_INT);
                    freereg:=true;
                    cg.a_load_loc_reg(exprasmlist,OS_INT,right.location,hreg);
                  end;
@@ -536,7 +542,7 @@ implementation
                location_release(exprasmlist,hightree.location);
                cg.a_cmp_loc_reg_label(exprasmlist,OS_INT,OC_BE,hightree.location,hreg,neglabel);
                if freereg then
-                 rg.ungetregisterint(exprasmlist,hreg);
+                 cg.ungetregister(exprasmlist,hreg);
                cg.a_label(exprasmlist,poslabel);
                cg.a_call_name(exprasmlist,'FPC_RANGEERROR');
                cg.a_label(exprasmlist,neglabel);
@@ -555,9 +561,9 @@ implementation
                cg.a_param_loc(exprasmlist,left.location,paraloc1);
                paramanager.freeparaloc(exprasmlist,paraloc1);
                paramanager.freeparaloc(exprasmlist,paraloc2);
-               rg.allocexplicitregistersint(exprasmlist,paramanager.get_volatile_registers_int(pocall_default));
+               cg.allocexplicitregisters(exprasmlist,R_INTREGISTER,paramanager.get_volatile_registers_int(pocall_default));
                cg.a_call_name(exprasmlist,'FPC_DYNARRAY_RANGECHECK');
-               rg.deallocexplicitregistersint(exprasmlist,paramanager.get_volatile_registers_int(pocall_default));
+               cg.deallocexplicitregisters(exprasmlist,R_INTREGISTER,paramanager.get_volatile_registers_int(pocall_default));
             end
          else
            cg.g_rangecheck(exprasmlist,right.location,right.resulttype.def,left.resulttype.def);
@@ -600,7 +606,7 @@ implementation
                 LOC_REFERENCE :
                   begin
                     location_release(exprasmlist,left.location);
-                    location.reference.base:=rg.getaddressregister(exprasmlist);
+                    location.reference.base:=cg.getaddressregister(exprasmlist);
                     cg.a_load_ref_reg(exprasmlist,OS_ADDR,OS_ADDR,left.location.reference,location.reference.base);
                   end;
                 else
@@ -615,9 +621,9 @@ implementation
                    paramanager.allocparaloc(exprasmlist,paraloc1);
                    cg.a_param_reg(exprasmlist,OS_ADDR,location.reference.base,paraloc1);
                    paramanager.freeparaloc(exprasmlist,paraloc1);
-                   rg.allocexplicitregistersint(exprasmlist,paramanager.get_volatile_registers_int(pocall_default));
+                   cg.allocexplicitregisters(exprasmlist,R_INTREGISTER,paramanager.get_volatile_registers_int(pocall_default));
                    cg.a_call_name(exprasmlist,'FPC_'+upper(tstringdef(left.resulttype.def).stringtypname)+'_CHECKZERO');
-                   rg.deallocexplicitregistersint(exprasmlist,paramanager.get_volatile_registers_int(pocall_default));
+                   cg.deallocexplicitregisters(exprasmlist,R_INTREGISTER,paramanager.get_volatile_registers_int(pocall_default));
                 end;
 
               { in ansistrings/widestrings S[1] is p<w>char(S)[0] !! }
@@ -636,7 +642,7 @@ implementation
                 LOC_CREFERENCE :
                   begin
                      location_release(exprasmlist,left.location);
-                     location.reference.base:=rg.getaddressregister(exprasmlist);
+                     location.reference.base:=cg.getaddressregister(exprasmlist);
                      cg.a_load_ref_reg(exprasmlist,OS_ADDR,OS_ADDR,
                       left.location.reference,location.reference.base);
                   end;
@@ -700,9 +706,9 @@ implementation
                               cg.a_param_ref(exprasmlist,OS_INT,href,paraloc1);
                               paramanager.freeparaloc(exprasmlist,paraloc1);
                               paramanager.freeparaloc(exprasmlist,paraloc2);
-                              rg.allocexplicitregistersint(exprasmlist,paramanager.get_volatile_registers_int(pocall_default));
+                              cg.allocexplicitregisters(exprasmlist,R_INTREGISTER,paramanager.get_volatile_registers_int(pocall_default));
                               cg.a_call_name(exprasmlist,'FPC_'+upper(tstringdef(left.resulttype.def).stringtypname)+'_RANGECHECK');
-                              rg.deallocexplicitregistersint(exprasmlist,paramanager.get_volatile_registers_int(pocall_default));
+                              cg.deallocexplicitregisters(exprasmlist,R_INTREGISTER,paramanager.get_volatile_registers_int(pocall_default));
                            end;
 
                          st_shortstring:
@@ -834,9 +840,9 @@ implementation
                               cg.a_param_ref(exprasmlist,OS_INT,href,paraloc1);
                               paramanager.freeparaloc(exprasmlist,paraloc1);
                               paramanager.freeparaloc(exprasmlist,paraloc2);
-                              rg.allocexplicitregistersint(exprasmlist,paramanager.get_volatile_registers_int(pocall_default));
+                              cg.allocexplicitregisters(exprasmlist,R_INTREGISTER,paramanager.get_volatile_registers_int(pocall_default));
                               cg.a_call_name(exprasmlist,'FPC_'+upper(tstringdef(left.resulttype.def).stringtypname)+'_RANGECHECK');
-                              rg.deallocexplicitregistersint(exprasmlist,paramanager.get_volatile_registers_int(pocall_default));
+                              cg.deallocexplicitregisters(exprasmlist,R_INTREGISTER,paramanager.get_volatile_registers_int(pocall_default));
                            end;
                          st_shortstring:
                            begin
@@ -870,7 +876,10 @@ begin
 end.
 {
   $Log$
-  Revision 1.77  2003-10-01 20:34:48  peter
+  Revision 1.78  2003-10-09 21:31:37  daniel
+    * Register allocator splitted, ans abstract now
+
+  Revision 1.77  2003/10/01 20:34:48  peter
     * procinfo unit contains tprocinfo
     * cginfo renamed to cgbase
     * moved cgmessage to verbose

compiler/ncgopt.pas

@@ -120,7 +120,7 @@ begin
         { free the registers of right }
         reference_release(exprasmlist,right.location.reference);
         { get register for the char }
-        hreg := rg.getregisterint(exprasmlist,OS_8);
+        hreg := cg.getintregister(exprasmlist,OS_8);
         cg.a_load_ref_reg(exprasmlist,OS_8,OS_8,right.location.reference,hreg);
         { I don't think a temp char exists, but it won't hurt (JM) }
         tg.ungetiftemp(exprasmlist,right.location.reference);
@@ -128,7 +128,7 @@ begin
     else hreg := right.location.register;
 
   { load the current string length }
-  lengthreg := rg.getregisterint(exprasmlist,OS_INT);
+  lengthreg := cg.getintregister(exprasmlist,OS_INT);
   cg.a_load_ref_reg(exprasmlist,OS_8,OS_INT,left.location.reference,lengthreg);
 
   { do we have to check the length ? }
@@ -181,15 +181,15 @@ begin
       { no new_reference(href2) because it's only }
       { used once (JM)                            }
       cg.a_load_reg_ref(exprasmlist,OS_8,OS_8,hreg,href2);
-      rg.ungetregisterint(exprasmlist,hreg);
+      cg.ungetregister(exprasmlist,hreg);
     end
   else
     cg.a_load_const_ref(exprasmlist,OS_8,tordconstnode(right).value,href2);
-  lengthreg:=rg.makeregsize(lengthreg,OS_8);
+  lengthreg:=cg.makeregsize(lengthreg,OS_8);
   { increase the string length }
   cg.a_op_const_reg(exprasmlist,OP_ADD,OS_8,1,lengthreg);
   cg.a_load_reg_ref(exprasmlist,OS_8,OS_8,lengthreg,left.location.reference);
-  rg.ungetregisterint(exprasmlist,lengthreg);
+  cg.ungetregister(exprasmlist,lengthreg);
   if checklength then
     cg.a_label(exprasmlist,l);
   location_copy(location,left.location);
@@ -201,7 +201,10 @@ end.
 
 {
   $Log$
-  Revision 1.9  2003-10-01 20:34:48  peter
+  Revision 1.10  2003-10-09 21:31:37  daniel
+    * Register allocator splitted, ans abstract now
+
+  Revision 1.9  2003/10/01 20:34:48  peter
     * procinfo unit contains tprocinfo
     * cginfo renamed to cgbase
     * moved cgmessage to verbose

compiler/ncgset.pas

@@ -252,7 +252,7 @@ implementation
          { location is always LOC_JUMP }
          location_reset(location,LOC_REGISTER,def_cgsize(resulttype.def));
          { allocate a register for the result }
-         location.register := rg.getregisterint(exprasmlist,location.size);
+         location.register := cg.getintregister(exprasmlist,location.size);
 
          if genjumps then
           begin
@@ -269,7 +269,7 @@ implementation
                { use the register as base in a reference (JM)                }
                if ranges then
                  begin
-                   pleftreg:=rg.makeregsize(left.location.register,OS_INT);
+                   pleftreg:=cg.makeregsize(left.location.register,OS_INT);
                    cg.a_load_reg_reg(exprasmlist,left.location.size,OS_INT,left.location.register,pleftreg);
                    if opsize <> OS_INT then
                      cg.a_op_const_reg(exprasmlist,OP_AND,OS_INT,255,pleftreg);
@@ -279,7 +279,7 @@ implementation
                  { otherwise simply use the lower 8 bits (no "and" }
                  { necessary this way) (JM)                        }
                  begin
-                   pleftreg:=rg.makeregsize(left.location.register,OS_8);
+                   pleftreg:=cg.makeregsize(left.location.register,OS_8);
                    opsize := OS_8;
                  end;
              end
@@ -287,7 +287,7 @@ implementation
              begin
                { load the value in a register }
                opsize := OS_INT;
-               pleftreg:=rg.getregisterint(exprasmlist,opsize);
+               pleftreg:=cg.getintregister(exprasmlist,opsize);
                cg.a_load_ref_reg(exprasmlist,def_cgsize(left.resulttype.def),opsize,left.location.reference,pleftreg);
              end;
 
@@ -314,7 +314,7 @@ implementation
                       if (left.location.loc = LOC_CREGISTER) and
                          (hr<>pleftreg) then
                         begin
-                          hr:=rg.getregisterint(exprasmlist,OS_INT);
+                          hr:=cg.getintregister(exprasmlist,OS_INT);
                           cg.a_op_const_reg_reg(exprasmlist,OP_SUB,opsize,setparts[i].start,pleftreg,hr);
                           pleftreg:=hr;
                           opsize := OS_INT;
@@ -362,13 +362,13 @@ implementation
              cg.a_label(exprasmlist,l3);
              case left.location.loc of
                LOC_CREGISTER :
-                 rg.ungetregisterint(exprasmlist,pleftreg);
+                 cg.ungetregister(exprasmlist,pleftreg);
                LOC_REGISTER :
-                 rg.ungetregisterint(exprasmlist,pleftreg);
+                 cg.ungetregister(exprasmlist,pleftreg);
                else
                  begin
                    reference_release(exprasmlist,left.location.reference);
-                   rg.ungetregisterint(exprasmlist,pleftreg);
+                   cg.ungetregister(exprasmlist,pleftreg);
                  end;
              end;
           end
@@ -388,7 +388,7 @@ implementation
                  { then SHR the register }
                  cg.a_op_const_reg_reg(exprasmlist,OP_SHR,OS_INT,
                    tordconstnode(left).value and 31,right.location.register,location.register);
-                 rg.ungetregisterint(exprasmlist,right.location.register);
+                 cg.ungetregister(exprasmlist,right.location.register);
                  { then extract the lowest bit }
                  cg.a_op_const_reg(exprasmlist,OP_AND,OS_INT,1,location.register);
                 end
@@ -398,14 +398,14 @@ implementation
                      LOC_REGISTER,
                      LOC_CREGISTER:
                        begin
-                          hr3:=rg.makeregsize(left.location.register,OS_INT);
+                          hr3:=cg.makeregsize(left.location.register,OS_INT);
                           cg.a_load_reg_reg(exprasmlist,left.location.size,OS_INT,left.location.register,hr3);
-                          hr:=rg.getregisterint(exprasmlist,OS_INT);
+                          hr:=cg.getintregister(exprasmlist,OS_INT);
                           cg.a_load_reg_reg(exprasmlist,OS_INT,OS_INT,hr3,hr);
                        end;
                   else
                     begin
-                      hr:=rg.getregisterint(exprasmlist,OS_INT);
+                      hr:=cg.getintregister(exprasmlist,OS_INT);
                       cg.a_load_ref_reg(exprasmlist,def_cgsize(left.resulttype.def),OS_INT,
                          left.location.reference,hr);
                       location_release(exprasmlist,left.location);
@@ -416,9 +416,9 @@ implementation
                   { emit bit test operation }
                   emit_bit_test_reg_reg(exprasmlist,hr,right.location.register,location.register);
                   { free the resources }
-                  rg.ungetregisterint(exprasmlist,right.location.register);
+                  cg.ungetregister(exprasmlist,right.location.register);
                   { free bitnumber register }
-                  rg.ungetregisterint(exprasmlist,hr);
+                  cg.ungetregister(exprasmlist,hr);
                 end;
              end
             else
@@ -436,7 +436,7 @@ implementation
                      LOC_REGISTER,
                      LOC_CREGISTER:
                        begin
-                          hr:=rg.makeregsize(left.location.register,OS_INT);
+                          hr:=cg.makeregsize(left.location.register,OS_INT);
                           cg.a_load_reg_reg(exprasmlist,left.location.size,OS_INT,left.location.register,hr);
                           cg.a_cmp_const_reg_label(exprasmlist,OS_INT,OC_BE,31,hr,l);
                         { reset of result register is done in routine entry }
@@ -444,7 +444,7 @@ implementation
                           cg.a_label(exprasmlist,l);
                         { We have to load the value into a register because
                           btl does not accept values only refs or regs (PFV) }
-                          hr2:=rg.getregisterint(exprasmlist,OS_INT);
+                          hr2:=cg.getintregister(exprasmlist,OS_INT);
                           cg.a_load_const_reg(exprasmlist,OS_INT,right.location.value,hr2);
                        end;
                      LOC_REFERENCE,
@@ -454,11 +454,11 @@ implementation
                           cg.a_jmp_always(exprasmlist,l2);
                           cg.a_label(exprasmlist,l);
                           location_release(exprasmlist,left.location);
-                          hr:=rg.getregisterint(exprasmlist,OS_INT);
+                          hr:=cg.getintregister(exprasmlist,OS_INT);
                           cg.a_load_ref_reg(exprasmlist,OS_INT,OS_INT,left.location.reference,hr);
                         { We have to load the value into a register because
                           btl does not accept values only refs or regs (PFV) }
-                          hr2:=rg.getregisterint(exprasmlist,OS_INT);
+                          hr2:=cg.getintregister(exprasmlist,OS_INT);
                           cg.a_load_const_reg(exprasmlist,OS_INT,right.location.value,hr2);
                        end;
                      else
@@ -466,9 +466,9 @@ implementation
                   end;
                   { emit bit test operation }
                   emit_bit_test_reg_reg(exprasmlist,hr,hr2,location.register);
-                  rg.ungetregisterint(exprasmlist,hr2);
+                  cg.ungetregister(exprasmlist,hr2);
                   if not (left.location.loc in [LOC_REGISTER,LOC_CREGISTER]) then
-                    rg.ungetregisterint(exprasmlist,hr);
+                    cg.ungetregister(exprasmlist,hr);
                   cg.a_label(exprasmlist,l2);
                 end { of right.location.loc=LOC_CONSTANT }
                { do search in a normal set which could have >32 elementsm
@@ -493,7 +493,7 @@ implementation
                   pleftreg := left.location.register;
 
                   location_freetemp(exprasmlist,left.location);
-                  hr := rg.getaddressregister(exprasmlist);
+                  hr := cg.getaddressregister(exprasmlist);
                   cg.a_op_const_reg_reg(exprasmlist,OP_SHR,OS_32,5,pleftreg,hr);
                   cg.a_op_const_reg(exprasmlist,OP_SHL,OS_32,2,hr);
 
@@ -505,18 +505,18 @@ implementation
                   else
                     begin
                       reference_release(exprasmlist,href);
-                      hr2 := rg.getaddressregister(exprasmlist);
+                      hr2 := cg.getaddressregister(exprasmlist);
                       cg.a_loadaddr_ref_reg(exprasmlist,href, hr2);
                       reference_reset_base(href,hr2,0);
                       href.index := hr;
                     end;
                   reference_release(exprasmlist,href);
                   cg.a_load_ref_reg(exprasmlist,OS_32,OS_32,href,location.register);
-                  rg.ungetregisterint(exprasmlist,pleftreg);
-                  hr := rg.getregisterint(exprasmlist,OS_32);
+                  cg.ungetregister(exprasmlist,pleftreg);
+                  hr := cg.getintregister(exprasmlist,OS_32);
                   cg.a_op_const_reg_reg(exprasmlist,OP_AND,OS_32,31,pleftreg,hr);
                   cg.a_op_reg_reg(exprasmlist,OP_SHR,OS_32,hr,location.register);
-                  rg.ungetregisterint(exprasmlist,hr);
+                  cg.ungetregister(exprasmlist,hr);
                   cg.a_op_const_reg(exprasmlist,OP_AND,OS_32,1,location.register);
                 end;
              end;
@@ -621,9 +621,9 @@ implementation
            begin
               last:=0;
               first:=true;
-              scratch_reg:=rg.getregisterint(exprasmlist,opsize);
+              scratch_reg:=cg.getintregister(exprasmlist,opsize);
               genitem(hp);
-              rg.ungetregisterint(exprasmlist,scratch_reg);
+              cg.ungetregister(exprasmlist,scratch_reg);
               cg.a_jmp_always(exprasmlist,elselabel);
            end;
       end;
@@ -956,7 +956,7 @@ implementation
                 genlinearlist(nodes);
            end;
 
-         rg.ungetregisterint(exprasmlist,hregister);
+         cg.ungetregister(exprasmlist,hregister);
 
          { now generate the instructions }
          hp:=tstatementnode(right);
@@ -1003,7 +1003,10 @@ begin
 end.
 {
   $Log$
-  Revision 1.49  2003-10-01 20:34:48  peter
+  Revision 1.50  2003-10-09 21:31:37  daniel
+    * Register allocator splitted, ans abstract now
+
+  Revision 1.49  2003/10/01 20:34:48  peter
     * procinfo unit contains tprocinfo
     * cginfo renamed to cgbase
     * moved cgmessage to verbose

compiler/ncgutil.pas

@@ -42,7 +42,7 @@ interface
 
     procedure firstcomplex(p : tbinarynode);
     procedure maketojumpbool(list:TAAsmoutput; p : tnode; loadregvars: tloadregvars);
-    procedure remove_non_regvars_from_loc(const t: tlocation; var regs:Tsuperregisterset);
+//    procedure remove_non_regvars_from_loc(const t: tlocation; var regs:Tsuperregisterset);
 
     procedure location_force_reg(list:TAAsmoutput;var l:tlocation;dst_size:TCGSize;maybeconst:boolean);
     procedure location_force_fpureg(list:TAAsmoutput;var l: tlocation;maybeconst:boolean);
@@ -236,6 +236,10 @@ implementation
       end;
 
 
+        (*
+        This code needs fixing. It is not safe to use rgint; on the m68000 it
+        would be rgaddr.
+
     procedure remove_non_regvars_from_loc(const t: tlocation; var regs:Tsuperregisterset);
       begin
         case t.loc of
@@ -249,14 +253,15 @@ implementation
           LOC_CREFERENCE,LOC_REFERENCE:
             begin
               if not(cs_regvars in aktglobalswitches) or
-                 (getsupreg(t.reference.base) in rg.usableregsint) then
+                 (getsupreg(t.reference.base) in cg.rgint.usableregs) then
                 exclude(regs,getsupreg(t.reference.base));
               if not(cs_regvars in aktglobalswitches) or
-                 (getsupreg(t.reference.index) in rg.usableregsint) then
+                 (getsupreg(t.reference.index) in cg.rgint.usableregs) then
                 exclude(regs,getsupreg(t.reference.index));
             end;
         end;
       end;
+        *)
 
 {*****************************************************************************
                             EXCEPTION MANAGEMENT
@@ -281,16 +286,16 @@ implementation
         paramanager.freeparaloc(list,paraloc3);
         paramanager.freeparaloc(list,paraloc2);
         paramanager.freeparaloc(list,paraloc1);
-        rg.allocexplicitregistersint(list,paramanager.get_volatile_registers_int(pocall_default));
+        cg.allocexplicitregisters(list,R_INTREGISTER,paramanager.get_volatile_registers_int(pocall_default));
         cg.a_call_name(list,'FPC_PUSHEXCEPTADDR');
-        rg.deallocexplicitregistersint(list,paramanager.get_volatile_registers_int(pocall_default));
+        cg.deallocexplicitregisters(list,R_INTREGISTER,paramanager.get_volatile_registers_int(pocall_default));
 
         paramanager.allocparaloc(list,paraloc1);
         cg.a_param_reg(list,OS_ADDR,NR_FUNCTION_RESULT_REG,paraloc1);
         paramanager.freeparaloc(list,paraloc1);
-        rg.allocexplicitregistersint(list,paramanager.get_volatile_registers_int(pocall_default));
+        cg.allocexplicitregisters(list,R_INTREGISTER,paramanager.get_volatile_registers_int(pocall_default));
         cg.a_call_name(list,'FPC_SETJMP');
-        rg.deallocexplicitregistersint(list,paramanager.get_volatile_registers_int(pocall_default));
+        cg.deallocexplicitregisters(list,R_INTREGISTER,paramanager.get_volatile_registers_int(pocall_default));
 
         cg.g_exception_reason_save(list, href);
         cg.a_cmp_const_reg_label(list,OS_S32,OC_NE,0,NR_FUNCTION_RESULT_REG,exceptlabel);
@@ -301,9 +306,9 @@ implementation
      a : aword ; endexceptlabel : tasmlabel; onlyfree : boolean);
 
      begin
-         rg.allocexplicitregistersint(list,paramanager.get_volatile_registers_int(pocall_default));
+         cg.allocexplicitregisters(list,R_INTREGISTER,paramanager.get_volatile_registers_int(pocall_default));
          cg.a_call_name(list,'FPC_POPADDRSTACK');
-         rg.deallocexplicitregistersint(list,paramanager.get_volatile_registers_int(pocall_default));
+         cg.deallocexplicitregisters(list,R_INTREGISTER,paramanager.get_volatile_registers_int(pocall_default));
 
          if not onlyfree then
           begin
@@ -338,13 +343,13 @@ implementation
               { load a smaller size to OS_64 }
               if l.loc=LOC_REGISTER then
                begin
-                 hregister:=rg.makeregsize(l.registerlow,OS_32);
+                 hregister:=cg.makeregsize(l.registerlow,OS_32);
                  cg.a_load_reg_reg(list,l.size,OS_32,l.registerlow,hregister);
                end
               else
                begin
                  location_release(list,l);
-                 hregister:=rg.getregisterint(list,OS_INT);
+                 hregister:=cg.getintregister(list,OS_INT);
                end;
               { load value in low register }
               case l.loc of
@@ -364,7 +369,7 @@ implementation
                   cg.a_load_loc_reg(list,OS_INT,l,hregister);
               end;
               { reset hi part, take care of the signed bit of the current value }
-              hregisterhi:=rg.getregisterint(list,OS_INT);
+              hregisterhi:=cg.getintregister(list,OS_INT);
               if (dst_size=OS_S64) and
                  (l.size in [OS_S8,OS_S16,OS_S32]) then
                begin
@@ -398,8 +403,8 @@ implementation
                end
               else
                begin
-                 hregister:=rg.getregisterint(list,OS_INT);
-                 hregisterhi:=rg.getregisterint(list,OS_INT);
+                 hregister:=cg.getintregister(list,OS_INT);
+                 hregisterhi:=cg.getintregister(list,OS_INT);
                  location_release(list,l);
                end;
               hreg64.reglo:=hregister;
@@ -413,19 +418,12 @@ implementation
          end
         else
          begin
-           { transformations to 32bit or smaller }
-           if (l.loc=LOC_REGISTER) and (l.size in [OS_64,OS_S64]) then
-             { if the previous was 64bit release the high register }
-             begin
-               rg.ungetregisterint(list,l.registerhigh);
-               l.registerhigh:=NR_NO;
-             end;
            {Do not bother to recycle the existing register. The register
             allocator eliminates unnecessary moves, so it's not needed
             and trying to recycle registers can cause problems because
             the registers changes size and may need aditional constraints.}
            location_release(list,l);
-           hregister:=rg.getregisterint(list,dst_size);
+           hregister:=cg.getintregister(list,dst_size);
            { load value in new register }
            case l.loc of
              LOC_FLAGS :
@@ -448,7 +446,7 @@ implementation
                  if (TCGSize2Size[dst_size]<TCGSize2Size[l.size]) then
                   begin
                     if (l.loc in [LOC_REGISTER,LOC_CREGISTER]) then
-                      l.register:=rg.makeregsize(l.register,dst_size);
+                      l.register:=cg.makeregsize(l.register,dst_size);
                     { for big endian systems, the reference's offset must }
                     { be increased in this case, since they have the      }
                     { MSB first in memory and e.g. byte(word_var) should  }
@@ -496,11 +494,11 @@ implementation
           begin
               { load a smaller size to OS_64 }
               if l.loc=LOC_REGISTER then
-               hregister:=rg.makeregsize(l.register,OS_INT)
+               hregister:=cg.makeregsize(l.register,OS_INT)
               else
                begin
                  location_release(list,l);
-                 hregister:=rg.getregisterint(list,OS_INT);
+                 hregister:=cg.getregisterint(list,OS_INT);
                end;
               { load value in low register }
               case l.loc of
@@ -542,10 +540,10 @@ implementation
               else
                begin
                  location_release(list,l);
-                 hregister:=rg.getregisterint(list,OS_INT);
+                 hregister:=cg.getregisterint(list,OS_INT);
                end;
             end;
-           hregister:=rg.makeregsize(hregister,dst_size);
+           hregister:=cg.makeregsize(hregister,dst_size);
            { load value in new register }
            case l.loc of
 {$ifdef cpuflags}
@@ -570,7 +568,7 @@ implementation
                  if (TCGSize2Size[dst_size]<TCGSize2Size[l.size]) then
                   begin
                     if (l.loc in [LOC_REGISTER,LOC_CREGISTER]) then
-                     l.register:=rg.makeregsize(l.register,dst_size);
+                     l.register:=cg.makeregsize(l.register,dst_size);
                     { for big endian systems, the reference's offset must }
                     { be increased in this case, since they have the      }
                     { MSB first in memory and e.g. byte(word_var) should  }
@@ -607,7 +605,7 @@ implementation
         if (l.loc<>LOC_FPUREGISTER)  and
            ((l.loc<>LOC_CFPUREGISTER) or (not maybeconst)) then
           begin
-            reg:=rg.getregisterfpu(list,l.size);
+            reg:=cg.getfpuregister(list,l.size);
             cg.a_loadfpu_loc_reg(list,l,reg);
             location_freetemp(list,l);
             location_release(list,l);
@@ -854,11 +852,11 @@ implementation
                    else
                      internalerror(2003091810);
                  end;
-                 tmpreg:=rg.getaddressregister(list);
+                 tmpreg:=cg.getaddressregister(list);
                  cg.a_load_ref_reg(list,OS_ADDR,OS_ADDR,href,tmpreg);
                  reference_reset_base(href,tmpreg,0);
                  cg.g_initialize(list,tvarsym(p).vartype.def,href,false);
-                 rg.ungetregisterint(list,tmpreg);
+                 cg.ungetregister(list,tmpreg);
                end;
            end;
          end;
@@ -928,9 +926,9 @@ implementation
                  paramanager.allocparaloc(list,paraloc1);
                  cg.a_paramaddr_ref(list,href,paraloc1);
                  paramanager.freeparaloc(list,paraloc1);
-                 rg.allocexplicitregistersint(list,paramanager.get_volatile_registers_int(pocall_default));
+                 cg.allocexplicitregisters(list,R_INTREGISTER,paramanager.get_volatile_registers_int(pocall_default));
                  cg.a_call_name(list,'FPC_ANSISTR_DECR_REF');
-                 rg.deallocexplicitregistersint(list,paramanager.get_volatile_registers_int(pocall_default));
+                 cg.deallocexplicitregisters(list,R_INTREGISTER,paramanager.get_volatile_registers_int(pocall_default));
                end;
              tt_widestring,
              tt_freewidestring :
@@ -939,9 +937,9 @@ implementation
                  paramanager.allocparaloc(list,paraloc1);
                  cg.a_paramaddr_ref(list,href,paraloc1);
                  paramanager.freeparaloc(list,paraloc1);
-                 rg.allocexplicitregistersint(list,paramanager.get_volatile_registers_int(pocall_default));
+                 cg.allocexplicitregisters(list,R_INTREGISTER,paramanager.get_volatile_registers_int(pocall_default));
                  cg.a_call_name(list,'FPC_WIDESTR_DECR_REF');
-                 rg.deallocexplicitregistersint(list,paramanager.get_volatile_registers_int(pocall_default));
+                 cg.deallocexplicitregisters(list,R_INTREGISTER,paramanager.get_volatile_registers_int(pocall_default));
                end;
              tt_interfacecom :
                begin
@@ -949,9 +947,9 @@ implementation
                  paramanager.allocparaloc(list,paraloc1);
                  cg.a_paramaddr_ref(list,href,paraloc1);
                  paramanager.freeparaloc(list,paraloc1);
-                 rg.allocexplicitregistersint(list,paramanager.get_volatile_registers_int(pocall_default));
+                 cg.allocexplicitregisters(list,R_INTREGISTER,paramanager.get_volatile_registers_int(pocall_default));
                  cg.a_call_name(list,'FPC_INTF_DECR_REF');
-                 rg.deallocexplicitregistersint(list,paramanager.get_volatile_registers_int(pocall_default));
+                 cg.deallocexplicitregisters(list,R_INTREGISTER,paramanager.get_volatile_registers_int(pocall_default));
                end;
            end;
            hp:=hp^.next;
@@ -964,7 +962,7 @@ implementation
         ressym : tvarsym;
         resloc : tlocation;
         href   : treference;
-        hreg,r,r2 : tregister;
+        hreg   : tregister;
       begin
         { Is the loading needed? }
         if is_void(current_procinfo.procdef.rettype.def) or
@@ -978,7 +976,7 @@ implementation
         { Constructors need to return self }
         if (current_procinfo.procdef.proctypeoption=potype_constructor) then
           begin
-            r:=rg.getexplicitregisterint(list,NR_FUNCTION_RETURN_REG);
+            cg.getexplicitregister(list,NR_FUNCTION_RETURN_REG);
             { return the self pointer }
             ressym:=tvarsym(current_procinfo.procdef.parast.search('self'));
             if not assigned(ressym) then
@@ -989,8 +987,8 @@ implementation
               else
                 internalerror(2003091810);
             end;
-            rg.ungetregisterint(list,r);
-            cg.a_load_ref_reg(list,OS_ADDR,OS_ADDR,href,r);
+            cg.ungetregister(list,NR_FUNCTION_RETURN_REG);
+            cg.a_load_ref_reg(list,OS_ADDR,OS_ADDR,href,NR_FUNCTION_RETURN_REG);
             uses_acc:=true;
             exit;
           end;
@@ -1032,18 +1030,19 @@ implementation
                   if resloc.size in [OS_64,OS_S64] then
                    begin
                      uses_acchi:=true;
-                     r:=rg.getexplicitregisterint(list,NR_FUNCTION_RETURN64_LOW_REG);
-                     r2:=rg.getexplicitregisterint(list,NR_FUNCTION_RETURN64_HIGH_REG);
-                     rg.ungetregisterint(list,r);
-                     rg.ungetregisterint(list,r2);
-                     cg64.a_load64_loc_reg(list,resloc,joinreg64(r,r2),false);
+                     cg.getexplicitregister(list,NR_FUNCTION_RETURN64_LOW_REG);
+                     cg.getexplicitregister(list,NR_FUNCTION_RETURN64_HIGH_REG);
+                     cg.ungetregister(list,NR_FUNCTION_RETURN64_LOW_REG);
+                     cg.ungetregister(list,NR_FUNCTION_RETURN64_HIGH_REG);
+                     cg64.a_load64_loc_reg(list,resloc,joinreg64(NR_FUNCTION_RETURN64_LOW_REG,
+                                           NR_FUNCTION_RETURN64_HIGH_REG),false);
                    end
                   else
     {$endif cpu64bit}
                    begin
-                     hreg:=rg.getexplicitregisterint(list,NR_FUNCTION_RETURN_REG);
-                     hreg:=rg.makeregsize(hreg,resloc.size);
-                     rg.ungetregisterint(list,hreg);
+                     cg.getexplicitregister(list,NR_FUNCTION_RETURN_REG);
+                     hreg:=cg.makeregsize(NR_FUNCTION_RETURN_REG,resloc.size);
+                     cg.ungetregister(list,hreg);
                      cg.a_load_loc_reg(list,resloc.size,resloc,hreg);
                    end;
                 end;
@@ -1052,11 +1051,10 @@ implementation
                   uses_fpu := true;
     {$ifdef cpufpemu}
                   if cs_fp_emulation in aktmoduleswitches then
-                    r:=NR_FUNCTION_RETURN_REG
+                    cg.a_loadfpu_loc_reg(list,resloc,NR_FUNCTION_RETURN_REG);
                   else
     {$endif cpufpemu}
-                    r:=NR_FPU_RESULT_REG;
-                  cg.a_loadfpu_loc_reg(list,resloc,r);
+                    cg.a_loadfpu_loc_reg(list,resloc,NR_FPU_RESULT_REG);
                 end;
               else
                 begin
@@ -1068,18 +1066,19 @@ implementation
                      if resloc.size in [OS_64,OS_S64] then
                       begin
                         uses_acchi:=true;
-                        r:=rg.getexplicitregisterint(list,NR_FUNCTION_RETURN64_LOW_REG);
-                        r2:=rg.getexplicitregisterint(list,NR_FUNCTION_RETURN64_HIGH_REG);
-                        rg.ungetregisterint(list,r);
-                        rg.ungetregisterint(list,r2);
-                        cg64.a_load64_loc_reg(list,resloc,joinreg64(r,r2),false);
+                        cg.getexplicitregister(list,NR_FUNCTION_RETURN64_LOW_REG);
+                        cg.getexplicitregister(list,NR_FUNCTION_RETURN64_HIGH_REG);
+                        cg.ungetregister(list,NR_FUNCTION_RETURN64_LOW_REG);
+                        cg.ungetregister(list,NR_FUNCTION_RETURN64_HIGH_REG);
+                        cg64.a_load64_loc_reg(list,resloc,joinreg64(NR_FUNCTION_RETURN64_LOW_REG,
+                                              NR_FUNCTION_RETURN64_HIGH_REG),false);
                       end
                      else
     {$endif cpu64bit}
                       begin
-                        hreg:=rg.getexplicitregisterint(list,NR_FUNCTION_RETURN_REG);
-                        hreg:=rg.makeregsize(hreg,resloc.size);
-                        rg.ungetregisterint(list,hreg);
+                        cg.getexplicitregister(list,NR_FUNCTION_RETURN_REG);
+                        hreg:=cg.makeregsize(NR_FUNCTION_RETURN_REG,resloc.size);
+                        cg.ungetregister(list,hreg);
                         cg.a_load_loc_reg(list,resloc.size,resloc,hreg);
                       end;
                     end
@@ -1124,23 +1123,23 @@ implementation
 {$ifndef cpu64bit}
                               if (hp.paraloc[calleeside].size in [OS_S64,OS_64]) then
                                 begin
-                                  rg.getexplicitregisterint(list,hp.paraloc[calleeside].registerlow);
-                                  rg.getexplicitregisterint(list,hp.paraloc[calleeside].registerhigh);
+                                  cg.getexplicitregister(list,hp.paraloc[calleeside].registerlow);
+                                  cg.getexplicitregister(list,hp.paraloc[calleeside].registerhigh);
                                 end
                               else
 {$endif cpu64bit}
-                                rg.getexplicitregisterint(list,hp.paraloc[calleeside].register);
+                                cg.getexplicitregister(list,hp.paraloc[calleeside].register);
                             end;
                           { Release parameter register }
 {$ifndef cpu64bit}
                           if (hp.paraloc[calleeside].size in [OS_S64,OS_64]) then
                             begin
-                              rg.ungetregisterint(list,hp.paraloc[calleeside].registerlow);
-                              rg.ungetregisterint(list,hp.paraloc[calleeside].registerhigh);
+                              cg.ungetregister(list,hp.paraloc[calleeside].registerlow);
+                              cg.ungetregister(list,hp.paraloc[calleeside].registerhigh);
                             end
                           else
 {$endif cpu64bit}
-                            rg.ungetregisterint(list,hp.paraloc[calleeside].register);
+                            cg.ungetregister(list,hp.paraloc[calleeside].register);
                           reference_reset_base(href,tvarsym(hp.parasym).localloc.reference.index,tvarsym(hp.parasym).localloc.reference.offset);
                           cg.a_load_param_ref(list,hp.paraloc[calleeside],href);
                         end;
@@ -1157,7 +1156,7 @@ implementation
                 while assigned(hp) do
                   begin
                     if (tvarsym(hp.parasym).localloc.loc=LOC_REGISTER) then
-                      rg.ungetregisterint(list,tvarsym(hp.parasym).localloc.register);
+                      cg.ungetregister(list,tvarsym(hp.parasym).localloc.register);
                     hp:=tparaitem(hp.next);
                   end;
               end;
@@ -1271,15 +1270,15 @@ implementation
               cg.a_paramaddr_ref(list,href,paraloc1);
               paramanager.freeparaloc(list,paraloc2);
               paramanager.freeparaloc(list,paraloc1);
-              rg.allocexplicitregistersint(list,paramanager.get_volatile_registers_int(pocall_cdecl));
+              cg.allocexplicitregisters(list,R_INTREGISTER,paramanager.get_volatile_registers_int(pocall_cdecl));
               cg.a_call_name(list,'_monstartup');
-              rg.deallocexplicitregistersint(list,paramanager.get_volatile_registers_int(pocall_cdecl));
+              cg.deallocexplicitregisters(list,R_INTREGISTER,paramanager.get_volatile_registers_int(pocall_cdecl));
             end;
 
            { initialize units }
-           rg.allocexplicitregistersint(list,paramanager.get_volatile_registers_int(pocall_default));
+           cg.allocexplicitregisters(list,R_INTREGISTER,paramanager.get_volatile_registers_int(pocall_default));
            cg.a_call_name(list,'FPC_INITIALIZEUNITS');
-           rg.deallocexplicitregistersint(list,paramanager.get_volatile_registers_int(pocall_default));
+           cg.deallocexplicitregisters(list,R_INTREGISTER,paramanager.get_volatile_registers_int(pocall_default));
          end;
 
 {$ifdef GDB}
@@ -1345,6 +1344,7 @@ implementation
       end;
 
 
+
     procedure gen_proc_symbol_end(list:Taasmoutput);
 {$ifdef GDB}
       var
@@ -1501,7 +1501,7 @@ implementation
           cg.g_save_all_registers(list)
         else
           if current_procinfo.procdef.proccalloption in savestdregs_pocalls then
-            cg.g_save_standard_registers(list,rg.used_in_proc_int);
+            cg.g_save_standard_registers(list);
       end;
 
 
@@ -1517,7 +1517,7 @@ implementation
           cg.g_restore_all_registers(list,usesacc,usesacchi)
         else
           if current_procinfo.procdef.proccalloption in savestdregs_pocalls then
-            cg.g_restore_standard_registers(list,rg.used_in_proc_int);
+            cg.g_restore_standard_registers(list);
       end;
 
 
@@ -1561,14 +1561,14 @@ implementation
 {$ifndef cpu64bit}
                  if resloc.size in [OS_64,OS_S64] then
                   begin
-                    r:=rg.getregisterint(list,OS_INT);
-                    r2:=rg.getregisterint(list,OS_INT);
+                    r:=cg.getregisterint(list,OS_INT);
+                    r2:=cg.getregisterint(list,OS_INT);
                     cg64.a_load64_loc_reg(list,resloc,joinreg64(r,r2),false);
                   end
                  else
 {$endif cpu64bit}
                   begin
-                    r:=rg.getregisterint(list,resloc.size);
+                    r:=cg.getregisterint(list,resloc.size);
                     cg.a_load_loc_reg(list,resloc.size,resloc,r);
                   end;
                end;
@@ -1590,14 +1590,14 @@ implementation
                     { Win32 can return records in EAX:EDX }
                     if resloc.size in [OS_64,OS_S64] then
                      begin
-                       r:=rg.getregisterint(list,OS_INT);
-                       r2:=rg.getregisterint(list,OS_INT);
+                       r:=cg.getregisterint(list,OS_INT);
+                       r2:=cg.getregisterint(list,OS_INT);
                        cg64.a_load64_loc_reg(list,resloc,joinreg64(r,r2),false);
                      end
                     else
 {$endif cpu64bit}
                      begin
-                       r:=rg.getregisterint(list,resloc.size);
+                       r:=cg.getregisterint(list,resloc.size);
                        cg.a_load_loc_reg(list,resloc.size,resloc,r);
                      end;
                    end
@@ -1789,12 +1789,12 @@ implementation
 {$ifndef cpu64bit}
                           if localloc.size in [OS_64,OS_S64] then
                             begin
-                              rg.ungetregister(list,localloc.registerlow);
-                              rg.ungetregister(list,localloc.registerhigh);
+                              cg.ungetregister(list,localloc.registerlow);
+                              cg.ungetregister(list,localloc.registerhigh);
                             end
                           else
 {$endif cpu64bit}
-                            rg.ungetregister(list,localloc.register);
+                            cg.ungetregister(list,localloc.register);
                         end;
                     end;
                   end;
@@ -1827,12 +1827,12 @@ implementation
 {$ifndef cpu64bit}
                                 if paraitem.paraloc[calleeside].size in [OS_64,OS_S64] then
                                   begin
-                                    paraitem.paraloc[calleeside].registerlow:=rg.getregisterint(list,OS_32);
-                                    paraitem.paraloc[calleeside].registerhigh:=rg.getregisterint(list,OS_32);
+                                    paraitem.paraloc[calleeside].registerlow:=cg.getregisterint(list,OS_32);
+                                    paraitem.paraloc[calleeside].registerhigh:=cg.getregisterint(list,OS_32);
                                   end
                                 else
 {$endif cpu64bit}
-                                  paraitem.paraloc[calleeside].register:=rg.getregisterint(list,localloc.size);
+                                  paraitem.paraloc[calleeside].register:=cg.getregisterint(list,localloc.size);
                               end;
                              *)
                             (*
@@ -1842,12 +1842,12 @@ implementation
 {$ifndef cpu64bit}
                             if localloc.size in [OS_64,OS_S64] then
                               begin
-                                localloc.registerlow:=rg.getregisterint(list,OS_32);
-                                localloc.registerhigh:=rg.getregisterint(list,OS_32);
+                                localloc.registerlow:=cg.getregisterint(list,OS_32);
+                                localloc.registerhigh:=cg.getregisterint(list,OS_32);
                               end
                             else
 {$endif cpu64bit}
-                              localloc.register:=rg.getregisterint(list,localloc.size);
+                              localloc.register:=cg.getregisterint(list,localloc.size);
                               *)
                             localloc.loc:=LOC_REFERENCE;
                             localloc.size:=paraitem.paraloc[calleeside].size;
@@ -1929,12 +1929,12 @@ implementation
 {$ifndef cpu64bit}
                               if localloc.size in [OS_64,OS_S64] then
                                 begin
-                                  rg.ungetregister(list,localloc.registerlow);
-                                  rg.ungetregister(list,localloc.registerhigh);
+                                  cg.ungetregister(list,localloc.registerlow);
+                                  cg.ungetregister(list,localloc.registerhigh);
                                 end
                               else
 {$endif cpu64bit}
-                                rg.ungetregister(list,localloc.register);
+                                cg.ungetregister(list,localloc.register);
                             end;
                         end;
                     end;
@@ -1948,7 +1948,10 @@ implementation
 end.
 {
   $Log$
-  Revision 1.156  2003-10-07 18:18:16  peter
+  Revision 1.157  2003-10-09 21:31:37  daniel
+    * Register allocator splitted, ans abstract now
+
+  Revision 1.156  2003/10/07 18:18:16  peter
     * fix register calling for assembler procedures
     * fix result loading for assembler procedures
 

compiler/nflw.pas

@@ -216,7 +216,7 @@ implementation
       globtype,systems,
       cutils,verbose,globals,
       symconst,symtable,paramgr,defutil,htypechk,pass_1,
-      ncal,nadd,ncon,nmem,nld,ncnv,nbas,rgobj,
+      ncal,nadd,ncon,nmem,nld,ncnv,nbas,cgobj,
     {$ifdef state_tracking}
       nstate,
     {$endif}
@@ -397,11 +397,11 @@ implementation
       begin
          result:=nil;
          expectloc:=LOC_VOID;
-         old_t_times:=rg.t_times;
+         old_t_times:=cg.t_times;
 
          { calc register weight }
          if not(cs_littlesize in aktglobalswitches ) then
-           rg.t_times:=rg.t_times*8;
+           cg.t_times:=cg.t_times*8;
 
          firstpass(left);
          if codegenerror then
@@ -429,7 +429,7 @@ implementation
 {$endif SUPPORT_MMX}
            end;
 
-         rg.t_times:=old_t_times;
+         cg.t_times:=old_t_times;
       end;
 
 {$ifdef state_tracking}
@@ -559,7 +559,7 @@ implementation
       begin
          result:=nil;
          expectloc:=LOC_VOID;
-         old_t_times:=rg.t_times;
+         old_t_times:=cg.t_times;
          firstpass(left);
          registers32:=left.registers32;
          registersfpu:=left.registersfpu;
@@ -569,9 +569,9 @@ implementation
 
          { determines registers weigths }
          if not(cs_littlesize in aktglobalswitches) then
-           rg.t_times:=rg.t_times div 2;
-         if rg.t_times=0 then
-           rg.t_times:=1;
+           cg.t_times:=cg.t_times div 2;
+         if cg.t_times=0 then
+           cg.t_times:=1;
 
          { if path }
          if assigned(right) then
@@ -633,7 +633,7 @@ implementation
                 end;
            end;
 
-         rg.t_times:=old_t_times;
+         cg.t_times:=old_t_times;
       end;
 
 
@@ -764,9 +764,9 @@ implementation
          result:=nil;
          expectloc:=LOC_VOID;
          { Calc register weight }
-         old_t_times:=rg.t_times;
+         old_t_times:=cg.t_times;
          if not(cs_littlesize in aktglobalswitches) then
-           rg.t_times:=rg.t_times*8;
+           cg.t_times:=cg.t_times*8;
 
          firstpass(left);
 
@@ -827,7 +827,7 @@ implementation
          { we need at least one register for comparisons PM }
          if registers32=0 then
            inc(registers32);
-         rg.t_times:=old_t_times;
+         cg.t_times:=old_t_times;
       end;
 
 
@@ -1431,7 +1431,10 @@ begin
 end.
 {
   $Log$
-  Revision 1.82  2003-10-08 19:19:45  peter
+  Revision 1.83  2003-10-09 21:31:37  daniel
+    * Register allocator splitted, ans abstract now
+
+  Revision 1.82  2003/10/08 19:19:45  peter
     * set_varstate cleanup
 
   Revision 1.81  2003/10/05 11:53:57  florian

compiler/nld.pas

@@ -145,9 +145,8 @@ implementation
       cutils,verbose,globtype,globals,systems,
       symtable,symnot,
       defutil,defcmp,
-      htypechk,pass_1,
-      ncon,ninl,ncnv,nmem,ncal,
-      paramgr,cpubase,rgobj,cgbase,procinfo
+      htypechk,pass_1,procinfo,paramgr,rgobj,
+      ncon,ninl,ncnv,nmem,ncal,cpubase,cgobj,cgbase
       ;
 
 {*****************************************************************************
@@ -491,8 +490,8 @@ implementation
                 else
                   Tvarsym(symtableentry).trigger_notifications(vn_onread);
                 { count variable references }
-                if rg.t_times>1 then
-                  inc(tvarsym(symtableentry).refs,rg.t_times-1);
+                if cg.t_times>1 then
+                  inc(tvarsym(symtableentry).refs,cg.t_times-1);
               end;
             typedconstsym :
                 ;
@@ -1246,7 +1245,10 @@ begin
 end.
 {
   $Log$
-  Revision 1.110  2003-10-08 19:19:45  peter
+  Revision 1.111  2003-10-09 21:31:37  daniel
+    * Register allocator splitted, ans abstract now
+
+  Revision 1.110  2003/10/08 19:19:45  peter
     * set_varstate cleanup
 
   Revision 1.109  2003/10/05 21:21:52  peter

compiler/nset.pas

@@ -118,7 +118,7 @@ implementation
       verbose,
       symconst,symdef,symsym,defutil,defcmp,
       htypechk,pass_1,
-      nbas,ncnv,ncon,nld,rgobj,cgbase;
+      nbas,ncnv,ncon,nld,cgobj,cgbase;
 
     function gencasenode(l,r : tnode;nodes : pcaserecord) : tnode;
 
@@ -584,12 +584,12 @@ implementation
          { walk through all instructions }
 
          {   estimates the repeat of each instruction }
-         old_t_times:=rg.t_times;
+         old_t_times:=cg.t_times;
          if not(cs_littlesize in aktglobalswitches) then
            begin
-              rg.t_times:=rg.t_times div case_count_labels(nodes);
-              if rg.t_times<1 then
-                rg.t_times:=1;
+              cg.t_times:=cg.t_times div case_count_labels(nodes);
+              if cg.t_times<1 then
+                cg.t_times:=1;
            end;
          { first case }
          hp:=tstatementnode(right);
@@ -625,7 +625,7 @@ implementation
                 registersmmx:=elseblock.registersmmx;
 {$endif SUPPORT_MMX}
            end;
-         rg.t_times:=old_t_times;
+         cg.t_times:=old_t_times;
 
          { there is one register required for the case expression    }
          { for 64 bit ints we cheat: the high dword is stored in EDI }
@@ -686,7 +686,10 @@ begin
 end.
 {
   $Log$
-  Revision 1.46  2003-10-08 19:19:45  peter
+  Revision 1.47  2003-10-09 21:31:37  daniel
+    * Register allocator splitted, ans abstract now
+
+  Revision 1.46  2003/10/08 19:19:45  peter
     * set_varstate cleanup
 
   Revision 1.45  2003/10/01 20:34:49  peter

compiler/paramgr.pas

@@ -286,18 +286,18 @@ implementation
 {$ifndef cpu64bit}
                   if (loc.size in [OS_64,OS_S64,OS_F64]) then
                     begin
-                      rg.getexplicitregisterint(list,loc.registerhigh);
-                      rg.getexplicitregisterint(list,loc.registerlow);
+                      cg.getexplicitregister(list,loc.registerhigh);
+                      cg.getexplicitregister(list,loc.registerlow);
                     end
                   else
 {$endif cpu64bit}
-                    rg.getexplicitregisterint(list,loc.register);
+                    cg.getexplicitregister(list,loc.register);
                 end;
             end;
           LOC_FPUREGISTER, LOC_CFPUREGISTER:
             begin
               if loc.register<>NR_NO then
-                rg.getexplicitregisterfpu(list,loc.register);
+                cg.getexplicitregister(list,loc.register);
             end;
           LOC_REFERENCE,LOC_CREFERENCE:
             { do nothing by default, most of the time it's the framepointer }
@@ -315,15 +315,15 @@ implementation
 {$ifndef cpu64bit}
               if (loc.size in [OS_64,OS_S64,OS_F64]) then
                 begin
-                  rg.ungetregisterint(list,loc.registerhigh);
-                  rg.ungetregisterint(list,loc.registerlow);
+                  cg.ungetregister(list,loc.registerhigh);
+                  cg.ungetregister(list,loc.registerlow);
                 end
               else
 {$endif cpu64bit}
-                rg.ungetregisterint(list,loc.register);
+                cg.ungetregister(list,loc.register);
             end;
           LOC_FPUREGISTER, LOC_CFPUREGISTER:
-            rg.ungetregisterfpu(list,loc.register,loc.size);
+            cg.ungetregister(list,loc.register);
           LOC_REFERENCE,LOC_CREFERENCE:
             { do nothing by default, most of the time it's the framepointer }
           else
@@ -369,12 +369,12 @@ implementation
 {$ifndef cpu64bit}
         if locpara.size in [OS_64,OS_S64] then
           begin
-            locpara.registerlow:=rg.getregisterint(list,OS_32);
-            locpara.registerhigh:=rg.getregisterint(list,OS_32);
+            locpara.registerlow:=cg.getintregister(list,OS_32);
+            locpara.registerhigh:=cg.getintregister(list,OS_32);
           end
         else
 {$endif cpu64bit}
-          locpara.register:=rg.getregisterint(list,locpara.size);
+          locpara.register:=cg.getintregister(list,locpara.size);
       end;
 
 
@@ -424,7 +424,10 @@ end.
 
 {
    $Log$
-   Revision 1.60  2003-10-05 21:21:52  peter
+   Revision 1.61  2003-10-09 21:31:37  daniel
+     * Register allocator splitted, ans abstract now
+
+   Revision 1.60  2003/10/05 21:21:52  peter
      * c style array of const generates callparanodes
      * varargs paraloc fixes
 

compiler/pass_2.pas

@@ -58,10 +58,7 @@ implementation
      aasmbase,aasmtai,
      pass_1,cpubase,cgbase,
      procinfo,
-{$ifdef EXTDEBUG}
-     cgobj,
-{$endif EXTDEBUG}
-     regvars,nflw,rgobj;
+     regvars,nflw,rgobj,cgobj;
 
 {*****************************************************************************
                               SecondPass
@@ -175,12 +172,6 @@ implementation
             oldcodegenerror:=codegenerror;
             oldlocalswitches:=aktlocalswitches;
             oldpos:=aktfilepos;
-{$ifdef TEMPREGDEBUG}
-            testregisters32;
-            prevp:=curptree;
-            curptree:=@p;
-            p^.usableregs:=usablereg32;
-{$endif TEMPREGDEBUG}
             aktfilepos:=p.fileinfo;
             aktlocalswitches:=p.localswitches;
             codegenerror:=false;
@@ -206,9 +197,11 @@ implementation
              end;
 
 {$ifdef i386}
-            if rg.unusedregsint*([first_int_supreg..last_int_supreg] - [RS_FRAME_POINTER_REG,RS_STACK_POINTER_REG])<>
-                                ([first_int_supreg..last_int_supreg] - [RS_FRAME_POINTER_REG,RS_STACK_POINTER_REG]) then
+{
+            if cg.rgint.unusedregsint*([first_int_supreg..last_int_supreg] - [RS_FRAME_POINTER_REG,RS_STACK_POINTER_REG])<>
+                                      ([first_int_supreg..last_int_supreg] - [RS_FRAME_POINTER_REG,RS_STACK_POINTER_REG]) then
               internalerror(200306171);
+}
 {$endif i386}
 {$endif EXTDEBUG}
             if codegenerror then
@@ -258,12 +251,11 @@ implementation
          flowcontrol:=[];
          { when size optimization only count occurrence }
          if cs_littlesize in aktglobalswitches then
-           rg.t_times:=1
+           cg.t_times:=1
          else
            { reference for repetition is 100 }
-           rg.t_times:=100;
+           cg.t_times:=100;
          { clear register count }
-         rg.clearregistercount;
          symtablestack.foreach_static({$ifdef FPCPROCVAR}@{$endif}clearrefs,nil);
          symtablestack.next.foreach_static({$ifdef FPCPROCVAR}@{$endif}clearrefs,nil);
          { firstpass everything }
@@ -281,23 +273,25 @@ implementation
 
               { process register variable stuff (JM) }
               assign_regvars(p);
-//              load_regvars(current_procinfo.aktentrycode,p);
+{              load_regvars(current_procinfo.aktentrycode,p);}
 
               { for the i386 it must be done in genexitcode because it has  }
               { to add 'fstp' instructions when using fpu regvars and those }
               { must come after the "exitlabel" (JM)                        }
 {$ifndef i386}
-//              cleanup_regvars(current_procinfo.aktexitcode);
+{              cleanup_regvars(current_procinfo.aktexitcode);}
 {$endif i386}
 
-              current_procinfo.allocate_framepointer_reg;
+{              current_procinfo.allocate_framepointer_reg;}
 
               do_secondpass(p);
 
 {$ifdef EXTDEBUG}
+{
               for sr:=first_int_imreg to last_int_imreg do
                 if not(sr in rg.unusedregsint) then
                   Comment(V_Warning,'Register '+std_regname(newreg(R_INTREGISTER,sr,R_SUBNONE))+' not released');
+}
 {$endif EXTDEBUG}
 
               if assigned(current_procinfo.procdef) then
@@ -310,7 +304,10 @@ implementation
 end.
 {
   $Log$
-  Revision 1.67  2003-10-01 20:34:49  peter
+  Revision 1.68  2003-10-09 21:31:37  daniel
+    * Register allocator splitted, ans abstract now
+
+  Revision 1.67  2003/10/01 20:34:49  peter
     * procinfo unit contains tprocinfo
     * cginfo renamed to cgbase
     * moved cgmessage to verbose

compiler/procinfo.pas

@@ -101,7 +101,7 @@ unit procinfo;
 
           { Allocate framepointer so it can not be used by the
             register allocator }
-          procedure allocate_framepointer_reg;virtual;
+{          procedure allocate_framepointer_reg;virtual;}
 
           procedure allocate_push_parasize(size:longint);virtual;
 
@@ -177,7 +177,7 @@ implementation
          aktlocaldata.free;
       end;
 
-
+(*
     procedure tprocinfo.allocate_framepointer_reg;
       begin
         if framepointer=NR_FRAME_POINTER_REG then
@@ -188,7 +188,7 @@ implementation
             exclude(rg.unusedregsint,RS_FRAME_POINTER_REG);
           end;
       end;
-
+*)
 
     procedure tprocinfo.allocate_push_parasize(size:longint);
       begin
@@ -217,7 +217,10 @@ implementation
 end.
 {
   $Log$
-  Revision 1.3  2003-10-05 21:21:52  peter
+  Revision 1.4  2003-10-09 21:31:37  daniel
+    * Register allocator splitted, ans abstract now
+
+  Revision 1.3  2003/10/05 21:21:52  peter
     * c style array of const generates callparanodes
     * varargs paraloc fixes
 

compiler/psub.pas

@@ -602,7 +602,7 @@ implementation
           exit;
 
         { The RA and Tempgen shall not be available yet }
-        if assigned(rg) or assigned(tg) then
+        if assigned(tg) then
           internalerror(200309201);
 
         oldprocinfo:=current_procinfo;
@@ -653,8 +653,9 @@ implementation
 {$ifdef i386}
         if (po_assembler in current_procinfo.procdef.procoptions) then
           begin
-            rg.used_in_proc_int:=paramanager.get_volatile_registers_int(pocall_oldfpccall);
-            rg.used_in_proc_other:=paramanager.get_volatile_registers_int(pocall_oldfpccall);
+            {$warning Fixme}
+{            Tcgx86(cg).rgint.used_in_proc:=paramanager.get_volatile_registers_int(pocall_oldfpccall);
+            Tcgx86(cg).rgother.used_in_proc:=paramanager.get_volatile_registers_int(pocall_oldfpccall);}
           end;
 {$endif i386}
 
@@ -729,39 +730,7 @@ implementation
           allocate the registers }
         if not(cs_no_regalloc in aktglobalswitches) then
           begin
-            {Do register allocation.}
-            spillingcounter:=0;
-            repeat
-{$ifdef ra_debug}
-              if aktfilepos.line=1206 then
-                rg.writegraph(spillingcounter);
-{$endif ra_debug}
-              rg.prepare_colouring;
-              rg.colour_registers;
-              rg.epilogue_colouring;
-              fastspill:=true;
-              if rg.spillednodes<>'' then
-                begin
-                  inc(spillingcounter);
-                  if spillingcounter>20 then
-{$ifdef ra_debug}
-                    break;
-{$else ra_debug}
-                    internalerror(200309041);
-{$endif ra_debug}
-
-{$ifdef ra_debug}
-                  if aktfilepos.line=1207 then
-                    begin
-                      writeln('Spilling registers:');
-                      for i:=1 to length(rg.spillednodes) do
-                        writeln(ord(rg.spillednodes[i]));
-                    end;
-{$endif ra_debug}
-                  fastspill:=rg.spill_registers(aktproccode,headertai,rg.spillednodes);
-                end;
-            until (rg.spillednodes='') or not fastspill;
-            aktproccode.translate_registers(rg.colour);
+            cg.do_register_allocation(aktproccode,headertai);
 (*
 {$ifndef NoOpt}
             if (cs_optimize in aktglobalswitches) and
@@ -772,7 +741,8 @@ implementation
 *)
           end;
 
-        translate_regvars(aktproccode,rg.colour);
+        {$warning fixme translate_regvars}
+{        translate_regvars(aktproccode,rg.colour);}
         { Add save and restore of used registers }
         aktfilepos:=entrypos;
         gen_save_used_regs(templist);
@@ -819,7 +789,6 @@ implementation
         tg.free;
         cg.done_register_allocators;
         tg:=nil;
-        rg:=nil;
 
         { restore symtablestack }
         remove_from_symtablestack;
@@ -1308,7 +1277,10 @@ begin
 end.
 {
   $Log$
-  Revision 1.160  2003-10-09 15:20:56  peter
+  Revision 1.161  2003-10-09 21:31:37  daniel
+    * Register allocator splitted, ans abstract now
+
+  Revision 1.160  2003/10/09 15:20:56  peter
     * self is not a token anymore. It is handled special when found
       in a code block and when parsing an method
 

compiler/regvars.pas

@@ -207,10 +207,11 @@ implementation
                       else
                         siz:=OS_32;
 
+                      {$warning fixme regvars}
                       { allocate a register for this regvar }
-                      regvarinfo^.regvars[i].localloc.register:=rg.getregisterint(exprasmlist,siz);
+{                      regvarinfo^.regvars[i].localloc.register:=rg.getregisterint(exprasmlist,siz);}
                       { and make sure it can't be freed }
-                      rg.makeregvarint(getsupreg(regvarinfo^.regvars[i].localloc.register));
+{                      rg.makeregvarint(getsupreg(regvarinfo^.regvars[i].localloc.register));}
                     end
                   else
                     begin
@@ -262,13 +263,14 @@ implementation
                      begin
 {$ifdef i386}
                        { reserve place on the FPU stack }
-                       regvarinfo^.fpuregvars[i].localloc.register:=trgcpu(rg).correct_fpuregister(NR_ST0,i);
+                       {$warning fixme regvars}
+{                       regvarinfo^.fpuregvars[i].localloc.register:=trgcpu(rg).correct_fpuregister(NR_ST0,i);}
 {$else i386}
 {$ifdef x86_64}
 {$endif x86_64}
                        begin
                          regvarinfo^.fpuregvars[i].localloc.register:=fpuvarregs[i];
-                         rg.makeregvarother(regvarinfo^.fpuregvars[i].localloc.register);
+{                         rg.makeregvarother(regvarinfo^.fpuregvars[i].localloc.register);}
                        end;
 {$endif i386}
                      end;
@@ -301,7 +303,8 @@ implementation
             if assigned(regvarinfo^.regvars[i]) and
                (getsupreg(regvarinfo^.regvars[i].localloc.register)=supreg) then
               begin
-                if supreg in rg.regvar_loaded_int then
+                {$warning fixme regvar_loaded_int}
+(*                if supreg in rg.regvar_loaded_int then
                   begin
                     vsym := tvarsym(regvarinfo^.regvars[i]);
                     { we only have to store the regvar back to memory if it's }
@@ -316,6 +319,7 @@ implementation
                     asml.concat(tai_regalloc.dealloc(vsym.localloc.register));
                     exclude(rg.regvar_loaded_int,supreg);
                   end;
+*)
                 break;
               end;
         end
@@ -324,6 +328,8 @@ implementation
           for i := 1 to maxvarregs do
             if assigned(regvarinfo^.regvars[i]) then
               begin
+                {$warning fixme regvars}
+(*
                 r:=rg.makeregsize(regvarinfo^.regvars[i].localloc.register,OS_INT);
                 if (r = reg) then
                   begin
@@ -345,6 +351,7 @@ implementation
                       end;
                     break;
                   end;
+*)
               end;
         end;
 {$endif i386}
@@ -362,8 +369,11 @@ implementation
       exit;
 {$endif i386}
       reg:=vsym.localloc.register;
+      {$warning fixme regvars}
+(*
       if getregtype(reg)=R_INTREGISTER then
         begin
+
           if not(getsupreg(reg) in rg.regvar_loaded_int) then
             begin
               asml.concat(tai_regalloc.alloc(reg));
@@ -394,6 +404,7 @@ implementation
               rg.regvar_loaded_other[regidx] := true;
             end;
         end;
+*)
     end;
 
     procedure load_regvar_reg(asml: TAAsmoutput; reg: tregister);
@@ -416,10 +427,10 @@ implementation
         end
       else
         begin
-          reg_spare := rg.makeregsize(reg,OS_INT);
+          reg_spare := cg.makeregsize(reg,OS_INT);
           for i := 1 to maxvarregs do
             if assigned(regvarinfo^.regvars[i]) and
-               (rg.makeregsize(regvarinfo^.regvars[i].localloc.register,OS_INT) = reg_spare) then
+               (cg.makeregsize(regvarinfo^.regvars[i].localloc.register,OS_INT) = reg_spare) then
               load_regvar(asml,tvarsym(regvarinfo^.regvars[i]))
         end;
     end;
@@ -457,7 +468,10 @@ implementation
                 begin
 {$ifdef i386}
                   { reserve place on the FPU stack }
+                  {$warning fixme fpustack}
+(*
                   regvarinfo^.fpuregvars[i].localloc.register:=trgcpu(rg).correct_fpuregister(NR_ST0,i-1);
+*)
                   asml.concat(Taicpu.op_none(A_FLDZ,S_NO));
 {$endif i386}
                 end;
@@ -492,6 +506,7 @@ implementation
     var
       counter: tregisterindex;
     begin
+(*
       for counter := low(rg.regvar_loaded_other) to high(rg.regvar_loaded_other) do
         begin
            rg.regvar_loaded_other[counter] := regvarsloaded1[counter] and
@@ -502,6 +517,7 @@ implementation
              else
                load_regvar_reg(list1,counter);
         end;
+*)
     end;
 
 
@@ -556,10 +572,13 @@ implementation
                     end
                   else
                     begin
-                      reg:=rg.makeregsize(reg,OS_INT);
+                      reg:=cg.makeregsize(reg,OS_INT);
                       regidx:=findreg_by_number(reg);
+                      {$warning fixme regvar dealloc}
+(*
                       if (rg.regvar_loaded_other[regidx]) then
                        asml.concat(tai_regalloc.dealloc(reg));
+*)
                     end;
                 end;
              end;
@@ -578,9 +597,12 @@ implementation
             if assigned(regvars[i]) { and
               (regvars[i] <> tvarsym(current_procinfo.procdef.funcretsym))} then
               begin
+                {$warning fixme regvarexclude}
                 { make sure the unget isn't just a nop }
+(*
                 exclude(rg.is_reg_var_int,getsupreg(regvars[i].localloc.register));
-                rg.ungetregisterint(list,regvars[i].localloc.register);
+*)
+                cg.ungetregister(list,regvars[i].localloc.register);
               end;
       end;
 
@@ -612,7 +634,10 @@ end.
 
 {
   $Log$
-  Revision 1.68  2003-10-01 20:34:49  peter
+  Revision 1.69  2003-10-09 21:31:37  daniel
+    * Register allocator splitted, ans abstract now
+
+  Revision 1.68  2003/10/01 20:34:49  peter
     * procinfo unit contains tprocinfo
     * cginfo renamed to cgbase
     * moved cgmessage to verbose

compiler/x86/aasmcpu.pas

@@ -359,7 +359,7 @@ implementation
 {$endif x86_64}
 
       subreg2type:array[tsubregister] of longint = (
-        OT_NONE,OT_REG8,OT_REG8,OT_REG16,OT_REG32,OT_REG64
+        OT_NONE,OT_REG8,OT_REG8,OT_REG16,OT_REG32,OT_REG64,OT_NONE
       );
 
 {****************************************************************************
@@ -2318,7 +2318,10 @@ implementation
 end.
 {
   $Log$
-  Revision 1.30  2003-10-01 20:34:50  peter
+  Revision 1.31  2003-10-09 21:31:37  daniel
+    * Register allocator splitted, ans abstract now
+
+  Revision 1.30  2003/10/01 20:34:50  peter
     * procinfo unit contains tprocinfo
     * cginfo renamed to cgbase
     * moved cgmessage to verbose

compiler/x86/cga.pas

@@ -139,7 +139,7 @@ implementation
           instr:=Taicpu.op_reg_reg(i,s,reg1,reg2);
           exprasmlist.concat(instr);
           if i=A_MOV then
-            rg.add_move_instruction(instr);
+            cg.add_move_instruction(instr);
         end;
     end;
 
@@ -161,7 +161,10 @@ implementation
 end.
 {
   $Log$
-  Revision 1.5  2003-10-01 20:34:50  peter
+  Revision 1.6  2003-10-09 21:31:37  daniel
+    * Register allocator splitted, ans abstract now
+
+  Revision 1.5  2003/10/01 20:34:50  peter
     * procinfo unit contains tprocinfo
     * cginfo renamed to cgbase
     * moved cgmessage to verbose

compiler/x86/cgx86.pas

@@ -31,14 +31,31 @@ unit cgx86;
     uses
        cgbase,cgobj,
        aasmbase,aasmtai,aasmcpu,
-       cpubase,cpuinfo,
+       cpubase,cpuinfo,rgobj,rgcpu,
        symconst,symtype;
 
     type
       tcgx86 = class(tcg)
+        rgint   : Tregisterallocatorcpu;
+        rgother : Trgcpu;
         procedure init_register_allocators;override;
         procedure done_register_allocators;override;
 
+        function  getintregister(list:Taasmoutput;size:Tcgsize):Tregister;override;
+        function  getaddressregister(list:Taasmoutput):Tregister;override;
+        function  getfpuregister(list:Taasmoutput;size:Tcgsize):Tregister;override;
+        procedure getexplicitregister(list:Taasmoutput;r:Tregister);override;
+        function  getabtregister(list:Taasmoutput;size:Tcgsize):Tregister;override;
+        procedure ungetregister(list:Taasmoutput;r:Tregister);override;
+        procedure ungetreference(list:Taasmoutput;const r:Treference);override;
+        procedure allocexplicitregisters(list:Taasmoutput;rt:Tregistertype;r:Tsuperregisterset);override;
+        procedure deallocexplicitregisters(list:Taasmoutput;rt:Tregistertype;r:Tsuperregisterset);override;
+        procedure add_move_instruction(instr:Taicpu);override;
+        procedure dec_fpu_stack;
+        procedure inc_fpu_stack;
+
+        procedure do_register_allocation(list:Taasmoutput;headertai:tai);override;
+
         { passing parameters, per default the parameter is pushed }
         { nr gives the number of the parameter (enumerated from   }
         { left to right), this allows to move the parameter to    }
@@ -111,8 +128,8 @@ unit cgx86;
         procedure g_stackframe_entry(list : taasmoutput;localsize : longint);override;
         procedure g_restore_frame_pointer(list : taasmoutput);override;
         procedure g_return_from_proc(list : taasmoutput;parasize : aword);override;
-        procedure g_save_standard_registers(list:Taasmoutput;usedinproc:Tsuperregisterset);override;
-        procedure g_restore_standard_registers(list:Taasmoutput;usedinproc:Tsuperregisterset);override;
+        procedure g_save_standard_registers(list:Taasmoutput);override;
+        procedure g_restore_standard_registers(list:Taasmoutput);override;
         procedure g_save_all_registers(list : taasmoutput);override;
         procedure g_restore_all_registers(list : taasmoutput;accused,acchiused:boolean);override;
 
@@ -141,8 +158,7 @@ unit cgx86;
 
     uses
        globtype,globals,verbose,systems,cutils,
-       symdef,paramgr,procinfo,
-       rgobj,tgobj,rgcpu;
+       symdef,paramgr,tgobj,procinfo;
 
 {$ifndef NOTARGETWIN32}
     const
@@ -160,15 +176,122 @@ unit cgx86;
     procedure Tcgx86.init_register_allocators;
 
     begin
-      rg:=Trgcpu.create(6,#0#1#2#3#4#5);
+      rgint:=Tregisterallocatorcpu.create(6,R_INTREGISTER,#0#1#2#3#4#5,first_int_imreg,[RS_EBP]);
+      rgother:=Trgcpu.create;
     end;
 
     procedure Tcgx86.done_register_allocators;
 
     begin
-      rg.free;
+      rgint.free;
+      rgother.free;
+    end;
+
+    function Tcgx86.getintregister(list:Taasmoutput;size:Tcgsize):Tregister;
+
+    begin
+      getintregister:=rgint.getregister(list,size);
+    end;
+
+    function Tcgx86.getaddressregister(list:Taasmoutput):Tregister;
+
+    begin
+      getaddressregister:=rgint.getregister(list,OS_INT);
     end;
 
+    function Tcgx86.getfpuregister(list:Taasmoutput;size:Tcgsize):Tregister;
+
+    begin
+      getfpuregister:=rgother.getregisterfpu(list,size);
+    end;
+
+    procedure Tcgx86.getexplicitregister(list:Taasmoutput;r:Tregister);
+      begin
+        case getregtype(r) of
+          R_INTREGISTER :
+            rgint.getexplicitregister(list,r);
+          else
+            internalerror(200310091);
+        end;
+      end;
+
+
+    function tcgx86.getabtregister(list:Taasmoutput;size:Tcgsize):Tregister;
+      begin
+        result:=rgint.getabtregister(list,size);
+      end;
+
+
+    procedure tcgx86.ungetregister(list:Taasmoutput;r:Tregister);
+      begin
+        case getregtype(r) of
+          R_INTREGISTER :
+            rgint.ungetregister(list,r);
+          R_FPUREGISTER :
+            rgother.ungetregisterfpu(list,r);
+          else
+            internalerror(200310091);
+        end;
+      end;
+
+
+    procedure tcgx86.ungetreference(list:Taasmoutput;const r:Treference);
+      begin
+        if r.base<>NR_NO then
+          rgint.ungetregister(list,r.base);
+        if r.index<>NR_NO then
+          rgint.ungetregister(list,r.index);
+      end;
+
+
+    procedure Tcgx86.allocexplicitregisters(list:Taasmoutput;rt:Tregistertype;r:Tsuperregisterset);
+      begin
+        case rt of
+          R_INTREGISTER :
+            rgint.allocexplicitregisters(list,r);
+          else
+            internalerror(200310092);
+        end;
+      end;
+
+
+    procedure Tcgx86.deallocexplicitregisters(list:Taasmoutput;rt:Tregistertype;r:Tsuperregisterset);
+      begin
+        case rt of
+          R_INTREGISTER :
+            rgint.deallocexplicitregisters(list,r);
+          else
+            internalerror(200310093);
+        end;
+      end;
+
+
+    procedure Tcgx86.add_move_instruction(instr:Taicpu);
+      begin
+        rgint.add_move_instruction(instr);
+      end;
+
+
+    procedure tcgx86.dec_fpu_stack;
+      begin
+        dec(rgother.fpuvaroffset);
+      end;
+
+
+    procedure tcgx86.inc_fpu_stack;
+      begin
+        inc(rgother.fpuvaroffset);
+      end;
+
+
+    procedure Tcgx86.do_register_allocation(list:Taasmoutput;headertai:tai);
+
+    begin
+      rgint.do_register_allocation(list,headertai);
+      list.translate_registers(rgint.colour);
+    end;
+
+
 {****************************************************************************
                        This is private property, keep out! :)
 ****************************************************************************}
@@ -268,7 +391,7 @@ unit cgx86;
       begin
          floatloadops(t,op,s);
          list.concat(Taicpu.Op_ref(op,s,ref));
-         inc(trgcpu(rg).fpuvaroffset);
+         inc_fpu_stack;
       end;
 
 
@@ -311,7 +434,7 @@ unit cgx86;
       begin
          floatstoreops(t,op,s);
          list.concat(Taicpu.Op_ref(op,s,ref));
-         dec(trgcpu(rg).fpuvaroffset);
+         dec_fpu_stack;
       end;
 
 
@@ -346,9 +469,9 @@ unit cgx86;
               OS_16,OS_S16:
                 begin
                   if locpara.alignment = 2 then
-                    list.concat(taicpu.op_reg(A_PUSH,S_W,rg.makeregsize(r,OS_16)))
+                    list.concat(taicpu.op_reg(A_PUSH,S_W,makeregsize(r,OS_16)))
                   else
-                    list.concat(taicpu.op_reg(A_PUSH,S_L,rg.makeregsize(r,OS_32)));
+                    list.concat(taicpu.op_reg(A_PUSH,S_L,makeregsize(r,OS_32)));
                 end;
               OS_32,OS_S32:
                 begin
@@ -408,10 +531,10 @@ unit cgx86;
                     pushsize:=OS_16
                   else
                     pushsize:=OS_32;
-                  tmpreg:=rg.getregisterint(list,pushsize);
+                  tmpreg:=getintregister(list,pushsize);
                   a_load_ref_reg(list,size,pushsize,r,tmpreg);
                   list.concat(taicpu.op_reg(A_PUSH,TCgsize2opsize[pushsize],tmpreg));
-                  rg.ungetregisterint(list,tmpreg);
+                  ungetregister(list,tmpreg);
                 end;
               OS_32,OS_S32:
                 list.concat(taicpu.op_ref(A_PUSH,S_L,r));
@@ -452,10 +575,10 @@ unit cgx86;
               list.concat(Taicpu.Op_reg(A_PUSH,S_L,r.base))
             else
               begin
-                tmpreg:=rg.getaddressregister(list);
+                tmpreg:=getaddressregister(list);
                 a_loadaddr_ref_reg(list,r,tmpreg);
                 list.concat(taicpu.op_reg(A_PUSH,S_L,tmpreg));
-                rg.ungetregisterint(list,tmpreg);
+                ungetregister(list,tmpreg);
               end;
           end
         else
@@ -509,10 +632,10 @@ unit cgx86;
 {$endif x86_64}
           :
             begin
-              tmpreg:=rg.getregisterint(list,tosize);
+              tmpreg:=getintregister(list,tosize);
               list.concat(taicpu.op_reg_reg(op,s,reg,tmpreg));
               a_load_reg_ref(list,tosize,tosize,tmpreg,ref);
-              rg.ungetregisterint(list,tmpreg);
+              ungetregister(list,tmpreg);
             end;
         else
           list.concat(taicpu.op_reg_ref(op,s,reg,ref));
@@ -553,7 +676,7 @@ unit cgx86;
         instr:=taicpu.op_reg_reg(op,s,reg1,reg2);
         {Notify the register allocator that we have written a move instruction so
          it can try to eliminate it.}
-        rg.add_move_instruction(instr);
+        Tcgx86(cg).rgint.add_move_instruction(instr);
         list.concat(instr);
       end;
 
@@ -585,15 +708,13 @@ unit cgx86;
        begin
          if (reg1<>NR_ST) then
            begin
-             list.concat(taicpu.op_reg(A_FLD,S_NO,
-               trgcpu(rg).correct_fpuregister(reg1,trgcpu(rg).fpuvaroffset)));
-             inc(trgcpu(rg).fpuvaroffset);
+             list.concat(taicpu.op_reg(A_FLD,S_NO,rgother.correct_fpuregister(reg1,rgother.fpuvaroffset)));
+             inc_fpu_stack;
            end;
          if (reg2<>NR_ST) then
            begin
-             list.concat(taicpu.op_reg(A_FSTP,S_NO,
-                 trgcpu(rg).correct_fpuregister(reg2,trgcpu(rg).fpuvaroffset)));
-             dec(trgcpu(rg).fpuvaroffset);
+             list.concat(taicpu.op_reg(A_FSTP,S_NO,rgother.correct_fpuregister(reg2,rgother.fpuvaroffset)));
+             dec_fpu_stack;
            end;
        end;
 
@@ -813,7 +934,6 @@ unit cgx86;
 
         var
           dstsize: topsize;
-          tmpreg : tregister;
           instr:Taicpu;
 
         begin
@@ -833,11 +953,10 @@ unit cgx86;
               internalerror(200109233);
             OP_SHR,OP_SHL,OP_SAR:
               begin
-                tmpreg:=rg.getexplicitregisterint(list,NR_CL);
-                a_load_reg_reg(list,size,OS_8,dst,tmpreg);
-                list.concat(taicpu.op_reg_reg(Topcg2asmop[op],S_B,src,
-                            tmpreg));
-                rg.ungetregisterint(list,tmpreg);
+                getexplicitregister(list,NR_CL);
+                a_load_reg_reg(list,size,OS_8,dst,NR_CL);
+                list.concat(taicpu.op_reg_reg(Topcg2asmop[op],S_B,src,NR_CL));
+                ungetregister(list,NR_CL);
               end;
             else
               begin
@@ -864,7 +983,7 @@ unit cgx86;
             internalerror(200109239);
           else
             begin
-              reg := rg.makeregsize(reg,size);
+              reg := makeregsize(reg,size);
               list.concat(taicpu.op_ref_reg(TOpCG2AsmOp[op],tcgsize2opsize[size],ref,reg));
             end;
         end;
@@ -1050,7 +1169,7 @@ unit cgx86;
         ai : taicpu;
         hreg : tregister;
       begin
-        hreg:=rg.makeregsize(reg,OS_8);
+        hreg:=makeregsize(reg,OS_8);
         ai:=Taicpu.op_reg(A_SETcc,S_B,hreg);
         ai.setcondition(flags_to_cond(f));
         list.concat(ai);
@@ -1076,7 +1195,7 @@ unit cgx86;
     procedure Tcgx86.g_concatcopy(list:Taasmoutput;const source,dest:Treference;
                                   len:aword;delsource,loadref:boolean);
     var srcref,dstref:Treference;
-        srcreg,destreg,countreg,r:Tregister;
+        r:Tregister;
         helpsize:aword;
         copysize:byte;
         cgsize:Tcgsize;
@@ -1106,9 +1225,9 @@ unit cgx86;
               dec(len,copysize);
               if (len=0) and delsource then
                 reference_release(list,source);
-              r:=rg.getregisterint(list,cgsize);
+              r:=getintregister(list,cgsize);
               a_load_ref_reg(list,cgsize,cgsize,srcref,r);
-              rg.ungetregisterint(list,r);
+              ungetregister(list,r);
               a_load_reg_ref(list,cgsize,cgsize,r,dstref);
               inc(srcref.offset,copysize);
               inc(dstref.offset,copysize);
@@ -1116,14 +1235,14 @@ unit cgx86;
         end
       else
         begin
-          destreg:=rg.getexplicitregisterint(list,NR_EDI);
-          a_loadaddr_ref_reg(list,dest,destreg);
-          srcreg:=rg.getexplicitregisterint(list,NR_ESI);
+          getexplicitregister(list,NR_EDI);
+          a_loadaddr_ref_reg(list,dest,NR_EDI);
+          getexplicitregister(list,NR_ESI);
           if loadref then
-            a_load_ref_reg(list,OS_ADDR,OS_ADDR,source,srcreg)
+            a_load_ref_reg(list,OS_ADDR,OS_ADDR,source,NR_ESI)
           else
             begin
-              a_loadaddr_ref_reg(list,source,srcreg);
+              a_loadaddr_ref_reg(list,source,NR_ESI);
               if delsource then
                 begin
                   srcref:=source;
@@ -1137,12 +1256,12 @@ unit cgx86;
                 end;
             end;
 
-          countreg:=rg.getexplicitregisterint(list,NR_ECX);
+          getexplicitregister(list,NR_ECX);
 
           list.concat(Taicpu.op_none(A_CLD,S_NO));
           if cs_littlesize in aktglobalswitches  then
             begin
-              a_load_const_reg(list,OS_INT,len,countreg);
+              a_load_const_reg(list,OS_INT,len,NR_ECX);
               list.concat(Taicpu.op_none(A_REP,S_NO));
               list.concat(Taicpu.op_none(A_MOVSB,S_NO));
             end
@@ -1152,7 +1271,7 @@ unit cgx86;
               len:=len and 3;
               if helpsize>1 then
                 begin
-                  a_load_const_reg(list,OS_INT,helpsize,countreg);
+                  a_load_const_reg(list,OS_INT,helpsize,NR_ECX);
                   list.concat(Taicpu.op_none(A_REP,S_NO));
                 end;
               if helpsize>0 then
@@ -1165,9 +1284,9 @@ unit cgx86;
               if len=1 then
                 list.concat(Taicpu.op_none(A_MOVSB,S_NO));
               end;
-          rg.ungetregisterint(list,countreg);
-          rg.ungetregisterint(list,srcreg);
-          rg.ungetregisterint(list,destreg);
+          ungetregister(list,NR_ECX);
+          ungetregister(list,NR_ESI);
+          ungetregister(list,NR_EDI);
         end;
       if delsource then
         tg.ungetiftemp(list,source);
@@ -1204,19 +1323,17 @@ unit cgx86;
 {$ifndef __NOWINPECOFF__}
         again,ok : tasmlabel;
 {$endif}
-        r : tregister;
       begin
         { get stack space }
-        r:=NR_EDI;
-        rg.getexplicitregisterint(list,r);
-        list.concat(Taicpu.op_ref_reg(A_MOV,S_L,lenref,r));
-        list.concat(Taicpu.op_reg(A_INC,S_L,r));
+        getexplicitregister(list,NR_EDI);
+        list.concat(Taicpu.op_ref_reg(A_MOV,S_L,lenref,NR_EDI));
+        list.concat(Taicpu.op_reg(A_INC,S_L,NR_EDI));
         if (elesize<>1) then
          begin
            if ispowerof2(elesize, power) then
-             list.concat(Taicpu.op_const_reg(A_SHL,S_L,power,r))
+             list.concat(Taicpu.op_const_reg(A_SHL,S_L,power,NR_EDI))
            else
-             list.concat(Taicpu.op_const_reg(A_IMUL,S_L,elesize,r));
+             list.concat(Taicpu.op_const_reg(A_IMUL,S_L,elesize,NR_EDI));
          end;
 {$ifndef __NOWINPECOFF__}
         { windows guards only a few pages for stack growing, }
@@ -1226,40 +1343,40 @@ unit cgx86;
              objectlibrary.getlabel(again);
              objectlibrary.getlabel(ok);
              a_label(list,again);
-             list.concat(Taicpu.op_const_reg(A_CMP,S_L,winstackpagesize,r));
+             list.concat(Taicpu.op_const_reg(A_CMP,S_L,winstackpagesize,NR_EDI));
              a_jmp_cond(list,OC_B,ok);
              list.concat(Taicpu.op_const_reg(A_SUB,S_L,winstackpagesize-4,NR_ESP));
-             list.concat(Taicpu.op_reg(A_PUSH,S_L,r));
-             list.concat(Taicpu.op_const_reg(A_SUB,S_L,winstackpagesize,r));
+             list.concat(Taicpu.op_reg(A_PUSH,S_L,NR_EDI));
+             list.concat(Taicpu.op_const_reg(A_SUB,S_L,winstackpagesize,NR_EDI));
              a_jmp_always(list,again);
 
              a_label(list,ok);
-             list.concat(Taicpu.op_reg_reg(A_SUB,S_L,r,NR_ESP));
-             rg.ungetregisterint(list,r);
+             list.concat(Taicpu.op_reg_reg(A_SUB,S_L,NR_EDI,NR_ESP));
+             ungetregister(list,NR_EDI);
              { now reload EDI }
-             rg.getexplicitregisterint(list,r);
-             list.concat(Taicpu.op_ref_reg(A_MOV,S_L,lenref,r));
-             list.concat(Taicpu.op_reg(A_INC,S_L,r));
+             getexplicitregister(list,NR_EDI);
+             list.concat(Taicpu.op_ref_reg(A_MOV,S_L,lenref,NR_EDI));
+             list.concat(Taicpu.op_reg(A_INC,S_L,NR_EDI));
 
              if (elesize<>1) then
               begin
                 if ispowerof2(elesize, power) then
-                  list.concat(Taicpu.op_const_reg(A_SHL,S_L,power,r))
+                  list.concat(Taicpu.op_const_reg(A_SHL,S_L,power,NR_EDI))
                 else
-                  list.concat(Taicpu.op_const_reg(A_IMUL,S_L,elesize,r));
+                  list.concat(Taicpu.op_const_reg(A_IMUL,S_L,elesize,NR_EDI));
               end;
           end
         else
 {$endif __NOWINPECOFF__}
-          list.concat(Taicpu.op_reg_reg(A_SUB,S_L,r,NR_ESP));
+          list.concat(Taicpu.op_reg_reg(A_SUB,S_L,NR_EDI,NR_ESP));
         { align stack on 4 bytes }
         list.concat(Taicpu.op_const_reg(A_AND,S_L,$fffffff4,NR_ESP));
         { load destination }
-        a_load_reg_reg(list,OS_INT,OS_INT,NR_ESP,r);
+        a_load_reg_reg(list,OS_INT,OS_INT,NR_ESP,NR_EDI);
 
         { Allocate other registers }
-        rg.getexplicitregisterint(list,NR_ECX);
-        rg.getexplicitregisterint(list,NR_ESI);
+        getexplicitregister(list,NR_ECX);
+        getexplicitregister(list,NR_ESI);
 
         { load count }
         a_load_ref_reg(list,OS_INT,OS_INT,lenref,NR_ECX);
@@ -1295,9 +1412,9 @@ unit cgx86;
           S_W : list.concat(Taicpu.Op_none(A_MOVSW,S_NO));
           S_L : list.concat(Taicpu.Op_none(A_MOVSD,S_NO));
         end;
-        rg.ungetregisterint(list,r);
-        rg.ungetregisterint(list,NR_ESI);
-        rg.ungetregisterint(list,NR_ECX);
+        ungetregister(list,NR_EDI);
+        ungetregister(list,NR_ECX);
+        ungetregister(list,NR_ESI);
 
         { patch the new address }
         a_load_reg_ref(list,OS_INT,OS_INT,NR_ESP,ref);
@@ -1367,7 +1484,7 @@ unit cgx86;
                 list.concat(Tai_section.Create(sec_code));
                 list.concat(Taicpu.Op_sym_ofs_reg(A_MOV,S_L,pl,0,NR_EDX));
                 a_call_name(list,target_info.Cprefix+'mcount');
-                include(rg.used_in_proc_int,RS_EDX);
+                include(rgint.used_in_proc,RS_EDX);
              end;
 
            system_i386_go32v2,system_i386_watcom:
@@ -1379,11 +1496,12 @@ unit cgx86;
 
 
     procedure tcgx86.g_stackpointer_alloc(list : taasmoutput;localsize : longint);
+
       var
         href : treference;
         i : integer;
         again : tasmlabel;
-        r : Tregister;
+
       begin
         if localsize>0 then
          begin
@@ -1406,14 +1524,14 @@ unit cgx86;
                else
                  begin
                     objectlibrary.getlabel(again);
-                    r:=rg.getexplicitregisterint(list,NR_EDI);
-                    list.concat(Taicpu.op_const_reg(A_MOV,S_L,localsize div winstackpagesize,r));
+                    getexplicitregister(list,NR_EDI);
+                    list.concat(Taicpu.op_const_reg(A_MOV,S_L,localsize div winstackpagesize,NR_EDI));
                     a_label(list,again);
                     list.concat(Taicpu.op_const_reg(A_SUB,S_L,winstackpagesize-4,NR_ESP));
                     list.concat(Taicpu.op_reg(A_PUSH,S_L,NR_EAX));
-                    list.concat(Taicpu.op_reg(A_DEC,S_L,r));
+                    list.concat(Taicpu.op_reg(A_DEC,S_L,NR_EDI));
                     a_jmp_cond(list,OC_NE,again);
-                    rg.ungetregisterint(list,r);
+                    ungetregister(list,NR_EDI);
                     list.concat(Taicpu.op_const_reg(A_SUB,S_L,localsize mod winstackpagesize,NR_ESP));
                  end
              end
@@ -1428,7 +1546,7 @@ unit cgx86;
 
     begin
       list.concat(tai_regalloc.alloc(NR_EBP));
-      include(rg.preserved_by_proc_int,RS_EBP);
+      include(rgint.preserved_by_proc,RS_EBP);
       list.concat(Taicpu.op_reg(A_PUSH,S_L,NR_EBP));
       list.concat(Taicpu.op_reg_reg(A_MOV,S_L,NR_ESP,NR_EBP));
       if localsize>0 then
@@ -1470,65 +1588,65 @@ unit cgx86;
       end;
 
 
-    procedure tcgx86.g_save_standard_registers(list:Taasmoutput;usedinproc:Tsuperregisterset);
+    procedure tcgx86.g_save_standard_registers(list:Taasmoutput);
       var
         href : treference;
         size : longint;
       begin
         { Get temp }
         size:=0;
-        if (RS_EBX in usedinproc) then
+        if (RS_EBX in rgint.used_in_proc) then
           inc(size,POINTER_SIZE);
-        if (RS_ESI in usedinproc) then
+        if (RS_ESI in rgint.used_in_proc) then
           inc(size,POINTER_SIZE);
-        if (RS_EDI in usedinproc) then
+        if (RS_EDI in rgint.used_in_proc) then
           inc(size,POINTER_SIZE);
         if size>0 then
           begin
             tg.GetTemp(list,size,tt_noreuse,current_procinfo.save_regs_ref);
             { Copy registers to temp }
             href:=current_procinfo.save_regs_ref;
-            if (RS_EBX in usedinproc) then
+            if (RS_EBX in rgint.used_in_proc) then
               begin
-                cg.a_load_reg_ref(list,OS_ADDR,OS_ADDR,NR_EBX,href);
+                a_load_reg_ref(list,OS_ADDR,OS_ADDR,NR_EBX,href);
                 inc(href.offset,POINTER_SIZE);
               end;
-            if (RS_ESI in usedinproc) then
+            if (RS_ESI in rgint.used_in_proc) then
               begin
-                cg.a_load_reg_ref(list,OS_ADDR,OS_ADDR,NR_ESI,href);
+                a_load_reg_ref(list,OS_ADDR,OS_ADDR,NR_ESI,href);
                 inc(href.offset,POINTER_SIZE);
               end;
-            if (RS_EDI in usedinproc) then
+            if (RS_EDI in rgint.used_in_proc) then
               begin
-                cg.a_load_reg_ref(list,OS_ADDR,OS_ADDR,NR_EDI,href);
+                a_load_reg_ref(list,OS_ADDR,OS_ADDR,NR_EDI,href);
                 inc(href.offset,POINTER_SIZE);
               end;
           end;
-        include(rg.preserved_by_proc_int,RS_EBX);
-        include(rg.preserved_by_proc_int,RS_ESI);
-        include(rg.preserved_by_proc_int,RS_EDI);
+        include(rgint.preserved_by_proc,RS_EBX);
+        include(rgint.preserved_by_proc,RS_ESI);
+        include(rgint.preserved_by_proc,RS_EDI);
       end;
 
 
-    procedure tcgx86.g_restore_standard_registers(list:Taasmoutput;usedinproc:Tsuperregisterset);
+    procedure tcgx86.g_restore_standard_registers(list:Taasmoutput);
       var
         href : treference;
       begin
         { Copy registers from temp }
         href:=current_procinfo.save_regs_ref;
-        if (RS_EBX in usedinproc) then
+        if (RS_EBX in rgint.used_in_proc) then
           begin
-            cg.a_load_ref_reg(list,OS_ADDR,OS_ADDR,href,NR_EBX);
+            a_load_ref_reg(list,OS_ADDR,OS_ADDR,href,NR_EBX);
             inc(href.offset,POINTER_SIZE);
           end;
-        if (RS_ESI in usedinproc) then
+        if (RS_ESI in rgint.used_in_proc) then
           begin
-            cg.a_load_ref_reg(list,OS_ADDR,OS_ADDR,href,NR_ESI);
+            a_load_ref_reg(list,OS_ADDR,OS_ADDR,href,NR_ESI);
             inc(href.offset,POINTER_SIZE);
           end;
-        if (RS_EDI in usedinproc) then
+        if (RS_EDI in rgint.used_in_proc) then
           begin
-            cg.a_load_ref_reg(list,OS_ADDR,OS_ADDR,href,NR_EDI);
+            a_load_ref_reg(list,OS_ADDR,OS_ADDR,href,NR_EDI);
             inc(href.offset,POINTER_SIZE);
           end;
         tg.UnGetTemp(list,current_procinfo.save_regs_ref);
@@ -1539,7 +1657,7 @@ unit cgx86;
       begin
         list.concat(Taicpu.Op_none(A_PUSHA,S_L));
         tg.GetTemp(list,POINTER_SIZE,tt_noreuse,current_procinfo.save_regs_ref);
-        cg.a_load_reg_ref(list,OS_ADDR,OS_ADDR,NR_ESP,current_procinfo.save_regs_ref);
+        a_load_reg_ref(list,OS_ADDR,OS_ADDR,NR_ESP,current_procinfo.save_regs_ref);
       end;
 
 
@@ -1547,7 +1665,7 @@ unit cgx86;
       var
         href : treference;
       begin
-        cg.a_load_ref_reg(list,OS_ADDR,OS_ADDR,current_procinfo.save_regs_ref,NR_ESP);
+        a_load_ref_reg(list,OS_ADDR,OS_ADDR,current_procinfo.save_regs_ref,NR_ESP);
         tg.UnGetTemp(list,current_procinfo.save_regs_ref);
         if acchiused then
          begin
@@ -1595,7 +1713,10 @@ unit cgx86;
 end.
 {
   $Log$
-  Revision 1.74  2003-10-07 16:09:03  florian
+  Revision 1.75  2003-10-09 21:31:37  daniel
+    * Register allocator splitted, ans abstract now
+
+  Revision 1.74  2003/10/07 16:09:03  florian
     * x86 supports only mem/reg to reg for movsx and movzx
 
   Revision 1.73  2003/10/07 15:17:07  peter

compiler/x86/cpubase.pas

@@ -226,7 +226,9 @@ uses
 *****************************************************************************}
 
     type
-      TResFlags = (F_E,F_NE,F_G,F_L,F_GE,F_LE,F_C,F_NC,F_A,F_AE,F_B,F_BE,F_S,F_NS);
+      TResFlags = (F_E,F_NE,F_G,F_L,F_GE,F_LE,F_C,F_NC,
+                   F_A,F_AE,F_B,F_BE,
+                   F_S,F_NS,F_O,F_NO);
 
 {*****************************************************************************
                                 Reference
@@ -427,7 +429,7 @@ implementation
     function reg2opsize(r:Tregister):topsize;
       const
         subreg2opsize : array[tsubregister] of topsize =
-          (S_NO,S_B,S_B,S_W,S_L,S_D);
+          (S_NO,S_B,S_B,S_W,S_L,S_D,S_NO);
       begin
         reg2opsize:=S_L;
         case getregtype(r) of
@@ -475,7 +477,9 @@ implementation
     procedure inverse_flags(var f: TResFlags);
       const
         inv_flags: array[TResFlags] of TResFlags =
-          (F_NE,F_E,F_LE,F_GE,F_L,F_G,F_NC,F_C,F_BE,F_B,F_AE,F_A,F_NS,F_S);
+          (F_NE,F_E,F_LE,F_GE,F_L,F_G,F_NC,F_C,
+           F_BE,F_B,F_AE,F_A,
+           F_NS,F_S,F_NO,F_O);
       begin
         f:=inv_flags[f];
       end;
@@ -484,7 +488,7 @@ implementation
     function flags_to_cond(const f: TResFlags) : TAsmCond;
       const
         flags_2_cond : array[TResFlags] of TAsmCond =
-          (C_E,C_NE,C_G,C_L,C_GE,C_LE,C_C,C_NC,C_A,C_AE,C_B,C_BE,C_S,C_NS);
+          (C_E,C_NE,C_G,C_L,C_GE,C_LE,C_C,C_NC,C_A,C_AE,C_B,C_BE,C_S,C_NS,C_O,C_NO);
       begin
         result := flags_2_cond[f];
       end;
@@ -559,7 +563,10 @@ implementation
 end.
 {
   $Log$
-  Revision 1.23  2003-10-03 22:00:33  peter
+  Revision 1.24  2003-10-09 21:31:37  daniel
+    * Register allocator splitted, ans abstract now
+
+  Revision 1.23  2003/10/03 22:00:33  peter
     * parameter alignment fixes
 
   Revision 1.22  2003/10/01 20:34:51  peter

compiler/x86/nx86cnv.pas

@@ -102,11 +102,11 @@ implementation
                 if left.location.size in [OS_64,OS_S64] then
                  begin
                    location_release(exprasmlist,left.location);
-                   hregister:=rg.getregisterint(exprasmlist,OS_INT);
+                   hregister:=cg.getintregister(exprasmlist,OS_INT);
                    cg.a_load_ref_reg(exprasmlist,OS_32,OS_32,left.location.reference,hregister);
                    href:=left.location.reference;
                    inc(href.offset,4);
-                   rg.ungetregisterint(exprasmlist,hregister);
+                   cg.ungetregister(exprasmlist,hregister);
                    cg.a_op_ref_reg(exprasmlist,OP_OR,OS_32,href,hregister);
                  end
                 else
@@ -126,9 +126,9 @@ implementation
 {$ifndef cpu64bit}
                 if left.location.size in [OS_64,OS_S64] then
                  begin
-                   hregister:=rg.getregisterint(exprasmlist,OS_32);
+                   hregister:=cg.getintregister(exprasmlist,OS_32);
                    cg.a_load_reg_reg(exprasmlist,OS_32,OS_32,left.location.registerlow,hregister);
-                   rg.ungetregisterint(exprasmlist,hregister);
+                   cg.ungetregister(exprasmlist,hregister);
                    location_release(exprasmlist,left.location);
                    cg.a_op_reg_reg(exprasmlist,OP_OR,OS_32,left.location.registerhigh,hregister);
                  end
@@ -141,7 +141,7 @@ implementation
               end;
             LOC_JUMP :
               begin
-                hregister:=rg.getregisterint(exprasmlist,OS_INT);
+                hregister:=cg.getintregister(exprasmlist,OS_INT);
                 objectlibrary.getlabel(hlabel);
                 cg.a_label(exprasmlist,truelabel);
                 cg.a_load_const_reg(exprasmlist,OS_INT,1,hregister);
@@ -149,7 +149,7 @@ implementation
                 cg.a_label(exprasmlist,falselabel);
                 cg.a_load_const_reg(exprasmlist,OS_INT,0,hregister);
                 cg.a_label(exprasmlist,hlabel);
-                rg.ungetregisterint(exprasmlist,hregister);
+                cg.ungetregister(exprasmlist,hregister);
                 cg.a_op_reg_reg(exprasmlist,OP_OR,OS_INT,hregister,hregister);
               end;
             else
@@ -157,7 +157,7 @@ implementation
          end;
          { load flags to register }
          location_reset(location,LOC_REGISTER,def_cgsize(resulttype.def));
-         location.register:=rg.getregisterint(exprasmlist,location.size);
+         location.register:=cg.getintregister(exprasmlist,location.size);
          cg.g_flags2reg(exprasmlist,location.size,resflags,location.register);
          truelabel:=oldtruelabel;
          falselabel:=oldfalselabel;
@@ -166,7 +166,10 @@ implementation
 end.
 {
   $Log$
-  Revision 1.5  2003-10-01 20:34:51  peter
+  Revision 1.6  2003-10-09 21:31:38  daniel
+    * Register allocator splitted, ans abstract now
+
+  Revision 1.5  2003/10/01 20:34:51  peter
     * procinfo unit contains tprocinfo
     * cginfo renamed to cgbase
     * moved cgmessage to verbose