/ray/src/vm/input/asmfile.cc

Go to the documentation of this file.

/*
 * vm/input/asmfile.cc
 * 
 * VM assembler input file. 
 * 
 * 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 "asmfile.h"
#include "classinfo.h"
#include <lib/message/message.h>


namespace VM
{

AssemblerFile::Config::Config()
{
    // For now, we read (by default) all we can :)
    read_non_pointer_members=1;
    read_member_var_names=1;
    
    emit_all_namespaces=0;  // should be 0
    emit_all_classinfo=0;   // should be 0
}

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

NamespaceInfo::SymbolEntryB *AssemblerFile::InternalSymbolList::LookupStore(
    SymRef symref)
{
    // Only for internal symrefs. 
    if(symref>=0)  return(NULL);
    
    // First see if we already have it. 
    NamespaceInfo::SymbolEntryB *seb=sym_map.lookup(symref);
    if(!seb)
    {
        // Allocate a new one. 
        sym_stor.PushHead(NamespaceInfo::SymbolEntryB());
        seb=sym_stor.head();
        
        seb->symref=symref;
        
        // Put into map: 
        NamespaceInfo::SymbolEntryB _unused_ *known=sym_map.AddNode(seb);
        Assert(!known);
    }
    
    return(seb);
}

AssemblerFile::InternalSymbolList::InternalSymbolList() : 
    sym_stor(/*chunk_size=*/32,/*keep_old=*/0),
    sym_map()
{
    // nothing to do
}

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

ClassInfoIE *AssemblerFile::InternalClassList::LookupStore(TypeID tid)
{
    // Only for internal TypeIDs. 
    if(tid>=0)  return(NULL);
    
    // First see if we already have it. 
    ClassInfoIE *cie=class_map.lookup(tid);
    if(!cie)
    {
        // Allocate a new one. 
        class_stor.PushHead(ClassInfoIE(tid));
        cie=class_stor.head();
        
        // Put into map: 
        ClassInfoIE _unused_ *known=class_map.AddNode(cie);
        Assert(!known);
    }
    
    return(cie);
}

AssemblerFile::InternalClassList::InternalClassList() : 
    class_stor(/*chunk_size=*/32,/*keep_old=*/0),
    class_map()
{
    // nothing to do
}

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

int AssemblerFile::_ResolveIDsNamespaceLocal_Recursive(NamespaceInfo *root)
{
    int errcnt=0;
    
    // Process this node. 
    switch(root->nstype)
    {
        case NamespaceInfo::NSClass:
        {
            ClassInfo *croot=static_cast<ClassInfo*>(root);
            
            // Look up base entries. 
            for(uint32 i=0,iend=croot->base.n(); i<iend; i++)
            {
                ClassInfo::BaseEntry *be=&croot->base[i];
                if(be->tid<0)
                {
                    be->ci=internal_classes.LookupStore(be->tid);
                }
                else
                {
                    ClassInfo *ci=tid2classinfo.lookup(be->tid);
                    if(!ci)
                    {
                        Error(croot->asm_loc,
                            "undeclared typeid %d in base spec of \"%s\"",
                            (int)be->tid,croot->CompleteName().str());
                        ++errcnt;
                    }
                    be->ci=ci;
                }
            }
            
            // Look up vtable entries: 
            for(uint32 i=0,iend=croot->vtable.n(); i<iend; i++)
            {
                if(croot->vtable[i].symref<0)
                {
                    // "Lookup" of internal symref in vtable. 
                    // (Just allocate one if not yet allocated.)
                    croot->vtable[i].se=internal_symbols.LookupStore(
                        croot->vtable[i].symref);
                }
                else
                {
                    NamespaceInfo::SymbolEntryE *se=symref2symbol.lookup(
                        croot->vtable[i].symref);
                    if(!se)
                    {
                        Error(filename,
                            "undefined symref $%d in vtable of %s",
                            (int)croot->vtable[i].symref,
                            croot->CompleteName().str());
                        ++errcnt;
                    }
                    croot->vtable[i].se=se;
                }
            }
            
        }   // NO BREAK; fall through. 
        case NamespaceInfo::NSNamespace:
            // For the plain namespace info, there is nothing to do. 
            break;
        default:  Assert(0);
    }
    
    // Recurse: 
    for(NamespaceInfo *i=root->down.first(); i; i=i->next)
    {  errcnt+=_ResolveIDsNamespaceLocal_Recursive(i);  }
    
    return(errcnt);
}


int AssemblerFile::_ResolveSymrefsInGlobal(_GlobVars *gvar)
{
    int errcnt=0;
    for(GlobalVarList::Iterator i(gvar->globvarq); i; i++)
    {
        // Global storage may not contain internal symbols. 
        Assert((*i)->symref>=0);
        
        NamespaceInfo::SymbolEntryE *se=symref2symbol.lookup((*i)->symref);
        if(!se)
        {
            Error(filename,
                "undefined symref $%d in global",
                (int)(*i)->symref);
            ++errcnt;
        }
        (*i)->se=se;
    }
    
    return(errcnt);
}


int AssemblerFile::ResolveIDsNamespaceLocal()
{
    int errcnt=0;
    
    // TypeIDs in base entries and SymRefs in vtables: 
    if(nspc_root)
    {  errcnt+=_ResolveIDsNamespaceLocal_Recursive(nspc_root);  }
    
    // SymRefs in global vars. 
    errcnt+=_ResolveSymrefsInGlobal(&gvar_v);
    errcnt+=_ResolveSymrefsInGlobal(&gvar_p);
    
    // SymRefs to functions in function program storage (one per function). 
    for(ProgramStorage::Function *pfunc=program.FirstFunction(); 
        pfunc; pfunc=pfunc->next)
    {
        // .init and .start may have phantasy symrefs...
        // (Actually, these do not have SymRefs but initially get the 
        // *se pointer set, so there is nothing to look up anyways.) 
        if(pfunc==slabel_init.pfunc || pfunc==slabel_start.pfunc) continue;
        
        Assert(pfunc->symref>=0);
        NamespaceInfo::SymbolEntryE *sent=symref2symbol.lookup(
            pfunc->symref);
        if(!sent)
        {
            Error(pfunc->loc,
                "undefined function symref $%d in program section",
                (int)pfunc->symref);
            ++errcnt;
        }
        pfunc->se=sent;
    }
    
    return(errcnt);
}


int AssemblerFile::ParseFile(const TLString &/*fname*/,SError &/*error*/,
    uint32 /*file_num*/)
{
    CritAssert(0);  // must be overridden
    return(-1);
}


int AssemblerFile::WriteFile(const TLString &/*fname*/,SError &/*error*/)
{
    CritAssert(0);  // must be overridden
    return(-1);
}


AssemblerFile::AssemblerFile() : 
    cfg(),
    filename(),
    file_num(0),
    gvar_v(),
    gvar_p(),
    program(),
    tid2classinfo(),
    symref2symbol(),
    internal_symbols(),
    internal_classes(),
    symref2function(),
    symref2globvar()
{
    nspc_root=NULL;
    
    slabel_start.pfunc=NULL;
    slabel_init.pfunc=NULL;
}

AssemblerFile::~AssemblerFile()
{
    // Recursively delete tree: 
    DELETE(nspc_root);
    
    // gvar_{v,p}.globvar tidy up themselves. 
    // program storage cleans up itself. 
    // tid2classinfo, symref2symbol, internal_symbols, internal_classes, 
    //    symref2function, symref2globvar tidy up themselves. 
    
    // The program storage takes care to free these: 
    slabel_start.pfunc=NULL;
    slabel_init.pfunc=NULL;
}

}  // end of namespace VM

---