* compiles again:

  * getcopy overhauled
  * goto node refers now the labelnode


git-svn-id: http://svn.freepascal.org/svn/fpc/branches/florian@441 3ad0048d-3df7-0310-abae-a5850022a9f2

18 files changed, 246 insertions, 221 deletions

diff --git a/nodeopt/compiler/nbas.pas b/nodeopt/compiler/nbas.pas
index 2a9951b67b..78bc6eb86a 100644
--- a/nodeopt/compiler/nbas.pas
+++ b/nodeopt/compiler/nbas.pas
@@ -61,7 +61,7 @@ interface
           procedure ppuwrite(ppufile:tcompilerppufile);override;
           procedure buildderefimpl;override;
           procedure derefimpl;override;
-          function getcopy : tnode;override;
+          function _getcopy : tnode;override;
           function pass_1 : tnode;override;
           function det_resulttype:tnode;override;
           function docompare(p: tnode): boolean; override;
@@ -123,7 +123,7 @@ interface
           procedure ppuwrite(ppufile:tcompilerppufile);override;
           procedure buildderefimpl;override;
           procedure derefimpl;override;
-          function getcopy: tnode; override;
+          function _getcopy: tnode; override;
           function pass_1 : tnode; override;
           function det_resulttype: tnode; override;
           function docompare(p: tnode): boolean; override;
@@ -137,7 +137,7 @@ interface
           constructor create_offset(const temp: ttempcreatenode;aoffset:longint);
           constructor ppuload(t:tnodetype;ppufile:tcompilerppufile);override;
           procedure ppuwrite(ppufile:tcompilerppufile);override;
-          function getcopy: tnode; override;
+          function _getcopy: tnode; override;
           procedure derefnode;override;
           function pass_1 : tnode; override;
           function det_resulttype : tnode; override;
@@ -159,7 +159,7 @@ interface
           constructor create_normal_temp(const temp: ttempcreatenode);
           constructor ppuload(t:tnodetype;ppufile:tcompilerppufile);override;
           procedure ppuwrite(ppufile:tcompilerppufile);override;
-          function getcopy: tnode; override;
+          function _getcopy: tnode; override;
           procedure derefnode;override;
           function pass_1: tnode; override;
           function det_resulttype: tnode; override;
@@ -622,11 +622,11 @@ implementation
       end;
 
 
-    function tasmnode.getcopy: tnode;
+    function tasmnode._getcopy: tnode;
       var
         n: tasmnode;
       begin
-        n := tasmnode(inherited getcopy);
+        n := tasmnode(inherited _getcopy);
         if assigned(p_asm) then
           begin
             n.p_asm:=taasmoutput.create;
@@ -634,7 +634,7 @@ implementation
           end
         else n.p_asm := nil;
         n.currenttai:=currenttai;
-        getcopy := n;
+        result:=n;
       end;
 
 
@@ -688,11 +688,11 @@ implementation
            (not tpointerdef(_restype.def).pointertype.def.needs_inittable));
       end;
 
-    function ttempcreatenode.getcopy: tnode;
+    function ttempcreatenode._getcopy: tnode;
       var
         n: ttempcreatenode;
       begin
-        n := ttempcreatenode(inherited getcopy);
+        n := ttempcreatenode(inherited _getcopy);
         n.size := size;
 
         new(n.tempinfo);
@@ -805,11 +805,11 @@ implementation
       end;
 
 
-    function ttemprefnode.getcopy: tnode;
+    function ttemprefnode._getcopy: tnode;
       var
         n: ttemprefnode;
       begin
-        n := ttemprefnode(inherited getcopy);
+        n := ttemprefnode(inherited _getcopy);
         n.offset := offset;
 
         if assigned(tempinfo^.hookoncopy) then
@@ -933,11 +933,11 @@ implementation
       end;
 
 
-    function ttempdeletenode.getcopy: tnode;
+    function ttempdeletenode._getcopy: tnode;
       var
         n: ttempdeletenode;
       begin
-        n := ttempdeletenode(inherited getcopy);
+        n := ttempdeletenode(inherited _getcopy);
         n.release_to_normal := release_to_normal;
 
         if assigned(tempinfo^.hookoncopy) then
diff --git a/nodeopt/compiler/ncal.pas b/nodeopt/compiler/ncal.pas
index ea736f3cbd..84a88843b0 100644
--- a/nodeopt/compiler/ncal.pas
+++ b/nodeopt/compiler/ncal.pas
@@ -115,7 +115,7 @@ interface
           procedure ppuwrite(ppufile:tcompilerppufile);override;
           procedure buildderefimpl;override;
           procedure derefimpl;override;
-          function  getcopy : tnode;override;
+          function  _getcopy : tnode;override;
           { Goes through all symbols in a class and subclasses and calls
             verify abstract for each .
           }
@@ -156,7 +156,7 @@ interface
           destructor destroy;override;
           constructor ppuload(t:tnodetype;ppufile:tcompilerppufile);override;
           procedure ppuwrite(ppufile:tcompilerppufile);override;
-          function getcopy : tnode;override;
+          function _getcopy : tnode;override;
           procedure insertintolist(l : tnodelist);override;
           procedure get_paratype;
           procedure insert_typeconv(do_count : boolean);
@@ -433,13 +433,13 @@ type
       end;
 
 
-    function tcallparanode.getcopy : tnode;
+    function tcallparanode._getcopy : tnode;
 
       var
          n : tcallparanode;
 
       begin
-         n:=tcallparanode(inherited getcopy);
+         n:=tcallparanode(inherited _getcopy);
          n.callparaflags:=callparaflags;
          n.parasym:=parasym;
          result:=n;
@@ -979,7 +979,7 @@ type
       end;
 
 
-    function tcallnode.getcopy : tnode;
+    function tcallnode._getcopy : tnode;
       var
         n : tcallnode;
         i : integer;
@@ -991,7 +991,7 @@ type
           the can reference methodpointer }
         oldleft:=left;
         left:=nil;
-        n:=tcallnode(inherited getcopy);
+        n:=tcallnode(inherited _getcopy);
         left:=oldleft;
         n.symtableprocentry:=symtableprocentry;
         n.symtableproc:=symtableproc;
@@ -999,30 +999,30 @@ type
         n.restype := restype;
         n.callnodeflags := callnodeflags;
         if assigned(methodpointerinit) then
-         n.methodpointerinit:=tblocknode(methodpointerinit.getcopy)
+         n.methodpointerinit:=tblocknode(methodpointerinit._getcopy)
         else
          n.methodpointerinit:=nil;
         { methodpointerinit is copied, now references to the temp will also be copied
           correctly. We can now copy the parameters and methodpointer }
         if assigned(left) then
-         n.left:=left.getcopy
+         n.left:=left._getcopy
         else
          n.left:=nil;
         if assigned(methodpointer) then
-         n.methodpointer:=methodpointer.getcopy
+         n.methodpointer:=methodpointer._getcopy
         else
          n.methodpointer:=nil;
         if assigned(methodpointerdone) then
-         n.methodpointerdone:=tblocknode(methodpointerdone.getcopy)
+         n.methodpointerdone:=tblocknode(methodpointerdone._getcopy)
         else
          n.methodpointerdone:=nil;
         if assigned(_funcretnode) then
-         n._funcretnode:=_funcretnode.getcopy
+         n._funcretnode:=_funcretnode._getcopy
         else
          n._funcretnode:=nil;
 {$ifdef PASS2INLINE}
         if assigned(inlinecode) then
-         n.inlinecode:=inlinecode.getcopy
+         n.inlinecode:=inlinecode._getcopy
         else
          n.inlinecode:=nil;
 {$endif PASS2INLINE}
diff --git a/nodeopt/compiler/ncgflw.pas b/nodeopt/compiler/ncgflw.pas
index a6f2fa835b..b786b29677 100644
--- a/nodeopt/compiler/ncgflw.pas
+++ b/nodeopt/compiler/ncgflw.pas
@@ -27,7 +27,7 @@ unit ncgflw;
 interface
 
     uses
-      node,nflw;
+      aasmbase,node,nflw;
 
     type
        tcgwhilerepeatnode = class(twhilerepeatnode)
@@ -59,6 +59,10 @@ interface
        end;
 
        tcglabelnode = class(tlabelnode)
+       private
+          asmlabel : tasmlabel;
+       public
+          function getasmlabel : tasmlabel;
           procedure pass_2;override;
        end;
 
@@ -82,7 +86,7 @@ implementation
 
     uses
       verbose,globals,systems,globtype,
-      symconst,symdef,symsym,aasmbase,aasmtai,aasmcpu,defutil,
+      symconst,symdef,symsym,aasmtai,aasmcpu,defutil,
       procinfo,cgbase,pass_2,parabase,
       cpubase,cpuinfo,
       nld,ncon,
@@ -745,7 +749,7 @@ implementation
 {$ifdef OLDREGVARS}
          load_all_regvars(exprasmlist);
 {$endif OLDREGVARS}
-         cg.a_jmp_always(exprasmlist,labsym.lab)
+         cg.a_jmp_always(exprasmlist,tcglabelnode(labelnode).getasmlabel)
        end;
 
 
@@ -753,6 +757,14 @@ implementation
                              SecondLabel
 *****************************************************************************}
 
+    function tcglabelnode.getasmlabel : tasmlabel;
+      begin
+        if not(assigned(asmlabel)) then
+          objectlibrary.getlabel(asmlabel);
+        result:=asmlabel
+      end;
+
+
     procedure tcglabelnode.pass_2;
       begin
          location_reset(location,LOC_VOID,OS_NO);
@@ -760,7 +772,7 @@ implementation
 {$ifdef OLDREGVARS}
          load_all_regvars(exprasmlist);
 {$endif OLDREGVARS}
-         cg.a_label(exprasmlist,labelnr);
+         cg.a_label(exprasmlist,getasmlabel);
          secondpass(left);
       end;
 
diff --git a/nodeopt/compiler/ncnv.pas b/nodeopt/compiler/ncnv.pas
index c83fb6af04..ce7690cb50 100644
--- a/nodeopt/compiler/ncnv.pas
+++ b/nodeopt/compiler/ncnv.pas
@@ -44,7 +44,7 @@ interface
           procedure ppuwrite(ppufile:tcompilerppufile);override;
           procedure buildderefimpl;override;
           procedure derefimpl;override;
-          function getcopy : tnode;override;
+          function _getcopy : tnode;override;
           procedure printnodeinfo(var t : text);override;
           function pass_1 : tnode;override;
           function det_resulttype:tnode;override;
@@ -175,7 +175,7 @@ interface
           constructor create(l,r : tnode);virtual;
           function pass_1 : tnode;override;
           function det_resulttype:tnode;override;
-          function getcopy: tnode;override;
+          function _getcopy: tnode;override;
           destructor destroy; override;
          protected
           call: tnode;
@@ -581,14 +581,14 @@ implementation
       end;
 
 
-    function ttypeconvnode.getcopy : tnode;
+    function ttypeconvnode._getcopy : tnode;
       var
          n : ttypeconvnode;
       begin
-         n:=ttypeconvnode(inherited getcopy);
+         n:=ttypeconvnode(inherited _getcopy);
          n.convtype:=convtype;
          n.totype:=totype;
-         getcopy:=n;
+         _getcopy:=n;
       end;
 
     procedure ttypeconvnode.printnodeinfo(var t : text);
@@ -2583,10 +2583,10 @@ implementation
       end;
 
 
-    function tasnode.getcopy: tnode;
+    function tasnode._getcopy: tnode;
 
       begin
-        result := inherited getcopy;
+        result := inherited _getcopy;
         if assigned(call) then
           tasnode(result).call := call.getcopy
         else
diff --git a/nodeopt/compiler/ncon.pas b/nodeopt/compiler/ncon.pas
index 8c45618ad4..219ed90f93 100644
--- a/nodeopt/compiler/ncon.pas
+++ b/nodeopt/compiler/ncon.pas
@@ -41,7 +41,7 @@ interface
           procedure ppuwrite(ppufile:tcompilerppufile);override;
           procedure buildderefimpl;override;
           procedure derefimpl;override;
-          function getcopy : tnode;override;
+          function _getcopy : tnode;override;
           function pass_1 : tnode;override;
           function det_resulttype:tnode;override;
           function docompare(p: tnode) : boolean; override;
@@ -62,7 +62,7 @@ interface
           procedure ppuwrite(ppufile:tcompilerppufile);override;
           procedure buildderefimpl;override;
           procedure derefimpl;override;
-          function getcopy : tnode;override;
+          function _getcopy : tnode;override;
           function pass_1 : tnode;override;
           function det_resulttype:tnode;override;
           function docompare(p: tnode) : boolean; override;
@@ -78,7 +78,7 @@ interface
           procedure ppuwrite(ppufile:tcompilerppufile);override;
           procedure buildderefimpl;override;
           procedure derefimpl;override;
-          function getcopy : tnode;override;
+          function _getcopy : tnode;override;
           function pass_1 : tnode;override;
           function det_resulttype:tnode;override;
           function docompare(p: tnode) : boolean; override;
@@ -98,7 +98,7 @@ interface
           procedure buildderefimpl;override;
           procedure derefimpl;override;
           destructor destroy;override;
-          function getcopy : tnode;override;
+          function _getcopy : tnode;override;
           function pass_1 : tnode;override;
           function det_resulttype:tnode;override;
           function getpcharcopy : pchar;
@@ -116,7 +116,7 @@ interface
           procedure ppuwrite(ppufile:tcompilerppufile);override;
           procedure buildderefimpl;override;
           procedure derefimpl;override;
-          function getcopy : tnode;override;
+          function _getcopy : tnode;override;
           function pass_1 : tnode;override;
           function det_resulttype:tnode;override;
           function docompare(p: tnode) : boolean; override;
@@ -135,7 +135,7 @@ interface
           constructor create(const g:tguid);virtual;
           constructor ppuload(t:tnodetype;ppufile:tcompilerppufile);override;
           procedure ppuwrite(ppufile:tcompilerppufile);override;
-          function getcopy : tnode;override;
+          function _getcopy : tnode;override;
           function pass_1 : tnode;override;
           function det_resulttype:tnode;override;
           function docompare(p: tnode) : boolean; override;
@@ -314,16 +314,16 @@ implementation
       end;
 
 
-    function trealconstnode.getcopy : tnode;
+    function trealconstnode._getcopy : tnode;
 
       var
          n : trealconstnode;
 
       begin
-         n:=trealconstnode(inherited getcopy);
+         n:=trealconstnode(inherited _getcopy);
          n.value_real:=value_real;
          n.lab_real:=lab_real;
-         getcopy:=n;
+         _getcopy:=n;
       end;
 
     function trealconstnode.det_resulttype:tnode;
@@ -406,16 +406,16 @@ implementation
       end;
 
 
-    function tordconstnode.getcopy : tnode;
+    function tordconstnode._getcopy : tnode;
 
       var
          n : tordconstnode;
 
       begin
-         n:=tordconstnode(inherited getcopy);
+         n:=tordconstnode(inherited _getcopy);
          n.value:=value;
          n.restype := restype;
-         getcopy:=n;
+         _getcopy:=n;
       end;
 
     function tordconstnode.det_resulttype:tnode;
@@ -491,16 +491,16 @@ implementation
       end;
 
 
-    function tpointerconstnode.getcopy : tnode;
+    function tpointerconstnode._getcopy : tnode;
 
       var
          n : tpointerconstnode;
 
       begin
-         n:=tpointerconstnode(inherited getcopy);
+         n:=tpointerconstnode(inherited _getcopy);
          n.value:=value;
          n.restype := restype;
-         getcopy:=n;
+         _getcopy:=n;
       end;
 
     function tpointerconstnode.det_resulttype:tnode;
@@ -645,13 +645,13 @@ implementation
       end;
 
 
-    function tstringconstnode.getcopy : tnode;
+    function tstringconstnode._getcopy : tnode;
 
       var
          n : tstringconstnode;
 
       begin
-         n:=tstringconstnode(inherited getcopy);
+         n:=tstringconstnode(inherited _getcopy);
          n.st_type:=st_type;
          n.len:=len;
          n.lab_str:=lab_str;
@@ -662,7 +662,7 @@ implementation
            end
          else
            n.value_str:=getpcharcopy;
-         getcopy:=n;
+         _getcopy:=n;
       end;
 
     function tstringconstnode.det_resulttype:tnode;
@@ -783,13 +783,13 @@ implementation
       end;
 
 
-    function tsetconstnode.getcopy : tnode;
+    function tsetconstnode._getcopy : tnode;
 
       var
          n : tsetconstnode;
 
       begin
-         n:=tsetconstnode(inherited getcopy);
+         n:=tsetconstnode(inherited _getcopy);
          if assigned(value_set) then
            begin
               new(n.value_set);
@@ -799,7 +799,7 @@ implementation
            n.value_set:=nil;
          n.restype := restype;
          n.lab_set:=lab_set;
-         getcopy:=n;
+         _getcopy:=n;
       end;
 
     function tsetconstnode.det_resulttype:tnode;
@@ -872,15 +872,15 @@ implementation
       end;
 
 
-    function tguidconstnode.getcopy : tnode;
+    function tguidconstnode._getcopy : tnode;
 
       var
          n : tguidconstnode;
 
       begin
-         n:=tguidconstnode(inherited getcopy);
+         n:=tguidconstnode(inherited _getcopy);
          n.value:=value;
-         getcopy:=n;
+         _getcopy:=n;
       end;
 
     function tguidconstnode.det_resulttype:tnode;
diff --git a/nodeopt/compiler/nflw.pas b/nodeopt/compiler/nflw.pas
index 2aeed4d27a..f8de9ae678 100644
--- a/nodeopt/compiler/nflw.pas
+++ b/nodeopt/compiler/nflw.pas
@@ -27,10 +27,11 @@ unit nflw;
 interface
 
     uses
-       node,cpubase,
-       aasmbase,aasmtai,aasmcpu,symnot,
-       symtype,symbase,symdef,symsym,
-       optunrol;
+      classes,
+      node,cpubase,
+      symnot,
+      symtype,symbase,symdef,symsym,
+      optunrol;
 
     type
        { flags used by loop nodes }
@@ -52,12 +53,14 @@ interface
          loopflagsequal = [lnf_backward];
 
     type
+       tlabelnode = class;
+
        tloopnode = class(tbinarynode)
           t1,t2 : tnode;
           loopflags : tloopflags;
           constructor create(tt : tnodetype;l,r,_t1,_t2 : tnode);virtual;
           destructor destroy;override;
-          function getcopy : tnode;override;
+          function _getcopy : tnode;override;
           constructor ppuload(t:tnodetype;ppufile:tcompilerppufile);override;
           procedure ppuwrite(ppufile:tcompilerppufile);override;
           procedure buildderefimpl;override;
@@ -85,7 +88,10 @@ interface
        tifnodeclass = class of tifnode;
 
        tfornode = class(tloopnode)
-          unrollinfo : tunrollinfo;
+          { if count isn divisable by unrolls then
+            the for loop must jump to this label to get the correct
+            number of executions }
+          entrylabel : tnode;
           loopvar_notid:cardinal;
           constructor create(l,r,_t1,_t2 : tnode;back : boolean);virtual;
           procedure loop_var_access(not_type:Tnotification_flag;symbol:Tsym);
@@ -118,18 +124,20 @@ interface
        tcontinuenodeclass = class of tcontinuenode;
 
        tgotonode = class(tnode)
-          // labsym : tlabelsym;
+          { we still need this for resolving forward gotos }
+          labelsym : tlabelsym;
           labelnode : tlabelnode;
-          labsymderef : tderef;
           exceptionblock : integer;
 {          internlab : tinterngotolabel;}
-          constructor create(p : tlabelsym);virtual;
+          constructor create(p : tlabelnode);virtual;
+          { as long as we don't know the label node we can't resolve it }
+          constructor create_sym(p : tlabelsym);virtual;
 {          constructor createintern(g:tinterngotolabel);}
           constructor ppuload(t:tnodetype;ppufile:tcompilerppufile);override;
           procedure ppuwrite(ppufile:tcompilerppufile);override;
           procedure buildderefimpl;override;
           procedure derefimpl;override;
-          function getcopy : tnode;override;
+          function _getcopy : tnode;override;
           function det_resulttype:tnode;override;
           function pass_1 : tnode;override;
           function docompare(p: tnode): boolean; override;
@@ -137,19 +145,17 @@ interface
        tgotonodeclass = class of tgotonode;
 
        tlabelnode = class(tunarynode)
-          labelnr : tasmlabel;
           exceptionblock : integer;
           { when copying trees, this points to the newly created copy of a label }
           copiedto : tlabelnode;
           { contains all goto nodesrefering to this label }
           referinggotonodes : tlist;
-          constructor createcase(p : tasmlabel;l:tnode);virtual;
-          constructor create(p : tlabelsym;l:tnode);virtual;
+          constructor create(l:tnode);virtual;
           constructor ppuload(t:tnodetype;ppufile:tcompilerppufile);override;
           procedure ppuwrite(ppufile:tcompilerppufile);override;
           procedure buildderefimpl;override;
           procedure derefimpl;override;
-          function getcopy : tnode;override;
+          function _getcopy : tnode;override;
           function det_resulttype:tnode;override;
           function pass_1 : tnode;override;
           function docompare(p: tnode): boolean; override;
@@ -163,7 +169,7 @@ interface
           procedure ppuwrite(ppufile:tcompilerppufile);override;
           procedure buildderefimpl;override;
           procedure derefimpl;override;
-          function getcopy : tnode;override;
+          function _getcopy : tnode;override;
           procedure insertintolist(l : tnodelist);override;
           function det_resulttype:tnode;override;
           function pass_1 : tnode;override;
@@ -195,7 +201,7 @@ interface
           constructor ppuload(t:tnodetype;ppufile:tcompilerppufile);override;
           function det_resulttype:tnode;override;
           function pass_1 : tnode;override;
-          function getcopy : tnode;override;
+          function _getcopy : tnode;override;
           function docompare(p: tnode): boolean; override;
        end;
        tonnodeclass = class of tonnode;
@@ -287,23 +293,23 @@ implementation
       end;
 
 
-    function tloopnode.getcopy : tnode;
+    function tloopnode._getcopy : tnode;
 
       var
          p : tloopnode;
 
       begin
-         p:=tloopnode(inherited getcopy);
+         p:=tloopnode(inherited _getcopy);
          if assigned(t1) then
-           p.t1:=t1.getcopy
+           p.t1:=t1._getcopy
          else
            p.t1:=nil;
          if assigned(t2) then
-           p.t2:=t2.getcopy
+           p.t2:=t2._getcopy
          else
            p.t2:=nil;
          p.loopflags:=loopflags;
-         getcopy:=p;
+         _getcopy:=p;
       end;
 
     procedure tloopnode.insertintolist(l : tnodelist);
@@ -894,18 +900,31 @@ implementation
                              TGOTONODE
 *****************************************************************************}
 
-    constructor tgotonode.create(p : tlabelsym);
+    constructor tgotonode.create(p : tlabelnode);
       begin
         inherited create(goton);
         exceptionblock:=aktexceptblock;
-        labsym:=p;
+        labelnode:=p;
+        labelsym:=nil;
+      end;
+
+
+    constructor tgotonode.create_sym(p : tlabelsym);
+      begin
+        inherited create(goton);
+        exceptionblock:=aktexceptblock;
+        if assigned(p.code) then
+          labelnode:=tlabelnode(p.code)
+        else
+          labelnode:=nil;
+        labelsym:=p;
       end;
 
 
     constructor tgotonode.ppuload(t:tnodetype;ppufile:tcompilerppufile);
       begin
         inherited ppuload(t,ppufile);
-        ppufile.getderef(labsymderef);
+        labelnode:=tlabelnode(ppuloadnoderef(ppufile));
         exceptionblock:=ppufile.getbyte;
       end;
 
@@ -913,7 +932,7 @@ implementation
     procedure tgotonode.ppuwrite(ppufile:tcompilerppufile);
       begin
         inherited ppuwrite(ppufile);
-        ppufile.putderef(labsymderef);
+        ppuwritenoderef(ppufile,labelnode);
         ppufile.putbyte(exceptionblock);
       end;
 
@@ -921,14 +940,14 @@ implementation
     procedure tgotonode.buildderefimpl;
       begin
         inherited buildderefimpl;
-        labsymderef.build(labsym);
+        //!!! deref(labelnode);
       end;
 
 
     procedure tgotonode.derefimpl;
       begin
         inherited derefimpl;
-        labsym:=tlabelsym(labsymderef.resolve);
+        //!!! deref(labelnode);
       end;
 
 
@@ -936,28 +955,36 @@ implementation
       begin
         result:=nil;
         resulttype:=voidtype;
+
+        if not(assigned(labelnode)) then
+          begin
+            if assigned(labelsym.code) then
+              labelnode:=tlabelnode(labelsym.code)
+            else
+              internalerror(200506183);
+          end;
       end;
 
 
     function tgotonode.pass_1 : tnode;
       begin
-         result:=nil;
-         expectloc:=LOC_VOID;
-         { check if }
-         if assigned(labsym) and
-            assigned(labsym.code) and
-            (exceptionblock<>tlabelnode(labsym.code).exceptionblock) then
+        result:=nil;
+        expectloc:=LOC_VOID;
+
+         { check if we don't mess with exception blocks }
+         if assigned(labelnode) and
+            (exceptionblock<>labelnode.exceptionblock) then
            CGMessage(cg_e_goto_inout_of_exception_block);
       end;
 
 
-   function tgotonode.getcopy : tnode;
+   function tgotonode._getcopy : tnode;
      var
        p : tgotonode;
        i : aint;
      begin
-        p:=tgotonode(inherited getcopy);
-        p.labsym:=labsym;
+        p:=tgotonode(inherited _getcopy);
+        {
         p.exceptionblock:=exceptionblock;
         { When we copying, we do an ugly trick to determine if the label used
           by the current goto node is already copied: if the referinggotonodes
@@ -979,7 +1006,7 @@ implementation
           end;
         p.labelnode:=newlabelnode;
         p.labelnode.referinggotonodes.add(self);
-
+        }
         result:=p;
      end;
 
@@ -994,32 +1021,16 @@ implementation
                              TLABELNODE
 *****************************************************************************}
 
-    constructor tlabelnode.createcase(p : tasmlabel;l:tnode);
-      begin
-        inherited create(labeln,l);
-        { it shouldn't be possible to jump to case labels using goto }
-        exceptionblock:=-1;
-        labsym:=nil;
-        labelnr:=p;
-      end;
-
-
-    constructor tlabelnode.create(p : tlabelsym;l:tnode);
+    constructor tlabelnode.create(l:tnode);
       begin
         inherited create(labeln,l);
         exceptionblock:=aktexceptblock;
-        labsym:=p;
-        labelnr:=p.lab;
-        { save the current labelnode in the labelsym }
-        p.code:=self;
       end;
 
 
     constructor tlabelnode.ppuload(t:tnodetype;ppufile:tcompilerppufile);
       begin
         inherited ppuload(t,ppufile);
-        ppufile.getderef(labsymderef);
-        labelnr:=tasmlabel(ppufile.getasmsymbol);
         exceptionblock:=ppufile.getbyte;
       end;
 
@@ -1027,8 +1038,6 @@ implementation
     procedure tlabelnode.ppuwrite(ppufile:tcompilerppufile);
       begin
         inherited ppuwrite(ppufile);
-        ppufile.putderef(labsymderef);
-        ppufile.putasmsymbol(labelnr);
         ppufile.putbyte(exceptionblock);
       end;
 
@@ -1036,15 +1045,12 @@ implementation
     procedure tlabelnode.buildderefimpl;
       begin
         inherited buildderefimpl;
-        labsymderef.build(labsym);
       end;
 
 
     procedure tlabelnode.derefimpl;
       begin
         inherited derefimpl;
-        labsym:=tlabelsym(labsymderef.resolve);
-        objectlibrary.derefasmsymbol(tasmsymbol(labelnr));
       end;
 
 
@@ -1074,18 +1080,13 @@ implementation
       end;
 
 
-   function tlabelnode.getcopy : tnode;
+   function tlabelnode._getcopy : tnode;
      var
         p : tlabelnode;
      begin
-        p:=tlabelnode(inherited getcopy);
-        { experimental, let's see if it breaks,
-          at least it makes no sense to have one asm label twice (FK)
-        p.labelnr:=labelnr;   }
-        p.labelnr:=
+        p:=tlabelnode(inherited _getcopy);
         p.exceptionblock:=exceptionblock;
 
-        p.labsym:=labsym;
         result:=p;
      end;
 
@@ -1137,16 +1138,16 @@ implementation
       end;
 
 
-    function traisenode.getcopy : tnode;
+    function traisenode._getcopy : tnode;
       var
          n : traisenode;
       begin
-         n:=traisenode(inherited getcopy);
+         n:=traisenode(inherited _getcopy);
          if assigned(frametree) then
-           n.frametree:=frametree.getcopy
+           n.frametree:=frametree._getcopy
          else
            n.frametree:=nil;
-         getcopy:=n;
+         _getcopy:=n;
       end;
 
 
@@ -1356,11 +1357,11 @@ implementation
       end;
 
 
-    function tonnode.getcopy : tnode;
+    function tonnode._getcopy : tnode;
       var
          n : tonnode;
       begin
-         n:=tonnode(inherited getcopy);
+         n:=tonnode(inherited _getcopy);
          n.exceptsymtable:=exceptsymtable.getcopy;
          n.excepttype:=excepttype;
          result:=n;
diff --git a/nodeopt/compiler/ninl.pas b/nodeopt/compiler/ninl.pas
index 244afa72de..a32ed3ab03 100644
--- a/nodeopt/compiler/ninl.pas
+++ b/nodeopt/compiler/ninl.pas
@@ -36,7 +36,7 @@ interface
           constructor create(number : byte;is_const:boolean;l : tnode);virtual;
           constructor ppuload(t:tnodetype;ppufile:tcompilerppufile);override;
           procedure ppuwrite(ppufile:tcompilerppufile);override;
-          function getcopy : tnode;override;
+          function _getcopy : tnode;override;
           function pass_1 : tnode;override;
           function det_resulttype:tnode;override;
           function docompare(p: tnode): boolean; override;
@@ -116,11 +116,11 @@ implementation
       end;
 
 
-    function tinlinenode.getcopy : tnode;
+    function tinlinenode._getcopy : tnode;
       var
          n : tinlinenode;
       begin
-         n:=tinlinenode(inherited getcopy);
+         n:=tinlinenode(inherited _getcopy);
          n.inlinenumber:=inlinenumber;
          result:=n;
       end;
diff --git a/nodeopt/compiler/nld.pas b/nodeopt/compiler/nld.pas
index 0a3accc5c1..93056648ad 100644
--- a/nodeopt/compiler/nld.pas
+++ b/nodeopt/compiler/nld.pas
@@ -47,7 +47,7 @@ interface
           procedure derefimpl;override;
           procedure set_mp(p:tnode);
           function  is_addr_param_load:boolean;
-          function  getcopy : tnode;override;
+          function  _getcopy : tnode;override;
           function  pass_1 : tnode;override;
           function  det_resulttype:tnode;override;
           procedure mark_write;override;
@@ -64,7 +64,7 @@ interface
           constructor create(l,r : tnode);virtual;
           constructor ppuload(t:tnodetype;ppufile:tcompilerppufile);override;
           procedure ppuwrite(ppufile:tcompilerppufile);override;
-          function getcopy : tnode;override;
+          function _getcopy : tnode;override;
           function pass_1 : tnode;override;
           function det_resulttype:tnode;override;
        {$ifdef state_tracking}
@@ -83,7 +83,7 @@ interface
 
        tarrayconstructornode = class(tbinarynode)
           constructor create(l,r : tnode);virtual;
-          function getcopy : tnode;override;
+          function _getcopy : tnode;override;
           function pass_1 : tnode;override;
           function det_resulttype:tnode;override;
           function docompare(p: tnode): boolean; override;
@@ -116,7 +116,7 @@ interface
           procedure ppuwrite(ppufile:tcompilerppufile);override;
           procedure buildderefimpl;override;
           procedure derefimpl;override;
-          function  getcopy : tnode;override;
+          function  _getcopy : tnode;override;
           function pass_1 : tnode;override;
           function det_resulttype:tnode;override;
           function docompare(p: tnode): boolean; override;
@@ -213,12 +213,12 @@ implementation
       end;
 
 
-    function tloadnode.getcopy : tnode;
+    function tloadnode._getcopy : tnode;
       var
          n : tloadnode;
 
       begin
-         n:=tloadnode(inherited getcopy);
+         n:=tloadnode(inherited _getcopy);
          n.symtable:=symtable;
          n.symtableentry:=symtableentry;
          n.procdef:=procdef;
@@ -475,15 +475,15 @@ implementation
       end;
 
 
-    function tassignmentnode.getcopy : tnode;
+    function tassignmentnode._getcopy : tnode;
 
       var
          n : tassignmentnode;
 
       begin
-         n:=tassignmentnode(inherited getcopy);
+         n:=tassignmentnode(inherited _getcopy);
          n.assigntype:=assigntype;
-         getcopy:=n;
+         result:=n;
       end;
 
 
@@ -860,11 +860,11 @@ implementation
       end;
 
 
-    function tarrayconstructornode.getcopy : tnode;
+    function tarrayconstructornode._getcopy : tnode;
       var
          n : tarrayconstructornode;
       begin
-         n:=tarrayconstructornode(inherited getcopy);
+         n:=tarrayconstructornode(inherited _getcopy);
          result:=n;
       end;
 
@@ -1158,11 +1158,11 @@ implementation
       end;
 
 
-    function trttinode.getcopy : tnode;
+    function trttinode._getcopy : tnode;
       var
          n : trttinode;
       begin
-         n:=trttinode(inherited getcopy);
+         n:=trttinode(inherited _getcopy);
          n.rttidef:=rttidef;
          n.rttitype:=rttitype;
          result:=n;
diff --git a/nodeopt/compiler/nmem.pas b/nodeopt/compiler/nmem.pas
index 2c9bb514b9..5e975ccecd 100644
--- a/nodeopt/compiler/nmem.pas
+++ b/nodeopt/compiler/nmem.pas
@@ -47,7 +47,7 @@ interface
           procedure derefimpl;override;
           function pass_1 : tnode;override;
           function det_resulttype:tnode;override;
-          function getcopy : tnode;override;
+          function _getcopy : tnode;override;
        end;
        tloadparentfpnodeclass = class of tloadparentfpnode;
 
@@ -61,7 +61,7 @@ interface
           procedure mark_write;override;
           procedure buildderefimpl;override;
           procedure derefimpl;override;
-          function getcopy : tnode;override;
+          function _getcopy : tnode;override;
           function pass_1 : tnode;override;
           function det_resulttype:tnode;override;
        end;
@@ -83,7 +83,7 @@ interface
           procedure ppuwrite(ppufile:tcompilerppufile);override;
           procedure buildderefimpl;override;
           procedure derefimpl;override;
-          function getcopy : tnode;override;
+          function _getcopy : tnode;override;
           function pass_1 : tnode;override;
           function docompare(p: tnode): boolean; override;
           function det_resulttype:tnode;override;
@@ -107,7 +107,7 @@ interface
           destructor destroy;override;
           constructor ppuload(t:tnodetype;ppufile:tcompilerppufile);override;
           procedure ppuwrite(ppufile:tcompilerppufile);override;
-          function getcopy : tnode;override;
+          function _getcopy : tnode;override;
           function pass_1 : tnode;override;
           function docompare(p: tnode): boolean; override;
           function det_resulttype:tnode;override;
@@ -218,13 +218,13 @@ implementation
       end;
 
 
-    function tloadparentfpnode.getcopy : tnode;
+    function tloadparentfpnode._getcopy : tnode;
       var
          p : tloadparentfpnode;
       begin
-         p:=tloadparentfpnode(inherited getcopy);
+         p:=tloadparentfpnode(inherited _getcopy);
          p.parentpd:=parentpd;
-         getcopy:=p;
+         _getcopy:=p;
       end;
 
 
@@ -318,15 +318,15 @@ implementation
       end;
 
 
-    function taddrnode.getcopy : tnode;
+    function taddrnode._getcopy : tnode;
 
       var
          p : taddrnode;
 
       begin
-         p:=taddrnode(inherited getcopy);
+         p:=taddrnode(inherited _getcopy);
          p.getprocvardef:=getprocvardef;
-         getcopy:=p;
+         _getcopy:=p;
       end;
 
 
@@ -559,15 +559,15 @@ implementation
       end;
 
 
-    function tsubscriptnode.getcopy : tnode;
+    function tsubscriptnode._getcopy : tnode;
 
       var
          p : tsubscriptnode;
 
       begin
-         p:=tsubscriptnode(inherited getcopy);
+         p:=tsubscriptnode(inherited _getcopy);
          p.vs:=vs;
-         getcopy:=p;
+         _getcopy:=p;
       end;
 
 
@@ -870,17 +870,17 @@ implementation
       end;
 
 
-    function twithnode.getcopy : tnode;
+    function twithnode._getcopy : tnode;
 
       var
          p : twithnode;
 
       begin
-         p:=twithnode(inherited getcopy);
+         p:=twithnode(inherited _getcopy);
          p.withsymtable:=withsymtable;
          p.tablecount:=tablecount;
          if assigned(p.withrefnode) then
-           p.withrefnode:=withrefnode.getcopy
+           p.withrefnode:=withrefnode._getcopy
          else
            p.withrefnode:=nil;
          result:=p;
diff --git a/nodeopt/compiler/node.pas b/nodeopt/compiler/node.pas
index 5250648f18..1e6a24d640 100644
--- a/nodeopt/compiler/node.pas
+++ b/nodeopt/compiler/node.pas
@@ -329,8 +329,11 @@ interface
           function isequal(p : tnode) : boolean;
           { to implement comparisation, override this method }
           function docompare(p : tnode) : boolean;virtual;
-          { gets a copy of the node }
-          function getcopy : tnode;virtual;
+          { wrapper for getcopy }
+          function getcopy : tnode;
+
+          { does the real copying of a node }
+          function _getcopy : tnode;virtual;
 
           procedure insertintolist(l : tnodelist);virtual;
           { writes a node for debugging purpose, shouldn't be called }
@@ -363,7 +366,7 @@ interface
           procedure concattolist(l : tlinkedlist);override;
           function ischild(p : tnode) : boolean;override;
           function docompare(p : tnode) : boolean;override;
-          function getcopy : tnode;override;
+          function _getcopy : tnode;override;
           procedure insertintolist(l : tnodelist);override;
           procedure left_max;
           procedure printnodedata(var t:text);override;
@@ -383,7 +386,7 @@ interface
           function ischild(p : tnode) : boolean;override;
           function docompare(p : tnode) : boolean;override;
           procedure swapleftright;
-          function getcopy : tnode;override;
+          function _getcopy : tnode;override;
           procedure insertintolist(l : tnodelist);override;
           procedure left_right_max;
           procedure printnodedata(var t:text);override;
@@ -404,6 +407,8 @@ interface
     procedure ppuwritenode(ppufile:tcompilerppufile;n:tnode);
     function ppuloadnodetree(ppufile:tcompilerppufile):tnode;
     procedure ppuwritenodetree(ppufile:tcompilerppufile;n:tnode);
+    procedure ppuwritenoderef(ppufile:tcompilerppufile;n:tnode);
+    function ppuloadnoderef(ppufile:tcompilerppufile) : tnode;
 
     const
       printnodespacing = '   ';
@@ -528,6 +533,20 @@ implementation
       end;
 
 
+    procedure ppuwritenoderef(ppufile:tcompilerppufile;n:tnode);
+      begin
+        { writing of node references isn't implemented yet (FK) }
+        internalerror(200506181);
+      end;
+
+
+    function ppuloadnoderef(ppufile:tcompilerppufile) : tnode;
+      begin
+        { reading of node references isn't implemented yet (FK) }
+        internalerror(200506182);
+      end;
+
+
     function ppuloadnodetree(ppufile:tcompilerppufile):tnode;
       begin
         if ppufile.readentry<>ibnodetree then
@@ -802,6 +821,12 @@ implementation
 
 
     function tnode.getcopy : tnode;
+      begin
+        result:=getcopy;
+      end;
+
+
+    function tnode._getcopy : tnode;
       var
          p : tnode;
       begin
@@ -826,7 +851,7 @@ implementation
          p.firstpasscount:=firstpasscount;
 {$endif extdebug}
 {         p.list:=list; }
-         getcopy:=p;
+         result:=p;
       end;
 
 
@@ -899,7 +924,7 @@ implementation
       end;
 
 
-    function tunarynode.getcopy : tnode;
+    function tunarynode._getcopy : tnode;
       var
          p : tunarynode;
       begin
@@ -908,7 +933,7 @@ implementation
            p.left:=left.getcopy
          else
            p.left:=nil;
-         getcopy:=p;
+         result:=p;
       end;
 
 
@@ -1030,7 +1055,7 @@ implementation
       end;
 
 
-    function tbinarynode.getcopy : tnode;
+    function tbinarynode._getcopy : tnode;
       var
          p : tbinarynode;
       begin
@@ -1039,7 +1064,7 @@ implementation
            p.right:=right.getcopy
          else
            p.right:=nil;
-         getcopy:=p;
+         result:=p;
       end;
 
 
diff --git a/nodeopt/compiler/nopt.pas b/nodeopt/compiler/nopt.pas
index 88d4a196fc..d5cbb08f82 100644
--- a/nodeopt/compiler/nopt.pas
+++ b/nodeopt/compiler/nopt.pas
@@ -40,7 +40,7 @@ type
      { By default, pass_2 is the same as for addnode           }
      { Only if there's a processor specific implementation, it }
      { will be overridden.                                     }
-     function getcopy: tnode; override;
+     function _getcopy: tnode; override;
      function docompare(p: tnode): boolean; override;
   end;
 
@@ -51,7 +51,7 @@ type
     { pass_1 must be overridden, otherwise we get an endless loop }
     function det_resulttype: tnode; override;
     function pass_1: tnode; override;
-    function getcopy: tnode; override;
+    function _getcopy: tnode; override;
     function docompare(p: tnode): boolean; override;
    protected
     procedure updatecurmaxlen;
@@ -101,13 +101,13 @@ begin
   subnodetype := ts;
 end;
 
-function taddoptnode.getcopy: tnode;
+function taddoptnode._getcopy: tnode;
 var
   hp: taddoptnode;
 begin
-  hp := taddoptnode(inherited getcopy);
+  hp := taddoptnode(inherited _getcopy);
   hp.subnodetype := subnodetype;
-  getcopy := hp;
+  _getcopy := hp;
 end;
 
 function taddoptnode.docompare(p: tnode): boolean;
@@ -143,13 +143,13 @@ begin
   include(current_procinfo.flags,pi_do_call);
 end;
 
-function taddsstringoptnode.getcopy: tnode;
+function taddsstringoptnode._getcopy: tnode;
 var
   hp: taddsstringoptnode;
 begin
-  hp := taddsstringoptnode(inherited getcopy);
+  hp := taddsstringoptnode(inherited _getcopy);
   hp.curmaxlen := curmaxlen;
-  getcopy := hp;
+  _getcopy := hp;
 end;
 
 function taddsstringoptnode.docompare(p: tnode): boolean;
diff --git a/nodeopt/compiler/nset.pas b/nodeopt/compiler/nset.pas
index cd0def72d6..9cc8d58149 100644
--- a/nodeopt/compiler/nset.pas
+++ b/nodeopt/compiler/nset.pas
@@ -82,7 +82,7 @@ interface
           procedure ppuwrite(ppufile:tcompilerppufile);override;
           procedure buildderefimpl;override;
           procedure derefimpl;override;
-          function getcopy : tnode;override;
+          function _getcopy : tnode;override;
           procedure insertintolist(l : tnodelist);override;
           function det_resulttype:tnode;override;
           function pass_1 : tnode;override;
@@ -647,15 +647,15 @@ implementation
       end;
 
 
-    function tcasenode.getcopy : tnode;
+    function tcasenode._getcopy : tnode;
 
       var
          n : tcasenode;
          i : longint;
       begin
-         n:=tcasenode(inherited getcopy);
+         n:=tcasenode(inherited _getcopy);
          if assigned(elseblock) then
-           n.elseblock:=elseblock.getcopy
+           n.elseblock:=elseblock._getcopy
          else
            n.elseblock:=nil;
          if assigned(labels) then
@@ -669,12 +669,12 @@ implementation
                begin
                  if not assigned(blocks[i]) then
                    internalerror(200411302);
-                 n.addblock(i,pcaseblock(blocks[i])^.statement.getcopy);
+                 n.addblock(i,pcaseblock(blocks[i])^.statement._getcopy);
                end;
            end
          else
            n.labels:=nil;
-         getcopy:=n;
+         _getcopy:=n;
       end;
 
     procedure tcasenode.insertintolist(l : tnodelist);
diff --git a/nodeopt/compiler/optunrol.pas b/nodeopt/compiler/optunrol.pas
index 49f1fadde7..957e93e983 100644
--- a/nodeopt/compiler/optunrol.pas
+++ b/nodeopt/compiler/optunrol.pas
@@ -7,15 +7,7 @@ unit optunrol;
     uses
       node;
 
-    type
-      tunrollinfo = record
-        { if count isn divisable by unrolls then
-          the for loop must jump to this label to get the correct
-          number of executions }
-        entrylabel : tnode;
-      end;
-
-    function unroll_loop(node : tnode;out unrollinfo : tunrollinfo) : tnode;
+    function unroll_loop(node : tnode) : tnode;
 
   implementation
 
@@ -70,7 +62,6 @@ unit optunrol;
           exit;
         if not(node.nodetype in [forn]) then
           exit;
-        fillchar(tfornode(node).unrollinfo,sizeof(tunrollinfo),0);
         unrolls:=number_unrolls(tfornode(node).t2);
         if unrolls>1 then
           begin
@@ -96,7 +87,7 @@ unit optunrol;
                     if (counts mod unrolls<>0) and
                       ((counts mod unrolls)=unrolls-i+1) then
                       begin
-                        tfornode(node).unrollinfo.entrylabel:=clabelnode.createcase(
+                        //!!!! tfornode(node).entrylabel:=clabelnode.createcase(
                       end;
                     { create and insert copy of the statement block }
                     addstatement(unrollstatement,tfornode(tfornode(node).t2).getcopy);
diff --git a/nodeopt/compiler/pdecl.pas b/nodeopt/compiler/pdecl.pas
index 75229b5872..ca11e118a4 100644
--- a/nodeopt/compiler/pdecl.pas
+++ b/nodeopt/compiler/pdecl.pas
@@ -250,11 +250,10 @@ implementation
              consume(_ID)
            else
              begin
-                objectlibrary.getlabel(hl);
                 if token=_ID then
-                 symtablestack.insert(tlabelsym.create(orgpattern,hl))
+                 symtablestack.insert(tlabelsym.create(orgpattern))
                 else
-                 symtablestack.insert(tlabelsym.create(pattern,hl));
+                 symtablestack.insert(tlabelsym.create(pattern));
                 consume(token);
              end;
            if token<>_SEMICOLON then consume(_COMMA);
diff --git a/nodeopt/compiler/pexpr.pas b/nodeopt/compiler/pexpr.pas
index 62f6bbae09..4a1821ad29 100644
--- a/nodeopt/compiler/pexpr.pas
+++ b/nodeopt/compiler/pexpr.pas
@@ -1466,7 +1466,7 @@ implementation
                         if tlabelsym(srsym).defined then
                           Message(sym_e_label_already_defined);
                         tlabelsym(srsym).defined:=true;
-                        p1:=clabelnode.create(tlabelsym(srsym),nil);
+                        p1:=clabelnode.create(nil);
                       end;
                   end;
 
diff --git a/nodeopt/compiler/pstatmnt.pas b/nodeopt/compiler/pstatmnt.pas
index b07974d832..ec90bd04d4 100644
--- a/nodeopt/compiler/pstatmnt.pas
+++ b/nodeopt/compiler/pstatmnt.pas
@@ -946,8 +946,8 @@ implementation
                          { goto is only allowed to labels within the current scope }
                          if srsym.owner<>current_procinfo.procdef.localst then
                            CGMessage(parser_e_goto_outside_proc);
-                         code:=cgotonode.create(tlabelsym(srsym));
-                         tgotonode(code).labsym:=tlabelsym(srsym);
+                         code:=cgotonode.create_sym(tlabelsym(srsym));
+                         tgotonode(code).labelsym:=tlabelsym(srsym);
                          { set flag that this label is used }
                          tlabelsym(srsym).used:=true;
                        end;
@@ -1011,7 +1011,7 @@ implementation
                    if tlabelsym(srsym).defined then
                     Message(sym_e_label_already_defined);
                    tlabelsym(srsym).defined:=true;
-                   p:=clabelnode.create(tlabelsym(srsym),nil);
+                   p:=clabelnode.create(nil);
                  end
                 else
                  begin
diff --git a/nodeopt/compiler/rautils.pas b/nodeopt/compiler/rautils.pas
index 60d3a5ab3f..2c254b5140 100644
--- a/nodeopt/compiler/rautils.pas
+++ b/nodeopt/compiler/rautils.pas
@@ -1366,7 +1366,9 @@ Begin
   case sym.typ of
     labelsym :
       begin
-        hl:=tlabelsym(sym).lab;
+        if not(assigned(tlabelsym(sym).asmblocklabel)) then
+          objectlibrary.getlabel(tlabelsym(sym).asmblocklabel);
+        hl:=tlabelsym(sym).asmblocklabel;
         if emit then
          tlabelsym(sym).defined:=true
         else
diff --git a/nodeopt/compiler/symsym.pas b/nodeopt/compiler/symsym.pas
index df41860775..b866682d8f 100644
--- a/nodeopt/compiler/symsym.pas
+++ b/nodeopt/compiler/symsym.pas
@@ -56,13 +56,18 @@ interface
        end;
 
        tlabelsym = class(tstoredsym)
-          lab     : tasmlabel;
           used,
           defined : boolean;
-          code : pointer; { should be tnode }
-          constructor create(const n : string; l : tasmlabel);
+          { points to the matching node, only valid resulttype pass is run and
+            the goto<->label relation in the node tree is created, should
+            be a tnode }
+          code : pointer;
+
+          { when the label is defined in an asm block, this points to the
+            generated asmlabel }
+          asmblocklabel : tasmlabel;
+          constructor create(const n : string);
           constructor ppuload(ppufile:tcompilerppufile);
-          function mangledname:string;override;
           procedure ppuwrite(ppufile:tcompilerppufile);override;
 {$ifdef GDB}
           function  stabstring : pchar;override;
@@ -507,11 +512,10 @@ implementation
                                  TLABELSYM
 ****************************************************************************}
 
-    constructor tlabelsym.create(const n : string; l : tasmlabel);
+    constructor tlabelsym.create(const n : string);
       begin
          inherited create(n);
          typ:=labelsym;
-         lab:=l;
          used:=false;
          defined:=false;
          code:=nil;
@@ -522,21 +526,12 @@ implementation
       begin
          inherited ppuload(ppufile);
          typ:=labelsym;
-         { this is all dummy
-           it is only used for local browsing }
-         lab:=nil;
          code:=nil;
          used:=false;
          defined:=true;
       end;
 
 
-    function tlabelsym.mangledname:string;
-      begin
-        result:=lab.name;
-      end;
-
-
     procedure tlabelsym.ppuwrite(ppufile:tcompilerppufile);
       begin
          if owner.symtabletype=globalsymtable then