/ray/src/vm/input/linker.cc

Go to the documentation of this file.

/*
 * vm/input/linker.cc
 * 
 * VM (assembler) linker. 
 * 
 * Copyright (c) 2004 by Wolfgang Wieser ] wwieser (a) gmx <*> de [ 
 * 
 * This file may be distributed and/or modified under the terms of the 
 * GNU General Public License version 2 as published by the Free Software 
 * Foundation. (See COPYING.GPL for details.)
 * 
 * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 * 
 */

#include "linker.h"
#include <lib/message/message.h>
#include "classinfo.h"
#include <lib/tl/sort.h>
#include <lib/tl/binsearch.h>
#include <lib/lex/strtreedump.h>


namespace VM
{

NamespaceInfo::SymbolEntryE *VMLinker::SymbolProvideMap::AddNode(
    NamespaceInfo::SymbolEntryE *s)
{
    NamespaceInfo::SymbolEntryE *known=NULL;
    if(map.store(s,/*allow_update=*/0,/*oldval=*/&known))
    {
        Assert(known);
        return(known);
    }
    return(NULL);
}

//------------------------------------------------------------------------------

// Used for binary search by offset in member vars. 
struct MemberVarEntryOffsetOperators
{
    static inline bool lt(ClassInfo::MemberVarEntry const &a,Offset const &b)
        {  return(a.off<b);   }
    static inline bool eq(ClassInfo::MemberVarEntry const &a,Offset const &b)
        {  return(a.off==b);  }
    
    template<typename I>static inline const ClassInfo::MemberVarEntry &idx(
        const ClassInfo::MemberVarEntry *array,I i)
        {  return(array[i]);  }
};


SymRef VMLinker::_SQPush(NamespaceInfo::SymbolEntryE *se,
    NamespaceInfo::SymbolEntryB **update_se,LSymbol::SFlag sflag)
{
    if(se->symref<0)
    {
        // Internal symbols may not be pushed. 
        Assert(0);
        Assert(!update_se);
        return(se->symref);
    }
    
    SymRef symref;
    if(sflag==LSymbol::SStart)
    {  symref=0;  }
    else
    {  symref=master_SymRef_cnt;  }
    LSymbol symb(se,symref,update_se,sflag);
    
    // Make sure we do not add the symbol twice. 
    LSymbol known;
    int rv=sq.store(symb,/*allow_update=*/0,/*oldval=*/&known);
    if(rv)  // already in the queue
    {
        Assert(known.se);
        return(known.symref);
    }
    
    Warning("added %s ($%d) to symbol queue",se->CompleteName().str(),
        (int)symref);
    
    if(symref==master_SymRef_cnt)
    {  ++master_SymRef_cnt;  }
    
    return(symb.symref);
}

SymRef VMLinker::_SQQuery(NamespaceInfo::SymbolEntryE *se)
{
    Assert(se->symref>=0);
    
    LSymbol key(se,0,NULL,LSymbol::SNone);
    LSymbol *known=sq.search(key);
    if(known)
    {  return(known->symref);  }
    else
    {  return(master_SymRef_cnt++);  }
}

void VMLinker::_SQPop(/*LSymbol &ls*/)
{
    /*int rv=sq.RemoveSmallest(&ls);
    return(rv==0);*/
    sq.RemoveSmallest(NULL);
}

bool VMLinker::_SQPeek(LSymbol &ls)
{
    LSymbol *s=sq.GetSmallest();
    if(s) ls=*s;
    return(s);
}


VMLinker::FileNode *VMLinker::_GetDefinitionFile(NamespaceInfo *from_here)
{
    FileNode *fn=NULL;
    
    // First, we need to find the file this NamespaceInfo is from. 
    // FIXME: We could avoid this lookup by using explicit FileNode pointers 
    //        in the NamespaceInfo. 
    // Therefore, first traverse to the root and then search the root 
    // in the file list. 
    NamespaceInfo *walker=from_here;
    for(; walker->parent; walker=walker->parent);
    
    for(FileNode *fni=flist.first(); fni; fni=fni->next)
    {
        if(fni->f->nspc_root==walker)
        {  fn=fni;  break;  }
    }
    
    // We MUST have found the namespace info somewhere. In case this assert 
    // fails, *from_here was probably from the master tree which is illegal. 
    Assert(fn);
    
    return(fn);
}


NamespaceInfo *VMLinker::_MergeNamespaceInfo_Recursive(
    NamespaceInfo **head_list,uint nheads)
{
    if(!nheads)  return(NULL);
    
    // NOTE: Cannot use CompleteName() and the like on the elements of 
    //       the tree being built up (i.e. "dest") as the tree is built 
    //       bottom-up and hence cannot be traversed to the root yet. 
    //       Hence, always use CompleteName() on the source nodes in 
    //       head_list[]. 
    
    //Warning("MNIR: nheads=%u:",nheads);
    //for(uint i=0; i<nheads; i++)
    //{  Warning("  %s",head_list[i]->CompleteName().str());  }
    
    // Join all elements from the head_list. 
    NamespaceInfo *dest=NULL;
    if(nheads==1)
    {
        // Trivial case. "Merge" all information from one single node. 
        // This is an optimized version of the below code. 
        switch(head_list[0]->nstype)
        {
            case NamespaceInfo::NSNamespace:
            {
                NamespaceInfo *s=head_list[0];
                dest = new NamespaceInfo(/*name=*/s->name,
                    /*parent=*/NULL/*for now*/);
                // Symbol information is not copied as it is per-file 
                // "map/need" information. 
                //dest->symbol is NOT s->symbol;
            }   break;
            case NamespaceInfo::NSClass:
            {
                ClassInfo *s = static_cast<ClassInfo*>(head_list[0]);
                ClassInfo *d = new ClassInfo(/*name=*/s->name,
                    /*TypeID=*/master_TypeID_cnt++,
                    /*parent=*/NULL/*for now*/);
                // Symbol information is not copied as it is per-file 
                // "map/need" information. 
                //d->symbol is NOT s->symbol;
                d->size=s->size;
                d->nvirtuals=s->nvirtuals;
                // base and vtable contain per-file data and are not yet 
                // copied but resolved lateron when the namespace hierarchy 
                // is built. 
                d->membvar=s->membvar;  // copy content
                dest=d;
            }   break;
            default: Assert(0);
        }
        head_list[0]->linked=dest;
    }
    else
    {
        NamespaceInfo::NSType dest_type=head_list[0]->nstype;
        for(uint i=1 /*<--correct*/; i<nheads; i++)
        {
            if(dest_type==head_list[i]->nstype)  continue;
            Error(head_list[i]->asm_loc,
                "%s \"%s\" redefined as %s",
                NamespaceInfo::NSType2String(dest_type),
                head_list[0]->CompleteName().str(),
                NamespaceInfo::NSType2String(head_list[i]->nstype));
            Error(head_list[0]->asm_loc,
                "  this is the location of the first definition");
            ++n_errors;
            // Use simplest possible type for now. 
            dest_type=NamespaceInfo::NSNamespace;
            break;
        }
        
        switch(dest_type)
        {
            case NamespaceInfo::NSNamespace:
            {
                dest = new NamespaceInfo(/*name=*/head_list[0]->name,
                    /*parent=*/NULL/*for now*/);
                // Symbol information is not copied as it is per-file 
                // "map/need" information. 
                // Hence, there is nothing left to be dealt with yet, 
                // for namespace info. 
                //for(uint i= >1?<; i<nheads; i++)
                //{
                //  NamespaceInfo *s=head_list[i];
                //}
            }   break;
            case NamespaceInfo::NSClass:
            {
                ClassInfo *d = new ClassInfo(/*name=*/head_list[0]->name,
                    /*TypeID=*/master_TypeID_cnt++,
                    /*parent=*/NULL/*for now*/);
                
                // Add a new entry to the map. This is not needed for linking 
                // but we should probably have the info in the output file. 
                if(!cfg.abandon_out_maps)
                {
                    ClassInfo _unused_ *known=out->tid2classinfo.AddNode(d);
                    Assert(!known);
                }
                
                dest=d;
                // Only the cotent which is not dependent on the file 
                // is merged here. Hence, no sybols, base, vtable. 
                // For the member vars, we use the one with the most entries 
                // as master and check all the others against it. We could 
                // do more fancy here but this is not (yet) needed. 
                NonResizeableArray<ClassInfo::MemberVarEntry,uint32> 
                    *most_members=NULL;
                for(uint i=0; i<nheads; i++)
                {
                    Assert(head_list[i]->nstype==NamespaceInfo::NSClass);
                    ClassInfo *s = static_cast<ClassInfo*>(head_list[i]);
                    
                    if(!i)  // First run. 
                    {
                        d->size=s->size;
                        d->nvirtuals=s->nvirtuals;
                        most_members=&s->membvar;
                    }
                    else
                    {
                        if(most_members->n()<s->membvar.n())
                        {  most_members=&s->membvar;  }
                        
                        const char *what=NULL;
                        
                        if(d->size!=s->size)  what="size";
                        else if(d->nvirtuals!=s->nvirtuals)  what="nvirtuals";
                        
                        if(what)
                        {
                            Error(s->asm_loc,
                                "mismatch of %s property in %s \"%s\"",
                                what,
                                NamespaceInfo::NSType2String(dest_type),
                                s->CompleteName().str());
                            Error(head_list[0]->asm_loc,
                                "  this is the location of the first "
                                "occurance");
                            ++n_errors;
                            break;  // Stop complaining now. 
                        }
                    }
                }
                
                // Now the member vars: 
                d->membvar=*most_members;  // copy content
                for(uint i=0; i<nheads; i++)
                {
                    Assert(head_list[i]->nstype==NamespaceInfo::NSClass);
                    ClassInfo *s = static_cast<ClassInfo*>(head_list[i]);
                    
                    // Skip master: Checking it against itself would just 
                    // be a waste of time. 
                    if(&s->membvar==most_members)  continue;
                    
                    // Note that the membvars are sorted by offset (checked 
                    // by the parser) so that we can efficiently search. 
                    // However, in case both have the same number of entries, 
                    // using the same index is good guess which will normally 
                    // hit. 
                    bool guess_first = d->membvar.n()==s->membvar.n();
                    // We could do some better than just reporting error with 
                    // number of mismatches but OTOH, this should not happen 
                    // anyways. 
                    uint n_mismatches=0;
                    uint n_missing=0;
                    for(uint j=0,jend=s->membvar.n(); j<jend; j++)
                    { // LOOP: SRC
                        ClassInfo::MemberVarEntry *se=&s->membvar[j];
                        ClassInfo::MemberVarEntry *de=NULL;
                        if(guess_first && se->off==d->membvar[j].off)
                        {  de=&d->membvar[j];  }
                        else
                        {
                            ssize_t idx=TLBinarySearch(
                                d->membvar.ptr(),d->membvar.n(),
                                se->off,MemberVarEntryOffsetOperators());
                            if(idx>=0)  de=&d->membvar[idx];
                        }
                        
                        if(!de)
                        {
                            // Entry in source but not in dest (master). 
                            ++n_missing;
                            // Pointer types MUST be specified; simple 
                            // ones can be ignored if told so. 
                            if(se->vtype.IsPointerType() || 
                                !cfg.ignore_simple_type_missing)
                            {  ++n_mismatches;  }
                            continue;
                        }
                        if(de->vtype!=se->vtype)  ++n_mismatches;
                        if(se->name)
                        {
                            if(!de->name)  de->name=se->name;
                            else if(de->name!=se->name)  ++n_mismatches;
                        }
                    }
                    
                    // Still need to check if required entries in dest 
                    // (pointers) are also in source. Can leave away this 
                    // check if we know that we looked at all values in 
                    // dest. 
                    if(s->membvar.n()-n_missing!=d->membvar.n())
                        for(uint j=0,jend=d->membvar.n(); j<jend; j++)
                    { // LOOP: DEST
                        //   already been looked up; these can be skipped here. 
                        ClassInfo::MemberVarEntry *se=NULL;
                        ClassInfo::MemberVarEntry *de=&d->membvar[j];
                        if(guess_first && de->off==s->membvar[j].off)
                        {  se=&s->membvar[j];  }
                        else
                        {
                            ssize_t idx=TLBinarySearch(
                                s->membvar.ptr(),s->membvar.n(),
                                de->off,MemberVarEntryOffsetOperators());
                            if(idx>=0)  se=&s->membvar[idx];
                        }
                        
                        // We need only look at the cases where the info is 
                        // in the master and NOT in the src; all the others 
                        // have already been treated. 
                        if(se)  continue;  // <-- NOT if(!se) !!
                        
                        // Entry in dest (master) but not in src. 
                        if(de->vtype.IsPointerType() || 
                            !cfg.ignore_simple_type_missing)
                        {  ++n_mismatches;  }
                        else
                        {
                            // In this case must add the information to the 
                            // master so that it can be compared to subsequent 
                            // occurances. As arrays are used, this is slow. 
                            // OTOH, this should not happen frequently as we 
                            // already use the node with the most entries as 
                            // master. 
                            // NOTE that this means that we also have to 
                            // check the previous files again as this may just 
                            // have produced a mismatch with older files. 
                            // Maybe, replace with a gather-stage followed by 
                            // a check stage. 
                            CritAssert(!"not yet implemented");  // FIXME. 
                        }
                    }
                    
                    if(n_mismatches)
                    {
                        Error(s->asm_loc,
                            "while merging member var info in %s \"%s\": "
                            "%u mismatches",
                            NamespaceInfo::NSType2String(dest_type),
                            s->CompleteName().str(),
                            n_mismatches);
                        ++n_errors;
                        break;  // Stop complaining now. 
                    }
                }
            }   break;
            default: Assert(0);
        }
        
        for(uint i=0; i<nheads; i++)
        {  head_list[i]->linked=dest;  }
    }
    Assert(dest);
    
    // Create new "list" with all children of all heads: 
    uint nchld=0;
    for(uint i=0; i<nheads; i++)
    {  nchld+=head_list[i]->down.count();  }
    if(nchld)
    {
        NamespaceInfo **chld_list=ALLOC<NamespaceInfo*>(nchld);
        nchld=0;
        for(uint i=0; i<nheads; i++)
            for(NamespaceInfo *j=head_list[i]->down.first(); j; j=j->next)
                chld_list[nchld++]=j;
        
        // All children of all heads are now in chld_list. 
        // Sort it by names: 
        // (Using heap sort to not get trapped when the input is already 
        // sorted.)
        if(nchld<=16)
        {
            InsertionSort<NamespaceInfo*,
                const NamespaceInfo::PtrListOperators<NamespaceInfo> >(
                chld_list,nchld,
                    NamespaceInfo::PtrListOperators<NamespaceInfo>());
        }
        else
        {
            HeapSort<NamespaceInfo*,
                const NamespaceInfo::PtrListOperators<NamespaceInfo> >(
                chld_list,nchld,
                    NamespaceInfo::PtrListOperators<NamespaceInfo>());
        }
        
        //Warning("    nchld=%u:",nchld);
        //for(uint i=0; i<nchld; i++)
        //{  Warning("      %s",chld_list[i]->CompleteName().str());  }
        
        // Find equally named children. As the list is sorted, this is easy. 
        TLString name=chld_list[0]->name;
        for(uint i0=0,i=1;;i++)
        {
            if(i<nchld && name==chld_list[i]->name)  continue;
            
            // Names i0..i-1 are equal. We need to recurse even if i-i0==1 
            // in order to not loose information. "Merging" will, however, 
            // clearly be trivial in this case. 
            NamespaceInfo *c=_MergeNamespaceInfo_Recursive(
                chld_list+i0,i-i0);
            dest->AddChild(c);   // AddChild(NULL) is a no-op. Will not happen. 
            
            if(i>=nchld) break;
            name=chld_list[i]->name;
            i0=i;  // do not move
        }
        
        FREE(chld_list);
    }
    
    //Warning("MNIR: POP");
    
    return(dest);
}


void VMLinker::_CheckNamespaceInfo_Recursive(FileNode *fn,NamespaceInfo *ni)
{
    do {
        // This should be set; only reason for it to be NULL is an error 
        // earlier during linking. 
        Assert(ni->linked);
        if(!ni->linked)  break;
        
        NamespaceInfo *master=ni->linked;
        Assert(ni->nstype==master->nstype);
        //Error("_CNIR: %d %s %s",(int)master->link_info_set,
        //  fn->f->filename.path().str(),ni->CompleteName().str());
        switch(master->nstype)
        {
            case NamespaceInfo::NSClass:
            {
                ClassInfo *cmaster = static_cast<ClassInfo*>(master);
                ClassInfo *cni = static_cast<ClassInfo*>(ni);
                
                // For the first occurance: Copy the values. 
                if(!cmaster->link_info_set)
                {
                    // BASE ENTRIES. 
                    cmaster->base.alloc(cni->base.n());
                    for(uint32 i=0,iend=cni->base.n(); i<iend; i++)
                    {
                        ClassInfo::BaseEntry *d=&cmaster->base[i];
                        ClassInfo::BaseEntry *s=&cni->base[i];
                        d->off=s->off;
                        // s->ci may only be NULL if an error occured during 
                        // lookup. In this case we should have bailed out 
                        // already. 
                        Assert(s->ci);
                        // Internal entries are simply to be copied. 
                        ClassInfo *sci=s->ci->ci();
                        if(sci)
                        {
                            // Non-internal. 
                            d->ci=static_cast<ClassInfo*>(sci->linked);
                            // d->ci (s->ci->linked) may only be NULL in case 
                            // of an error in the tree merging; we should have 
                            // bailed out already in this case. 
                            Assert(d->ci);
                            Assert(d->ci->ci());
                            Assert(d->ci->ci()->nstype=NamespaceInfo::NSClass);
                        }
                        else
                        {
                            // Internal. Simply allocate a new one; this works 
                            // much like internal_symbols. 
                            d->ci=out->internal_classes.LookupStore(
                                s->ci->class_tid);
                        }
                    }
                    
                    // VTABLE ENTRIES. 
                    cmaster->vtable.alloc(cni->vtable.n());
                    for(uint32 i=0,iend=cni->vtable.n(); i<iend; i++)
                    {
                        ClassInfo::VTableEntry *d=&cmaster->vtable[i];
                        ClassInfo::VTableEntry *s=&cni->vtable[i];
                        
                        // Much the same as s->ci in the BASE entries above. 
                        Assert(s->se);
                        
                        // The problem here is that symbols are not yet 
                        // merged/linked. This means, we now use pointers 
                        // into the non-master tree until resolving. 
                        d->se=s->se;
                        Assert(!d->se->ep() || d->se->ep()->nspc->linked);
                    }
                    
                    //cmaster->link_info_set=1; <-- Done below to allow 
                    //   for link_info_set checks in "case"s further down. 
                }
                else
                {
                    // BASE ENTRIES. 
                    uint n_mismatches=0;
                    if(cni->base.n()!=cmaster->base.n())
                    {  ++n_mismatches;  }
                    else for(uint32 i=0,iend=cmaster->base.n(); i<iend; i++)
                    {
                        ClassInfo::BaseEntry *d=&cmaster->base[i];
                        ClassInfo::BaseEntry *s=&cni->base[i];
                        
                        // Compare offset: 
                        if(d->off!=s->off)  ++n_mismatches;
                        
                        // Compare TypeID...
                        Assert(s->ci);  // see above ("first occurance" branch)
                        ClassInfo *ssci=s->ci->ci();
                        ClassInfo *dsci=d->ci->ci();
                        if(ssci && dsci)
                        {
                            // Both non-internal. 
                            ClassInfo *sci_lnk=static_cast<ClassInfo*>(
                                ssci->linked);
                            // see above ("first occurance" branch)
                            Assert(sci_lnk); 
                            Assert(sci_lnk->nstype=NamespaceInfo::NSClass);
                            
                            if(sci_lnk!=dsci)  ++n_mismatches;
                        }
                        else if(!ssci && !dsci)
                        {
                            // Both internal. 
                            if(s->ci->class_tid!=d->ci->class_tid)
                            {  ++n_mismatches;  }
                        }
                        else  // Internal versus external. 
                        {  ++n_mismatches;  }
                    }
                    if(n_mismatches)
                    {
                        Error(cni->asm_loc,
                            "while merging base class info in %s \"%s\": "
                            "%u mismatches",
                            NamespaceInfo::NSType2String(master->nstype),
                            master->CompleteName().str(),
                            n_mismatches);
                        ++n_errors;
                    }
                    
                    // VTABLE ENTRIES. 
                    n_mismatches=0;
                    if(cni->vtable.n()!=cmaster->vtable.n())
                    {  ++n_mismatches;  }
                    else for(uint32 i=0,iend=cmaster->vtable.n(); i<iend; i++)
                    {
                        // Look at the vtable(s). Their symbol names and 
                        // types must match. 
                        ClassInfo::VTableEntry *du=&cmaster->vtable[i];
                        ClassInfo::VTableEntry *su=&cni->vtable[i];
                        
                        // This will compare type and name: 
                        // Also works for internal symbols. 
                        if(!du->se->CompareTo(*su->se))  ++n_mismatches;
                        // Still have to compare namespaces for non-internal 
                        // symbols. 
                        if(du->se->ep())
                        {
                            NamespaceInfo::SymbolEntryE *d=du->se->ep();
                            NamespaceInfo::SymbolEntryE *s=su->se->ep();
                            //Assert(d->nspc->linked); <- Known already.
                            Assert(s->nspc->linked);
                            if(d->nspc->linked!=s->nspc->linked)
                            {  ++n_mismatches;  }
                        }
                    }
                    if(n_mismatches)
                    {
                        Error(cni->asm_loc,
                            "while merging vtable class info in %s \"%s\": "
                            "%u mismatches",
                            NamespaceInfo::NSType2String(master->nstype),
                            master->CompleteName().str(),
                            n_mismatches);
                        ++n_errors;
                    }
                }
            }   // NO BREAK; fall through. 
            case NamespaceInfo::NSNamespace:
                // Nothing to do. 
                break;
            default: Assert(0);
        }
        
        master->link_info_set=1;  // do not move
    } while(0);
    
    // Call recursively on children: 
    for(NamespaceInfo *j=ni->down.first(); j; j=j->next)
        _CheckNamespaceInfo_Recursive(fn,j);
}


int VMLinker::_CheckBaseRecursion(ClassInfo *cni)
{
    Assert(cni->nstype==NamespaceInfo::NSClass);
    
    int errcnt=0;
    
    // In this case we have a recursion in the base classes. 
    if(cni->recursion_flag)
    {  ++errcnt;  return(errcnt);  }
    
    cni->recursion_flag=1;
    for(uint32 i=0,iend=cni->base.n(); i<iend; i++)
    {
        ClassInfoIE *cii=cni->base[i].ci;
        Assert(cii);
        ClassInfo *ci=cii->ci();
        if(!ci)  continue;  // Ignore internal base classes. 
        errcnt+=_CheckBaseRecursion(ci);
    }
    cni->recursion_flag=0;
    
    return(errcnt);
}


void VMLinker::_CheckBaseRecursion_Recursive(FileNode *fn,NamespaceInfo *ni)
{
    if(ni->nstype==NamespaceInfo::NSClass && 
        _CheckBaseRecursion(static_cast<ClassInfo*>(ni)))
    {
        Error(ni->asm_loc,
            "recursion in base class hierarchy of \"%s\""
            " (what'chew doin' to me, Willis?!)",
            ni->CompleteName().str());
        ++n_errors;
    }
    
    // Call recursively on children: 
    for(NamespaceInfo *j=ni->down.first(); j; j=j->next)
        _CheckBaseRecursion_Recursive(fn,j);
}


void VMLinker::_MergeNamespaceAndVTableInfo()
{
    Assert(!out->nspc_root);
    
    // *** Merge namespace info. ***
    uint nheads=0;
    for(FileNode *fn=flist.first(); fn; fn=fn->next)
    {
        NamespaceInfo *f_nspc_root=fn->f->nspc_root;
        if(!f_nspc_root)  continue;
        ++nheads;
    }
    
    if(nheads)
    {
        NamespaceInfo **head_list=ALLOC<NamespaceInfo*>(nheads);
        
        nheads=0;
        for(FileNode *fn=flist.first(); fn; fn=fn->next)
        {
            NamespaceInfo *f_nspc_root=fn->f->nspc_root;
            if(!f_nspc_root)  continue;
            head_list[nheads++]=f_nspc_root;
        }
        
        out->nspc_root=_MergeNamespaceInfo_Recursive(head_list,nheads);
        
        FREE(head_list);
    }
    
    // It is important that we bail out on error here. 
    // Otherwise, we may dereference some NULL pointers. 
    if(n_errors)  return;
    
    // Okay, now the nspc_root tree is built up and we can do the second 
    // part of the merging/checking. Note that the TypeIDs and VTableIDs 
    // in the namespace tree are already looked up. 
    
    for(FileNode *fn=flist.first(); fn; fn=fn->next)
    {
        NamespaceInfo *f_nspc_root=fn->f->nspc_root;
        if(!f_nspc_root)  continue;
        _CheckNamespaceInfo_Recursive(fn,f_nspc_root);
    }
    
    // Bail out before we do ugly and confusing things. 
    if(n_errors)  return;
    
    // Finally, check for recursion in the base classes. In case we 
    // have recursion, this is lethal for usage flag propagation so 
    // we need to add to n_errors and rely on bailing out before 
    // the actual linker symbol resolve loop. 
    for(FileNode *fn=flist.first(); fn; fn=fn->next)
    {
        NamespaceInfo *f_nspc_root=fn->f->nspc_root;
        if(!f_nspc_root)  continue;
        _CheckBaseRecursion_Recursive(fn,f_nspc_root);
    }
}


void VMLinker::_GenerateSymbolProvideMap_AddGlobal(FileNode *fn,
    AssemblerFile::_GlobVars *gvar)
{
    for(AssemblerFile::GlobalVarList::Iterator i(gvar->globvarq); i; i++)
    {
        NamespaceInfo::SymbolEntryE *se=(*i)->se;
        NamespaceInfo::SymbolEntryE *known=symbol_provide_map.AddNode(se);
        if(known)
        {
            Error(fn->f->filename,
                "duplicate variable symbol \"%s\"",se->CompleteName().str());
            if(known->nspc)
            {  Error(known->nspc->asm_loc,"  this is the location of the "
                "previous occurance");  }
            ++n_errors;
            // This means that the symbol names are duplicate in different 
            // files because we already checked for same files at 
            // parse time. 
        }
        
        Warning(fn->f->filename,"%s added to provide map",
            se->CompleteName().str());
    }
}


void VMLinker::_GenerateSymbolProvideMap()
{
    symbol_provide_map.clear();  // be sure...
    
    for(FileNode *fn=flist.first(); fn; fn=fn->next)
    {   
        NamespaceInfo *f_nspc_root=fn->f->nspc_root;
        if(!f_nspc_root)  continue;
        
        for(ProgramStorage::Function *i=fn->f->program.FirstFunction(); 
            i; i=i->next)
        {
            NamespaceInfo::SymbolEntryE *known=
                symbol_provide_map.AddNode(i->se);
            if(known)
            {
                // This means that the symbol names are duplicate in different 
                // files because we already checked for same files at 
                // parse time. There may exist only one function with this 
                // name which is exported. In case a non-exported one is 
                // there as well, it must be one of the both: 
                // *known or *i->se. 
                // We could try and solve this problem by attaching a 
                // different name on the non-exported one. This is, however, 
                // dangerous as the names are also references by some maps 
                // (BTrees; notably symbol_provide_map and map_name2symbol) 
                // and changing the name is likely to require re-insertion 
                // into these maps. 
                // Instead, the problem is solved in the input stage by 
                // attaching a unique suffix to non-exported symbols. 
                // Hence, it is an internal error if we collide with a 
                // non-exported symbol here. 
                // FIXME: We could support non-exported variables in 
                //        global storage in the same way. 
                Error(i->loc,
                    "duplicate function symbol \"%s\"",
                    i->se->CompleteName().str());
                if(known->nspc)
                {  Error(known->nspc->asm_loc,"  this is the location "
                    "of the previous occurance");  }
                ++n_errors;
                
                if(known->extid==NamespaceInfo::SymbolEntryE::ExtFunction && 
                    i->se->extid==NamespaceInfo::SymbolEntryE::ExtFunction && 
                    (!known->ftype.exported || !i->se->ftype.exported))
                {  Assert(0);  }  // <-- Read large comment above. 
            }
            
            Warning(i->loc,"%s added to provide map",
                i->se->CompleteName().str());
        }
        
        _GenerateSymbolProvideMap_AddGlobal(fn,&fn->f->gvar_v);
        _GenerateSymbolProvideMap_AddGlobal(fn,&fn->f->gvar_p);
    }
}


void VMLinker::_LinkGlobalStorage(FileNode *fn,AssemblerFile::_GlobVars *gvar,
    AssemblerFile::_GlobVars *dest,char which)
{
    Warning(fn->f->filename,"linking %cglobal storage (%u bytes)",
        which,(uint)gvar->size);
    
    // Accumulate size. 
    Offset base=dest->size;
    dest->size+=gvar->size;
    
    for(AssemblerFile::GlobalVarList::Iterator i(gvar->globvarq); i; i++)
    {
        AssemblerFile::GlobalVarEntry *s=(*i);
        
        dest->globvarq.PushHead(*s);  // copy
        AssemblerFile::GlobalVarEntry *dest_ent=dest->globvarq.head();
        // Add offset into global storage. 
        dest_ent->off+=base;
        // Need to use linked symbol entry. Let's see...
        dest_ent->se=NULL;
        
        // Of course, the var symbol may not yet be linked. 
        // If this assert fails "legally", we can replace it with an error. 
        Assert(!s->se->linked);
        // Only non-internal entries are allowed, of course. 
        Assert(s->se->symref>=0);
        // The global var must be in the provide map of the file, obviously. 
        Assert(fn->f->symref2globvar.lookup(s->se->symref));
        
        // Add entry in the linked namespace. 
        NamespaceInfo *master_parent=s->se->nspc->linked;
        Assert(master_parent);
        Assert(!master_parent->linked);  // master_parent in master tree. 
        // Push a copy of the symbol entry, we will modify some entries below. 
        master_parent->symbol.PushHead(/*a copy of:*/*s->se);
        NamespaceInfo::SymbolEntryE *master_se=master_parent->symbol.head();
        master_se->nspc=master_parent;
        master_se->symref=_SQQuery(s->se);
        master_se->linked=NULL;   // We're in the master tree. 
        
        // Link the symbol entry: 
        s->se->linked=master_se;
        // Set symbol entry pointer for entry in global vars of linked output. 
        dest_ent->se=master_se;
        
        // Still add entry to the mapping: 
        NamespaceInfo::SymbolEntryE *known=NULL;
        Assert(master_se->symref>=0);  // Non-internal ones, only. 
        int srv=master_parent->map_name2symbol.store(master_se,
            /*allow_update=*/0,/*old_val=*/&known);
        if(srv)
        {
            Assert(known);
            Assert(!known->linked);
            Error(fn->f->filename,
                "global variable symbol \"%s\" defined multiple times",
                master_se->CompleteName().str());
            ++n_errors;
            // Unfortunately, we do not know where as *known in the master 
            // tree does not have source information. 
            // We can find it by searching throuh the provide map. 
            // This here is not a particularly fast way as we have O(log(n)) 
            // for each symbol while we could do with O(log(n)+k) with 
            // k = "number of symbols with same name" as B-trees conserve the 
            // order. But, OTOH, errors need not be fast and O(log(n)) is 
            // still worst-case optimal searching...
        // FIXME: Do it; probably in an own function. 
        //NamespaceInfo::SymbolEntry **prev,**next;  // <-- Not set up. 
        //symbol_provide_map.SearchNeighbours(
        }
        
        if(!cfg.abandon_out_maps)
        {
            NamespaceInfo::SymbolEntryE _unused_ *known=
                out->symref2symbol.AddNode(master_se);
            Assert(!known);
            
            bool is_known;  // not set up
            out->symref2globvar.AddNode(dest_ent->se->symref,dest_ent,&is_known);
            Assert(!is_known);
        }
    }
}


void VMLinker::_LinkerFileNeeded(FileNode *fn)
{
    // If the file is already marked as needed, we need not do any more here. 
    if(fn->needed)  return;
    
    // Mark the file as needed and process the global and .init content. 
    // .start need not be processed as this was already done. 
    fn->needed=1;
    
    if(fn->f->slabel_init.pfunc)
    {
        _SQPush(&fn->f->slabel_init.se);
    }
    
    _LinkGlobalStorage(fn,&fn->f->gvar_v,&out->gvar_v,'v');
    _LinkGlobalStorage(fn,&fn->f->gvar_p,&out->gvar_p,'p');
}


void VMLinker::_LinkFunction(FileNode *fn,ProgramStorage::Function *psf,
    NamespaceInfo::SymbolEntryE *se_linked)
{
    Assert(se_linked);
    
    bool is_start_func=(se_linked==&out->slabel_start.se);
    // Make sure symref is set (>0): 
    Assert(is_start_func || se_linked->symref>0);
    
    ProgramStorage::Function *dest = new ProgramStorage::Function(
        se_linked->symref,psf->loc,psf->length());
    dest->se=se_linked;
    
    // Scan through the instructions and resolve TypeIDs and SymRefs. 
    for(PrgAdr adr=0; adr<psf->length(); )
    {
        const INST::DescEntry *ide=INST::Desc(psf->InstructionAt(adr));
        if(!ide)
        {
            Error(psf->loc,
                "illegal instruction at address 0x%x in \"%s\"",
                (uint)adr,psf->se->CompleteName().str());
            ++n_errors;
            break;  // No use to go on; we cannto compute the size of the skip. 
        }
        
        // Copy instruction to destination (linked) memory. 
        char *inst_base_src=&psf->index(adr);
        dest->append(inst_base_src,ide->size);
        char *inst_base_dest=&dest->index(adr);
        
        // Only instructions with a TypeID or SymRef are interesting. 
        if(ide->typeid_off)
        {
            // Extract TypeID from program memory: 
            TypeID val=*(TypeID*)(inst_base_src+ide->typeid_off);
            
            // Internal TypeIDs stay unchanged. 
            TypeID new_val;
            if(val<0)
            {  new_val=val;  }
            else
            {
                // Look up TypeID: 
                ClassInfo *found=fn->f->tid2classinfo.lookup(val);
                if(!found)
                {
                    Error(dest->loc,
                        "undeclared TypeID %d at address 0x%x",
                        (int)val,(uint)adr);
                    ++n_errors;
                    new_val=0;
                }
                else
                {
                    Assert(found->linked);
                    Assert(found->linked->nstype==NamespaceInfo::NSClass);
                    
                    ClassInfo *ci=static_cast<ClassInfo*>(found->linked);
                    // See for what we need the class. 
                    switch(psf->InstructionAt(adr))
                    {
                        case INST::ONEW:
                            if(!ci->need_construct)
                            {  _LinkerNeedClassConstruct(ci);  }
                            break;
                        case INST::SCAST:
                        case INST::DCAST:
                            if(!ci->need_cast)
                            {  ci->need_cast=1;  }
                            break;
                        default: Assert(0);
                    }
                    
                    new_val=ci->class_tid;
                    Assert(new_val);
                }
            }
            
            // Write result back into program memory. 
            *(TypeID*)(inst_base_dest+ide->typeid_off)=(TypeID)new_val;
        }
        
        if(ide->symref_off)
        {
            // Extract SymRef from program memory: 
            SymRef val=*(SymRef*)(inst_base_src+ide->symref_off);
            
            // Look up SymRef: Internal symrefs stay unchanged. 
            SymRef new_val;
            if(val<0)
            {  new_val=val;  }
            else
            {
                NamespaceInfo::SymbolEntryE *found=
                    fn->f->symref2symbol.lookup(val);
                if(!found)
                {
                    Error(dest->loc,
                        "undeclared SymRef $%d at address 0x%x",
                        (int)val,(uint)adr);
                    ++n_errors;
                    new_val=0;
                }
                else
                {
                    // So, it is the symbol entry *found which may or may not 
                    // yet be linked. 
                    if(found->linked)
                    {
                        // Already linked. This is easy. 
                        new_val=found->linked->symref;
                    }
                    else
                    {
                        // See if it is in the symbol queue already and if not, 
                        // push it. 
                        new_val=_SQPush(found);
                    }
                    
                    Assert(new_val);
                }
            }
            
            //fprintf(stderr,"symref subst %d -> %d +++++++++++\n",val,new_val);
            
            // Write result back into program memory. 
            *(SymRef*)(inst_base_dest+ide->symref_off)=(SymRef)new_val;
            
            //val=*(SymRef*)(inst_base_src+ide->symref_off);
            //new_val=*(SymRef*)(inst_base_dest+ide->symref_off);
            //fprintf(stderr,"NOW %d -> %d +++++++++++\n",val,new_val);
        }
        
        // Skip to next instruction. 
        adr+=ide->size;
    }
    
    /*static_cast<AssemblerFile_Plaintext*>(out)->WriteFunctionProgram(stderr,
        psf);
    static_cast<AssemblerFile_Plaintext*>(out)->WriteFunctionProgram(stderr,
        dest);*/
    
    // Important: Add function to (linked, master) program storage: 
    out->program.AddFunction(dest);
    if(is_start_func)
    {  out->slabel_start.pfunc=dest;  }
    
    if(!cfg.abandon_out_maps && !is_start_func)
    {
        bool is_known;  // not set up. 
        out->symref2function.AddNode(se_linked->symref,dest,&is_known);
        Assert(!is_known);
    }
}


void VMLinker::_LinkerNeedClassConstruct(ClassInfo *ci)
{
    // We are in master tree. 
    Assert(!ci->linked);
    
    // Avoid doing things twice. 
    if(ci->need_construct)  return;
    ci->need_construct=1;
    
    Warning("processing %u vtable entries of %s",
        (uint)ci->vtable.n(),ci->CompleteName().str());
    
    // This means, we need the vtables. 
    // NOTE: Up to here, the vtable entries in the master tree point 
    //       to SymbolEntries in NON-master tree. The reason is that 
    //       these symbols simply do not yet exist in the master tree. 
    for(uint32 i=0,iend=ci->vtable.n(); i<iend; i++)
    {
        ClassInfo::VTableEntry *ve=&ci->vtable[i];
        Assert(ve->se);
        
        if(ve->se->ep())
        {
            // Non-internal symbols here. 
            NamespaceInfo::SymbolEntryE *vese=ve->se->ep();
            Assert(vese->nspc->linked);
            
            // We will put NULL in the *se pointer in the master tree until we 
            // resolve the symbol. 
            if(vese->linked)
            {
                // Symbol already linked. 
                ve->se=vese->linked;
            }
            else
            {
                // Symbol not yet resolved. 
                _SQPush(vese,&ve->se);
                ve->se=NULL;
            }
        }
        else
        {
            // Internal symbols here. 
            // This means: we need to allocate an internal symbol entry 
            // and assign it. If the internal symbol entry is already 
            // allocated, a lookup is enough. This is done by 
            // InternalSymbolList's LookupStore(). 
            ve->se=out->internal_symbols.LookupStore(ve->se->symref);
            // Nothing more to do. 
        }
    }
}


void VMLinker::_DoPropagateUseFlags(ClassInfo *from,ClassInfo *cni)
{
    // NOTE: If we need a class for construction, then the need_construct is 
    //       not set on the bases because we do not need the vtables of the 
    //       bases. 
    if(from->need_construct || from->need_cast)
    {
        cni->need_cast=1;
    }
    
    // Recurse up the base hierarchy: 
    for(uint32 i=0,iend=cni->base.n(); i<iend; i++)
    {
        ClassInfoIE *cii=cni->base[i].ci;
        Assert(cii);
        ClassInfo *ci=cii->ci();
        if(!ci)  continue;  // Ignore internal base classes. 
        _DoPropagateUseFlags(from,ci);
    }
}

void VMLinker::_PropagateUseFlags_Recursive(NamespaceInfo *ni)
{
    if(ni->nstype==NamespaceInfo::NSClass)
    {
        ClassInfo *ci=static_cast<ClassInfo*>(ni);
        
        if(ci->need_construct || ci->need_cast)
        {  _DoPropagateUseFlags(ci,ci);  }
    }
    
    // Call recursively on children: 
    for(NamespaceInfo *j=ni->down.first(); j; j=j->next)
        _PropagateUseFlags_Recursive(j);
}


void VMLinker::_CreateInitFunction()
{
    // Create the ".init" function for this file by emitting CALL 
    // instructions for the .init functions in the source files. 
    ProgramStorage::Function *inifunc=new ProgramStorage::Function(
        /*symref=*/0,SCLocation());
    
    int n_added=0;
    for(FileNode *fn=flist.first(); fn; fn=fn->next)
    {
        if(!fn->needed)  continue;
        if(!fn->f->slabel_init.pfunc)  continue;
        
        // Init function of needed file must have been linked. 
        Assert(fn->f->slabel_init.se.linked);
        
        SymRef symref=fn->f->slabel_init.se.linked->symref;
        inifunc->append(INST::CALL,symref);
        ++n_added;
    }
    if(!n_added)
    {
        // Do not need an init function. 
        DELETE(inifunc);
    }
    else
    {
        // Append return instruction...
        inifunc->append(INST::RET);
        
        // Add init function to program memory. 
        out->program.AddFunction(inifunc);
        inifunc->se=&out->slabel_init.se;
        
        // Create a nice SymbolEntryE for the init function. 
        out->slabel_init.pfunc=inifunc;
        out->slabel_init.se.extid=NamespaceInfo::SymbolEntryE::ExtFunction;
        out->slabel_init.se.ftype=FuncType(FuncType::Function,/*exported=*/0);
        out->slabel_init.se.name=".init";
        out->slabel_init.se.nspc=out->nspc_root;
        out->slabel_init.se.linked=NULL;
    }
}

int VMLinker::LinkAll(AssemblerFile *_out)
{
    // Well, then let's start...
    DELETE(out);
    out=_out;
    n_errors=0;
    
    // Be sure to start at "zero". 
    symbol_provide_map.clear();
    master_TypeID_cnt=1;
    master_SymRef_cnt=1;
    sq.clear();
    
    // Something to base debugging and testing on: Complete namespace 
    // tree dump of all input files: 
    for(FileNode *fn=flist.first(); fn; fn=fn->next)
    {   
        NamespaceInfo *f_nspc_root=fn->f->nspc_root;
        if(!f_nspc_root)  continue;
        
        StringTreeDump dump;
        dump.append("------------<"+fn->f->filename.path()+
            ">------------\n");
        f_nspc_root->DumpTree(dump,/*IDs_resolved=*/0);
        dump.write(stdout);
    }
    
    // First, find the file which has the start symbol. 
    // If there is more than one, this is an error. 
    FileNode *start_fn=NULL;
    FileNode *abi_version_fn=NULL;
    for(FileNode *fn=flist.first(); fn; fn=fn->next)
    {
        fn->needed=0;  // be sure...
        
        if(fn->f->slabel_start.pfunc)
        {
            if(!start_fn)
            {  start_fn=fn;  }
            else
            {
                Error(fn->f->filename,
                    "multiple start labels; previous definition in %s",
                    start_fn->f->filename.path().str());
                ++n_errors;
            }
        }
        
        if(fn->f->abi_version)
        {
            if(!abi_version_fn)
            {  abi_version_fn=fn;  }
            else if(abi_version_fn->f->abi_version!=fn->f->abi_version)
            {
                Error(fn->f->filename,
                    "incompatible ABI versions: \"%s\" vs \"%s\" in %s",
                    fn->f->abi_version.str(),
                    abi_version_fn->f->abi_version.str(),
                    abi_version_fn->f->filename.path().str());
                ++n_errors;
            }
        }
        else
        {
            Warning(fn->f->filename,
                "ABI version information missing; assuming compatible");
        }
    }
    if(!start_fn)
    {  Error("no start label present");  ++n_errors;  }
    if(n_errors)
    {
        Error("bailing out at stage 0 (find start)");
        return(n_errors);
    }
    
    // Set output ABI version: 
    out->abi_version=abi_version_fn->f->abi_version;
    
    // Okay, start_file contains the start label. 
    // We need to determine which file (of all the passed ones) we 
    // actually need and throw away those which we do not need without 
    // investing too much work into those. 
    
    // To see which files are needed, we must look up all symbols in those 
    // files which are needed until now. If the new symbol is in a file 
    // which is not yet needed, then this must be marked as needed. 
    // If a symbol which we need appars more than once, this is an error. 
    // If an unneeded symbol appears more than once, we can ignore that. 
    
    // Look up all the TypeIDs and VTableIDs in the namespace part of all 
    // files (not the code part). Also, resolve the SymRefs. 
    for(FileNode *fn=flist.first(); fn; fn=fn->next)
    {
        if(fn->f->ResolveIDsNamespaceLocal())
        {  ++n_errors;  }
    }
    if(n_errors)
    {
        Error("bailing out at stage 1 (resolve IDs local)");
        return(n_errors);
    }
    
    // First join all the namespaces (including class names, TypeIDs and 
    // VTableIDs) and make sure that classes have equal definitions. 
    _MergeNamespaceAndVTableInfo();
    if(n_errors)
    {
        Error("bailing out at stage 2 (merge namespaces)");
        return(n_errors);
    }
    
    // Set up the symbol_provide_map. 
    _GenerateSymbolProvideMap();
    // It is important that we quit here on duplicate symbols. 
    if(n_errors)
    {
        Error("bailing out at stage 3 (create symbol map)");
        return(n_errors);
    }
    
    // Okay, do the actual linking of the symbols and the program. 
    // We put all symbols which we need into a queue. All entries in the 
    // queue are processed and when processing those results in new symbols 
    // needed, then they are again added to the queue. 
    
    // We start with the fact that we need the .start function. 
    // Anything else is walking the dependencies. 
    out->slabel_start.pfunc=NULL;
    _SQPush(&start_fn->f->slabel_start.se,NULL,LSymbol::SStart);
    
    // This is the main symbol lookup linker loop. 
    LSymbol ls;
    while(_SQPeek(ls))
    {
        Warning("Looking up %s...",ls.se->CompleteName().str());
        
        // So, we need symbol >ls<... 
        FileNode *definition_fn=NULL;
        if(ls.se->linked || ls.se->symref<0)
        {
            // Oops, an already linked symbol in the queue. 
            // Or, an internal symbol in the queue. 
            // Both these may not happen. 
            Assert(0);
        }
        else
        {
            // Only non-internal symbols here. 
            // The symbol must be in a namespace which must have been 
            // merged already. We actually did the latter above. 
            Assert(ls.se->nspc);
            NamespaceInfo *linked=ls.se->nspc->linked;
            Assert(linked);
            
            NamespaceInfo::SymbolEntryE *found=NULL;
            do {
                // Go searching in the provide map. 
                found=symbol_provide_map.lookup(ls.se);
                if(found)
                {
                    // Get the file in which the symbol is defined in. 
                    definition_fn=_GetDefinitionFile(found->nspc);
                    
                    // See if already linked. 
                    if(found->linked)
                    {
                        // Just update the link pointer so that we do not 
                        // look that up again. 
                        ls.se->linked=found->linked;  // WAS: found
                        
                        break;
                    }
                    
                    // We need the file in which the symbol is defined in 
                    // case we did not yet process it. This will put the 
                    // necessary things into the queue. 
                    _LinkerFileNeeded(definition_fn);
                    
                    // See if it is now linked (after calling 
                    // _LinkerFileNeeded() which will link the global vars). 
                    if(found->linked)
                    {
                        // Just update the link pointer so that we do not 
                        // look that up again. 
                        ls.se->linked=found->linked;  // WAS: found
                        
                        break;
                    }
                    
                    // Found, but not in master tree. 
                    // Add to our linked destination symbols. 
                    NamespaceInfo *master_parent=found->nspc->linked;
                    Assert(master_parent);
                    
                    // This will make a new copy of the SymbolEntryE for the 
                    // master tree: 
                    if(ls.sflag==LSymbol::SStart)
                    {
                        out->slabel_start.se=*found;  // C++ assignment
                        found=&out->slabel_start.se;
                    }
                    else
                    {
                        master_parent->symbol.PushHead(*found);
                        found=master_parent->symbol.head();
                    }
                    
                    // Update tree info for master tree: 
                    found->nspc=master_parent;
                    found->linked=NULL;   // (unused in master tree)
                    found->symref=ls.symref;
                    
                    // ...and "link" it: 
                    ls.se->linked=found;
                    
                    // Still add entry to the mapping: 
                    Assert(found->symref>=0);  // Non-internal ones, only. 
                    int _unused_ srv=master_parent->map_name2symbol.store(
                        found,/*allow_update=*/0);
                    // If this assert "legally" fails, then we need to replace 
                    // it with an error. 
                    Assert(!srv);
                    
                    if(!cfg.abandon_out_maps)
                    {
                        NamespaceInfo::SymbolEntryE _unused_ *known=
                            out->symref2symbol.AddNode(found);
                        Assert(!known);
                    }
                }
                
                // (Try more possibilites for lookup here.) 
            } while(0);
            
            if(!found)
            {
                Error(ls.se->nspc->asm_loc,"undefined symbol \"%s\"",
                    ls.se->CompleteName().str());
                ++n_errors;
            }
        }
        
        // Update the symbol entry pointer if specified. We update with NULL 
        // in case resolving failed. 
        if(ls.update_se)
        {  *ls.update_se=ls.se->linked;  }
        
        // Now, remove symbol rom the queue. 
        _SQPop();
        
        if(!ls.se->linked)
        {
            // Symbol could not be found. Give up and take next one. 
            continue;
        }
        
        // We must know the file where the symbol is defined if we found it. 
        Assert(definition_fn);
        
        switch(ls.se->extid)
        {
            case NamespaceInfo::SymbolEntryE::ExtFunction:
            {
                Warning(ls.se->nspc->asm_loc,"get code for function %s "
                    "(symref $%d)",
                    ls.se->CompleteName().str(),(int)ls.se->symref);
                Warning(definition_fn->f->filename,"  looking in this file");
                
                // Get program code for function. 
                ProgramStorage::Function *pfunc;
                if(ls.se==&definition_fn->f->slabel_init.se)
                {  pfunc=definition_fn->f->slabel_init.pfunc;  }
                else if(ls.se==&definition_fn->f->slabel_start.se)
                {  pfunc=definition_fn->f->slabel_start.pfunc;  }
                else
                {  pfunc=definition_fn->f->symref2function.lookup(
                    ls.se->symref);  }
                
                // The SymRef MUST be known...
                Assert(pfunc);
                
                Assert(ls.se->linked->symref==ls.symref);
                _LinkFunction(definition_fn,pfunc,ls.se->linked);
            }   break;
            case NamespaceInfo::SymbolEntryE::ExtVariable:
                // Currently nothing to do. 
                // The global storage has already been linked. 
                if(ls.se->symref>=0)  // Only non-internal symbols. 
                {  Assert(ls.se->linked->nspc->map_name2symbol.search(
                    ls.se->name));  }
                //fprintf(stderr,"VAR SYMBOL: %s %d\n",
                //  ls.se->name.str(),ls.symref);
                break;
            default: Assert(0);
        }
    }
    
    if(n_errors)
    {
        Error("bailing out at stage 4 (resolve symbols)");
        return(n_errors);
    }
    
    if(out->nspc_root)
    {
        _PropagateUseFlags_Recursive(out->nspc_root);
        
        _CreateInitFunction();
    }
    
    // Warn user about not needed input files. 
    for(FileNode *fn=flist.first(); fn; fn=fn->next)
    {
        if(!fn->needed)
        {  Warning(fn->f->filename,"input file not needed");  }
    }
    
    // Produce a dump of the master namespace for debugging. 
    if(out->nspc_root)
    {
        StringTreeDump dump;
        out->nspc_root->DumpTree(dump,/*IDs_resolved=*/1);
        dump.write(stdout);
    }
    
    return(n_errors);
}


int VMLinker::AddFile(AssemblerFile *afile)
{
    if(!afile)  return(0);
    
    FileNode *n=new FileNode(afile);
    flist.append(n);
    
    return(0);
}


VMLinker::VMLinker() : 
    cfg(),
    flist(),
    n_errors(0),
    sq(/*m=*/8),  // <-- 4 or 8 as we do lots of RemoveSmallest(). 
    master_TypeID_cnt(1),  // <-- start with 1
    master_SymRef_cnt(1),  // start with 1
    symbol_provide_map(/*m=16*/),
    out(NULL)
{
    
}

VMLinker::~VMLinker()
{
    // Delete output file if non-NULL. 
    DELETE(out);
    
    // Kill all files (and all their content). 
    while(!flist.IsEmpty())
    {  delete flist.PopFirst();  }
}

//------------------------------------------------------------------------------

VMLinker::Config::Config()
{
    ignore_simple_type_missing=0;
    abandon_out_maps=0;
}

}  // end of namespace VM


#if 1  /* Small test program: "test linker" */

#include <lib/message/manager.h>
#include <lib/message/handler_console.h>
#include <vm/input/tasm/tasm-file.h>


static int _DoParseFile(const char *file,VM::AssemblerFile_Plaintext *asmfile,
    uint32 cnt)
{
    SError error;
    
    int rv=asmfile->ParseFile(file,error,cnt);
    if(rv)
    {
        if(error)
        {  Error("parsing %s: %s",file,error.msg().str());  }
        else
        {  Error("%d lexer/parser errors",rv);  }
        return(1);
    }
    
    return(0);
}

int main(int argc,char **arg)
{
    MessageManager::init();
    MessageHandler_Console cons_hdl(
        Message::MTAll,
        //Message::MTAllNonDebug,
        /*use_color=*/0);
    
    VM::VMLinker linker;
    
    int fail=0;
    for(int i=1; i<argc; i++)
    {
        VM::AssemblerFile_Plaintext *asmfile = 
            new VM::AssemblerFile_Plaintext();
        int rv=_DoParseFile(arg[i],asmfile,i);
        if(rv)
        {  DELETE(asmfile);  ++fail;  }
        else
        {  linker.AddFile(asmfile);  }
    }
    
    if(!fail)
    {
        VM::AssemblerFile *output=new VM::AssemblerFile_Plaintext();
        
        fail=linker.LinkAll(output);
        if(!fail)
        {
            SError error;
            fail=output->WriteFile("linker.out",error);
        }
    }
    
    MessageManager::cleanup();
    return(fail);
}

#endif

---