/ray/src/vm/input/tasm/tasm-file.cc

Go to the documentation of this file.

/*
 * vm/input/tasm/tasm-file.cc
 * 
 * VM plaintext assembly 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 "tasm-file.h"
#include <lib/serror.h>
#include <lib/message/message.h>
#include <lib/lex/strtreedump.h>

// NOTE: The parsing routines are in parse.cc. 
//       Only the non-parsing routines go here. 


namespace VM
{

int AssemblerFile_Plaintext::_WriteFunctionProgram(FILE *fp,
    ProgramStorage::Function *pfunc)
{
    int errcnt=0;
    
    if(pfunc==slabel_start.pfunc)
    {  fprintf(fp,".start:");  }
    else if(pfunc==slabel_init.pfunc)
    {  fprintf(fp,".init:");  }
    else
    {  fprintf(fp,"$%d:",(int)pfunc->se->symref);  }
    // Be a bit verbose what we dump here...
    fprintf(fp,"  # Function %s (type: %s)\n",
        pfunc->se->CompleteName().str(),
        pfunc->se->ftype.TypeString().str());
    
    bool free_p2c=!prgadr2codemark;
    if(free_p2c)
    {  prgadr2codemark=new TLArrayHeap<RJumpEntry,RJumpEntry_Operators>();  }
    else
    {
        // Purge old content to be sure. 
        prgadr2codemark->clear(/*keep_memory=*/1);
    }
    
    // First, scan the function for jumps: 
    CodeMark cmark_cnt=1;  // Start with 1; the same as below!!
    for(PrgAdr adr=0; adr<pfunc->length(); )
    {
        const INST::DescEntry *ide=INST::Desc(pfunc->InstructionAt(adr));
        if(!ide)
        {
            Error(pfunc->loc,
                "illegal instruction at address 0x%x in \"%s\"",
                (uint)adr,pfunc->se->CompleteName().str());
            // No use to go on; we cannto compute the size of the skip. 
            return(errcnt+1);
        }
        
        if(ide->codemark_off)
        {
            // Extract jump address from program memory: 
            char *prg_inst_adr = &pfunc->index(adr+ide->codemark_off) ;
            PrgAdr rel_adr=*(PrgAdr*)prg_inst_adr;
            
            PrgAdr dadr = int32(adr)+int32(rel_adr);
            
            // Put into list: 
            prgadr2codemark->insert(RJumpEntry(dadr,cmark_cnt++));
        }
        
        // Skip to next instruction. 
        adr+=ide->size;
    }
    
    TLString itmp;
    cmark_cnt=1;  // Start with 1; the same as above!!
    for(PrgAdr adr=0; adr<pfunc->length(); )
    {
        const INST::DescEntry *ide=INST::Desc(pfunc->InstructionAt(adr));
        Assert(ide);
        
        // Well, the only thing we must back-convert is codemark labels. 
        if(!prgadr2codemark->IsEmpty() && prgadr2codemark->first()->adr<=adr)
        {
            if(prgadr2codemark->first()->adr<adr)
            {
                Error(pfunc->loc,
                    "illegal relative jump to address 0x%x in \"%s\"",
                    (uint)prgadr2codemark->first()->adr,
                    pfunc->se->CompleteName().str());
                prgadr2codemark->PopFirst();
                ++errcnt;
            }
            else
            {
                fprintf(fp,"&0x%x:\n",
                    (uint)prgadr2codemark->first()->cmark);
                
                int _unused_ rv=prgadr2codemark->PopFirst();
                Assert(!rv);
            }
        }
        
        if(ide->codemark_off)
        {
            // Temporarily replace relavtive address with CodeMark: 
            char *prg_inst_adr = &pfunc->index(adr+ide->codemark_off) ;
            PrgAdr rel_adr=*(PrgAdr*)prg_inst_adr;
            
            // Change program memory. 
            *(CodeMark*)prg_inst_adr=(CodeMark)(cmark_cnt++);
            
            itmp=pfunc->DumpInstruction(adr);
            
            // Undo change to program memory. 
            *(PrgAdr*)prg_inst_adr=(PrgAdr)rel_adr;
        }
        else
        {
            itmp=pfunc->DumpInstruction(adr);
        }
        
        fprintf(fp,"\t%s\n",itmp.str());
        
        // Skip to next instruction. 
        adr+=ide->size;
    }
    
    if(!prgadr2codemark->IsEmpty())
    {
        Error(pfunc->loc,
            "%u illegal relative jumps in \"%s\"",
            (uint)prgadr2codemark->NElem(),
            pfunc->se->CompleteName().str());
        prgadr2codemark->PopFirst();
        ++errcnt;
    }
    
    if(free_p2c)
    {  DELETE(prgadr2codemark);  }
    
    return(errcnt);
}


int AssemblerFile_Plaintext::_MustDumpNamespace(NamespaceInfo *ni)
{
    ClassInfo *ci=NULL;
    switch(ni->nstype)
    {
        case NamespaceInfo::NSNamespace:  break;
        case NamespaceInfo::NSClass:  ci=static_cast<ClassInfo*>(ni);  break;
        default: Assert(0);
    }
    
    bool need_class = (ci && (ci->need_construct || ci->need_cast));
    
    int need = need_class ? 2 : 0;
    if(!need)
    {
        for(NamespaceInfo *i=ni->down.first(); i; i=i->next)
        {
            int rv=_MustDumpNamespace(i);
            if(rv)
            {  need=1;  break;  }
        }
    }
    
    if(need<2 && cfg.emit_all_classinfo)  need=2;
    else if(need<1 && cfg.emit_all_namespaces)  need=1;
    
    return(need);
}


int AssemblerFile_Plaintext::_WriteSymbols_Recursive(StringTreeDump &out,
    NamespaceInfo *ni)
{
    int errcnt=0;
    
    bool has_children = !ni->down.IsEmpty();
    int need_info = _MustDumpNamespace(ni);
    ClassInfo *ci=NULL;
    switch(ni->nstype)
    {
        case NamespaceInfo::NSNamespace:  break;
        case NamespaceInfo::NSClass:  ci=static_cast<ClassInfo*>(ni);  break;
        default: Assert(0);
    }
    
    // Dump namespace info (first part) if needed. 
    TLString tmp;
    if(need_info)
    {
        if(ni->parent)
        {
            if(ci)
            {  tmp.sprintf("class %d %s\n",
                (int)ci->class_tid,ci->name.str());  }
            else
            {  tmp.sprintf("namespace %s\n",ni->name.str());  }
            out+=tmp;
        }
        out.AddIndent();
    }
    
    // Dump class info if needed. 
    if(need_info>1 && ci)
    {
        Assert(ci);
        
        if(ci->base.n())
        {
            tmp.sprintf("base %u",(uint)ci->base.n());
            out+=tmp;
            
            for(uint32 i=0; i<ci->base.n(); i++)
            {
                const ClassInfo::BaseEntry *e=&ci->base[i];
                tmp.sprintf(", %d 0x%x",e->ci->class_tid,(uint)e->off);
                out+=tmp;
            }
            
            out+=";\n";
        }
        
        {
            uint32 num_p=0,num_v=0;
            for(uint32 i=0; i<ci->membvar.n(); i++)
            {
                const ClassInfo::MemberVarEntry *e=&ci->membvar[i];
                if(e->vtype.IsPointerType())  ++num_p;
                else  ++num_v;
            }
            
            tmp.sprintf("size 0x%x %u,%u\n",
                (uint)ci->size,num_p,num_v);
            out+=tmp;
            
            if(num_p || num_v)
            {
                out.AddIndent();
                
                for(uint32 i=0; i<ci->membvar.n(); i++)
                {
                    const ClassInfo::MemberVarEntry *e=&ci->membvar[i];
                    tmp.sprintf("%s 0x%x%s%s\n",
                        e->vtype.TypeString().str(),
                        (uint)e->off,
                        e->name ? ", " : "",
                        e->name ? e->name.str() : "");
                    out+=tmp;
                }
                
                out.SubIndent();
            }
            
            out+=";\n";
        }
        
        if(ci->nvirtuals)
        {
            tmp.sprintf("virtual %u\n",(uint)ci->nvirtuals);
            out+=tmp;
        }
        
        if(ci->vtable.n())
        {
            tmp.sprintf("vtable %u",(uint)ci->vtable.n());
            out+=tmp;
            
            for(uint32 i=0; i<ci->vtable.n(); i++)
            {
                const ClassInfo::VTableEntry *e=&ci->vtable[i];
                tmp.sprintf(" $%d",(int)e->se->symref);
                out+=tmp;
            }
            
            out+=";\n";
        }
    }
    
    // Dump namespace info (second part) if needed. 
    if(need_info)
    {
        // Recurse: 
        if(has_children)
        {
            tmp.deref();
            for(NamespaceInfo *i=ni->down.first(); i; i=i->next)
            {  _WriteSymbols_Recursive(out,i);  }
        }
        
        if(!ni->symbol.IsEmpty())
        {
            out+="symbols\n";
            out.AddIndent();
        }
        for(NamespaceInfo::SymbolList::Iterator i(ni->symbol); i; i++)
        {
            const NamespaceInfo::SymbolEntryE *se=*i;
            
            switch(se->extid)
            {
                case NamespaceInfo::SymbolEntryE::ExtFunction:
                {
                    const char *ftype_base=NULL;
                    switch(se->ftype.id)
                    {
                        case FuncType::Function:  ftype_base="function";  break;
                        case FuncType::Method:    ftype_base="method";    break;
                        case FuncType::VMethod:   ftype_base="vmethod";   break;
                        //case FuncType::Unknown:   ftype_base="???";  break;
                        default: Assert(0);
                    }

                    tmp.sprintf("%s%s $%d %s\n",
                        se->ftype.exported ? "" : "s",
                        ftype_base,
                        (int)se->symref,
                        se->name.str());
                    out+=tmp;
                } break;
                case NamespaceInfo::SymbolEntryE::ExtVariable:
                {
                    tmp.sprintf("%s $%d %s\n",
                        se->vtype.TypeString().str(),
                        (int)se->symref,
                        se->name.str());
                    out+=tmp;
                } break;
                default: Assert(0);
            }
        }
        if(!ni->symbol.IsEmpty())
        {
            out.SubIndent();
            out+=";\n";
        }
        
        out.SubIndent();
        if(ni->parent)
        {  out+=";\n";  }
    }
    
    return(errcnt);
}


int AssemblerFile_Plaintext::_WriteSymbols_Global(StringTreeDump &out,
    _GlobVars *gvar,char which)
{
    TLString tmp;
    tmp.sprintf("%cglobal 0x%x\n",which,(uint)gvar->size);
    out+=tmp;
    
    if(!gvar->globvarq.IsEmpty())
    {
        out.AddIndent();
        
        for(GlobalVarList::Iterator i(gvar->globvarq); i; i++)
        {
            const GlobalVarEntry *e=(*i);
            tmp.sprintf("%s 0x%x $%d\n",
                e->vtype.TypeString().str(),
                (uint)e->off,
                (int)e->se->symref);
            out+=tmp;
        }
        
        out.SubIndent();
    }
    
    out+=";\n";
    
    return(0);
}


int AssemblerFile_Plaintext::_WriteSymbolSectionContent(FILE *fp)
{
    int errcnt=0;
    
    StringTreeDump out;
    
    if(_WriteSymbols_Recursive(out,nspc_root))
    {  ++errcnt;  }
    
    out.AddIndent();
    if(_WriteSymbols_Global(out,&gvar_v,'v'))  ++errcnt;
    if(_WriteSymbols_Global(out,&gvar_p,'p'))  ++errcnt;
    out.SubIndent();
    
    out.write(fp,1,'\t');
    
    return(errcnt);
}


int AssemblerFile_Plaintext::WriteFile(const TLString &fname,SError &error)
{
    FILE *fp=fopen(fname.str(),"w");
    if(!fp)
    {  error=SError("error blah blah...",1);  return(-2);  }
    
    int errcnt=0;
    
    prgadr2codemark=new TLArrayHeap<RJumpEntry,RJumpEntry_Operators>();
    
    do {
        // Write info section. 
        fprintf(fp,"info:\n");
        if(abi_version)
        {  fprintf(fp,"\tabiversion %s\n",abi_version.str());  }
        fprintf(fp,"\n");
        
        // Write symbols section. 
        fprintf(fp,"symbols:\n");
        if(_WriteSymbolSectionContent(fp))
        {  ++errcnt;  }
        fprintf(fp,"\n");
        
        // Write program section. 
        fprintf(fp,"program:\n");
        for(ProgramStorage::Function *pfunc=program.FirstFunction();
            pfunc; pfunc=pfunc->next)
        {
            if(_WriteFunctionProgram(fp,pfunc))
            {  ++errcnt;  }
            if(pfunc->next)
            {  fprintf(fp,"\n");  }
        }
        
        fprintf(fp,"\n#EOF\n");
    } while(0);
    
    // Clean up: 
    DELETE(prgadr2codemark);
    
    fclose(fp);
    return(errcnt);
}


AssemblerFile_Plaintext::AssemblerFile_Plaintext() : 
    AssemblerFile(),
    scan(),
    n_errors(0),
    codemark2prgadr(),
    prgadr2codemark(NULL),
    tok(NULL)
{
    
}

AssemblerFile_Plaintext::~AssemblerFile_Plaintext()
{
    DELETE(prgadr2codemark);
    
    // codemark2prgadr tidies up itself. 
}

}  // end of namespace VM


#if 0  /* small test program */

#include <lib/message/manager.h>
#include <lib/message/handler_console.h>


static int _DoParseFile(const char *file)
{
    VM::AssemblerFile_Plaintext asmfile;
    SError error;
    
    int rv=asmfile.ParseFile(file,error);
    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);
    
    int rv=_DoParseFile(argc>1 ? arg[1] : "parser-test.tasm");
    
    MessageManager::cleanup();
    return(rv);
}

#endif

---