* changed getpointerdef() into a tpointerdef.getreusable() class method

   o allows removing the ugly x86 hacks

git-svn-id: trunk@31144 -

compiler/aarch64/cpupara.pas

@@ -318,7 +318,7 @@ unit cpupara;
                 hp.paraloc[side].size:=OS_ADDR;
                 hp.paraloc[side].alignment:=voidpointertype.alignment;
                 hp.paraloc[side].intsize:=voidpointertype.size;
-                hp.paraloc[side].def:=getpointerdef(hp.vardef);
+                hp.paraloc[side].def:=cpointerdef.getreusable(hp.vardef);
                 with hp.paraloc[side].add_location^ do
                   begin
                     size:=OS_ADDR;
@@ -397,7 +397,7 @@ unit cpupara;
 
         if push_addr_param(varspez,paradef,p.proccalloption) then
           begin
-            paradef:=getpointerdef(paradef);
+            paradef:=cpointerdef.getreusable(paradef);
             loc:=LOC_REGISTER;
             paracgsize:=OS_ADDR;
             paralen:=tcgsize2size[OS_ADDR];

compiler/aasmcnst.pas

@@ -1442,9 +1442,9 @@ implementation
 
    procedure ttai_typedconstbuilder.queue_emit_staticvar(vs: tstaticvarsym);
      begin
-       { getpointerdef because we are emitting a pointer to the staticvarsym
+       { pointerdef because we are emitting a pointer to the staticvarsym
          data, not the data itself }
-       emit_tai(Tai_const.Createname(vs.mangledname,fqueue_offset),getpointerdef(vs.vardef));
+       emit_tai(Tai_const.Createname(vs.mangledname,fqueue_offset),cpointerdef.getreusable(vs.vardef));
        fqueue_offset:=low(fqueue_offset);
      end;
 
@@ -1470,9 +1470,9 @@ implementation
 
    procedure ttai_typedconstbuilder.queue_emit_asmsym(sym: tasmsymbol; def: tdef);
      begin
-       { getpointerdef, because "sym" represents the address of whatever the
+       { pointerdef, because "sym" represents the address of whatever the
          data is }
-       def:=getpointerdef(def);
+       def:=cpointerdef.getreusable(def);
        emit_tai(Tai_const.Create_sym_offset(sym,fqueue_offset),def);
        fqueue_offset:=low(fqueue_offset);
      end;

compiler/arm/cpupara.pas

@@ -92,7 +92,7 @@ unit cpupara;
         psym:=tparavarsym(pd.paras[nr-1]);
         pdef:=psym.vardef;
         if push_addr_param(psym.varspez,pdef,pd.proccalloption) then
-          pdef:=getpointerdef(pdef);
+          pdef:=cpointerdef.getreusable(pdef);
         cgpara.reset;
         cgpara.size:=def_cgsize(pdef);
         cgpara.intsize:=tcgsize2size[cgpara.size];
@@ -379,7 +379,7 @@ unit cpupara;
 
             if push_addr_param(hp.varspez,paradef,p.proccalloption) then
               begin
-                paradef:=getpointerdef(paradef);
+                paradef:=cpointerdef.getreusable(paradef);
                 loc:=LOC_REGISTER;
                 paracgsize := OS_ADDR;
                 paralen := tcgsize2size[OS_ADDR];
@@ -560,7 +560,7 @@ unit cpupara;
                         if push_addr_param(hp.varspez,paradef,p.proccalloption) then
                           begin
                             paraloc^.size:=OS_ADDR;
-                            paraloc^.def:=getpointerdef(paradef);
+                            paraloc^.def:=cpointerdef.getreusable(paradef);
                             assignintreg
                           end
                         else

compiler/avr/cpupara.pas

@@ -255,7 +255,7 @@ unit cpupara;
 
             if push_addr_param(hp.varspez,paradef,p.proccalloption) then
               begin
-                paradef:=getpointerdef(paradef);
+                paradef:=cpointerdef.getreusable(paradef);
                 loc:=LOC_REGISTER;
                 paracgsize:=OS_ADDR;
                 paralen:=tcgsize2size[OS_ADDR];
@@ -353,7 +353,7 @@ unit cpupara;
                         if push_addr_param(hp.varspez,paradef,p.proccalloption) then
                           begin
                             paraloc^.size:=OS_ADDR;
-                            paraloc^.def:=getpointerdef(paradef);
+                            paraloc^.def:=cpointerdef.getreusable(paradef);
                             assignintreg
                           end
                         else

compiler/fmodule.pas

@@ -142,7 +142,7 @@ interface
         checkforwarddefs,
         deflist,
         symlist       : TFPObjectList;
-        ptrdefs       : tPtrDefHashSet; { list of pointerdefs created in this module so we can reuse them (not saved/restored) }
+        ptrdefs       : THashSet; { list of pointerdefs created in this module so we can reuse them (not saved/restored) }
         arraydefs     : THashSet; { list of single-element-arraydefs created in this module so we can reuse them (not saved/restored) }
         procaddrdefs  : THashSet; { list of procvardefs created when getting the address of a procdef (not saved/restored) }
 {$ifdef llvm}
@@ -571,7 +571,7 @@ implementation
         derefdataintflen:=0;
         deflist:=TFPObjectList.Create(false);
         symlist:=TFPObjectList.Create(false);
-        ptrdefs:=cPtrDefHashSet.Create;
+        ptrdefs:=THashSet.Create(64,true,false);
         arraydefs:=THashSet.Create(64,true,false);
         procaddrdefs:=THashSet.Create(64,true,false);
 {$ifdef llvm}
@@ -756,7 +756,7 @@ implementation
         symlist.free;
         symlist:=TFPObjectList.Create(false);
         ptrdefs.free;
-        ptrdefs:=cPtrDefHashSet.Create;
+        ptrdefs:=THashSet.Create(64,true,false);
         arraydefs.free;
         arraydefs:=THashSet.Create(64,true,false);
         procaddrdefs.free;

compiler/hlcgobj.pas

@@ -1601,7 +1601,7 @@ implementation
       href: treference;
     begin
       href:=ref;
-      g_ptrtypecast_ref(list,getpointerdef(fromsize),getpointerdef(u8inttype),href);
+      g_ptrtypecast_ref(list,cpointerdef.getreusable(fromsize),cpointerdef.getreusable(u8inttype),href);
       a_load_subsetref_reg(list,u8inttype,destsize,get_bit_const_ref_sref(bitnumber,fromsize,href),destreg);
     end;
 
@@ -1630,7 +1630,7 @@ implementation
       href: treference;
     begin
       href:=ref;
-      g_ptrtypecast_ref(list,getpointerdef(refsize),getpointerdef(u8inttype),href);
+      g_ptrtypecast_ref(list,cpointerdef.getreusable(refsize),cpointerdef.getreusable(u8inttype),href);
       a_load_subsetref_reg(list,u8inttype,destsize,get_bit_reg_ref_sref(list,bitnumbersize,refsize,bitnumber,href),destreg);
     end;
 
@@ -1718,13 +1718,13 @@ implementation
       href: treference;
     begin
       href:=ref;
-      g_ptrtypecast_ref(list,getpointerdef(destsize),getpointerdef(u8inttype),href);
+      g_ptrtypecast_ref(list,cpointerdef.getreusable(destsize),cpointerdef.getreusable(u8inttype),href);
       a_load_const_subsetref(list,u8inttype,ord(doset),get_bit_const_ref_sref(bitnumber,destsize,href));
     end;
 
   procedure thlcgobj.a_bit_set_const_reg(list: TAsmList; doset: boolean; destsize: tdef; bitnumber: tcgint; destreg: tregister);
     begin
-      g_ptrtypecast_reg(list,getpointerdef(destsize),getpointerdef(u8inttype),destreg);
+      g_ptrtypecast_reg(list,cpointerdef.getreusable(destsize),cpointerdef.getreusable(u8inttype),destreg);
       a_load_const_subsetreg(list,u8inttype,ord(doset),get_bit_const_reg_sreg(destsize,bitnumber,destreg));
     end;
 
@@ -1748,7 +1748,7 @@ implementation
       href: treference;
     begin
       href:=ref;
-      g_ptrtypecast_ref(list,getpointerdef(tosize),getpointerdef(u8inttype),href);
+      g_ptrtypecast_ref(list,cpointerdef.getreusable(tosize),cpointerdef.getreusable(u8inttype),href);
       a_load_const_subsetref(list,u8inttype,ord(doset),get_bit_reg_ref_sref(list,fromsize,tosize,bitnumber,ref));
     end;
 
@@ -2419,7 +2419,7 @@ implementation
       if result.ref.index<>NR_NO then
         begin
           { don't just add to ref.index, as it may be scaled }
-          refptrdef:=getpointerdef(refsize);
+          refptrdef:=cpointerdef.getreusable(refsize);
           newbase:=getaddressregister(list,refptrdef);
           a_loadaddr_ref_reg(list,refsize,refptrdef,ref,newbase);
           reference_reset_base(result.ref,refptrdef,newbase,0,result.ref.alignment);
@@ -2546,7 +2546,7 @@ implementation
               internalerror(2014080603);
             { convert the reference from a floating point location to an
               integer location, and load that }
-            intptrdef:=getpointerdef(cgpara.location^.def);
+            intptrdef:=cpointerdef.getreusable(cgpara.location^.def);
             hreg:=getaddressregister(list,intptrdef);
             a_loadaddr_ref_reg(list,fromsize,intptrdef,ref,hreg);
             reference_reset_base(href,intptrdef,hreg,0,ref.alignment);
@@ -3677,7 +3677,7 @@ implementation
       a_op_const_reg_reg(list,OP_ADD,sinttype,1,lenreg,sizereg);
       a_op_const_reg(list,OP_IMUL,sinttype,arrdef.elesize,sizereg);
       { load source }
-      ptrarrdef:=getpointerdef(arrdef);
+      ptrarrdef:=cpointerdef.getreusable(arrdef);
       sourcereg:=getaddressregister(list,ptrarrdef);
       a_loadaddr_ref_reg(list,arrdef,ptrarrdef,ref,sourcereg);
 
@@ -3740,7 +3740,7 @@ implementation
       cgpara1.init;
       paramanager.getintparaloc(list,pd,1,cgpara1);
       { load source }
-      a_load_loc_cgpara(list,getpointerdef(arrdef),l,cgpara1);
+      a_load_loc_cgpara(list,cpointerdef.getreusable(arrdef),l,cgpara1);
       paramanager.freecgpara(list,cgpara1);
       g_call_system_proc(list,pd,[@cgpara1],nil);
       cgpara1.done;
@@ -4015,14 +4015,14 @@ implementation
             begin
               if not loadref then
                 internalerror(200410231);
-              reference_reset_base(ref,getpointerdef(def),l.register,0,alignment);
+              reference_reset_base(ref,cpointerdef.getreusable(def),l.register,0,alignment);
             end;
           LOC_REFERENCE,
           LOC_CREFERENCE :
             begin
               if loadref then
                 begin
-                  pdef:=getpointerdef(def);
+                  pdef:=cpointerdef.getreusable(def);
                   reference_reset_base(ref,pdef,getaddressregister(list,voidpointertype),0,alignment);
                   { it's a pointer to def }
                   a_load_ref_reg(list,pdef,pdef,l.reference,ref.base);
@@ -5180,7 +5180,7 @@ implementation
           retdef:=ressym.vardef;
           { and TP-style constructors return a pointer to self }
           if is_object(ressym.vardef) then
-            retdef:=getpointerdef(retdef);
+            retdef:=cpointerdef.getreusable(retdef);
         end
       else
         begin

compiler/i386/cpupara.pas

@@ -422,7 +422,7 @@ unit cpupara;
               begin
                 paralen:=sizeof(aint);
                 paracgsize:=OS_ADDR;
-                paradef:=getpointerdef(paradef);
+                paradef:=cpointerdef.getreusable(paradef);
               end
             else
               begin
@@ -574,7 +574,7 @@ unit cpupara;
                       begin
                         paralen:=sizeof(aint);
                         paracgsize:=OS_ADDR;
-                        paradef:=getpointerdef(paradef);
+                        paradef:=cpointerdef.getreusable(paradef);
                       end
                     else
                       begin

compiler/i386/symcpu.pas

@@ -267,7 +267,5 @@ begin
   cconstsym:=tcpuconstsym;
   cenumsym:=tcpuenumsym;
   csyssym:=tcpusyssym;
-
-  cPtrDefHashSet:=tx86PtrDefHashSet;
 end.
 

compiler/i8086/cpupara.pas

@@ -236,7 +236,7 @@ unit cpupara;
         psym:=tparavarsym(pd.paras[nr-1]);
         pdef:=psym.vardef;
         if push_addr_param(psym.varspez,pdef,pd.proccalloption) then
-          pdef:=getpointerdef(pdef);
+          pdef:=cpointerdef.getreusable(pdef);
         cgpara.reset;
         cgpara.size:=def_cgsize(pdef);
         cgpara.intsize:=tcgsize2size[cgpara.size];
@@ -442,7 +442,7 @@ unit cpupara;
               begin
                 paralen:=voidpointertype.size;
                 paracgsize:=int_cgsize(voidpointertype.size);
-                paradef:=getpointerdef(paradef);
+                paradef:=cpointerdef.getreusable(paradef);
               end
             else
               begin
@@ -602,7 +602,7 @@ unit cpupara;
                       begin
                         paralen:=voidpointertype.size;
                         paracgsize:=int_cgsize(voidpointertype.size);
-                        paradef:=getpointerdef(paradef);
+                        paradef:=cpointerdef.getreusable(paradef);
                       end
                     else
                       begin

compiler/i8086/n8086mem.pas

@@ -199,7 +199,7 @@ implementation
             result:=ccallnode.createintern(procname,
               ccallparanode.create(right,
               ccallparanode.create(ttypeconvnode(left).left,nil)));
-            inserttypeconv_internal(result,getx86pointerdef(arraydef.elementdef,x86pt_huge));
+            inserttypeconv_internal(result,tx86pointerdef(cpointerdef).getreusablex86(arraydef.elementdef,x86pt_huge));
             result:=cderefnode.create(result);
 
             ttypeconvnode(left).left:=nil;

compiler/i8086/symcpu.pas

@@ -510,7 +510,5 @@ begin
   cconstsym:=tcpuconstsym;
   cenumsym:=tcpuenumsym;
   csyssym:=tcpusyssym;
-
-  cPtrDefHashSet:=tx86PtrDefHashSet;
 end.
 

compiler/jvm/cpupara.pas

@@ -160,7 +160,7 @@ implementation
         else if jvmimplicitpointertype(result.def) then
           begin
             retcgsize:=OS_ADDR;
-            result.def:=getpointerdef(result.def);
+            result.def:=cpointerdef.getreusable(result.def);
           end
         else
           begin
@@ -237,7 +237,7 @@ implementation
             else if jvmimplicitpointertype(hp.vardef) then
               begin
                 paracgsize:=OS_ADDR;
-                paradef:=getpointerdef(hp.vardef);
+                paradef:=cpointerdef.getreusable(hp.vardef);
               end
             else
               begin

compiler/jvm/njvmadd.pas

@@ -324,7 +324,7 @@ interface
           evaluation }
         if not is_boolean(resultdef) then
           begin
-            inserttypeconv_explicit(result,getpointerdef(resultdef));
+            inserttypeconv_explicit(result,cpointerdef.getreusable(resultdef));
             result:=cderefnode.create(result);
           end;
         { left and right are reused as parameters }

compiler/jvm/njvmcal.pas

@@ -225,7 +225,7 @@ implementation
         if parasym.vardef.typ=formaldef then
           arreledef:=java_jlobject
         else if implicitptrpara then
-          arreledef:=getpointerdef(orgparadef)
+          arreledef:=cpointerdef.getreusable(orgparadef)
         else
           arreledef:=parasym.vardef;
         arrdef:=getarraydef(arreledef,1+ord(cs_check_var_copyout in current_settings.localswitches));
@@ -309,7 +309,7 @@ implementation
                   tempn:=cinlinenode.create(in_unbox_x_y,false,ccallparanode.create(
                     ctypenode.create(orgparadef),ccallparanode.create(tempn,nil)))
                 else if implicitptrpara then
-                  tempn:=ctypeconvnode.create_explicit(tempn,getpointerdef(orgparadef))
+                  tempn:=ctypeconvnode.create_explicit(tempn,cpointerdef.getreusable(orgparadef))
               end;
             if implicitptrpara then
               tempn:=cderefnode.create(tempn)

compiler/jvm/njvmcnv.pas

@@ -368,7 +368,7 @@ implementation
                       genintconstnode(tsetdef(left.resultdef).setbase),
                         ccallparanode.create(left,nil))));
               end;
-            inserttypeconv_explicit(result,getpointerdef(resultdef));
+            inserttypeconv_explicit(result,cpointerdef.getreusable(resultdef));
             result:=cderefnode.create(result);
             { reused }
             left:=nil;
@@ -387,7 +387,7 @@ implementation
         result:=ccallnode.createinternmethod(
           cloadvmtaddrnode.create(ctypenode.create(tcpuprocvardef(resultdef).classdef)),'CREATE',nil);
         { method pointer is an implicit pointer type }
-        result:=ctypeconvnode.create_explicit(result,getpointerdef(resultdef));
+        result:=ctypeconvnode.create_explicit(result,cpointerdef.getreusable(resultdef));
         result:=cderefnode.create(result);
       end;
 
@@ -494,7 +494,7 @@ implementation
           result:=ctypeconvnode.create_explicit(result,resultdef)
         else
           begin
-            result:=ctypeconvnode.create_explicit(result,getpointerdef(resultdef));
+            result:=ctypeconvnode.create_explicit(result,cpointerdef.getreusable(resultdef));
             result:=cderefnode.create(result)
           end;
         { reused }
@@ -1263,7 +1263,7 @@ implementation
                   a proper checkcast is inserted }
                 if not check_only then
                   begin
-                    resnode:=ctypeconvnode.create_explicit(left,getpointerdef(resultdef));
+                    resnode:=ctypeconvnode.create_explicit(left,cpointerdef.getreusable(resultdef));
                     resnode:=cderefnode.create(resnode);
                     left:=nil;
                   end;
@@ -1385,7 +1385,7 @@ implementation
                   begin
                     resnode:=to_set_explicit_typecast;
                     { convert to desired result }
-                    inserttypeconv_explicit(resnode,getpointerdef(resultdef));
+                    inserttypeconv_explicit(resnode,cpointerdef.getreusable(resultdef));
                     resnode:=cderefnode.create(resnode);
                   end;
                 result:=true;

compiler/jvm/njvmcon.pas

@@ -391,7 +391,7 @@ implementation
                 begin
                   result:=buildbitset;
                 end;
-              inserttypeconv_explicit(result,getpointerdef(resultdef));
+              inserttypeconv_explicit(result,cpointerdef.getreusable(resultdef));
               result:=cderefnode.create(result);
             end;
           else

compiler/jvm/njvmld.pas

@@ -221,7 +221,7 @@ function tjvmloadnode.handle_threadvar_access: tnode;
       end
     else
       begin
-        result:=ctypeconvnode.create_explicit(result,getpointerdef(resultdef));
+        result:=ctypeconvnode.create_explicit(result,cpointerdef.getreusable(resultdef));
         result:=cderefnode.create(result);
       end;
   end;

compiler/llvm/hlcgllvm.pas

@@ -207,9 +207,9 @@ implementation
               { llvmparadef is a record in this case, with every field corresponding
                 to a single paraloc }
               paraloctoloc(location,hloc);
-              tmpreg:=getaddressregister(list,getpointerdef(location^.def));
-              list.concat(taillvm.getelementptr_reg_size_ref_size_const(tmpreg,getpointerdef(size),initialref,s32inttype,paralocidx,true));
-              reference_reset_base(tmpref,getpointerdef(location^.def),tmpreg,0,newalignment(initialref.alignment,totaloffset));
+              tmpreg:=getaddressregister(list,cpointerdef.getreusable(location^.def));
+              list.concat(taillvm.getelementptr_reg_size_ref_size_const(tmpreg,cpointerdef.getreusable(size),initialref,s32inttype,paralocidx,true));
+              reference_reset_base(tmpref,cpointerdef.getreusable(location^.def),tmpreg,0,newalignment(initialref.alignment,totaloffset));
             end
           else
             tmpref:=initialref;
@@ -238,7 +238,7 @@ implementation
               begin
                  if assigned(location^.next) then
                    internalerror(2010052906);
-                 reference_reset_base(ref,getpointerdef(size),location^.reference.index,location^.reference.offset,newalignment(cgpara.alignment,cgpara.intsize-sizeleft));
+                 reference_reset_base(ref,cpointerdef.getreusable(size),location^.reference.index,location^.reference.offset,newalignment(cgpara.alignment,cgpara.intsize-sizeleft));
                  if (def_cgsize(size)<>OS_NO) and
                     (size.size=sizeleft) and
                     (sizeleft<=sizeof(aint)) then
@@ -281,9 +281,9 @@ implementation
       newrefsize:=llvmgetcgparadef(para,true);
       if refsize<>newrefsize then
         begin
-          reg:=getaddressregister(list,getpointerdef(newrefsize));
-          a_loadaddr_ref_reg(list,refsize,getpointerdef(newrefsize),initialref,reg);
-          reference_reset_base(newref,getpointerdef(newrefsize),reg,0,initialref.alignment);
+          reg:=getaddressregister(list,cpointerdef.getreusable(newrefsize));
+          a_loadaddr_ref_reg(list,refsize,cpointerdef.getreusable(newrefsize),initialref,reg);
+          reference_reset_base(newref,cpointerdef.getreusable(newrefsize),reg,0,initialref.alignment);
           refsize:=newrefsize;
         end
       else
@@ -375,7 +375,7 @@ implementation
                     internalerror(2014012307)
                   else
                     begin
-                      reference_reset_base(href, getpointerdef(callpara^.def), paraloc^.reference.index, paraloc^.reference.offset, paraloc^.def.alignment);
+                      reference_reset_base(href, cpointerdef.getreusable(callpara^.def), paraloc^.reference.index, paraloc^.reference.offset, paraloc^.def.alignment);
                       res:=getregisterfordef(list, paraloc^.def);
                       load_ref_anyreg(callpara^.def, href, res, callpara);
                     end;
@@ -488,7 +488,7 @@ implementation
          is_64bit(tosize) then
         begin
           sref:=make_simple_ref(list,ref,tosize);
-          list.concat(taillvm.op_size_const_size_ref(la_store,tosize,a,getpointerdef(tosize),sref))
+          list.concat(taillvm.op_size_const_size_ref(la_store,tosize,a,cpointerdef.getreusable(tosize),sref))
         end
       else
         inherited;
@@ -538,9 +538,9 @@ implementation
                   tg.gethltemp(list,fromsize,fromsize.size,tt_normal,tmpref);
                   a_load_reg_ref(list,fromsize,fromsize,register,tmpref);
                   { typecast pointer to memory into pointer to integer type }
-                  hreg:=getaddressregister(list,getpointerdef(tmpsize));
-                  a_loadaddr_ref_reg(list,fromsize,getpointerdef(tmpsize),tmpref,hreg);
-                  reference_reset_base(sref,getpointerdef(tmpsize),hreg,0,tmpref.alignment);
+                  hreg:=getaddressregister(list,cpointerdef.getreusable(tmpsize));
+                  a_loadaddr_ref_reg(list,fromsize,cpointerdef.getreusable(tmpsize),tmpref,hreg);
+                  reference_reset_base(sref,cpointerdef.getreusable(tmpsize),hreg,0,tmpref.alignment);
                   { load the integer from the temp into the destination }
                   a_load_ref_ref(list,tmpsize,tosize,tmpref,sref);
                   tg.ungettemp(list,tmpref);
@@ -560,9 +560,9 @@ implementation
             end
           else
             begin
-              hreg2:=getaddressregister(list,getpointerdef(fromsize));
-              a_loadaddr_ref_reg(list,tosize,getpointerdef(fromsize),sref,hreg2);
-              reference_reset_base(sref,getpointerdef(fromsize),hreg2,0,sref.alignment);
+              hreg2:=getaddressregister(list,cpointerdef.getreusable(fromsize));
+              a_loadaddr_ref_reg(list,tosize,cpointerdef.getreusable(fromsize),sref,hreg2);
+              reference_reset_base(sref,cpointerdef.getreusable(fromsize),hreg2,0,sref.alignment);
               tosize:=fromsize;
             end;
         end
@@ -571,7 +571,7 @@ implementation
           hreg:=getregisterfordef(list,tosize);
           a_load_reg_reg(list,fromsize,tosize,register,hreg);
         end;
-      list.concat(taillvm.op_size_reg_size_ref(la_store,tosize,hreg,getpointerdef(tosize),sref));
+      list.concat(taillvm.op_size_reg_size_ref(la_store,tosize,hreg,cpointerdef.getreusable(tosize),sref));
     end;
 
 
@@ -628,7 +628,7 @@ implementation
              (fromsize<>tosize) then
             begin
               tg.gethltemp(list,fromsize,fromsize.size,tt_normal,tmpref);
-              list.concat(taillvm.op_size_ref_size_ref(la_store,fromsize,sref,getpointerdef(fromsize),tmpref));
+              list.concat(taillvm.op_size_ref_size_ref(la_store,fromsize,sref,cpointerdef.getreusable(fromsize),tmpref));
               a_load_ref_reg(list,fromsize,tosize,tmpref,register);
               tg.ungettemp(list,tmpref);
             end
@@ -651,9 +651,9 @@ implementation
                       { typecast the pointer to the struct into a pointer to an
                         integer of equal size }
                       tmpsize:=def2intdef(fromsize,tosize);
-                      hreg:=getaddressregister(list,getpointerdef(tmpsize));
-                      a_loadaddr_ref_reg(list,fromsize,getpointerdef(tmpsize),sref,hreg);
-                      reference_reset_base(sref,getpointerdef(tmpsize),hreg,0,sref.alignment);
+                      hreg:=getaddressregister(list,cpointerdef.getreusable(tmpsize));
+                      a_loadaddr_ref_reg(list,fromsize,cpointerdef.getreusable(tmpsize),sref,hreg);
+                      reference_reset_base(sref,cpointerdef.getreusable(tmpsize),hreg,0,sref.alignment);
                       { load that integer }
                       a_load_ref_reg(list,tmpsize,tosize,sref,register);
                     end
@@ -681,16 +681,16 @@ implementation
                      itself if they have the same size but are of different
                      kinds, because we can't e.g. typecast a loaded <{i32, i32}>
                      to an i64 *)
-                  hreg:=getaddressregister(list,getpointerdef(tosize));
-                  a_loadaddr_ref_reg(list,fromsize,getpointerdef(tosize),sref,hreg);
-                  reference_reset_base(sref,getpointerdef(tosize),hreg,0,sref.alignment);
+                  hreg:=getaddressregister(list,cpointerdef.getreusable(tosize));
+                  a_loadaddr_ref_reg(list,fromsize,cpointerdef.getreusable(tosize),sref,hreg);
+                  reference_reset_base(sref,cpointerdef.getreusable(tosize),hreg,0,sref.alignment);
                   fromsize:=tosize;
                 end;
             end;
           hreg:=register;
           if fromsize<>tosize then
             hreg:=getregisterfordef(list,fromsize);
-          list.concat(taillvm.op_reg_size_ref(la_load,hreg,getpointerdef(fromsize),sref));
+          list.concat(taillvm.op_reg_size_ref(la_load,hreg,cpointerdef.getreusable(fromsize),sref));
           if hreg<>register then
             a_load_reg_reg(list,fromsize,tosize,hreg,register);
         end;
@@ -705,7 +705,7 @@ implementation
          (sref.refaddr=addr_full) then
         begin
           sdref:=make_simple_ref(list,dref,tosize);
-          list.concat(taillvm.op_size_ref_size_ref(la_store,fromsize,sref,getpointerdef(tosize),sdref));
+          list.concat(taillvm.op_size_ref_size_ref(la_store,fromsize,sref,cpointerdef.getreusable(tosize),sdref));
         end
       else
         inherited
@@ -720,7 +720,7 @@ implementation
       if ref.refaddr=addr_full then
         internalerror(2013102306);
       sref:=make_simple_ref(list,ref,fromsize);
-      list.concat(taillvm.op_reg_size_ref_size(la_bitcast,r,getpointerdef(fromsize),sref,tosize));
+      list.concat(taillvm.op_reg_size_ref_size(la_bitcast,r,cpointerdef.getreusable(fromsize),sref,tosize));
     end;
 
 
@@ -952,7 +952,7 @@ implementation
        else
          tmpreg:=reg;
        { %tmpreg = load size* %ref }
-       list.concat(taillvm.op_reg_size_ref(la_load,tmpreg,getpointerdef(fromsize),href));
+       list.concat(taillvm.op_reg_size_ref(la_load,tmpreg,cpointerdef.getreusable(fromsize),href));
        if tmpreg<>reg then
          if fromcompcurr then
            { treat as extended as long as it's in a register }
@@ -989,7 +989,7 @@ implementation
        else
          tmpreg:=reg;
        { store tosize tmpreg, tosize* href }
-       list.concat(taillvm.op_size_reg_size_ref(la_store,tosize,tmpreg,getpointerdef(tosize),href));
+       list.concat(taillvm.op_size_reg_size_ref(la_store,tosize,tmpreg,cpointerdef.getreusable(tosize),href));
      end;
 
 
@@ -1201,7 +1201,7 @@ implementation
             internalerror(2013060220);
           href:=make_simple_ref(list,ref,fromsize);
           { %reg = load size* %ref }
-          list.concat(taillvm.op_reg_size_ref(la_load,reg,getpointerdef(fromsize),href));
+          list.concat(taillvm.op_reg_size_ref(la_load,reg,cpointerdef.getreusable(fromsize),href));
         end;
     end;
 
@@ -1219,7 +1219,7 @@ implementation
             internalerror(2013060220);
           href:=make_simple_ref(list,ref,tosize);
           { store tosize reg, tosize* href }
-          list.concat(taillvm.op_size_reg_size_ref(la_store,tosize,reg,getpointerdef(tosize),href))
+          list.concat(taillvm.op_size_reg_size_ref(la_store,tosize,reg,cpointerdef.getreusable(tosize),href))
         end;
     end;
 
@@ -1365,18 +1365,18 @@ implementation
             tg.gethltemp(list,llvmparadef,llvmparadef.size,tt_normal,href)
           else
             begin
-              hreg:=getaddressregister(list,getpointerdef(llvmparadef));
-              a_loadaddr_ref_reg(list,vardef,getpointerdef(llvmparadef),destloc.reference,hreg);
-              reference_reset_base(href,getpointerdef(llvmparadef),hreg,0,destloc.reference.alignment);
+              hreg:=getaddressregister(list,cpointerdef.getreusable(llvmparadef));
+              a_loadaddr_ref_reg(list,vardef,cpointerdef.getreusable(llvmparadef),destloc.reference,hreg);
+              reference_reset_base(href,cpointerdef.getreusable(llvmparadef),hreg,0,destloc.reference.alignment);
             end;
           index:=0;
           offset:=0;
           ploc:=para.location;
           repeat
             paraloctoloc(ploc,hloc);
-            hreg:=getaddressregister(list,getpointerdef(ploc^.def));
-            list.concat(taillvm.getelementptr_reg_size_ref_size_const(hreg,getpointerdef(llvmparadef),href,s32inttype,index,true));
-            reference_reset_base(href2,getpointerdef(ploc^.def),hreg,0,newalignment(href.alignment,offset));
+            hreg:=getaddressregister(list,cpointerdef.getreusable(ploc^.def));
+            list.concat(taillvm.getelementptr_reg_size_ref_size_const(hreg,cpointerdef.getreusable(llvmparadef),href,s32inttype,index,true));
+            reference_reset_base(href2,cpointerdef.getreusable(ploc^.def),hreg,0,newalignment(href.alignment,offset));
             a_load_loc_ref(list,ploc^.def,ploc^.def,hloc,href2);
             inc(offset,ploc^.def.size);
             inc(index);
@@ -1490,7 +1490,7 @@ implementation
           exit;
         end;
 
-      hreg2:=getaddressregister(list,getpointerdef(def));
+      hreg2:=getaddressregister(list,cpointerdef.getreusable(def));
       defsize:=def.size;
       { for voiddef/formaldef }
       if defsize=0 then
@@ -1504,9 +1504,9 @@ implementation
           if assigned(ref.symbol) then
             reference_reset_symbol(tmpref,ref.symbol,0,ref.alignment)
           else
-            reference_reset_base(tmpref,getpointerdef(def),ref.base,0,ref.alignment);
-          list.concat(taillvm.getelementptr_reg_size_ref_size_const(hreg2,getpointerdef(def),tmpref,ptruinttype,ptrindex,assigned(ref.symbol)));
-          reference_reset_base(result,getpointerdef(def),hreg2,0,ref.alignment);
+            reference_reset_base(tmpref,cpointerdef.getreusable(def),ref.base,0,ref.alignment);
+          list.concat(taillvm.getelementptr_reg_size_ref_size_const(hreg2,cpointerdef.getreusable(def),tmpref,ptruinttype,ptrindex,assigned(ref.symbol)));
+          reference_reset_base(result,cpointerdef.getreusable(def),hreg2,0,ref.alignment);
           exit;
         end;
       { for now, perform all calculations using plain pointer arithmetic. Later
@@ -1522,11 +1522,11 @@ implementation
           if ref.base<>NR_NO then
             internalerror(2012111301);
           reference_reset_symbol(tmpref,ref.symbol,0,ref.alignment);
-          list.concat(taillvm.getelementptr_reg_size_ref_size_const(hreg1,getpointerdef(def),tmpref,ptruinttype,0,true));
+          list.concat(taillvm.getelementptr_reg_size_ref_size_const(hreg1,cpointerdef.getreusable(def),tmpref,ptruinttype,0,true));
         end
       else if ref.base<>NR_NO then
         begin
-          a_load_reg_reg(list,getpointerdef(def),ptruinttype,ref.base,hreg1);
+          a_load_reg_reg(list,cpointerdef.getreusable(def),ptruinttype,ref.base,hreg1);
         end
       else
         { todo: support for absolute addresses on embedded platforms }
@@ -1544,9 +1544,9 @@ implementation
           a_op_const_reg_reg(list,OP_ADD,ptruinttype,ref.offset,hreg1,hreg2);
           hreg1:=hreg2;
         end;
-      hreg2:=getaddressregister(list,getpointerdef(def));
-      a_load_reg_reg(list,ptruinttype,getpointerdef(def),hreg1,hreg2);
-      reference_reset_base(result,getpointerdef(def),hreg2,0,ref.alignment);
+      hreg2:=getaddressregister(list,cpointerdef.getreusable(def));
+      a_load_reg_reg(list,ptruinttype,cpointerdef.getreusable(def),hreg1,hreg2);
+      reference_reset_base(result,cpointerdef.getreusable(def),hreg2,0,ref.alignment);
     end;
 
 

compiler/llvm/llvmpara.pas

@@ -140,7 +140,7 @@ unit llvmpara;
                 a pointer to the value that it should place on the stack (or
                 passed in registers, in some cases) }
               paraloc^.llvmvalueloc:=false;
-              paraloc^.def:=getpointerdef(paraloc^.def);
+              paraloc^.def:=cpointerdef.getreusable(paraloc^.def);
               paraloc^.size:=def_cgsize(paraloc^.def);
               paraloc^.loc:=LOC_REGISTER;
               paraloc^.register:=hlcg.getaddressregister(list,paraloc^.def);

compiler/llvm/llvmtype.pas

@@ -263,11 +263,11 @@ implementation
                   begin
                     if symdef.typ=procdef then
                       { ugly, but can't use getcopyas(procvardef) due to the
-                        symtablestack not being available here (getpointerdef
+                        symtablestack not being available here (cpointerdef.getreusable
                         is hardcoded to put things in the current module's
                         symtable) and "pointer to procedure" results in the
                         correct llvm type }
-                      symdef:=getpointerdef(tprocdef(symdef));
+                      symdef:=cpointerdef.getreusable(tprocdef(symdef));
                     cnv:=taillvm.op_reg_size_sym_size(la_bitcast,NR_NO,symdef,p.oper[3]^.ref^.symbol,p.oper[0]^.def);
                     p.loadtai(3,cnv);
                   end;
@@ -317,7 +317,7 @@ implementation
                         refer to the data itself, just like you can't initialise
                         a Pascal (typed) constant with the contents of another
                         typed constant) }
-                      symdef:=getpointerdef(symdef);
+                      symdef:=cpointerdef.getreusable(symdef);
                       if not equal_llvm_defs(symdef,p.def) then
                         begin
                           cnv:=taillvm.op_reg_tai_size(la_bitcast,NR_NO,tai_simpletypedconst.create(tck_simple,symdef,tai_simpletypedconst(p).val),p.def);

compiler/llvm/nllvmcnv.pas

@@ -100,9 +100,9 @@ procedure tllvmtypeconvnode.second_int_to_int;
     else if left.resultdef<>resultdef then
       begin
         { just typecast the pointer type }
-        hreg:=hlcg.getaddressregister(current_asmdata.CurrAsmList,getpointerdef(resultdef));
-        hlcg.a_loadaddr_ref_reg(current_asmdata.CurrAsmList,left.resultdef,getpointerdef(resultdef),left.location.reference,hreg);
-        hlcg.reference_reset_base(location.reference,getpointerdef(resultdef),hreg,0,location.reference.alignment);
+        hreg:=hlcg.getaddressregister(current_asmdata.CurrAsmList,cpointerdef.getreusable(resultdef));
+        hlcg.a_loadaddr_ref_reg(current_asmdata.CurrAsmList,left.resultdef,cpointerdef.getreusable(resultdef),left.location.reference,hreg);
+        hlcg.reference_reset_base(location.reference,cpointerdef.getreusable(resultdef),hreg,0,location.reference.alignment);
       end;
   end;
 
@@ -113,8 +113,8 @@ procedure tllvmtypeconvnode.second_pointer_to_array;
   begin
     inherited;
     { insert type conversion }
-    hreg:=hlcg.getaddressregister(current_asmdata.CurrAsmList,getpointerdef(resultdef));
-    hlcg.a_loadaddr_ref_reg(current_asmdata.CurrAsmList,tpointerdef(left.resultdef).pointeddef,getpointerdef(resultdef),location.reference,hreg);
+    hreg:=hlcg.getaddressregister(current_asmdata.CurrAsmList,cpointerdef.getreusable(resultdef));
+    hlcg.a_loadaddr_ref_reg(current_asmdata.CurrAsmList,tpointerdef(left.resultdef).pointeddef,cpointerdef.getreusable(resultdef),location.reference,hreg);
     reference_reset_base(location.reference,hreg,0,location.reference.alignment);
   end;
 
@@ -152,7 +152,7 @@ procedure tllvmtypeconvnode.second_bool_to_int;
       case location.loc of
         LOC_REFERENCE,LOC_CREFERENCE:
           begin
-            pdef:=getpointerdef(resultdef);
+            pdef:=cpointerdef.getreusable(resultdef);
             hreg:=hlcg.getaddressregister(current_asmdata.CurrAsmList,pdef);
             hlcg.a_loadaddr_ref_reg(current_asmdata.CurrAsmList,left.resultdef,pdef,location.reference,hreg);
             hlcg.reference_reset_base(location.reference,pdef,hreg,0,location.reference.alignment);
@@ -221,8 +221,8 @@ procedure tllvmtypeconvnode.second_nothing;
           (left.resultdef.size<>resultdef.size) then
           internalerror(2014012216);
         hlcg.location_force_mem(current_asmdata.CurrAsmList,left.location,left.resultdef);
-        hreg:=hlcg.getaddressregister(current_asmdata.CurrAsmList,getpointerdef(resultdef));
-        hlcg.a_loadaddr_ref_reg(current_asmdata.CurrAsmList,left.resultdef,getpointerdef(resultdef),left.location.reference,hreg);
+        hreg:=hlcg.getaddressregister(current_asmdata.CurrAsmList,cpointerdef.getreusable(resultdef));
+        hlcg.a_loadaddr_ref_reg(current_asmdata.CurrAsmList,left.resultdef,cpointerdef.getreusable(resultdef),left.location.reference,hreg);
         location_reset_ref(location,left.location.loc,left.location.size,left.location.reference.alignment);
         reference_reset_base(location.reference,hreg,0,location.reference.alignment);
       end

compiler/llvm/nllvmcon.pas

@@ -83,7 +83,7 @@ implementation
                 internalerror(2014071203);
             end;
             { get address of array as pchar }
-            resptrdef:=getpointerdef(resultdef);
+            resptrdef:=cpointerdef.getreusable(resultdef);
             hreg:=hlcg.getaddressregister(current_asmdata.CurrAsmList,resptrdef);
             hlcg.a_loadaddr_ref_reg(current_asmdata.CurrAsmList,datadef,resptrdef,location.reference,hreg);
             hlcg.reference_reset_base(location.reference,resptrdef,hreg,0,location.reference.alignment);
@@ -126,7 +126,7 @@ implementation
         if llvmfield.fieldoffset<>field.fieldoffset then
           internalerror(2015061001);
         { pointerdef to the string data array }
-        dataptrdef:=getpointerdef(field.vardef);
+        dataptrdef:=cpointerdef.getreusable(field.vardef);
         { load the address of the string data }
         reg:=hlcg.getaddressregister(current_asmdata.CurrAsmList,dataptrdef);
         reference_reset_symbol(href, lab_str, 0, const_align(strpointerdef.size));

compiler/llvm/nllvminl.pas

@@ -59,9 +59,9 @@ implementation
               internalerror(2014080806);
            { typecast the shortstring reference into a length byte reference }
            location_reset_ref(location,left.location.loc,def_cgsize(resultdef),left.location.reference.alignment);
-           hregister:=hlcg.getaddressregister(current_asmdata.CurrAsmList,getpointerdef(resultdef));
-           hlcg.a_loadaddr_ref_reg(current_asmdata.CurrAsmList,left.resultdef,getpointerdef(resultdef),left.location.reference,hregister);
-           hlcg.reference_reset_base(location.reference,getpointerdef(resultdef),hregister,0,left.location.reference.alignment);
+           hregister:=hlcg.getaddressregister(current_asmdata.CurrAsmList,cpointerdef.getreusable(resultdef));
+           hlcg.a_loadaddr_ref_reg(current_asmdata.CurrAsmList,left.resultdef,cpointerdef.getreusable(resultdef),left.location.reference,hregister);
+           hlcg.reference_reset_base(location.reference,cpointerdef.getreusable(resultdef),hregister,0,left.location.reference.alignment);
          end
         else
          begin
@@ -73,11 +73,11 @@ implementation
            else
              lendef:=ossinttype;
            hlcg.location_force_reg(current_asmdata.CurrAsmList,left.location,
-             left.resultdef,getpointerdef(lendef),true);
+             left.resultdef,cpointerdef.getreusable(lendef),true);
            current_asmdata.getjumplabel(nillab);
            current_asmdata.getjumplabel(lengthlab);
-           hlcg.a_cmp_const_reg_label(current_asmdata.CurrAsmList,getpointerdef(lendef),OC_EQ,0,left.location.register,nillab);
-           hlcg.reference_reset_base(href,getpointerdef(lendef),left.location.register,-lendef.size,lendef.alignment);
+           hlcg.a_cmp_const_reg_label(current_asmdata.CurrAsmList,cpointerdef.getreusable(lendef),OC_EQ,0,left.location.register,nillab);
+           hlcg.reference_reset_base(href,cpointerdef.getreusable(lendef),left.location.register,-lendef.size,lendef.alignment);
            hregister:=hlcg.getintregister(current_asmdata.CurrAsmList,resultdef);
            hlcg.a_load_ref_reg(current_asmdata.CurrAsmList,lendef,resultdef,href,hregister);
            if is_widestring(left.resultdef) then

compiler/llvm/nllvmld.pas

@@ -57,7 +57,7 @@ procedure tllvmarrayconstructornode.makearrayref(var ref: treference; eledef: td
   begin
     { the array elements are addressed as pointer to the individual elements ->
       convert }
-    hlcg.g_ptrtypecast_ref(current_asmdata.CurrAsmList,getpointerdef(resultdef),getpointerdef(eledef),ref);
+    hlcg.g_ptrtypecast_ref(current_asmdata.CurrAsmList,cpointerdef.getreusable(resultdef),cpointerdef.getreusable(eledef),ref);
   end;
 
 

compiler/llvm/nllvmmem.pas

@@ -78,8 +78,8 @@ implementation
           begin
             { typecast the result to the expected type, but don't actually index
               (that still has to be done by the generic code, so return false) }
-            newbase:=hlcg.getaddressregister(current_asmdata.CurrAsmList,getpointerdef(resultdef));
-            hlcg.a_loadaddr_ref_reg(current_asmdata.CurrAsmList,left.resultdef,getpointerdef(resultdef),location.reference,newbase);
+            newbase:=hlcg.getaddressregister(current_asmdata.CurrAsmList,cpointerdef.getreusable(resultdef));
+            hlcg.a_loadaddr_ref_reg(current_asmdata.CurrAsmList,left.resultdef,cpointerdef.getreusable(resultdef),location.reference,newbase);
             reference_reset_base(location.reference,newbase,0,location.reference.alignment);
             result:=false;
           end
@@ -100,12 +100,12 @@ implementation
                 if implicitpointer then
                   newbase:=hlcg.getaddressregister(current_asmdata.CurrAsmList,parentdef)
                 else
-                  newbase:=hlcg.getaddressregister(current_asmdata.CurrAsmList,getpointerdef(parentdef));
+                  newbase:=hlcg.getaddressregister(current_asmdata.CurrAsmList,cpointerdef.getreusable(parentdef));
                 location.reference:=thlcgllvm(hlcg).make_simple_ref(current_asmdata.CurrAsmList,location.reference,left.resultdef);
                 if implicitpointer then
                   subscriptdef:=currentstructdef
                 else
-                  subscriptdef:=getpointerdef(currentstructdef);
+                  subscriptdef:=cpointerdef.getreusable(currentstructdef);
                 { recurse into the first field }
                 current_asmdata.CurrAsmList.concat(taillvm.getelementptr_reg_size_ref_size_const(newbase,subscriptdef,location.reference,s32inttype,0,true));
                 reference_reset_base(location.reference,newbase,vs.offsetfromllvmfield,newalignment(location.reference.alignment,vs.fieldoffset));
@@ -118,9 +118,9 @@ implementation
             if implicitpointer then
               subscriptdef:=currentstructdef
             else
-              subscriptdef:=getpointerdef(currentstructdef);
+              subscriptdef:=cpointerdef.getreusable(currentstructdef);
             { load the address of that shadow field }
-            newbase:=hlcg.getaddressregister(current_asmdata.CurrAsmList,getpointerdef(llvmfielddef));
+            newbase:=hlcg.getaddressregister(current_asmdata.CurrAsmList,cpointerdef.getreusable(llvmfielddef));
             location.reference:=thlcgllvm(hlcg).make_simple_ref(current_asmdata.CurrAsmList,location.reference,left.resultdef);
             current_asmdata.CurrAsmList.concat(taillvm.getelementptr_reg_size_ref_size_const(newbase,subscriptdef,location.reference,s32inttype,vs.llvmfieldnr,true));
             reference_reset_base(location.reference,newbase,vs.offsetfromllvmfield,newalignment(location.reference.alignment,vs.fieldoffset));
@@ -129,12 +129,12 @@ implementation
               size for extended, which is usually larger) into an extended }
             if (llvmfielddef.typ=floatdef) and
                (tfloatdef(llvmfielddef).floattype=s80real) then
-              hlcg.g_ptrtypecast_ref(current_asmdata.CurrAsmList,getpointerdef(getarraydef(u8inttype,10)),getpointerdef(s80floattype),location.reference);
+              hlcg.g_ptrtypecast_ref(current_asmdata.CurrAsmList,cpointerdef.getreusable(getarraydef(u8inttype,10)),cpointerdef.getreusable(s80floattype),location.reference);
             { if it doesn't match the requested field exactly (variant record),
               adjust the type of the pointer }
             if (vs.offsetfromllvmfield<>0) or
                (llvmfielddef<>resultdef) then
-              hlcg.g_ptrtypecast_ref(current_asmdata.CurrAsmList,getpointerdef(llvmfielddef),getpointerdef(resultdef),location.reference);
+              hlcg.g_ptrtypecast_ref(current_asmdata.CurrAsmList,cpointerdef.getreusable(llvmfielddef),cpointerdef.getreusable(resultdef),location.reference);
             location.size:=def_cgsize(resultdef);
             result:=true;
           end;
@@ -168,9 +168,9 @@ implementation
           10 bytes) }
         if (resultdef.typ=floatdef) and
            (tfloatdef(resultdef).floattype=s80real) then
-          arrptrelementdef:=getpointerdef(getarraydef(u8inttype,10))
+          arrptrelementdef:=cpointerdef.getreusable(getarraydef(u8inttype,10))
         else
-          arrptrelementdef:=getpointerdef(resultdef);
+          arrptrelementdef:=cpointerdef.getreusable(resultdef);
       end;
 
     begin
@@ -187,7 +187,7 @@ implementation
           getarrelementptrdef;
           hreg:=hlcg.getaddressregister(current_asmdata.CurrAsmList,arrptrelementdef);
           locref^:=thlcgllvm(hlcg).make_simple_ref(current_asmdata.CurrAsmList,location.reference,left.resultdef);
-          current_asmdata.CurrAsmList.Concat(taillvm.getelementptr_reg_size_ref_size_const(hreg,getpointerdef(left.resultdef),
+          current_asmdata.CurrAsmList.Concat(taillvm.getelementptr_reg_size_ref_size_const(hreg,cpointerdef.getreusable(left.resultdef),
             locref^,ptruinttype,constarrayoffset,true));
           reference_reset_base(locref^,hreg,0,locref^.alignment);
         end;
@@ -198,8 +198,8 @@ implementation
        begin
          if not assigned(locref) then
            getarrelementptrdef;
-         hreg:=hlcg.getaddressregister(current_asmdata.CurrAsmList,getpointerdef(resultdef));
-         hlcg.a_load_reg_reg(current_asmdata.CurrAsmList,arrptrelementdef,getpointerdef(resultdef),locref^.base,hreg);
+         hreg:=hlcg.getaddressregister(current_asmdata.CurrAsmList,cpointerdef.getreusable(resultdef));
+         hlcg.a_load_reg_reg(current_asmdata.CurrAsmList,arrptrelementdef,cpointerdef.getreusable(resultdef),locref^.base,hreg);
          locref^.base:=hreg;
        end;
     end;
@@ -217,14 +217,14 @@ implementation
           hlcg.a_op_const_reg_reg(current_asmdata.CurrAsmList,OP_ADD,ptruinttype,constarrayoffset,maybe_const_reg,hreg);
           maybe_const_reg:=hreg;
         end;
-      hreg:=hlcg.getaddressregister(current_asmdata.CurrAsmList,getpointerdef(resultdef));
+      hreg:=hlcg.getaddressregister(current_asmdata.CurrAsmList,cpointerdef.getreusable(resultdef));
       location.reference:=thlcgllvm(hlcg).make_simple_ref(current_asmdata.CurrAsmList,location.reference,left.resultdef);
       if not is_dynamicstring(left.resultdef) and
          not is_dynamic_array(left.resultdef) then
         begin
           { get address of indexed array element and convert pointer to array into
             pointer to the elementdef in the process }
-          current_asmdata.CurrAsmList.Concat(taillvm.getelementptr_reg_size_ref_size_reg(hreg,getpointerdef(left.resultdef),
+          current_asmdata.CurrAsmList.Concat(taillvm.getelementptr_reg_size_ref_size_reg(hreg,cpointerdef.getreusable(left.resultdef),
             location.reference,ptruinttype,maybe_const_reg,true));
           arraytopointerconverted:=true;
         end
@@ -282,8 +282,8 @@ implementation
       offsetreg:=hlcg.getintregister(current_asmdata.CurrAsmList,ptruinttype);
       hlcg.a_op_const_reg_reg(current_asmdata.CurrAsmList,OP_SHR,ptruinttype,3+alignpower,hreg,offsetreg);
       { index the array using this chunk index }
-      basereg:=hlcg.getaddressregister(current_asmdata.CurrAsmList,getpointerdef(defloadsize));
-      current_asmdata.CurrAsmList.Concat(taillvm.getelementptr_reg_size_ref_size_reg(basereg,getpointerdef(left.resultdef),
+      basereg:=hlcg.getaddressregister(current_asmdata.CurrAsmList,cpointerdef.getreusable(defloadsize));
+      current_asmdata.CurrAsmList.Concat(taillvm.getelementptr_reg_size_ref_size_reg(basereg,cpointerdef.getreusable(left.resultdef),
         sref.ref,ptruinttype,offsetreg,true));
       arraytopointerconverted:=true;
       reference_reset_base(sref.ref,basereg,0,sref.ref.alignment);

compiler/llvm/nllvmtcon.pas

@@ -272,7 +272,7 @@ implementation
           { field corresponding to this offset }
           field:=trecordsymtable(strrecdef.symtable).findfieldbyoffset(offset);
           { pointerdef to the string data array }
-          dataptrdef:=getpointerdef(field.vardef);
+          dataptrdef:=cpointerdef.getreusable(field.vardef);
           queue_init(charptrdef);
           queue_addrn(dataptrdef,charptrdef);
           queue_subscriptn(strrecdef,field);
@@ -379,8 +379,8 @@ implementation
         else
           internalerror(2014062203);
       end;
-      aityped:=wrap_with_type(ai,getpointerdef(eledef));
-      update_queued_tai(getpointerdef(eledef),aityped,ai,1);
+      aityped:=wrap_with_type(ai,cpointerdef.getreusable(eledef));
+      update_queued_tai(cpointerdef.getreusable(eledef),aityped,ai,1);
     end;
 
 
@@ -399,7 +399,7 @@ implementation
       getllvmfieldaddr:=taillvm.getelementptr_reg_tai_size_const(NR_NO,nil,s32inttype,vs.llvmfieldnr,true);
       { getelementptr doesn't contain its own resultdef, so encode it via a
         tai_simpletypedconst tai }
-      getllvmfieldaddrtyped:=wrap_with_type(getllvmfieldaddr,getpointerdef(llvmfielddef));
+      getllvmfieldaddrtyped:=wrap_with_type(getllvmfieldaddr,cpointerdef.getreusable(llvmfielddef));
       { if it doesn't match the requested field exactly (variant record),
         fixup the result }
       getpascalfieldaddr:=getllvmfieldaddrtyped;
@@ -419,14 +419,14 @@ implementation
               { add the offset }
               getpascalfieldaddr:=taillvm.getelementptr_reg_tai_size_const(NR_NO,getpascalfieldaddr,ptrsinttype,vs.offsetfromllvmfield,true);
               { ... and set the result type of the getelementptr }
-              getpascalfieldaddr:=wrap_with_type(getpascalfieldaddr,getpointerdef(u8inttype));
+              getpascalfieldaddr:=wrap_with_type(getpascalfieldaddr,cpointerdef.getreusable(u8inttype));
               llvmfielddef:=u8inttype;
             end;
           { bitcast the data at the final offset to the right type }
           if llvmfielddef<>vs.vardef then
-            getpascalfieldaddr:=wrap_with_type(taillvm.op_reg_tai_size(la_bitcast,NR_NO,getpascalfieldaddr,getpointerdef(vs.vardef)),getpointerdef(vs.vardef));
+            getpascalfieldaddr:=wrap_with_type(taillvm.op_reg_tai_size(la_bitcast,NR_NO,getpascalfieldaddr,cpointerdef.getreusable(vs.vardef)),cpointerdef.getreusable(vs.vardef));
         end;
-      update_queued_tai(getpointerdef(vs.vardef),getpascalfieldaddr,getllvmfieldaddr,1);
+      update_queued_tai(cpointerdef.getreusable(vs.vardef),getpascalfieldaddr,getllvmfieldaddr,1);
     end;
 
 

compiler/llvm/rgllvm.pas

@@ -92,7 +92,7 @@ implementation
         def:=tdef(reginfo[orgsupreg].def);
         if not assigned(def) then
           internalerror(2013110803);
-        ins:=taillvm.op_reg_size_ref(la_load,tempreg,getpointerdef(def),spilltemp);
+        ins:=taillvm.op_reg_size_ref(la_load,tempreg,cpointerdef.getreusable(def),spilltemp);
         list.insertafter(ins,pos);
         {$ifdef DEBUG_SPILLING}
         list.Insertbefore(tai_comment.Create(strpnew('Spilling: Spill Read')),ins);
@@ -108,7 +108,7 @@ implementation
         def:=tdef(reginfo[orgsupreg].def);
         if not assigned(def) then
           internalerror(2013110802);
-        ins:=taillvm.op_size_reg_size_ref(la_store,def,tempreg,getpointerdef(def),spilltemp);
+        ins:=taillvm.op_size_reg_size_ref(la_store,def,tempreg,cpointerdef.getreusable(def),spilltemp);
         list.insertafter(ins,pos);
         {$ifdef DEBUG_SPILLING}
         list.Insertbefore(tai_comment.Create(strpnew('Spilling: Spill Write')),ins);

compiler/m68k/cpupara.pas

@@ -275,7 +275,7 @@ unit cpupara;
 
             if push_addr_param(hp.varspez,paradef,p.proccalloption) then
               begin
-                paradef:=getpointerdef(paradef);
+                paradef:=cpointerdef.getreusable(paradef);
                 paracgsize := OS_ADDR;
                 paralen := tcgsize2size[OS_ADDR];
               end

compiler/mips/cpupara.pas

@@ -273,7 +273,7 @@ implementation
               begin
                 paracgsize := OS_ADDR;
                 paralen := tcgsize2size[paracgsize];
-                paradef := getpointerdef(paradef);
+                paradef := cpointerdef.getreusable(paradef);
               end
             else
               begin

compiler/nadd.pas

@@ -2037,7 +2037,7 @@ implementation
           begin
             if is_zero_based_array(rd) then
               begin
-                resultdef:=getpointerdef(tarraydef(rd).elementdef);
+                resultdef:=cpointerdef.getreusable(tarraydef(rd).elementdef);
                 inserttypeconv(right,resultdef);
               end
             else
@@ -2069,7 +2069,7 @@ implementation
            begin
              if is_zero_based_array(ld) then
                begin
-                  resultdef:=getpointerdef(tarraydef(ld).elementdef);
+                  resultdef:=cpointerdef.getreusable(tarraydef(ld).elementdef);
                   inserttypeconv(left,resultdef);
                end
              else

compiler/ncal.pas

@@ -1875,7 +1875,7 @@ implementation
                       is_object(p.resultdef);
 
             if usederef then
-              hdef:=getpointerdef(p.resultdef)
+              hdef:=cpointerdef.getreusable(p.resultdef)
             else
               hdef:=p.resultdef;
 
@@ -4458,7 +4458,7 @@ implementation
         tempnode: ttempcreatenode;
         paraaddr: taddrnode;
       begin
-        ptrtype:=getpointerdef(para.left.resultdef);
+        ptrtype:=cpointerdef.getreusable(para.left.resultdef);
         tempnode:=ctempcreatenode.create(ptrtype,ptrtype.size,tt_persistent,true);
         addstatement(inlineinitstatement,tempnode);
         addstatement(inlinecleanupstatement,ctempdeletenode.create(tempnode));

compiler/ncgcal.pas

@@ -383,7 +383,7 @@ implementation
                           if (left.location.reference.index<>NR_NO) or
                              (left.location.reference.offset<>0) then
                             internalerror(200410107);
-                          hlcg.a_load_reg_cgpara(current_asmdata.CurrAsmList,getpointerdef(left.resultdef),left.location.reference.base,tempcgpara)
+                          hlcg.a_load_reg_cgpara(current_asmdata.CurrAsmList,cpointerdef.getreusable(left.resultdef),left.location.reference.base,tempcgpara)
                         end
                       else
                         begin
@@ -476,7 +476,7 @@ implementation
         literaldef: trecorddef;
       begin
         literaldef:=get_block_literal_type_for_proc(tabstractprocdef(right.resultdef));
-        hlcg.location_force_reg(current_asmdata.CurrAsmList,right.location,right.resultdef,getpointerdef(literaldef),true);
+        hlcg.location_force_reg(current_asmdata.CurrAsmList,right.location,right.resultdef,cpointerdef.getreusable(literaldef),true);
         { load the invoke pointer }
         hlcg.reference_reset_base(href,right.resultdef,right.location.register,0,right.resultdef.alignment);
         if not searchsym_in_record(literaldef,'INVOKE',srsym,srsymtable) or
@@ -838,7 +838,7 @@ implementation
          else
            begin
              hlcg.location_force_mem(current_asmdata.CurrAsmList,right.location,procdefinition);
-             hlcg.g_ptrtypecast_ref(current_asmdata.CurrAsmList,getpointerdef(procdefinition),getpointerdef(codeprocdef),right.location.reference);
+             hlcg.g_ptrtypecast_ref(current_asmdata.CurrAsmList,cpointerdef.getreusable(procdefinition),cpointerdef.getreusable(codeprocdef),right.location.reference);
              hlcg.a_load_ref_reg(current_asmdata.CurrAsmList,codeprocdef,codeprocdef,right.location.reference,result);
            end;
        end;

compiler/ncgcnv.pas

@@ -408,8 +408,8 @@ interface
                tg.gethltemp(current_asmdata.CurrAsmList,cshortstringtype,256,tt_normal,location.reference);
                tmpref:=location.reference;
                hlcg.g_ptrtypecast_ref(current_asmdata.CurrAsmList,
-                 getpointerdef(cshortstringtype),
-                 getpointerdef(left.resultdef),tmpref);
+                 cpointerdef.getreusable(cshortstringtype),
+                 cpointerdef.getreusable(left.resultdef),tmpref);
                hlcg.a_load_loc_ref(current_asmdata.CurrAsmList,left.resultdef,left.resultdef,left.location,
                  tmpref);
                location_freetemp(current_asmdata.CurrAsmList,left.location);

compiler/ncgld.pas

@@ -448,7 +448,7 @@ implementation
                       hregister:=location.register
                     else
                       begin
-                        vd:=getpointerdef(resultdef);
+                        vd:=cpointerdef.getreusable(resultdef);
                         hregister:=hlcg.getaddressregister(current_asmdata.CurrAsmList,vd);
                         { we need to load only an address }
                         location.size:=int_cgsize(vd.size);
@@ -675,7 +675,7 @@ implementation
             else if (right.nodetype=stringconstn) and
                (tstringconstnode(right).len=0) then
               begin
-                hlcg.g_ptrtypecast_ref(current_asmdata.CurrAsmList,getpointerdef(left.resultdef),tpointerdef(charpointertype),left.location.reference);
+                hlcg.g_ptrtypecast_ref(current_asmdata.CurrAsmList,cpointerdef.getreusable(left.resultdef),tpointerdef(charpointertype),left.location.reference);
                 hlcg.a_load_const_ref(current_asmdata.CurrAsmList,cansichartype,0,left.location.reference);
               end
             { char loading }
@@ -683,7 +683,7 @@ implementation
               begin
                 if right.nodetype=ordconstn then
                   begin
-                    hlcg.g_ptrtypecast_ref(current_asmdata.CurrAsmList,getpointerdef(left.resultdef),getpointerdef(u16inttype),left.location.reference);
+                    hlcg.g_ptrtypecast_ref(current_asmdata.CurrAsmList,cpointerdef.getreusable(left.resultdef),cpointerdef.getreusable(u16inttype),left.location.reference);
                     if (target_info.endian = endian_little) then
                       hlcg.a_load_const_ref(current_asmdata.CurrAsmList,u16inttype,(tordconstnode(right).value.svalue shl 8) or 1,
                           setalignment(left.location.reference,1))
@@ -694,7 +694,7 @@ implementation
                 else
                   begin
                     href:=left.location.reference;
-                    hlcg.g_ptrtypecast_ref(current_asmdata.CurrAsmList,getpointerdef(left.resultdef),tpointerdef(charpointertype),href);
+                    hlcg.g_ptrtypecast_ref(current_asmdata.CurrAsmList,cpointerdef.getreusable(left.resultdef),tpointerdef(charpointertype),href);
                     hlcg.a_load_const_ref(current_asmdata.CurrAsmList,cansichartype,1,href);
                     inc(href.offset,1);
                     case right.location.loc of

compiler/ncgutil.pas

@@ -1567,7 +1567,7 @@ implementation
                             begin
                               if isaddr then
                                 begin
-                                  ptrdef:=getpointerdef(vs.vardef);
+                                  ptrdef:=cpointerdef.getreusable(vs.vardef);
                                   tg.GetLocal(list,ptrdef.size,ptrdef,vs.initialloc.reference)
                                 end
                               else

compiler/ncgvmt.pas

@@ -259,7 +259,7 @@ implementation
 
          { write name label }
          tcb.maybe_begin_aggregate(entrydef);
-         tcb.emit_tai(Tai_const.Create_sym(p^.nl),getpointerdef(getarraydef(cansichartype,length(p^.data.messageinf.str^)+1)));
+         tcb.emit_tai(Tai_const.Create_sym(p^.nl),cpointerdef.getreusable(getarraydef(cansichartype,length(p^.data.messageinf.str^)+1)));
          tcb.queue_init(voidcodepointertype);
          tcb.queue_emit_proc(p^.data);
          tcb.maybe_end_aggregate(entrydef);
@@ -543,7 +543,7 @@ implementation
                      addr : codepointer;
                   end;
               }
-              lists.methodnamerec:=getrecorddef('fpc_intern_tmethodnamerec',[getpointerdef(cshortstringtype),voidcodepointertype],1);
+              lists.methodnamerec:=getrecorddef('fpc_intern_tmethodnamerec',[cpointerdef.getreusable(cshortstringtype),voidcodepointertype],1);
               { from objpas.inc:
                   tmethodnametable = packed record
                     count : dword;
@@ -655,7 +655,7 @@ implementation
               targetinfos[target_info.system]^.alignment.recordalignmin,
               targetinfos[target_info.system]^.alignment.maxCrecordalign);
             datatcb.emit_tai(Tai_const.Create_16bit(fieldcount),u16inttype);
-            datatcb.emit_tai(Tai_const.Create_sym(classtable),getpointerdef(classtabledef));
+            datatcb.emit_tai(Tai_const.Create_sym(classtable),cpointerdef.getreusable(classtabledef));
             for i:=0 to _class.symtable.SymList.Count-1 do
               begin
                 sym:=tsym(_class.symtable.SymList[i]);
@@ -741,9 +741,9 @@ implementation
         { GUID (or nil for Corba interfaces) }
         if AImplIntf.IntfDef.objecttype in [odt_interfacecom] then
           tcb.emit_tai(Tai_const.CreateName(
-            make_mangledname('IID',AImplIntf.IntfDef.owner,AImplIntf.IntfDef.objname^),AT_DATA,0),getpointerdef(rec_tguid))
+            make_mangledname('IID',AImplIntf.IntfDef.owner,AImplIntf.IntfDef.objname^),AT_DATA,0),cpointerdef.getreusable(rec_tguid))
         else
-          tcb.emit_tai(Tai_const.Create_nil_dataptr,getpointerdef(rec_tguid));
+          tcb.emit_tai(Tai_const.Create_nil_dataptr,cpointerdef.getreusable(rec_tguid));
 
         { VTable }
         tcb.queue_init(voidpointertype);
@@ -769,12 +769,12 @@ implementation
         end;
 
         { IIDStr }
-        tcb.queue_init(getpointerdef(cshortstringtype));
+        tcb.queue_init(cpointerdef.getreusable(cshortstringtype));
         tcb.queue_emit_asmsym(
           current_asmdata.RefAsmSymbol(
             make_mangledname('IIDSTR',AImplIntf.IntfDef.owner,AImplIntf.IntfDef.objname^),
             AT_DATA),
-          getpointerdef(getarraydef(cansichartype,length(AImplIntf.IntfDef.iidstr^)+1)));
+          cpointerdef.getreusable(getarraydef(cansichartype,length(AImplIntf.IntfDef.iidstr^)+1)));
         { IType }
         tcb.emit_ord_const(aint(AImplIntf.VtblImplIntf.IType),interfaceentrytypedef);
         tcb.maybe_end_aggregate(interfaceentrydef);
@@ -1117,7 +1117,7 @@ implementation
          { it's not used yet, but the delphi-operators as and is need it (FK) }
          { it is not written for parents that don't have any vmt !! }
          if is_class(_class) then
-           parentvmtdef:=getpointerdef(search_system_type('TVMT').typedef)
+           parentvmtdef:=cpointerdef.getreusable(search_system_type('TVMT').typedef)
          else
            parentvmtdef:=voidpointertype;
          if assigned(_class.childof) and
@@ -1135,13 +1135,13 @@ implementation
          if is_class(_class) then
           begin
             { pointer to class name string }
-            tcb.queue_init(getpointerdef(cshortstringtype));
+            tcb.queue_init(cpointerdef.getreusable(cshortstringtype));
             tcb.queue_emit_asmsym(classnamelabel,classnamedef);
             { pointer to dynamic table or nil }
             if (oo_has_msgint in _class.objectoptions) then
               begin
                 tcb.queue_init(voidpointertype);
-                tcb.queue_emit_asmsym(intmessagetable,getpointerdef(intmessagetabledef));
+                tcb.queue_emit_asmsym(intmessagetable,cpointerdef.getreusable(intmessagetabledef));
               end
             else
               tcb.emit_tai(Tai_const.Create_nil_dataptr,voidpointertype);
@@ -1149,7 +1149,7 @@ implementation
             if assigned(methodnametable) then
               begin
                 tcb.queue_init(voidpointertype);
-                tcb.queue_emit_asmsym(methodnametable,getpointerdef(methodnametabledef))
+                tcb.queue_emit_asmsym(methodnametable,cpointerdef.getreusable(methodnametabledef))
               end
             else
               tcb.emit_tai(Tai_const.Create_nil_dataptr,voidpointertype);

compiler/nld.pas

@@ -341,7 +341,7 @@ implementation
                  begin
                    if (is_object(resultdef) or is_record(resultdef)) and
                       (loadnf_load_self_pointer in loadnodeflags) then
-                     resultdef:=getpointerdef(resultdef)
+                     resultdef:=cpointerdef.getreusable(resultdef)
                    else if (resultdef=objc_idtype) and
                       (po_classmethod in tprocdef(symtableentry.owner.defowner).procoptions) then
                      resultdef:=cclassrefdef.create(tprocdef(symtableentry.owner.defowner).struct)

compiler/nmem.pas

@@ -632,7 +632,7 @@ implementation
                 hp:=tunarynode(hp).left;
               end;
             if nf_typedaddr in flags then
-              res:=cpointerconstnode.create(offset,getpointerdef(left.resultdef))
+              res:=cpointerconstnode.create(offset,cpointerdef.getreusable(left.resultdef))
             else
               res:=cpointerconstnode.create(offset,voidpointertype);
             result:=true;
@@ -643,7 +643,7 @@ implementation
             if not(nf_typedaddr in flags) then
               resultdef:=voidpointertype
             else
-              resultdef:=getpointerdef(left.resultdef);
+              resultdef:=cpointerdef.getreusable(left.resultdef);
             result:=true;
           end
       end;

compiler/nutils.pas

@@ -636,12 +636,12 @@ implementation
           result:=cderefnode.create(
             ctypeconvnode.create_explicit(
               self_node,
-              getpointerdef(voidpointertype)
+              cpointerdef.getreusable(voidpointertype)
             )
           );
         result:=ctypeconvnode.create_explicit(
           result,
-          getpointerdef(obj_def.vmt_def));
+          cpointerdef.getreusable(obj_def.vmt_def));
         typecheckpass(result);
         if docheck then
           begin

compiler/objcutil.pas

@@ -124,7 +124,7 @@ end;
           result:=ctypeconvnode.create_internal(
             cderefnode.create(
               ctypeconvnode.create_internal(n,
-                getpointerdef(getpointerdef(voidpointertype))
+                cpointerdef.getreusable(cpointerdef.getreusable(voidpointertype))
               )
             ),tfieldvarsym(vs).vardef
           )

compiler/optcse.pas

@@ -387,7 +387,7 @@ unit optcse;
                         addrstored:=((def.typ in [arraydef,recorddef]) or is_object(def)) and not(is_dynamic_array(def));
 
                         if addrstored then
-                          templist[i]:=ctempcreatenode.create_value(getpointerdef(def),voidpointertype.size,tt_persistent,
+                          templist[i]:=ctempcreatenode.create_value(cpointerdef.getreusable(def),voidpointertype.size,tt_persistent,
                             true,caddrnode.create_internal(tnode(lists.nodelist[i])))
                         else
                           templist[i]:=ctempcreatenode.create_value(def,def.size,tt_persistent,

compiler/paramgr.pas

@@ -560,7 +560,7 @@ implementation
             retloc.def:=tdef(p.owner.defowner);
             if not (is_implicit_pointer_object_type(retloc.def) or
                (retloc.def.typ<>objectdef)) then
-              retloc.def:=getpointerdef(retloc.def);
+              retloc.def:=cpointerdef.getreusable(retloc.def);
           end;
         retcgsize:=def_cgsize(retloc.def);
         retloc.intsize:=retloc.def.size;
@@ -568,7 +568,7 @@ implementation
         { Return is passed as var parameter }
         if ret_in_param(retloc.def,p) then
           begin
-            retloc.def:=getpointerdef(retloc.def);
+            retloc.def:=cpointerdef.getreusable(retloc.def);
             paraloc:=retloc.add_location;
             paraloc^.loc:=LOC_REFERENCE;
             paraloc^.size:=retcgsize;

compiler/pexpr.pas

@@ -239,7 +239,7 @@ implementation
            begin
              typecheckpass(p1);
              result:=internalstatements(newstatement);
-             hdef:=getpointerdef(p1.resultdef);
+             hdef:=cpointerdef.getreusable(p1.resultdef);
              temp:=ctempcreatenode.create(hdef,sizeof(pint),tt_persistent,false);
              addstatement(newstatement,temp);
              addstatement(newstatement,cassignmentnode.create(ctemprefnode.create(temp),caddrnode.create_internal(p1)));
@@ -1896,7 +1896,7 @@ implementation
                      ft_typed:
                        begin
                          p1:=cderefnode.create(ctypeconvnode.create_internal(ccallnode.createintern('fpc_getbuf_typedfile',ccallparanode.create(p1,nil)),
-                           getpointerdef(tfiledef(p1.resultdef).typedfiledef)));
+                           cpointerdef.getreusable(tfiledef(p1.resultdef).typedfiledef)));
                          typecheckpass(p1);
                        end;
                    end;

compiler/powerpc/cpupara.pas

@@ -87,7 +87,7 @@ unit cpupara;
         psym:=tparavarsym(pd.paras[nr-1]);
         pdef:=psym.vardef;
         if push_addr_param(psym.varspez,pdef,pd.proccalloption) then
-          pdef:=getpointerdef(pdef);
+          pdef:=cpointerdef.getreusable(pdef);
         cgpara.reset;
         cgpara.size:=def_cgsize(pdef);
         cgpara.intsize:=tcgsize2size[cgpara.size];
@@ -389,7 +389,7 @@ unit cpupara;
 
               if push_addr_param(hp.varspez,paradef,p.proccalloption) then
                 begin
-                  paradef:=getpointerdef(paradef);
+                  paradef:=cpointerdef.getreusable(paradef);
                   loc:=LOC_REGISTER;
                   paracgsize := OS_ADDR;
                   paralen := tcgsize2size[OS_ADDR];

compiler/powerpc64/cpupara.pas

@@ -88,7 +88,7 @@ begin
   psym:=tparavarsym(pd.paras[nr-1]);
   pdef:=psym.vardef;
   if push_addr_param(psym.varspez,pdef,pd.proccalloption) then
-    pdef:=getpointerdef(pdef);
+    pdef:=cpointerdef.getreusable(pdef);
   cgpara.reset;
   cgpara.size := def_cgsize(pdef);
   cgpara.intsize := tcgsize2size[cgpara.size];
@@ -418,7 +418,7 @@ begin
     next 8 byte boundary? }
   paraaligned:=false;
   if push_addr_param(varspez, paradef, p.proccalloption) then begin
-    paradef := getpointerdef(paradef);
+    paradef := cpointerdef.getreusable(paradef);
     loc := LOC_REGISTER;
     paracgsize := OS_ADDR;
     paralen := tcgsize2size[OS_ADDR];

compiler/pparautl.pas

@@ -184,7 +184,7 @@ implementation
             { generate the first hidden parameter, which is a so-called "block
               literal" describing the block and containing its invocation
               procedure  }
-            hdef:=getpointerdef(get_block_literal_type_for_proc(pd));
+            hdef:=cpointerdef.getreusable(get_block_literal_type_for_proc(pd));
             { mark as vo_is_parentfp so that proc2procvar comparisons will
               succeed when assigning arbitrary routines to the block }
             vs:=cparavarsym.create('$_block_literal',paranr_blockselfpara,vs_value,

compiler/ptype.pas

@@ -1663,7 +1663,7 @@ implementation
                     else
                       Message(parser_e_no_generics_as_types);
                   end;
-                { don't use getpointerdef() here, since this is a type
+                { don't use cpointerdef.getreusable() here, since this is a type
                   declaration (-> must create new typedef) }
                 def:=cpointerdef.create(tt2);
                 if tt2.typ=forwarddef then

compiler/sparc/cpupara.pas

@@ -196,7 +196,7 @@ implementation
             if push_addr_param(hp.varspez,paradef,p.proccalloption) then
               begin
                 paracgsize:=OS_ADDR;
-                paradef:=getpointerdef(paradef);
+                paradef:=cpointerdef.getreusable(paradef);
               end
             else
               begin

compiler/symcreat.pas

@@ -1132,7 +1132,7 @@ implementation
 {$endif}
       symtablestack.free;
       symtablestack:=old_symtablestack.getcopyuntil(pd.localst);
-      pnestedvarsdef:=getpointerdef(nestedvarsdef);
+      pnestedvarsdef:=cpointerdef.getreusable(nestedvarsdef);
       nestedvars:=clocalvarsym.create('$nestedvars',vs_var,nestedvarsdef,[]);
       pd.localst.insert(nestedvars);
       pd.parentfpstruct:=nestedvars;
@@ -1163,7 +1163,7 @@ implementation
           nestedvarsst:=trecorddef(nestedvarsdef).symtable;
           { indicate whether or not this is a var/out/constref/... parameter }
           if addrparam then
-            fieldvardef:=getpointerdef(vardef)
+            fieldvardef:=cpointerdef.getreusable(vardef)
           else
             fieldvardef:=vardef;
           result:=cfieldvarsym.create(sym.realname,vs_value,fieldvardef,[]);

compiler/symdef.pas

@@ -217,6 +217,9 @@ interface
        tpointerdef = class(tabstractpointerdef)
           has_pointer_math : boolean;
           constructor create(def:tdef);virtual;
+          { returns a pointerdef for def, reusing an existing one in case it
+            exists in the current module }
+          class function getreusable(def: tdef): tpointerdef; virtual;
           function size:asizeint;override;
           function getcopy:tstoreddef;override;
           constructor ppuload(ppufile:tcompilerppufile);
@@ -1122,9 +1125,6 @@ interface
 
     function use_vectorfpu(def : tdef) : boolean;
 
-    { returns a pointerdef for def, reusing an existing one in case it exists
-      in the current module }
-    function getpointerdef(def: tdef): tpointerdef;
     { returns an arraydef for an array containing a single array of def, resuing
       an existing one in case it exists in the current module }
     function getsingletonarraydef(def: tdef): tarraydef;
@@ -3120,6 +3120,33 @@ implementation
       end;
 
 
+    class function tpointerdef.getreusable(def: tdef): tpointerdef;
+      var
+        res: PHashSetItem;
+        oldsymtablestack: tsymtablestack;
+      begin
+        if not assigned(current_module) then
+          internalerror(2011071101);
+        res:=current_module.ptrdefs.FindOrAdd(@def,sizeof(def));
+        if not assigned(res^.Data) then
+          begin
+            { since these pointerdefs can be reused anywhere in the current
+              unit, add them to the global/staticsymtable }
+            oldsymtablestack:=symtablestack;
+            { do not simply push/pop current_module.localsymtable, because
+              that can have side-effects (e.g., it removes helpers) }
+            symtablestack:=nil;
+            res^.Data:=cpointerdef.create(def);
+            if assigned(current_module.localsymtable) then
+              current_module.localsymtable.insertdef(tdef(res^.Data))
+            else
+              current_module.globalsymtable.insertdef(tdef(res^.Data));
+            symtablestack:=oldsymtablestack;
+          end;
+        result:=tpointerdef(res^.Data);
+      end;
+
+
     function tpointerdef.size: asizeint;
       begin
         result:=sizeof(pint);
@@ -4722,7 +4749,7 @@ implementation
                 tabstractprocdef(result).returndef:=tdef(owner.defowner);
                 if not(is_implicit_pointer_object_type(returndef) or
                    (returndef.typ<>objectdef)) then
-                  tabstractprocdef(result).returndef:=getpointerdef(tabstractprocdef(result).returndef);
+                  tabstractprocdef(result).returndef:=cpointerdef.getreusable(tabstractprocdef(result).returndef);
                 tabstractprocdef(result).proctypeoption:=potype_function;
               end
             else if is_void(returndef) then
@@ -7604,33 +7631,6 @@ implementation
       end;
 
 
-    function getpointerdef(def: tdef): tpointerdef;
-      var
-        res: PHashSetItem;
-        oldsymtablestack: tsymtablestack;
-      begin
-        if not assigned(current_module) then
-          internalerror(2011071101);
-        res:=current_module.ptrdefs.FindOrAdd(@def,sizeof(def));
-        if not assigned(res^.Data) then
-          begin
-            { since these pointerdefs can be reused anywhere in the current
-              unit, add them to the global/staticsymtable }
-            oldsymtablestack:=symtablestack;
-            { do not simply push/pop current_module.localsymtable, because
-              that can have side-effects (e.g., it removes helpers) }
-            symtablestack:=nil;
-            res^.Data:=cpointerdef.create(def);
-            if assigned(current_module.localsymtable) then
-              current_module.localsymtable.insertdef(tdef(res^.Data))
-            else
-              current_module.globalsymtable.insertdef(tdef(res^.Data));
-            symtablestack:=oldsymtablestack;
-          end;
-        result:=tpointerdef(res^.Data);
-      end;
-
-
     function getsingletonarraydef(def: tdef): tarraydef;
       begin
         result:=getarraydef(def,1);

compiler/symsym.pas

@@ -458,14 +458,6 @@ interface
           function GetCopy:tmacro;
        end;
 
-       { tPtrDefHashSet }
-
-       tPtrDefHashSet = class(THashSet)
-       public
-         constructor Create;virtual;
-       end;
-       tPtrDefHashSetClass = class of tPtrDefHashSet;
-
     var
        generrorsym : tsym;
 
@@ -484,7 +476,6 @@ interface
        cconstsym: tconstsymclass;
        cenumsym: tenumsymclass;
        csyssym: tsyssymclass;
-       cPtrDefHashSet : tPtrDefHashSetClass = tPtrDefHashSet;
 
     { generate internal static field name based on regular field name }
     function internal_static_field_name(const fieldname: TSymStr): TSymStr;
@@ -2742,13 +2733,4 @@ implementation
       end;
 
 
-{****************************************************************************
-                             tPtrDefHashSet
- ****************************************************************************}
-
-    constructor tPtrDefHashSet.Create;
-      begin
-        inherited Create(64,true,false);
-      end;
-
 end.

compiler/x86/symx86.pas

@@ -37,6 +37,8 @@ type
    public
     x86pointertyp : tx86pointertyp;
     constructor create(def: tdef); override;
+    class function getreusable(def: tdef): tpointerdef; override;
+    class function getreusablex86(def: tdef; x86typ: tx86pointertyp): tpointerdef;
     constructor createx86(def:tdef;x86typ:tx86pointertyp);virtual;
     function size: asizeint; override;
     function getcopy: tstoreddef; override;
@@ -45,35 +47,49 @@ type
   end;
   tx86pointerdefclass = class of tx86pointerdef;
 
-  tx86PtrDefKey = packed record
-    def: tdef;
-    x86typ:tx86pointertyp;
-  end;
-
-  { tx86PtrDefHashSet }
-
-  tx86PtrDefHashSet = class(TPtrDefHashSet)
-   private
-    class procedure Key2FullKey(Key: Pointer; out FullKey: tx86PtrDefKey);
-   public
-    function Find(Key: Pointer; KeyLen: Integer): PHashSetItem;override;
-    function FindOrAdd(Key: Pointer; KeyLen: Integer;
-      var Found: Boolean): PHashSetItem;override;
-    function FindOrAdd(Key: Pointer; KeyLen: Integer): PHashSetItem;override;
-    function Get(Key: Pointer; KeyLen: Integer): TObject;override;
-  end;
-
-  { returns a pointerdef for def, reusing an existing one in case it exists
-    in the current module }
-  function getx86pointerdef(def: tdef;x86typ:tx86pointertyp): tpointerdef;
-
 implementation
 
   uses
     globals, verbose,
     symbase, fmodule;
 
-  function getx86pointerdef(def: tdef;x86typ:tx86pointertyp): tpointerdef;
+{****************************************************************************
+                             tx86pointerdef
+****************************************************************************}
+
+  procedure tx86pointerdef.ppuload_platform(ppufile: tcompilerppufile);
+    begin
+      inherited;
+      x86pointertyp:=tx86pointertyp(ppufile.getbyte);
+    end;
+
+
+  procedure tx86pointerdef.ppuwrite_platform(ppufile: tcompilerppufile);
+    begin
+      inherited;
+      ppufile.putbyte(byte(x86pointertyp));
+    end;
+
+
+  constructor tx86pointerdef.create(def: tdef);
+    begin
+      inherited create(def);
+      x86pointertyp := default_x86_data_pointer_type;
+    end;
+
+
+  class function tx86pointerdef.getreusable(def: tdef): tpointerdef;
+    begin
+      result:=getreusablex86(def,default_x86_data_pointer_type);
+    end;
+
+
+  class function tx86pointerdef.getreusablex86(def: tdef; x86typ: tx86pointertyp): tpointerdef;
+    type
+      tx86PtrDefKey = packed record
+        def: tdef;
+        x86typ:tx86pointertyp;
+      end;
     var
       res: PHashSetItem;
       oldsymtablestack: tsymtablestack;
@@ -102,30 +118,6 @@ implementation
       result:=tpointerdef(res^.Data);
     end;
 
-{****************************************************************************
-                             tx86pointerdef
-****************************************************************************}
-
-  procedure tx86pointerdef.ppuload_platform(ppufile: tcompilerppufile);
-    begin
-      inherited;
-      x86pointertyp:=tx86pointertyp(ppufile.getbyte);
-    end;
-
-
-  procedure tx86pointerdef.ppuwrite_platform(ppufile: tcompilerppufile);
-    begin
-      inherited;
-      ppufile.putbyte(byte(x86pointertyp));
-    end;
-
-
-  constructor tx86pointerdef.create(def: tdef);
-    begin
-      inherited create(def);
-      x86pointertyp := default_x86_data_pointer_type;
-    end;
-
 
   constructor tx86pointerdef.createx86(def: tdef; x86typ: tx86pointertyp);
     begin
@@ -187,70 +179,5 @@ implementation
       result:=x86pt_near;
     end;
 
-
-{****************************************************************************
-                             tx86PtrDefHashSet
-****************************************************************************}
-
-    class procedure tx86PtrDefHashSet.Key2FullKey(Key: Pointer; out FullKey: tx86PtrDefKey);
-      type
-        pdef=^tdef;
-      begin
-        FullKey.def:=pdef(Key)^;
-        FullKey.x86typ:=tx86pointerdefclass(cpointerdef).default_x86_data_pointer_type;
-      end;
-
-    function tx86PtrDefHashSet.Find(Key: Pointer; KeyLen: Integer): PHashSetItem;
-      var
-        FullKey: tx86PtrDefKey;
-      begin
-        if KeyLen=SizeOf(tdef) then
-          begin
-            Key2FullKey(Key, FullKey);
-            Result:=inherited Find(@FullKey, SizeOf(FullKey));
-          end
-        else
-          Result:=inherited Find(Key, KeyLen);
-      end;
-
-    function tx86PtrDefHashSet.FindOrAdd(Key: Pointer; KeyLen: Integer; var Found: Boolean): PHashSetItem;
-      var
-        FullKey: tx86PtrDefKey;
-      begin
-        if KeyLen=SizeOf(tdef) then
-          begin
-            Key2FullKey(Key, FullKey);
-            Result:=inherited FindOrAdd(@FullKey, SizeOf(FullKey), Found);
-          end
-        else
-          Result:=inherited FindOrAdd(Key, KeyLen, Found);
-      end;
-
-    function tx86PtrDefHashSet.FindOrAdd(Key: Pointer; KeyLen: Integer): PHashSetItem;
-      var
-        FullKey: tx86PtrDefKey;
-      begin
-        if KeyLen=SizeOf(tdef) then
-          begin
-            Key2FullKey(Key, FullKey);
-            Result:=inherited FindOrAdd(@FullKey, SizeOf(FullKey));
-          end
-        else
-          Result:=inherited FindOrAdd(Key, KeyLen);
-      end;
-
-    function tx86PtrDefHashSet.Get(Key: Pointer; KeyLen: Integer): TObject;
-      var
-        FullKey: tx86PtrDefKey;
-      begin
-        if KeyLen=SizeOf(tdef) then
-          begin
-            Key2FullKey(Key, FullKey);
-            Result:=inherited Get(@FullKey, SizeOf(FullKey));
-          end
-        else
-          Result:=inherited Get(Key, KeyLen);
-      end;
-
 end.
 

compiler/x86_64/cpupara.pas

@@ -1102,7 +1102,7 @@ unit cpupara;
                 loc[2].typ:=X86_64_NO_CLASS;
                 paracgsize:=OS_ADDR;
                 paralen:=sizeof(pint);
-                paradef:=getpointerdef(paradef);
+                paradef:=cpointerdef.getreusable(paradef);
                 loc[1].def:=paradef;
               end
             else

compiler/x86_64/symcpu.pas

@@ -212,7 +212,5 @@ begin
   cconstsym:=tcpuconstsym;
   cenumsym:=tcpuenumsym;
   csyssym:=tcpusyssym;
-
-  cPtrDefHashSet:=tx86PtrDefHashSet;
 end.