tllvmcallpara: turned into object and added convenience methods

compiler/llvm/aasmllvm.pas

@@ -212,13 +212,7 @@ interface
     tllvmcallparaflag = (lcp_byval, lcp_sret);
     tllvmcallparaflags = set of tllvmcallparaflag;
 
-    { parameter to an llvm call instruction }
-    pllvmcallpara = ^tllvmcallpara;
-    tllvmcallpara = record
-      def: tdef;
-      alignment: shortint;
-      valueext: tllvmvalueextension;
-      flags: tllvmcallparaflags;
+    tllvmcallparaval = record
       case typ: toptype of
         top_none: ();
         top_reg: (register: tregister);
@@ -228,17 +222,38 @@ interface
         top_tai    : (ai: tai);
     end;
 
+    { parameter to an llvm call instruction }
+    pllvmcallpara = ^tllvmcallpara;
+    tllvmcallpara = object
+      def: tdef;
+      alignment: shortint;
+      valueext: tllvmvalueextension;
+      flags: tllvmcallparaflags;
+      val: tllvmcallparaval;
+
+      constructor initwithcopy(_other: pllvmcallpara);
+      constructor init(_def: tdef; _alignment: shortint; _valueext: tllvmvalueextension; _flags: tllvmcallparaflags);
+      destructor done;
+      procedure clearpara;
+      procedure loadreg(reg: tregister);
+      procedure loadsym(sym: TAsmSymbol);
+      procedure loadconst(value: int64);
+      procedure loadtai(ai: tai);
+      procedure loadlocalsym(localsym: tsym);
+      procedure loadundef;
+    end;
 
     TLLVMAsmData = class(TAsmDataDef)
      fnextmetaid: cardinal;
     end;
 
+
 implementation
 
-uses
-  cutils, strings,
-  symconst,
-  aasmcpu;
+    uses
+      cutils, strings,
+      symconst,
+      aasmcpu;
 
     { taillvmprocdecl }
 
@@ -365,12 +380,11 @@ uses
             oper[opidx]^.paras:=tfplist.create;
             for i:=0 to o.paras.count-1 do
               begin
-                new(callpara);
-                callpara^:=pllvmcallpara(o.paras[i])^;
+                new(callpara,initwithcopy(pllvmcallpara(o.paras[i])));
                 oper[opidx]^.paras.add(callpara);
-                if (callpara^.typ = top_reg) and
+                if (callpara^.val.typ = top_reg) and
                    assigned(add_reg_instruction_hook) then
-                  add_reg_instruction_hook(self,callpara^.register);
+                  add_reg_instruction_hook(self,callpara^.val.register);
               end;
           end;
       end;
@@ -387,13 +401,7 @@ uses
               for i:=0 to oper[opidx]^.paras.count-1 do
                 begin
                   callpara:=pllvmcallpara(oper[opidx]^.paras[i]);
-                  case callpara^.typ of
-                    top_tai:
-                      callpara^.ai.free;
-                    else
-                      ;
-                  end;
-                  dispose(callpara);
+                  dispose(callpara,done);
                 end;
               oper[opidx]^.paras.free;
             end;
@@ -520,9 +528,9 @@ uses
             for i:=0 to _paras.count-1 do
               begin
                 callpara:=pllvmcallpara(_paras[i]);
-                if (callpara^.typ=top_reg) and
+                if (callpara^.val.typ=top_reg) and
                    assigned(add_reg_instruction_hook) then
-                  add_reg_instruction_hook(self,callpara^.register);
+                  add_reg_instruction_hook(self,callpara^.val.register);
               end;
             typ:=top_para;
           end;
@@ -1264,6 +1272,89 @@ uses
         loadparas(1,paras);
       end;
 
+
+    { tllvmcallpara }
+
+    constructor tllvmcallpara.initwithcopy(_other: pllvmcallpara);
+      begin
+        self:=_other^;
+      end;
+
+
+    constructor tllvmcallpara.init(_def: tdef; _alignment: shortint; _valueext: tllvmvalueextension; _flags: tllvmcallparaflags);
+      begin
+        def:=_def;
+        alignment:=_alignment;
+        valueext:=_valueext;
+        flags:=_flags;
+        val.typ:=top_none;
+      end;
+
+
+    destructor tllvmcallpara.done;
+      begin
+        clearpara;
+      end;
+
+
+    procedure tllvmcallpara.clearpara;
+      begin
+        case val.typ of
+          top_tai:
+            val.ai.free;
+          else
+            ;
+        end;
+        val.typ:=top_none;
+      end;
+
+
+    procedure tllvmcallpara.loadreg(reg: tregister);
+      begin
+        clearpara;
+        val.typ:=top_reg;
+        val.register:=reg;
+      end;
+
+
+    procedure tllvmcallpara.loadsym(sym: TAsmSymbol);
+      begin
+        clearpara;
+        val.typ:=top_ref;
+        val.sym:=sym;
+      end;
+
+
+    procedure tllvmcallpara.loadconst(value: int64);
+      begin
+        clearpara;
+        val.typ:=top_const;
+        val.value:=value;
+      end;
+
+
+    procedure tllvmcallpara.loadtai(ai: tai);
+      begin
+        clearpara;
+        val.typ:=top_tai;
+        val.ai:=ai;
+      end;
+
+
+    procedure tllvmcallpara.loadlocalsym(localsym: tsym);
+      begin
+        clearpara;
+        val.typ:=top_local;
+        val.localsym:=localsym;
+      end;
+
+    procedure tllvmcallpara.loadundef;
+      begin
+        clearpara;
+        val.typ:=top_undef
+      end;
+
+
 begin
   casmdata:=TLLVMAsmData;
 end.

compiler/llvm/agllvm.pas

@@ -366,27 +366,27 @@ implementation
                owner.writer.AsmWrite(' align ');
                owner.writer.AsmWrite(tostr(abs(para^.alignment)));
              end;
-           case para^.typ of
+           case para^.val.typ of
              top_reg:
                begin
                  owner.writer.AsmWrite(' ');
-                 owner.writer.AsmWrite(getregisterstring(para^.register));
+                 owner.writer.AsmWrite(getregisterstring(para^.val.register));
                end;
              top_ref:
                begin
                  owner.writer.AsmWrite(' ');
-                 owner.writer.AsmWrite(llvmasmsymname(para^.sym));
+                 owner.writer.AsmWrite(llvmasmsymname(para^.val.sym));
                end;
              top_const:
                begin
                  owner.writer.AsmWrite(' ');
-                 owner.writer.AsmWrite(tostr(para^.value));
+                 owner.writer.AsmWrite(tostr(para^.val.value));
                end;
              top_tai:
                begin
                  tmpinline:=1;
                  tmpasmblock:=false;
-                 hp:=para^.ai;
+                 hp:=para^.val.ai;
                  if para^.def<>llvm_metadatatype then
                    metadatakind:=mk_none
                  else

compiler/llvm/hlcgllvm.pas

@@ -226,7 +226,7 @@ implementation
         begin
           cgpara.check_simple_location;
           location^.llvmvalueloc:=true;
-          location^.llvmloc.loc:=LOC_CREFERENCE;
+          location^.llvmloc.loc:=LOC_REFERENCE;
           location^.llvmloc.sym:=initialref.symbol;
           exit;
         end;
@@ -475,8 +475,7 @@ implementation
         firstparaloc:=true;
         while assigned(paraloc) do
           begin
-            new(callpara);
-            callpara^.flags:=[];
+            new(callpara,init(paraloc^.def,std_param_align,lve_none,[]));
             callpara^.def:=paraloc^.def;
             { if the paraloc doesn't contain the value itself, it's a byval
               parameter }
@@ -491,20 +490,20 @@ implementation
               end;
             if firstparaloc and
                (lcp_byval in callpara^.flags) then
-              callpara^.alignment:=paras[i]^.Alignment
-            else
-              callpara^.alignment:=std_param_align;
+              callpara^.alignment:=paras[i]^.Alignment;
             llvmextractvalueextinfo(paras[i]^.def, callpara^.def, callpara^.valueext);
             case paraloc^.llvmloc.loc of
               LOC_CONSTANT:
                 begin
-                  callpara^.typ:=top_const;
-                  callpara^.value:=paraloc^.llvmloc.value;
+                  callpara^.loadconst(paraloc^.llvmloc.value);
+                end;
+              LOC_REFERENCE:
+                begin
+                  callpara^.loadsym(paraloc^.llvmloc.sym);
                 end;
               LOC_CREFERENCE:
                 begin
-                  callpara^.typ:=top_ref;
-                  callpara^.sym:=paraloc^.llvmloc.sym;
+                  callpara^.loadlocalsym(paraloc^.llvmloc.localsym);
                 end
               else
                 begin
@@ -515,18 +514,16 @@ implementation
                           internalerror(2014012307)
                         else
                           begin
-                            callpara^.typ:=top_reg;
                             reference_reset_base(href, cpointerdef.getreusable(callpara^.def), paraloc^.reference.index, paraloc^.reference.offset, ctempposinvalid, paraloc^.def.alignment, []);
                             res:=getregisterfordef(list, paraloc^.def);
                             load_ref_anyreg(callpara^.def, href, res);
+                            callpara^.loadreg(res);
                           end;
-                        callpara^.register:=res
                       end;
                     LOC_REGISTER,
                     LOC_FPUREGISTER,
                     LOC_MMREGISTER:
                       begin
-                        callpara^.typ:=top_reg;
                         { undo explicit value extension }
                         if callpara^.valueext<>lve_none then
                           begin
@@ -534,12 +531,12 @@ implementation
                             a_load_reg_reg(list, paraloc^.def, callpara^.def, paraloc^.register, res);
                             paraloc^.register:=res;
                           end;
-                        callpara^.register:=paraloc^.register
+                        callpara^.loadreg(paraloc^.register);
                       end;
                     { empty records }
                     LOC_VOID:
                       begin
-                        callpara^.typ:=top_undef;
+                        callpara^.loadundef;
                       end
                     else
                       internalerror(2014010605);

compiler/llvm/llvmtype.pas

@@ -275,8 +275,8 @@ implementation
                 begin
                   callpara:=pllvmcallpara(p.oper[opidx]^.paras[paraidx]);
                   record_def(callpara^.def);
-                  if callpara^.typ=top_tai then
-                    collect_tai_info(deftypelist,callpara^.ai);
+                  if callpara^.val.typ=top_tai then
+                    collect_tai_info(deftypelist,callpara^.val.ai);
                 end;
             else
               ;
@@ -372,16 +372,15 @@ implementation
                       for paraidx:=0 to p.oper[i]^.paras.count-1 do
                         begin
                           callpara:=pllvmcallpara(p.oper[i]^.paras[paraidx]);
-                          case callpara^.typ of
+                          case callpara^.val.typ of
                             top_tai:
-                              insert_tai_typeconversions(toplevellist,callpara^.ai);
+                              insert_tai_typeconversions(toplevellist,callpara^.val.ai);
                             top_ref:
                               begin
-                                cnv:=check_insert_bitcast(toplevellist,callpara^.sym,callpara^.def);
+                                cnv:=check_insert_bitcast(toplevellist,callpara^.val.sym,callpara^.def);
                                 if assigned(cnv) then
                                   begin
-                                    callpara^.typ:=top_tai;
-                                    callpara^.ai:=cnv;
+                                    callpara^.loadtai(cnv);
                                   end;
                               end;
                             else

compiler/llvm/nllvmbas.pas

@@ -78,20 +78,17 @@ interface
         end;
         res: PHashSetItem;
         callpara: pllvmcallpara;
+        paradef: tpointerdef;
       begin
         key.sym:=sym;
         res:=fsymbollookup.FindOrAdd(@key,sizeof(key));
         if not assigned(res^.Data) then
           begin
-            new(callpara);
-            callpara^.alignment:=std_param_align;
-            callpara^.def:=cpointerdef.getreusable(sym.vardef);
+            paradef:=cpointerdef.getreusable(sym.vardef);
             if (sym.typ=paravarsym) and
                paramanager.push_addr_param(sym.varspez,sym.vardef,current_procinfo.procdef.proccalloption) then
-              callpara^.def:=cpointerdef.getreusable(callpara^.def);
-            callpara^.flags:=[];
-            callpara^.valueext:=lve_none;
-            callpara^.typ:=top_reg;
+              paradef:=cpointerdef.getreusable(paradef);
+            new(callpara,init(paradef,std_param_align,lve_none,[]));
             { address must be a temp register }
             if (sym.localloc.loc<>LOC_REFERENCE) or
                (sym.localloc.reference.base=NR_NO) or
@@ -99,7 +96,7 @@ interface
                (sym.localloc.reference.offset<>0) or
                assigned(sym.localloc.reference.symbol) then
               internalerror(2016111001);
-            callpara^.register:=sym.localloc.reference.base;
+            callpara^.loadreg(sym.localloc.reference.base);
             fsymboldata.add(callpara);
             ptruint(res^.Data):=fsymboldata.count-1;
           end;

compiler/llvm/rgllvm.pas

@@ -135,10 +135,10 @@ implementation
                   for paracnt:=0 to paras.count-1 do
                     begin
                       callpara:=pllvmcallpara(paras[paracnt]);
-                      if (callpara^.typ=top_reg) and
-                         (getregtype(callpara^.register)=regtype) then
+                      if (callpara^.val.typ=top_reg) and
+                         (getregtype(callpara^.val.register)=regtype) then
                         begin
-                          result:=addreginfo(regs,r,callpara^.register,operand_read) or result;
+                          result:=addreginfo(regs,r,callpara^.val.register,operand_read) or result;
                           break
                         end;
                     end;
@@ -162,9 +162,9 @@ implementation
                 for paracnt:=0 to paras.count-1 do
                   begin
                     callpara:=pllvmcallpara(paras[paracnt]);
-                    if (callpara^.typ=top_reg) and
-                       (getregtype(callpara^.register)=regtype) then
-                      try_replace_reg(regs, callpara^.register,true);
+                    if (callpara^.val.typ=top_reg) and
+                       (getregtype(callpara^.val.register)=regtype) then
+                      try_replace_reg(regs, callpara^.val.register,true);
                   end;
               end;
             else
@@ -247,9 +247,9 @@ implementation
                   for paracnt:=0 to taillvm(supstart).oper[i]^.paras.count-1 do
                     begin
                       callpara:=pllvmcallpara(taillvm(supstart).oper[i]^.paras[paracnt]);
-                      if (callpara^.typ=top_reg) and
-                         (getregtype(callpara^.register)=regtype) and
-                         (getsupreg(callpara^.register)=supreg) then
+                      if (callpara^.val.typ=top_reg) and
+                         (getregtype(callpara^.val.register)=regtype) and
+                         (getsupreg(callpara^.val.register)=supreg) then
                         begin
                           def:=callpara^.def;
                           break

compiler/parabase.pas

@@ -65,6 +65,8 @@ unit parabase;
                stored in a temp with this register as base address }
              LOC_REGISTER:  (reg: tregister);
              LOC_CONSTANT:  (value: int64);
+             { for debug info }
+             LOC_CREFERENCE: (localsym: tsym);
          end;
 {$endif llvm}
          case TCGLoc of