* reverted Peter's alloctemp patch; hopefully properly

compiler/cg64f32.pas

@@ -72,10 +72,10 @@ unit cg64f32;
         procedure a_op64_loc_reg(list : taasmoutput;op:TOpCG;const l : tlocation;reg : tregister64);override;
         procedure a_op64_const_ref(list : taasmoutput;op:TOpCG;value : qword;const ref : treference);override;
 
-        procedure a_param64_reg(list : taasmoutput;reg : tregister64;var locpara : tparalocation;alloctemp:boolean);override;
-        procedure a_param64_const(list : taasmoutput;value : qword;var locpara : tparalocation;alloctemp:boolean);override;
-        procedure a_param64_ref(list : taasmoutput;const r : treference;var locpara : tparalocation;alloctemp:boolean);override;
-        procedure a_param64_loc(list : taasmoutput;const l : tlocation;var locpara : tparalocation;alloctemp:boolean);override;
+        procedure a_param64_reg(list : taasmoutput;reg : tregister64;const locpara : tparalocation);override;
+        procedure a_param64_const(list : taasmoutput;value : qword;const locpara : tparalocation);override;
+        procedure a_param64_ref(list : taasmoutput;const r : treference;const locpara : tparalocation);override;
+        procedure a_param64_loc(list : taasmoutput;const l : tlocation;const locpara : tparalocation);override;
 
         {# This routine tries to optimize the a_op64_const_reg operation, by
            removing superfluous opcodes. Returns TRUE if normal processing
@@ -452,43 +452,31 @@ unit cg64f32;
       end;
 
 
-    procedure tcg64f32.a_param64_reg(list : taasmoutput;reg : tregister64;var locpara : tparalocation;alloctemp:boolean);
+    procedure tcg64f32.a_param64_reg(list : taasmoutput;reg : tregister64;const locpara : tparalocation);
       var
         tmplochi,tmploclo: tparalocation;
       begin
-        if alloctemp then
-          paramanager.alloctempparaloc(list,locpara)
-        else
-          paramanager.allocparaloc(list,locpara);
         paramanager.splitparaloc64(locpara,tmploclo,tmplochi);
-        cg.a_param_reg(list,OS_32,reg.reghi,tmplochi,false);
-        cg.a_param_reg(list,OS_32,reg.reglo,tmploclo,false);
+        cg.a_param_reg(list,OS_32,reg.reghi,tmplochi);
+        cg.a_param_reg(list,OS_32,reg.reglo,tmploclo);
       end;
 
 
-    procedure tcg64f32.a_param64_const(list : taasmoutput;value : qword;var locpara : tparalocation;alloctemp:boolean);
+    procedure tcg64f32.a_param64_const(list : taasmoutput;value : qword;const locpara : tparalocation);
       var
         tmplochi,tmploclo: tparalocation;
       begin
-        if alloctemp then
-          paramanager.alloctempparaloc(list,locpara)
-        else
-          paramanager.allocparaloc(list,locpara);
         paramanager.splitparaloc64(locpara,tmploclo,tmplochi);
-        cg.a_param_const(list,OS_32,hi(value),tmplochi,false);
-        cg.a_param_const(list,OS_32,lo(value),tmploclo,false);
+        cg.a_param_const(list,OS_32,hi(value),tmplochi);
+        cg.a_param_const(list,OS_32,lo(value),tmploclo);
       end;
 
 
-    procedure tcg64f32.a_param64_ref(list : taasmoutput;const r : treference;var locpara : tparalocation;alloctemp:boolean);
+    procedure tcg64f32.a_param64_ref(list : taasmoutput;const r : treference;const locpara : tparalocation);
       var
         tmprefhi,tmpreflo : treference;
         tmploclo,tmplochi : tparalocation;
       begin
-        if alloctemp then
-          paramanager.alloctempparaloc(list,locpara)
-        else
-          paramanager.allocparaloc(list,locpara);
         paramanager.splitparaloc64(locpara,tmploclo,tmplochi);
         tmprefhi:=r;
         tmpreflo:=r;
@@ -496,22 +484,22 @@ unit cg64f32;
           inc(tmpreflo.offset,4)
         else
           inc(tmprefhi.offset,4);
-        cg.a_param_ref(list,OS_32,tmprefhi,tmplochi,false);
-        cg.a_param_ref(list,OS_32,tmpreflo,tmploclo,false);
+        cg.a_param_ref(list,OS_32,tmprefhi,tmplochi);
+        cg.a_param_ref(list,OS_32,tmpreflo,tmploclo);
       end;
 
 
-    procedure tcg64f32.a_param64_loc(list : taasmoutput;const l:tlocation;var locpara : tparalocation;alloctemp:boolean);
+    procedure tcg64f32.a_param64_loc(list : taasmoutput;const l:tlocation;const locpara : tparalocation);
       begin
         case l.loc of
           LOC_REGISTER,
           LOC_CREGISTER :
-            a_param64_reg(list,l.register64,locpara,alloctemp);
+            a_param64_reg(list,l.register64,locpara);
           LOC_CONSTANT :
-            a_param64_const(list,l.valueqword,locpara,alloctemp);
+            a_param64_const(list,l.valueqword,locpara);
           LOC_CREFERENCE,
           LOC_REFERENCE :
-            a_param64_ref(list,l.reference,locpara,alloctemp);
+            a_param64_ref(list,l.reference,locpara);
           else
             internalerror(200203287);
         end;
@@ -773,7 +761,10 @@ begin
 end.
 {
   $Log$
-  Revision 1.53  2003-12-03 23:13:19  peter
+  Revision 1.54  2003-12-06 01:15:22  florian
+    * reverted Peter's alloctemp patch; hopefully properly
+
+  Revision 1.53  2003/12/03 23:13:19  peter
     * delayed paraloc allocation, a_param_*() gets extra parameter
       if it needs to allocate temp or real paralocation
     * optimized/simplified int-real loading

compiler/cgobj.pas

@@ -117,7 +117,7 @@ unit cgobj;
              @param(r register source of the operand)
              @param(locpara where the parameter will be stored)
           }
-          procedure a_param_reg(list : taasmoutput;size : tcgsize;r : tregister;var locpara : tparalocation;alloctemp:boolean);virtual;
+          procedure a_param_reg(list : taasmoutput;size : tcgsize;r : tregister;const locpara : tparalocation);virtual;
           {# Pass a parameter, which is a constant, to a routine.
 
              A generic version is provided. This routine should
@@ -128,7 +128,7 @@ unit cgobj;
              @param(a value of constant to send)
              @param(locpara where the parameter will be stored)
           }
-          procedure a_param_const(list : taasmoutput;size : tcgsize;a : aword;var locpara : tparalocation;alloctemp:boolean);virtual;
+          procedure a_param_const(list : taasmoutput;size : tcgsize;a : aword;const locpara : tparalocation);virtual;
           {# Pass the value of a parameter, which is located in memory, to a routine.
 
              A generic version is provided. This routine should
@@ -139,7 +139,7 @@ unit cgobj;
              @param(r Memory reference of value to send)
              @param(locpara where the parameter will be stored)
           }
-          procedure a_param_ref(list : taasmoutput;size : tcgsize;const r : treference;var locpara : tparalocation;alloctemp:boolean);virtual;
+          procedure a_param_ref(list : taasmoutput;size : tcgsize;const r : treference;const locpara : tparalocation);virtual;
           {# Pass the value of a parameter, which can be located either in a register or memory location,
              to a routine.
 
@@ -149,7 +149,7 @@ unit cgobj;
              @param(nr parameter number (starting from one) of routine (from left to right))
              @param(locpara where the parameter will be stored)
           }
-          procedure a_param_loc(list : taasmoutput;const l : tlocation;var locpara : tparalocation;alloctemp:boolean);
+          procedure a_param_loc(list : taasmoutput;const l : tlocation;const locpara : tparalocation);
           {# Pass the address of a reference to a routine. This routine
              will calculate the address of the reference, and pass this
              calculated address as a parameter.
@@ -161,10 +161,10 @@ unit cgobj;
              @param(r reference to get address from)
              @param(nr parameter number (starting from one) of routine (from left to right))
           }
-          procedure a_paramaddr_ref(list : taasmoutput;const r : treference;var locpara : tparalocation;alloctemp:boolean);virtual;
+          procedure a_paramaddr_ref(list : taasmoutput;const r : treference;const locpara : tparalocation);virtual;
 
           { Copies a whole memory block to the stack, the locpara must be a memory location }
-          procedure a_param_copy_ref(list : taasmoutput;size : qword;const r : treference;var locpara : tparalocation;alloctemp:boolean);
+          procedure a_param_copy_ref(list : taasmoutput;size : qword;const r : treference;const locpara : tparalocation);
           { Remarks:
             * If a method specifies a size you have only to take care
               of that number of bits, i.e. load_const_reg with OP_8 must
@@ -475,10 +475,10 @@ unit cgobj;
         procedure a_op64_const_reg_reg(list: taasmoutput;op:TOpCG;value : qword;regsrc,regdst : tregister64);virtual;
         procedure a_op64_reg_reg_reg(list: taasmoutput;op:TOpCG;regsrc1,regsrc2,regdst : tregister64);virtual;
 
-        procedure a_param64_reg(list : taasmoutput;reg64 : tregister64;var loc : tparalocation;alloctemp:boolean);virtual;abstract;
-        procedure a_param64_const(list : taasmoutput;value : qword;var loc : tparalocation;alloctemp:boolean);virtual;abstract;
-        procedure a_param64_ref(list : taasmoutput;const r : treference;var loc : tparalocation;alloctemp:boolean);virtual;abstract;
-        procedure a_param64_loc(list : taasmoutput;const l : tlocation;var loc : tparalocation;alloctemp:boolean);virtual;abstract;
+        procedure a_param64_reg(list : taasmoutput;reg64 : tregister64;const loc : tparalocation);virtual;abstract;
+        procedure a_param64_const(list : taasmoutput;value : qword;const loc : tparalocation);virtual;abstract;
+        procedure a_param64_ref(list : taasmoutput;const r : treference;const loc : tparalocation);virtual;abstract;
+        procedure a_param64_loc(list : taasmoutput;const l : tlocation;const loc : tparalocation);virtual;abstract;
 
         {
              This routine tries to optimize the const_reg opcode, and should be
@@ -600,14 +600,10 @@ implementation
           for better code generation these methods should be overridden
 ******************************************************************************}
 
-    procedure tcg.a_param_reg(list : taasmoutput;size : tcgsize;r : tregister;var locpara : tparalocation;alloctemp:boolean);
+    procedure tcg.a_param_reg(list : taasmoutput;size : tcgsize;r : tregister;const locpara : tparalocation);
       var
          ref : treference;
       begin
-         if alloctemp then
-           paramanager.alloctempparaloc(list,locpara)
-         else
-           paramanager.allocparaloc(list,locpara);
          case locpara.loc of
             LOC_REGISTER,LOC_CREGISTER:
               a_load_reg_reg(list,size,locpara.size,r,locpara.register);
@@ -623,8 +619,8 @@ implementation
          end;
       end;
 
+    procedure tcg.a_param_const(list : taasmoutput;size : tcgsize;a : aword;const locpara : tparalocation);
 
-    procedure tcg.a_param_const(list : taasmoutput;size : tcgsize;a : aword;var locpara : tparalocation;alloctemp:boolean);
       var
          hr : tregister;
 
@@ -632,50 +628,49 @@ implementation
          hr:=getintregister(list,size);
          a_load_const_reg(list,size,a,hr);
          ungetregister(list,hr);
-         a_param_reg(list,size,hr,locpara,alloctemp);
+         a_param_reg(list,size,hr,locpara);
       end;
 
-
-    procedure tcg.a_param_ref(list : taasmoutput;size : tcgsize;const r : treference;var locpara : tparalocation;alloctemp:boolean);
+    procedure tcg.a_param_ref(list : taasmoutput;size : tcgsize;const r : treference;const locpara : tparalocation);
       var
          hr : tregister;
       begin
          hr:=getintregister(list,size);
          a_load_ref_reg(list,size,size,r,hr);
          ungetregister(list,hr);
-         a_param_reg(list,size,hr,locpara,alloctemp);
+         a_param_reg(list,size,hr,locpara);
       end;
 
 
-    procedure tcg.a_param_loc(list : taasmoutput;const l:tlocation;var locpara : tparalocation;alloctemp:boolean);
+    procedure tcg.a_param_loc(list : taasmoutput;const l:tlocation;const locpara : tparalocation);
       begin
         case l.loc of
           LOC_REGISTER,
           LOC_CREGISTER :
-            a_param_reg(list,l.size,l.register,locpara,alloctemp);
+            a_param_reg(list,l.size,l.register,locpara);
           LOC_CONSTANT :
-            a_param_const(list,l.size,l.value,locpara,alloctemp);
+            a_param_const(list,l.size,l.value,locpara);
           LOC_CREFERENCE,
           LOC_REFERENCE :
-            a_param_ref(list,l.size,l.reference,locpara,alloctemp);
+            a_param_ref(list,l.size,l.reference,locpara);
         else
           internalerror(2002032211);
         end;
       end;
 
 
-    procedure tcg.a_paramaddr_ref(list : taasmoutput;const r : treference;var locpara : tparalocation;alloctemp:boolean);
+    procedure tcg.a_paramaddr_ref(list : taasmoutput;const r : treference;const locpara : tparalocation);
       var
          hr : tregister;
       begin
          hr:=getaddressregister(list);
          a_loadaddr_ref_reg(list,r,hr);
          ungetregister(list,hr);
-         a_param_reg(list,OS_ADDR,hr,locpara,alloctemp);
+         a_param_reg(list,OS_ADDR,hr,locpara);
       end;
 
 
-    procedure tcg.a_param_copy_ref(list : taasmoutput;size : qword;const r : treference;var locpara : tparalocation;alloctemp:boolean);
+    procedure tcg.a_param_copy_ref(list : taasmoutput;size : qword;const r : treference;const locpara : tparalocation);
       var
         ref : treference;
       begin
@@ -1278,14 +1273,17 @@ implementation
         paraloc1:=paramanager.getintparaloc(pocall_default,1);
         paraloc2:=paramanager.getintparaloc(pocall_default,2);
         paraloc3:=paramanager.getintparaloc(pocall_default,3);
-        a_paramaddr_ref(list,dest,paraloc3,false);
+        paramanager.allocparaloc(list,paraloc3);
+        a_paramaddr_ref(list,dest,paraloc3);
+        paramanager.allocparaloc(list,paraloc2);
         if loadref then
-          a_param_ref(list,OS_ADDR,source,paraloc2,false)
+          a_param_ref(list,OS_ADDR,source,paraloc2)
         else
-          a_paramaddr_ref(list,source,paraloc2,false);
+          a_paramaddr_ref(list,source,paraloc2);
         if delsource then
          reference_release(list,source);
-        a_param_const(list,OS_INT,len,paraloc1,false);
+        paramanager.allocparaloc(list,paraloc1);
+        a_param_const(list,OS_INT,len,paraloc1);
         paramanager.freeparaloc(list,paraloc3);
         paramanager.freeparaloc(list,paraloc2);
         paramanager.freeparaloc(list,paraloc1);
@@ -1319,7 +1317,8 @@ implementation
          if incrfunc<>'' then
           begin
             { these functions get the pointer by value }
-            a_param_ref(list,OS_ADDR,ref,paraloc1,false);
+            paramanager.allocparaloc(list,paraloc1);
+            a_param_ref(list,OS_ADDR,ref,paraloc1);
             paramanager.freeparaloc(list,paraloc1);
             allocexplicitregisters(list,R_INTREGISTER,paramanager.get_volatile_registers_int(pocall_default));
             a_call_name(list,incrfunc);
@@ -1328,11 +1327,13 @@ implementation
          else
           begin
             reference_reset_symbol(href,tstoreddef(t).get_rtti_label(initrtti),0);
-            a_paramaddr_ref(list,href,paraloc2,false);
+            paramanager.allocparaloc(list,paraloc2);
+            a_paramaddr_ref(list,href,paraloc2);
+            paramanager.allocparaloc(list,paraloc1);
             if loadref then
-              a_param_ref(list,OS_ADDR,ref,paraloc1,false)
+              a_param_ref(list,OS_ADDR,ref,paraloc1)
             else
-              a_paramaddr_ref(list,ref,paraloc1,false);
+              a_paramaddr_ref(list,ref,paraloc1);
             paramanager.freeparaloc(list,paraloc1);
             paramanager.freeparaloc(list,paraloc2);
             allocexplicitregisters(list,R_INTREGISTER,paramanager.get_volatile_registers_int(pocall_default));
@@ -1371,12 +1372,14 @@ implementation
             if needrtti then
              begin
                reference_reset_symbol(href,tstoreddef(t).get_rtti_label(initrtti),0);
-               a_paramaddr_ref(list,href,paraloc2,false);
+               paramanager.allocparaloc(list,paraloc2);
+               a_paramaddr_ref(list,href,paraloc2);
              end;
+            paramanager.allocparaloc(list,paraloc1);
             if loadref then
-              a_param_ref(list,OS_ADDR,ref,paraloc1,false)
+              a_param_ref(list,OS_ADDR,ref,paraloc1)
             else
-              a_paramaddr_ref(list,ref,paraloc1,false);
+              a_paramaddr_ref(list,ref,paraloc1);
             paramanager.freeparaloc(list,paraloc1);
             if needrtti then
               paramanager.freeparaloc(list,paraloc2);
@@ -1387,11 +1390,13 @@ implementation
          else
           begin
             reference_reset_symbol(href,tstoreddef(t).get_rtti_label(initrtti),0);
-            a_paramaddr_ref(list,href,paraloc2,false);
+            paramanager.allocparaloc(list,paraloc2);
+            a_paramaddr_ref(list,href,paraloc2);
+            paramanager.allocparaloc(list,paraloc1);
             if loadref then
-              a_param_ref(list,OS_ADDR,ref,paraloc1,false)
+              a_param_ref(list,OS_ADDR,ref,paraloc1)
             else
-              a_paramaddr_ref(list,ref,paraloc1,false);
+              a_paramaddr_ref(list,ref,paraloc1);
             paramanager.freeparaloc(list,paraloc1);
             paramanager.freeparaloc(list,paraloc2);
             allocexplicitregisters(list,R_INTREGISTER,paramanager.get_volatile_registers_int(pocall_default));
@@ -1415,11 +1420,13 @@ implementation
          else
            begin
               reference_reset_symbol(href,tstoreddef(t).get_rtti_label(initrtti),0);
-              a_paramaddr_ref(list,href,paraloc2,false);
+              paramanager.allocparaloc(list,paraloc2);
+              a_paramaddr_ref(list,href,paraloc2);
+              paramanager.allocparaloc(list,paraloc1);
               if loadref then
-                a_param_ref(list,OS_ADDR,ref,paraloc1,false)
+                a_param_ref(list,OS_ADDR,ref,paraloc1)
               else
-                a_paramaddr_ref(list,ref,paraloc1,false);
+                a_paramaddr_ref(list,ref,paraloc1);
               paramanager.freeparaloc(list,paraloc1);
               paramanager.freeparaloc(list,paraloc2);
               allocexplicitregisters(list,R_INTREGISTER,paramanager.get_volatile_registers_int(pocall_default));
@@ -1443,11 +1450,13 @@ implementation
          else
            begin
               reference_reset_symbol(href,tstoreddef(t).get_rtti_label(initrtti),0);
-              a_paramaddr_ref(list,href,paraloc2,false);
+              paramanager.allocparaloc(list,paraloc2);
+              a_paramaddr_ref(list,href,paraloc2);
+              paramanager.allocparaloc(list,paraloc1);
               if loadref then
-                a_param_ref(list,OS_ADDR,ref,paraloc1,false)
+                a_param_ref(list,OS_ADDR,ref,paraloc1)
               else
-                a_paramaddr_ref(list,ref,paraloc1,false);
+                a_paramaddr_ref(list,ref,paraloc1);
               paramanager.freeparaloc(list,paraloc1);
               paramanager.freeparaloc(list,paraloc2);
               allocexplicitregisters(list,R_INTREGISTER,paramanager.get_volatile_registers_int(pocall_default));
@@ -1572,7 +1581,8 @@ implementation
         paraloc1 : tparalocation;
       begin
          paraloc1:=paramanager.getintparaloc(pocall_default,1);
-         a_param_const(list,OS_32,stackframesize,paraloc1,false);
+         paramanager.allocparaloc(list,paraloc1);
+         a_param_const(list,OS_32,stackframesize,paraloc1);
          paramanager.freeparaloc(list,paraloc1);
          { No register saving needed, saveregisters is used }
          a_call_name(list,'FPC_STACKCHECK');
@@ -1602,7 +1612,8 @@ implementation
            objectlibrary.getlabel(oklabel);
            a_cmp_const_reg_label(list,OS_ADDR,OC_NE,0,reg,oklabel);
            paraloc1:=paramanager.getintparaloc(pocall_default,1);
-           a_param_const(list,OS_INT,210,paraloc1,false);
+           paramanager.allocparaloc(list,paraloc1);
+           a_param_const(list,OS_INT,210,paraloc1);
            paramanager.freeparaloc(list,paraloc1);
            a_call_name(list,'FPC_HANDLEERROR');
            a_label(list,oklabel);
@@ -1620,8 +1631,10 @@ implementation
         if (cs_check_object in aktlocalswitches) then
          begin
            reference_reset_symbol(hrefvmt,objectlibrary.newasmsymboldata(objdef.vmt_mangledname),0);
-           a_paramaddr_ref(list,hrefvmt,paraloc2,false);
-           a_param_reg(list,OS_ADDR,reg,paraloc1,false);
+           paramanager.allocparaloc(list,paraloc2);
+           a_paramaddr_ref(list,hrefvmt,paraloc2);
+           paramanager.allocparaloc(list,paraloc1);
+           a_param_reg(list,OS_ADDR,reg,paraloc1);
            paramanager.freeparaloc(list,paraloc1);
            paramanager.freeparaloc(list,paraloc2);
            { No register saving needed, saveregisters is used }
@@ -1630,7 +1643,8 @@ implementation
         else
          if (cs_check_range in aktlocalswitches) then
           begin
-            a_param_reg(list,OS_ADDR,reg,paraloc1,false);
+            paramanager.allocparaloc(list,paraloc1);
+            a_param_reg(list,OS_ADDR,reg,paraloc1);
             paramanager.freeparaloc(list,paraloc1);
             { No register saving needed, saveregisters is used }
             a_call_name(list,'FPC_CHECK_OBJECT');
@@ -1803,7 +1817,10 @@ finalization
 end.
 {
   $Log$
-  Revision 1.135  2003-12-03 23:13:19  peter
+  Revision 1.136  2003-12-06 01:15:22  florian
+    * reverted Peter's alloctemp patch; hopefully properly
+
+  Revision 1.135  2003/12/03 23:13:19  peter
     * delayed paraloc allocation, a_param_*() gets extra parameter
       if it needs to allocate temp or real paralocation
     * optimized/simplified int-real loading

compiler/i386/n386add.pas

@@ -356,7 +356,8 @@ interface
                          end
                        else
                          begin
-                           cg.a_paramaddr_ref(exprasmlist,left.location.reference,paraloc2,false);
+                           paramanager.allocparaloc(exprasmlist,paraloc2);
+                           cg.a_paramaddr_ref(exprasmlist,left.location.reference,paraloc2);
                          end;
                        secondpass(right);
                        location_release(exprasmlist,right.location);
@@ -367,18 +368,21 @@ interface
                          end
                        else
                          begin
-                           cg.a_paramaddr_ref(exprasmlist,right.location.reference,paraloc1,false);
+                           paramanager.allocparaloc(exprasmlist,paraloc1);
+                           cg.a_paramaddr_ref(exprasmlist,right.location.reference,paraloc1);
                          end;
                        { push parameters }
                        if paraloc1.loc=LOC_REGISTER then
                          begin
                            cg.ungetregister(exprasmlist,hregister2);
-                           cg.a_param_reg(exprasmlist,OS_ADDR,hregister2,paraloc2,false);
+                           paramanager.allocparaloc(exprasmlist,paraloc2);
+                           cg.a_param_reg(exprasmlist,OS_ADDR,hregister2,paraloc2);
                          end;
                        if paraloc2.loc=LOC_REGISTER then
                          begin
                            cg.ungetregister(exprasmlist,hregister1);
-                           cg.a_param_reg(exprasmlist,OS_ADDR,hregister1,paraloc1,false);
+                           paramanager.allocparaloc(exprasmlist,paraloc1);
+                           cg.a_param_reg(exprasmlist,OS_ADDR,hregister1,paraloc1);
                          end;
                        paramanager.freeparaloc(exprasmlist,paraloc1);
                        paramanager.freeparaloc(exprasmlist,paraloc2);
@@ -1491,7 +1495,10 @@ begin
 end.
 {
   $Log$
-  Revision 1.87  2003-12-03 23:13:20  peter
+  Revision 1.88  2003-12-06 01:15:23  florian
+    * reverted Peter's alloctemp patch; hopefully properly
+
+  Revision 1.87  2003/12/03 23:13:20  peter
     * delayed paraloc allocation, a_param_*() gets extra parameter
       if it needs to allocate temp or real paralocation
     * optimized/simplified int-real loading

compiler/ncgcal.pas

@@ -35,6 +35,7 @@ interface
        tcgcallparanode = class(tcallparanode)
        private
           tempparaloc : tparalocation;
+          procedure allocate_tempparaloc;
           procedure push_addr_para;
           procedure push_value_para;
        public
@@ -98,12 +99,22 @@ implementation
                              TCGCALLPARANODE
 *****************************************************************************}
 
+    procedure tcgcallparanode.allocate_tempparaloc;
+      begin
+         { Allocate (temporary) paralocation }
+         tempparaloc:=paraitem.paraloc[callerside];
+         if (tempparaloc.loc in [LOC_REGISTER,LOC_FPUREGISTER,LOC_MMREGISTER]) then
+           paramanager.alloctempregs(exprasmlist,tempparaloc)
+      end;
+
+
     procedure tcgcallparanode.push_addr_para;
       begin
         if not(left.location.loc in [LOC_CREFERENCE,LOC_REFERENCE]) then
           internalerror(200304235);
         location_release(exprasmlist,left.location);
-        cg.a_paramaddr_ref(exprasmlist,left.location.reference,tempparaloc,true);
+        allocate_tempparaloc;
+        cg.a_paramaddr_ref(exprasmlist,left.location.reference,tempparaloc);
         inc(tcgcallnode(aktcallnode).pushedparasize,POINTER_SIZE);
       end;
 
@@ -126,6 +137,7 @@ implementation
         if left.resulttype.def.deftype=floatdef then
          begin
            location_release(exprasmlist,left.location);
+           allocate_tempparaloc;
 {$ifdef i386}
            if tempparaloc.loc<>LOC_REFERENCE then
              internalerror(200309291);
@@ -168,7 +180,7 @@ implementation
                            dec(href.offset,2);
                            dec(size,2);
                          end;
-                        cg.a_param_ref(exprasmlist,cgsize,href,tempparaloc,true);
+                        cg.a_param_ref(exprasmlist,cgsize,href,tempparaloc);
                       end;
                    end
                  else
@@ -203,6 +215,7 @@ implementation
                   aktcallnode.procdefinition.proccalloption) then
             begin
               location_release(exprasmlist,left.location);
+              allocate_tempparaloc;
 {$ifdef i386}
               if tempparaloc.loc<>LOC_REFERENCE then
                 internalerror(200309292);
@@ -236,14 +249,16 @@ implementation
                     if cgsize in [OS_64,OS_S64] then
                      begin
                        inc(tcgcallnode(aktcallnode).pushedparasize,8);
-                       cg64.a_param64_loc(exprasmlist,left.location,tempparaloc,true);
+                       allocate_tempparaloc;
+                       cg64.a_param64_loc(exprasmlist,left.location,tempparaloc);
                        location_release(exprasmlist,left.location);
                      end
                     else
                      begin
                        location_release(exprasmlist,left.location);
+                       allocate_tempparaloc;
                        inc(tcgcallnode(aktcallnode).pushedparasize,align(tcgsize2size[tempparaloc.size],tempparaloc.alignment));
-                       cg.a_param_loc(exprasmlist,left.location,tempparaloc,true);
+                       cg.a_param_loc(exprasmlist,left.location,tempparaloc);
                      end;
                   end;
 {$ifdef SUPPORT_MMX}
@@ -251,6 +266,7 @@ implementation
                 LOC_CMMXREGISTER:
                   begin
                      location_release(exprasmlist,left.location);
+                     allocate_tempparaloc;
                      inc(tcgcallnode(aktcallnode).pushedparasize,8);
                      cg.a_parammm_reg(exprasmlist,left.location.register);
                   end;
@@ -275,12 +291,6 @@ implementation
                 (nf_varargs_para in flags)) then
            internalerror(200304242);
 
-         { Initialize temporary paralocation, only reset register
-           value for register parameters }
-         tempparaloc:=paraitem.paraloc[callerside];
-         if (tempparaloc.loc in [LOC_REGISTER,LOC_FPUREGISTER,LOC_MMREGISTER]) then
-           tempparaloc.register:=NR_NO;
-
          { Skip nothingn nodes which are used after disabling
            a parameter }
          if (left.nodetype<>nothingn) then
@@ -327,7 +337,8 @@ implementation
                     begin
                       inc(tcgcallnode(aktcallnode).pushedparasize,POINTER_SIZE);
                       location_release(exprasmlist,left.location);
-                      cg.a_param_loc(exprasmlist,left.location,tempparaloc,true);
+                      allocate_tempparaloc;
+                      cg.a_param_loc(exprasmlist,left.location,tempparaloc);
                     end
                   else
                     push_addr_para;
@@ -1116,7 +1127,10 @@ begin
 end.
 {
   $Log$
-  Revision 1.143  2003-12-03 23:13:20  peter
+  Revision 1.144  2003-12-06 01:15:22  florian
+    * reverted Peter's alloctemp patch; hopefully properly
+
+  Revision 1.143  2003/12/03 23:13:20  peter
     * delayed paraloc allocation, a_param_*() gets extra parameter
       if it needs to allocate temp or real paralocation
     * optimized/simplified int-real loading

compiler/ncgflw.pas

@@ -825,16 +825,18 @@ implementation
               { Push parameters }
               if assigned(right) then
                 begin
+                  paramanager.allocparaloc(exprasmlist,paraloc3);
                   if assigned(frametree) then
                     begin
                       location_release(exprasmlist,frametree.location);
-                      cg.a_param_loc(exprasmlist,frametree.location,paraloc3,false)
+                      cg.a_param_loc(exprasmlist,frametree.location,paraloc3)
                     end
                   else
-                    cg.a_param_const(exprasmlist,OS_INT,0,paraloc3,false);
+                    cg.a_param_const(exprasmlist,OS_INT,0,paraloc3);
                   { push address }
                   location_release(exprasmlist,right.location);
-                  cg.a_param_loc(exprasmlist,right.location,paraloc2,false);
+                  paramanager.allocparaloc(exprasmlist,paraloc2);
+                  cg.a_param_loc(exprasmlist,right.location,paraloc2);
                 end
               else
                 begin
@@ -843,15 +845,18 @@ implementation
                    cg.a_label(exprasmlist,a);
                    reference_reset_symbol(href2,a,0);
                    { push current frame }
-                   cg.a_param_reg(exprasmlist,OS_ADDR,NR_FRAME_POINTER_REG,paraloc3,false);
+                   paramanager.allocparaloc(exprasmlist,paraloc3);
+                   cg.a_param_reg(exprasmlist,OS_ADDR,NR_FRAME_POINTER_REG,paraloc3);
                    { push current address }
+                   paramanager.allocparaloc(exprasmlist,paraloc2);
                    if target_info.system <> system_powerpc_macos then
-                     cg.a_paramaddr_ref(exprasmlist,href2,paraloc2,false)
+                     cg.a_paramaddr_ref(exprasmlist,href2,paraloc2)
                    else
-                     cg.a_param_const(exprasmlist,OS_INT,0,paraloc2,false);
+                     cg.a_param_const(exprasmlist,OS_INT,0,paraloc2);
                 end;
               location_release(exprasmlist,left.location);
-              cg.a_param_loc(exprasmlist,left.location,paraloc1,false);
+              paramanager.allocparaloc(exprasmlist,paraloc1);
+              cg.a_param_loc(exprasmlist,left.location,paraloc1);
               paramanager.freeparaloc(exprasmlist,paraloc1);
               paramanager.freeparaloc(exprasmlist,paraloc2);
               paramanager.freeparaloc(exprasmlist,paraloc3);
@@ -907,7 +912,8 @@ implementation
          cg.a_call_name(exprasmlist,'FPC_POPOBJECTSTACK');
          cg.deallocexplicitregisters(exprasmlist,R_INTREGISTER,paramanager.get_volatile_registers_int(pocall_default));
          paraloc1:=paramanager.getintparaloc(pocall_default,1);
-         cg.a_param_reg(exprasmlist,OS_ADDR,NR_FUNCTION_RESULT_REG,paraloc1,false);
+         paramanager.allocparaloc(exprasmlist,paraloc1);
+         cg.a_param_reg(exprasmlist,OS_ADDR,NR_FUNCTION_RESULT_REG,paraloc1);
          paramanager.freeparaloc(exprasmlist,paraloc1);
          cg.allocexplicitregisters(exprasmlist,R_INTREGISTER,paramanager.get_volatile_registers_int(pocall_default));
          cg.a_call_name(exprasmlist,'FPC_DESTROYEXCEPTION');
@@ -1015,7 +1021,8 @@ implementation
                 'default handler' flag (=-1)
               }
               paraloc1:=paramanager.getintparaloc(pocall_default,1);
-              cg.a_param_const(exprasmlist,OS_ADDR,aword(-1),paraloc1,false);
+              paramanager.allocparaloc(exprasmlist,paraloc1);
+              cg.a_param_const(exprasmlist,OS_ADDR,aword(-1),paraloc1);
               paramanager.freeparaloc(exprasmlist,paraloc1);
               cg.allocexplicitregisters(exprasmlist,R_INTREGISTER,paramanager.get_volatile_registers_int(pocall_default));
               cg.a_call_name(exprasmlist,'FPC_CATCHES');
@@ -1042,7 +1049,8 @@ implementation
               cg.deallocexplicitregisters(exprasmlist,R_INTREGISTER,paramanager.get_volatile_registers_int(pocall_default));
 
               paraloc1:=paramanager.getintparaloc(pocall_default,1);
-              cg.a_param_reg(exprasmlist, OS_ADDR, NR_FUNCTION_RESULT_REG, paraloc1,false);
+              paramanager.allocparaloc(exprasmlist,paraloc1);
+              cg.a_param_reg(exprasmlist, OS_ADDR, NR_FUNCTION_RESULT_REG, paraloc1);
               paramanager.freeparaloc(exprasmlist,paraloc1);
               cg.allocexplicitregisters(exprasmlist,R_INTREGISTER,paramanager.get_volatile_registers_int(pocall_default));
               cg.a_call_name(exprasmlist,'FPC_DESTROYEXCEPTION');
@@ -1178,7 +1186,8 @@ implementation
          { send the vmt parameter }
          reference_reset_symbol(href2,objectlibrary.newasmsymboldata(excepttype.vmt_mangledname),0);
          paraloc1:=paramanager.getintparaloc(pocall_default,1);
-         cg.a_paramaddr_ref(exprasmlist,href2,paraloc1,false);
+         paramanager.allocparaloc(exprasmlist,paraloc1);
+         cg.a_paramaddr_ref(exprasmlist,href2,paraloc1);
          paramanager.freeparaloc(exprasmlist,paraloc1);
          cg.allocexplicitregisters(exprasmlist,R_INTREGISTER,paramanager.get_volatile_registers_int(pocall_default));
          cg.a_call_name(exprasmlist,'FPC_CATCHES');
@@ -1236,7 +1245,8 @@ implementation
          cg.a_call_name(exprasmlist,'FPC_POPSECONDOBJECTSTACK');
          cg.deallocexplicitregisters(exprasmlist,R_INTREGISTER,paramanager.get_volatile_registers_int(pocall_default));
          paraloc1:=paramanager.getintparaloc(pocall_default,1);
-         cg.a_param_reg(exprasmlist, OS_ADDR, NR_FUNCTION_RESULT_REG, paraloc1,false);
+         paramanager.allocparaloc(exprasmlist,paraloc1);
+         cg.a_param_reg(exprasmlist, OS_ADDR, NR_FUNCTION_RESULT_REG, paraloc1);
          paramanager.freeparaloc(exprasmlist,paraloc1);
          cg.allocexplicitregisters(exprasmlist,R_INTREGISTER,paramanager.get_volatile_registers_int(pocall_default));
          cg.a_call_name(exprasmlist,'FPC_DESTROYEXCEPTION');
@@ -1469,7 +1479,10 @@ begin
 end.
 {
   $Log$
-  Revision 1.86  2003-12-03 23:13:20  peter
+  Revision 1.87  2003-12-06 01:15:22  florian
+    * reverted Peter's alloctemp patch; hopefully properly
+
+  Revision 1.86  2003/12/03 23:13:20  peter
     * delayed paraloc allocation, a_param_*() gets extra parameter
       if it needs to allocate temp or real paralocation
     * optimized/simplified int-real loading

compiler/ncginl.pas

@@ -188,20 +188,24 @@ implementation
        maketojumpbool(exprasmlist,tcallparanode(left).left,lr_load_regvars);
        cg.a_label(exprasmlist,falselabel);
        { erroraddr }
-       cg.a_param_reg(exprasmlist,OS_ADDR,NR_FRAME_POINTER_REG,paraloc4,false);
+       paramanager.allocparaloc(exprasmlist,paraloc4);
+       cg.a_param_reg(exprasmlist,OS_ADDR,NR_FRAME_POINTER_REG,paraloc4);
        { lineno }
-       cg.a_param_const(exprasmlist,OS_INT,aktfilepos.line,paraloc3,false);
+       paramanager.allocparaloc(exprasmlist,paraloc3);
+       cg.a_param_const(exprasmlist,OS_INT,aktfilepos.line,paraloc3);
        { filename string }
        hp2:=cstringconstnode.createstr(current_module.sourcefiles.get_file_name(aktfilepos.fileindex),st_shortstring);
        firstpass(tnode(hp2));
        secondpass(tnode(hp2));
        if codegenerror then
           exit;
-       cg.a_paramaddr_ref(exprasmlist,hp2.location.reference,paraloc2,false);
+       paramanager.allocparaloc(exprasmlist,paraloc2);
+       cg.a_paramaddr_ref(exprasmlist,hp2.location.reference,paraloc2);
        hp2.free;
        { push msg }
        secondpass(tcallparanode(tcallparanode(left).right).left);
-       cg.a_paramaddr_ref(exprasmlist,tcallparanode(tcallparanode(left).right).left.location.reference,paraloc1,false);
+       paramanager.allocparaloc(exprasmlist,paraloc1);
+       cg.a_paramaddr_ref(exprasmlist,tcallparanode(tcallparanode(left).right).left.location.reference,paraloc1);
        { call }
        paramanager.freeparaloc(exprasmlist,paraloc1);
        paramanager.freeparaloc(exprasmlist,paraloc2);
@@ -652,7 +656,10 @@ end.
 
 {
   $Log$
-  Revision 1.48  2003-12-03 23:13:20  peter
+  Revision 1.49  2003-12-06 01:15:22  florian
+    * reverted Peter's alloctemp patch; hopefully properly
+
+  Revision 1.48  2003/12/03 23:13:20  peter
     * delayed paraloc allocation, a_param_*() gets extra parameter
       if it needs to allocate temp or real paralocation
     * optimized/simplified int-real loading

compiler/ncgld.pas

@@ -154,7 +154,8 @@ implementation
                        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);
-                       cg.a_param_ref(exprasmlist,OS_ADDR,href,paraloc1,false);
+                       paramanager.allocparaloc(exprasmlist,paraloc1);
+                       cg.a_param_ref(exprasmlist,OS_ADDR,href,paraloc1);
                        paramanager.freeparaloc(exprasmlist,paraloc1);
                        cg.allocexplicitregisters(exprasmlist,R_INTREGISTER,paramanager.get_volatile_registers_int(pocall_default));
                        cg.a_call_reg(exprasmlist,hregister);
@@ -891,7 +892,10 @@ begin
 end.
 {
   $Log$
-  Revision 1.101  2003-12-03 23:13:20  peter
+  Revision 1.102  2003-12-06 01:15:22  florian
+    * reverted Peter's alloctemp patch; hopefully properly
+
+  Revision 1.101  2003/12/03 23:13:20  peter
     * delayed paraloc allocation, a_param_*() gets extra parameter
       if it needs to allocate temp or real paralocation
     * optimized/simplified int-real loading

compiler/ncgmat.pas

@@ -331,7 +331,8 @@ implementation
                   objectlibrary.getlabel(hl);
                   cg.a_cmp_const_reg_label(exprasmlist,OS_INT,OC_NE,0,hdenom,hl);
                   paraloc1:=paramanager.getintparaloc(pocall_default,1);
-                  cg.a_param_const(exprasmlist,OS_S32,200,paraloc1,false);
+                  paramanager.allocparaloc(exprasmlist,paraloc1);
+                  cg.a_param_const(exprasmlist,OS_S32,200,paraloc1);
                   paramanager.freeparaloc(exprasmlist,paraloc1);
                   cg.a_call_name(exprasmlist,'FPC_HANDLERROR');
                   cg.a_label(exprasmlist,hl);
@@ -501,7 +502,10 @@ begin
 end.
 {
   $Log$
-  Revision 1.22  2003-12-03 23:13:20  peter
+  Revision 1.23  2003-12-06 01:15:22  florian
+    * reverted Peter's alloctemp patch; hopefully properly
+
+  Revision 1.22  2003/12/03 23:13:20  peter
     * delayed paraloc allocation, a_param_*() gets extra parameter
       if it needs to allocate temp or real paralocation
     * optimized/simplified int-real loading

compiler/ncgmem.pas

@@ -292,7 +292,8 @@ implementation
             (not tpointerdef(left.resulttype.def).is_far) then
           begin
             paraloc1:=paramanager.getintparaloc(pocall_default,1);
-            cg.a_param_reg(exprasmlist, OS_ADDR,location.reference.base,paraloc1,false);
+            paramanager.allocparaloc(exprasmlist,paraloc1);
+            cg.a_param_reg(exprasmlist, OS_ADDR,location.reference.base,paraloc1);
             paramanager.freeparaloc(exprasmlist,paraloc1);
             { FPC_CHECKPOINTER uses saveregisters }
             cg.a_call_name(exprasmlist,'FPC_CHECKPOINTER');
@@ -345,7 +346,8 @@ implementation
                 not(cs_compilesystem in aktmoduleswitches) then
               begin
                 paraloc1:=paramanager.getintparaloc(pocall_default,1);
-                cg.a_param_reg(exprasmlist, OS_ADDR,location.reference.base,paraloc1,false);
+                paramanager.allocparaloc(exprasmlist,paraloc1);
+                cg.a_param_reg(exprasmlist, OS_ADDR,location.reference.base,paraloc1);
                 paramanager.freeparaloc(exprasmlist,paraloc1);
                 { FPC_CHECKPOINTER uses saveregisters }
                 cg.a_call_name(exprasmlist,'FPC_CHECKPOINTER');
@@ -361,7 +363,8 @@ implementation
                 not(cs_compilesystem in aktmoduleswitches) then
               begin
                 paraloc1:=paramanager.getintparaloc(pocall_default,1);
-                cg.a_param_reg(exprasmlist, OS_ADDR,location.reference.base,paraloc1,false);
+                paramanager.allocparaloc(exprasmlist,paraloc1);
+                cg.a_param_reg(exprasmlist, OS_ADDR,location.reference.base,paraloc1);
                 paramanager.freeparaloc(exprasmlist,paraloc1);
                 { FPC_CHECKPOINTER uses saveregisters }
                 cg.a_call_name(exprasmlist,'FPC_CHECKPOINTER');
@@ -554,8 +557,10 @@ implementation
             begin
                paraloc1:=paramanager.getintparaloc(pocall_default,1);
                paraloc2:=paramanager.getintparaloc(pocall_default,2);
-               cg.a_param_loc(exprasmlist,right.location,paraloc2,false);
-               cg.a_param_loc(exprasmlist,left.location,paraloc1,false);
+               paramanager.allocparaloc(exprasmlist,paraloc2);
+               cg.a_param_loc(exprasmlist,right.location,paraloc2);
+               paramanager.allocparaloc(exprasmlist,paraloc1);
+               cg.a_param_loc(exprasmlist,left.location,paraloc1);
                paramanager.freeparaloc(exprasmlist,paraloc1);
                paramanager.freeparaloc(exprasmlist,paraloc2);
                cg.allocexplicitregisters(exprasmlist,R_INTREGISTER,paramanager.get_volatile_registers_int(pocall_default));
@@ -615,7 +620,8 @@ implementation
               if (cs_check_range in aktlocalswitches) then
                 begin
                    paraloc1:=paramanager.getintparaloc(pocall_default,1);
-                   cg.a_param_reg(exprasmlist,OS_ADDR,location.reference.base,paraloc1,false);
+                   paramanager.allocparaloc(exprasmlist,paraloc1);
+                   cg.a_param_reg(exprasmlist,OS_ADDR,location.reference.base,paraloc1);
                    paramanager.freeparaloc(exprasmlist,paraloc1);
                    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');
@@ -694,10 +700,12 @@ implementation
                            begin
                               paraloc1:=paramanager.getintparaloc(pocall_default,1);
                               paraloc2:=paramanager.getintparaloc(pocall_default,2);
-                              cg.a_param_const(exprasmlist,OS_INT,tordconstnode(right).value,paraloc2,false);
+                              paramanager.allocparaloc(exprasmlist,paraloc2);
+                              cg.a_param_const(exprasmlist,OS_INT,tordconstnode(right).value,paraloc2);
                               href:=location.reference;
                               dec(href.offset,7);
-                              cg.a_param_ref(exprasmlist,OS_INT,href,paraloc1,false);
+                              paramanager.allocparaloc(exprasmlist,paraloc1);
+                              cg.a_param_ref(exprasmlist,OS_INT,href,paraloc1);
                               paramanager.freeparaloc(exprasmlist,paraloc1);
                               paramanager.freeparaloc(exprasmlist,paraloc2);
                               cg.allocexplicitregisters(exprasmlist,R_INTREGISTER,paramanager.get_volatile_registers_int(pocall_default));
@@ -826,10 +834,12 @@ implementation
                            begin
                               paraloc1:=paramanager.getintparaloc(pocall_default,1);
                               paraloc2:=paramanager.getintparaloc(pocall_default,2);
-                              cg.a_param_reg(exprasmlist,OS_INT,right.location.register,paraloc2,false);
+                              paramanager.allocparaloc(exprasmlist,paraloc2);
+                              cg.a_param_reg(exprasmlist,OS_INT,right.location.register,paraloc2);
                               href:=location.reference;
                               dec(href.offset,7);
-                              cg.a_param_ref(exprasmlist,OS_INT,href,paraloc1,false);
+                              paramanager.allocparaloc(exprasmlist,paraloc1);
+                              cg.a_param_ref(exprasmlist,OS_INT,href,paraloc1);
                               paramanager.freeparaloc(exprasmlist,paraloc1);
                               paramanager.freeparaloc(exprasmlist,paraloc2);
                               cg.allocexplicitregisters(exprasmlist,R_INTREGISTER,paramanager.get_volatile_registers_int(pocall_default));
@@ -868,7 +878,10 @@ begin
 end.
 {
   $Log$
-  Revision 1.82  2003-12-03 23:13:20  peter
+  Revision 1.83  2003-12-06 01:15:22  florian
+    * reverted Peter's alloctemp patch; hopefully properly
+
+  Revision 1.82  2003/12/03 23:13:20  peter
     * delayed paraloc allocation, a_param_*() gets extra parameter
       if it needs to allocate temp or real paralocation
     * optimized/simplified int-real loading

compiler/ncgutil.pas

@@ -278,10 +278,13 @@ implementation
         paraloc1:=paramanager.getintparaloc(pocall_default,1);
         paraloc2:=paramanager.getintparaloc(pocall_default,2);
         paraloc3:=paramanager.getintparaloc(pocall_default,3);
-        cg.a_paramaddr_ref(list,envbuf,paraloc3,false);
-        cg.a_paramaddr_ref(list,jmpbuf,paraloc2,false);
+        paramanager.allocparaloc(list,paraloc3);
+        cg.a_paramaddr_ref(list,envbuf,paraloc3);
+        paramanager.allocparaloc(list,paraloc2);
+        cg.a_paramaddr_ref(list,jmpbuf,paraloc2);
         { push type of exceptionframe }
-        cg.a_param_const(list,OS_S32,1,paraloc1,false);
+        paramanager.allocparaloc(list,paraloc1);
+        cg.a_param_const(list,OS_S32,1,paraloc1);
         paramanager.freeparaloc(list,paraloc3);
         paramanager.freeparaloc(list,paraloc2);
         paramanager.freeparaloc(list,paraloc1);
@@ -290,7 +293,8 @@ implementation
         cg.deallocexplicitregisters(list,R_INTREGISTER,paramanager.get_volatile_registers_int(pocall_default));
 
         paraloc1:=paramanager.getintparaloc(pocall_default,1);
-        cg.a_param_reg(list,OS_ADDR,NR_FUNCTION_RESULT_REG,paraloc1,false);
+        paramanager.allocparaloc(list,paraloc1);
+        cg.a_param_reg(list,OS_ADDR,NR_FUNCTION_RESULT_REG,paraloc1);
         paramanager.freeparaloc(list,paraloc1);
         cg.allocexplicitregisters(list,R_INTREGISTER,paramanager.get_volatile_registers_int(pocall_default));
         cg.a_call_name(list,'FPC_SETJMP');
@@ -1282,9 +1286,11 @@ implementation
               reference_reset_symbol(href,objectlibrary.newasmsymboldata('etext'),0);
               paraloc1:=paramanager.getintparaloc(pocall_default,1);
               paraloc2:=paramanager.getintparaloc(pocall_default,2);
-              cg.a_paramaddr_ref(list,href,paraloc2,false);
+              paramanager.allocparaloc(list,paraloc2);
+              cg.a_paramaddr_ref(list,href,paraloc2);
               reference_reset_symbol(href,objectlibrary.newasmsymboldata('__image_base__'),0);
-              cg.a_paramaddr_ref(list,href,paraloc1,false);
+              paramanager.allocparaloc(list,paraloc1);
+              cg.a_paramaddr_ref(list,href,paraloc1);
               paramanager.freeparaloc(list,paraloc2);
               paramanager.freeparaloc(list,paraloc1);
               cg.allocexplicitregisters(list,R_INTREGISTER,paramanager.get_volatile_registers_int(pocall_cdecl));
@@ -1995,7 +2001,10 @@ implementation
 end.
 {
   $Log$
-  Revision 1.172  2003-12-03 23:13:20  peter
+  Revision 1.173  2003-12-06 01:15:22  florian
+    * reverted Peter's alloctemp patch; hopefully properly
+
+  Revision 1.172  2003/12/03 23:13:20  peter
     * delayed paraloc allocation, a_param_*() gets extra parameter
       if it needs to allocate temp or real paralocation
     * optimized/simplified int-real loading

compiler/paramgr.pas

@@ -83,7 +83,6 @@ unit paramgr;
             @param(loc Parameter location)
           }
           procedure allocparaloc(list: taasmoutput; const loc: tparalocation); virtual;
-          procedure alloctempparaloc(list: taasmoutput;var locpara:tparalocation);virtual;
 
           {# free a parameter location allocated with allocparaloc
 
@@ -113,6 +112,7 @@ unit paramgr;
           { Return the location of the low and high part of a 64bit parameter }
           procedure splitparaloc64(const locpara:tparalocation;var loclopara,lochipara:tparalocation);virtual;
 
+          procedure alloctempregs(list: taasmoutput;var locpara:tparalocation);virtual;
        end;
 
 
@@ -320,39 +320,6 @@ implementation
       end;
 
 
-    procedure tparamanager.alloctempparaloc(list: taasmoutput;var locpara:tparalocation);
-      begin
-        case locpara.loc of
-          LOC_REFERENCE:
-            begin
-              { no temp needed by default }
-            end;
-          LOC_REGISTER:
-            begin
-{$ifndef cpu64bit}
-              if locpara.size in [OS_64,OS_S64] then
-                begin
-                  locpara.registerlow:=cg.getintregister(list,OS_32);
-                  locpara.registerhigh:=cg.getintregister(list,OS_32);
-                end
-              else
-{$endif cpu64bit}
-                locpara.register:=cg.getintregister(list,locpara.size);
-            end;
-          LOC_FPUREGISTER:
-            begin
-              locpara.register:=cg.getfpuregister(list,locpara.size);
-            end;
-          LOC_MMREGISTER:
-            begin
-              locpara.register:=cg.getfpuregister(list,locpara.size);
-            end;
-          else
-            internalerror(200308123);
-        end;
-      end;
-
-
     procedure tparamanager.freeparaloc(list: taasmoutput; const loc: tparalocation);
       begin
         case loc.loc of
@@ -408,6 +375,35 @@ implementation
       end;
 
 
+    procedure tparamanager.alloctempregs(list: taasmoutput;var locpara:tparalocation);
+      begin
+        case locpara.loc of
+          LOC_REGISTER:
+            begin
+{$ifndef cpu64bit}
+              if locpara.size in [OS_64,OS_S64] then
+                begin
+                  locpara.registerlow:=cg.getintregister(list,OS_32);
+                  locpara.registerhigh:=cg.getintregister(list,OS_32);
+                end
+              else
+{$endif cpu64bit}
+                locpara.register:=cg.getintregister(list,locpara.size);
+            end;
+          LOC_FPUREGISTER:
+            begin
+              locpara.register:=cg.getfpuregister(list,locpara.size);
+            end;
+          LOC_MMREGISTER:
+            begin
+              locpara.register:=cg.getfpuregister(list,locpara.size);
+            end;
+          else
+            internalerror(200308123);
+        end;
+      end;
+
+
     function tparamanager.create_inline_paraloc_info(p : tabstractprocdef):longint;
       var
         hp : tparaitem;
@@ -454,7 +450,10 @@ end.
 
 {
    $Log$
-   Revision 1.66  2003-12-03 23:13:20  peter
+   Revision 1.67  2003-12-06 01:15:22  florian
+     * reverted Peter's alloctemp patch; hopefully properly
+
+   Revision 1.66  2003/12/03 23:13:20  peter
      * delayed paraloc allocation, a_param_*() gets extra parameter
        if it needs to allocate temp or real paralocation
      * optimized/simplified int-real loading

compiler/pp.pas

@@ -133,9 +133,6 @@ uses
   {$ifdef profile}
     profile,
   {$endif profile}
-  {$ifdef heaptrc}
-    ppheap,
-  {$endif heaptrc}
   {$ifdef EXTDEBUG}
     checkmem,
   {$endif EXTDEBUG}
@@ -193,6 +190,9 @@ end;
 begin
   oldexit:=exitproc;
   exitproc:=@myexit;
+{$ifdef extheaptrc}
+  keepreleased:=true;
+{$endif extheaptrc}
   SetFPUExceptionMask([exInvalidOp, exDenormalized, exZeroDivide,
                         exOverflow, exUnderflow, exPrecision]);
 { Call the compiler with empty command, so it will take the parameters }
@@ -200,7 +200,10 @@ begin
 end.
 {
   $Log$
-  Revision 1.27  2003-09-06 16:47:24  florian
+  Revision 1.28  2003-12-06 01:15:22  florian
+    * reverted Peter's alloctemp patch; hopefully properly
+
+  Revision 1.27  2003/09/06 16:47:24  florian
     + support of NaN and Inf in the compiler as values of real constants
 
   Revision 1.26  2003/09/05 17:41:12  florian

compiler/x86/cgx86.pas

@@ -62,10 +62,10 @@ unit cgx86;
         { left to right), this allows to move the parameter to    }
         { register, if the cpu supports register calling          }
         { conventions                                             }
-        procedure a_param_reg(list : taasmoutput;size : tcgsize;r : tregister;var locpara : tparalocation;alloctemp:boolean);override;
-        procedure a_param_const(list : taasmoutput;size : tcgsize;a : aword;var locpara : tparalocation;alloctemp:boolean);override;
-        procedure a_param_ref(list : taasmoutput;size : tcgsize;const r : treference;var locpara : tparalocation;alloctemp:boolean);override;
-        procedure a_paramaddr_ref(list : taasmoutput;const r : treference;var locpara : tparalocation;alloctemp:boolean);override;
+        procedure a_param_reg(list : taasmoutput;size : tcgsize;r : tregister;const locpara : tparalocation);override;
+        procedure a_param_const(list : taasmoutput;size : tcgsize;a : aword;const locpara : tparalocation);override;
+        procedure a_param_ref(list : taasmoutput;size : tcgsize;const r : treference;const locpara : tparalocation);override;
+        procedure a_paramaddr_ref(list : taasmoutput;const r : treference;const locpara : tparalocation);override;
 
         procedure a_call_name(list : taasmoutput;const s : string);override;
         procedure a_call_reg(list : taasmoutput;reg : tregister);override;
@@ -488,7 +488,7 @@ unit cgx86;
     { we implement the following routines because otherwise we can't }
     { instantiate the class since it's abstract                      }
 
-    procedure tcgx86.a_param_reg(list : taasmoutput;size : tcgsize;r : tregister;var locpara : tparalocation;alloctemp:boolean);
+    procedure tcgx86.a_param_reg(list : taasmoutput;size : tcgsize;r : tregister;const locpara : tparalocation);
       begin
         check_register_size(size,r);
         if (locpara.loc=LOC_REFERENCE) and
@@ -514,11 +514,11 @@ unit cgx86;
             end;
           end
         else
-          inherited a_param_reg(list,size,r,locpara,alloctemp);
+          inherited a_param_reg(list,size,r,locpara);
       end;
 
 
-    procedure tcgx86.a_param_const(list : taasmoutput;size : tcgsize;a : aword;var locpara : tparalocation;alloctemp:boolean);
+    procedure tcgx86.a_param_const(list : taasmoutput;size : tcgsize;a : aword;const locpara : tparalocation);
 
       begin
         if (locpara.loc=LOC_REFERENCE) and
@@ -539,11 +539,11 @@ unit cgx86;
             end;
           end
         else
-          inherited a_param_const(list,size,a,locpara,alloctemp);
+          inherited a_param_const(list,size,a,locpara);
       end;
 
 
-    procedure tcgx86.a_param_ref(list : taasmoutput;size : tcgsize;const r : treference;var locpara : tparalocation;alloctemp:boolean);
+    procedure tcgx86.a_param_ref(list : taasmoutput;size : tcgsize;const r : treference;const locpara : tparalocation);
 
       var
         pushsize : tcgsize;
@@ -577,11 +577,11 @@ unit cgx86;
             end;
           end
         else
-          inherited a_param_ref(list,size,r,locpara,alloctemp);
+          inherited a_param_ref(list,size,r,locpara);
       end;
 
 
-    procedure tcgx86.a_paramaddr_ref(list : taasmoutput;const r : treference;var locpara : tparalocation;alloctemp:boolean);
+    procedure tcgx86.a_paramaddr_ref(list : taasmoutput;const r : treference;const locpara : tparalocation);
       var
         tmpreg : tregister;
       begin
@@ -612,7 +612,7 @@ unit cgx86;
               end;
           end
         else
-          inherited a_paramaddr_ref(list,r,locpara,alloctemp);
+          inherited a_paramaddr_ref(list,r,locpara);
       end;
 
 
@@ -1751,7 +1751,10 @@ unit cgx86;
 end.
 {
   $Log$
-  Revision 1.88  2003-12-03 23:13:20  peter
+  Revision 1.89  2003-12-06 01:15:23  florian
+    * reverted Peter's alloctemp patch; hopefully properly
+
+  Revision 1.88  2003/12/03 23:13:20  peter
     * delayed paraloc allocation, a_param_*() gets extra parameter
       if it needs to allocate temp or real paralocation
     * optimized/simplified int-real loading