instrset.cc

Go to the documentation of this file.

// instrset.cc
//
// uda - universal disassembler
// Date: 2003-05-04
//
// Copyright (c) 2002-2003 Ales Smrcka 
//
// This program is licensed under GNU Library GPL. See the file COPYING.
//
// Implementation of loading instruction set from file and
// creating tables and variables. This file including builtin tables in
// namespace BuiltinTables. Tables, Table, TableItem include core of decoding.
//
// usage:
//   instructionset.Build();
//   instructionset.Load(processor_type);
//   decoder.Decode(section_name);
//

#include <iomanip>
#include <iostream>
#include <fstream>
#include <map>
#include <string>
#include <ctype.h>
#include <dlfcn.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <dirent.h>
#include <libgen.h>
#include "instrset.h"
#include "shared.h"
#include "symtable.h"
#include "decoder.h"
#include "udaclasses.h"
using namespace std;

InstructionSet instructionset;

const string instrsetdirectory="instrset/";
const string defaultinstrset="default";

// InstructionSet. (Facade, Singleton)
InstructionSet::InstructionSet()
{
    variables=new Variables;
    tables=new Tables(variables);
    tables->Add("Ib", new BuiltinTables::Ib);
    tables->Add("Iw", new BuiltinTables::Iw);
    tables->Add("Id", new BuiltinTables::Id);
    tables->Add("Ibw", new BuiltinTables::Ibw);
    tables->Add("Ibd", new BuiltinTables::Ibd);
    tables->Add("SIb", new BuiltinTables::SIb);
    tables->Add("SIw", new BuiltinTables::SIw);
    tables->Add("SId", new BuiltinTables::SId);
    tables->Add("SIbw", new BuiltinTables::SIbw);
    tables->Add("SIbd", new BuiltinTables::SIbd);
    tables->Add("Jb", new BuiltinTables::Jb);
    tables->Add("Jw", new BuiltinTables::Jw);
    tables->Add("Jd", new BuiltinTables::Jd);
    tables->Add("Apw", new BuiltinTables::Apw);
    tables->Add("Apd", new BuiltinTables::Apd);
    tables->Add("Aw", new BuiltinTables::Aw);
    tables->Add("Ad", new BuiltinTables::Ad);
    tables->Add("BIb", new BuiltinTables::BIb);
    tables->Add("BIw", new BuiltinTables::BIw);
    tables->Add("BId", new BuiltinTables::BId);
    tables->Add("BIbw", new BuiltinTables::BIbw);
    tables->Add("BIbd", new BuiltinTables::BIbd);
    tables->Add("SBIb", new BuiltinTables::SBIb);
    tables->Add("SBIw", new BuiltinTables::SBIw);
    tables->Add("SBId", new BuiltinTables::SBId);
    tables->Add("SBIbw", new BuiltinTables::SBIbw);
    tables->Add("SBIbd", new BuiltinTables::SBIbd);
    tables->Add("BJb", new BuiltinTables::BJb);
    tables->Add("BJw", new BuiltinTables::BJw);
    tables->Add("BJd", new BuiltinTables::BJd);
    tables->Add("BApw", new BuiltinTables::BApw);
    tables->Add("BApd", new BuiltinTables::BApd);
    tables->Add("BAw", new BuiltinTables::BAw);
    tables->Add("BAd", new BuiltinTables::BAd);
}

InstructionSet::~InstructionSet()
{
    if (tables!=NULL)
        delete tables;
    if (variables!=NULL)
        delete variables;
}

int InstructionSet::LoadFile(const string filename)
{
    debug("InstructionSet: Loading instructions set from "<<basename((char*)filename.c_str())<<endl);
    if (tables==NULL || variables==NULL)
        return 0;
    struct stat buf;
    if ((stat(filename.c_str(), &buf)==0) && S_ISREG(buf.st_mode))
    {
        Scanner scanner(filename.c_str());
        Parser parser(scanner, *tables, *variables);
        parser.Parse();
        return 1;
    }
    else
        return 0;
}

void InstructionSet::Load(const string processor)
{
    if (processor!="") //processor defined
        if (!LoadFile(basedir+instrsetdirectory+processor)) //load this instruction set
            throw Exception(string("can not read file ")+instrsetdirectory+processor);
        else;
    else
        if (!LoadFile(basedir+instrsetdirectory+defaultinstrset)) //load default instruction set
            throw Exception(string("can not open default instructions: ")+instrsetdirectory+defaultinstrset);
}

// clear instruction set
void InstructionSet::Clear()
{
    variables->Clear();
    tables->Clear();
}

// Scanner. Scans input for tokens
int Scanner::getc()
{
    if (unget!=-1)
    {
        int result=unget;
        unget=-1;
        if (result=='\n')
            _line++;
        return result;
    }
    int c=input.get();
    if (c=='\n')
        _line++;
    return c;
}

void Scanner::ungetc(int c)
{
    unget=c;
    if (c=='\n')
        _line--;
}

Scanner::Scanner(const char *filename) : input(filename)
{
    unget=-1;
    _line=1;
}

Scanner::Token Scanner::Scan()
{
    Token token;
    int c=getc(); //character from stream
    enum {
        normal,
        ident,
        text,
        textspec,
        num,
        numdec,
        numhex,
        comment
    } state=normal;
    while (!token && c!=-1)
    {
        switch (state) {
            case normal:
                switch (c) {
                    case '=': token.type=tk_equal; break;
                    case '+': token.type=tk_plus; break;
                    case ',': token.type=tk_comma; break;
                    case ';': token.type=tk_semicol; break;
                    case '{': token.type=tk_parop; break;
                    case '}': token.type=tk_parcl; break;
                    case '0': state=num; break;
                    case '"': state=text; break;
                    case '#': state=comment; break;
                    default:
                        if (isspace(c))
                            break;
                        if (isdigit(c))
                        {
                            token.int_value=c-'0';
                            token.str_value=c;
                            state=numdec;
                        }
                        else
                        if (isalpha(c)||c=='_')
                        {
                            state=ident;
                            token.str_value=c;
                        }
                        else
                            throw ScannerException(string("unexpected character `")+(char)c+"'", line());
                }
                break; //normal state
            case ident:
                if (isalnum(c)||c=='_')
                    token.str_value+=c;
                else
                {
                    ungetc(c);
                    token.type=tk_ident;
                }
                break;
            case text:
                if (c=='"')
                    token.type=tk_text;
                else
                    if (c=='\\')
                        state=textspec;
                    else
                        token.str_value+=c;
                break;
            case textspec:
                token.str_value+=c;
                state=text;
                break;
            case num:
                if (c=='x')
                    state=numhex;
                else
                    if (isdigit(c))
                    {
                        token.int_value=c-'0';
                        token.str_value=c;
                        state=numdec;
                    }
                    else
                    {
                        ungetc(c);
                        if (token.int_value==0)
                            token.str_value="0";
                        token.type=tk_number;
                    }
                break;
            case numdec:
                if (isdigit(c))
                {
                    token.int_value=token.int_value*10+(c-'0');
                    token.str_value+=c;
                }
                else
                {
                    ungetc(c);
                    token.type=tk_number;
                }
                break;
            case numhex:
                if (isxdigit(c))
                    if (isdigit(c))
                        token.int_value=(token.int_value<<4)|(c-'0');
                    else
                        token.int_value=(token.int_value<<4)|(lower(c)-'a'+10);
                else
                {
                    ungetc(c);
                    token.str_value=uint2str(token.int_value);
                    token.type=tk_number;
                }
                break;
            case comment:
                if (c=='\n')
                    state=normal;
                break;
        }
        c=getc();
    } //while
    ungetc(c);
    return token;
}

// Parser. Creates tables and variables

void Parser::Error()
{
    throw ParserException("unexpected token", scanner.line());
}

// GLOBAL     -> $
// GLOBAL     -> ident VARTAB -- save ident
// VARTAB     -> = textlit ; GLOBAL -- create new variable
// VARTAB     -> { ITEMS } GLOBAL -- create new table
// ITEMS      -> e
// ITEMS      -> number , number , textlit , LENGTH ; ITEMS -- create new table item
// LENGTH     -> number NEXTLENGTH
// NEXTLENGTH -> e
// NEXTLENGTH -> + ident NEXTLENGTH
//
// Runs parser to create new tables and variables
void Parser::Parse()
{
    Scanner::Token token=scanner.Scan();
    string tmp, tmp2; //temptorary variable
    unsigned mask, tag;
    Table *table;
    enum NonTerm { GLOBAL, VARTAB, ITEMS, LENGTH, NEXTLENGTH } nonterm=GLOBAL;
    while (1)
    {
        switch (nonterm) {
            case GLOBAL:
                switch (token) {
                    case tk_end: return;
                    case tk_ident:
                        tmp=token.str_value;
                        nonterm=VARTAB;
                        token=scanner.Scan();
                        break;
                    default: Error();
                }
                break;
            case VARTAB:
                switch (token) {
                    case tk_equal: //creating new variable
                        if ((token=scanner.Scan())!=tk_text)
                            Error();
                        variables.Add(tmp, token.str_value);
                        if ((token=scanner.Scan())!=tk_semicol)
                            Error();
                        token=scanner.Scan();
                        nonterm=GLOBAL;
                        break;
                    case tk_parop: //creating new table
                        table=tables.Add(tmp);
                        token=scanner.Scan();
                        nonterm=ITEMS;
                        break;
                    default: Error();
                }
                break;
            case ITEMS:
                switch (token) {
                    case tk_parcl:
                        nonterm=GLOBAL;
                        token=scanner.Scan();
                        break;
                    case tk_number:
                        mask=token.int_value;
                        if ((token=scanner.Scan())==tk_comma)
                        if ((token=scanner.Scan())==tk_number)
                        {
                            tag=token.int_value;
                            if ((token=scanner.Scan())==tk_comma)
                            if ((token=scanner.Scan())==tk_text)
                            {
                                tmp=token.str_value;
                                if ((token=scanner.Scan())==tk_comma)
                                {
                                    token=scanner.Scan();
                                    nonterm=LENGTH;
                                    break;
                                }
                            }
                        }
                        Error();
                        break;
                    default: Error();
                }
                break;
            case LENGTH:
                switch (token) {
                    case (tk_number):
                    case (tk_ident):
                        tmp2=token.str_value;
                        nonterm=NEXTLENGTH;
                        token=scanner.Scan();
                        break;
                    default: Error();
                }
                break;
            case NEXTLENGTH:
                switch (token) {
                    case tk_plus:
                        tmp2+='+';
                        if ((token=scanner.Scan())==tk_ident)
                        {
                            tmp2+=token.str_value;
                            token=scanner.Scan();
                        }
                        else
                            Error();
                        break;
                    case tk_semicol:
                        table->Add(mask, tag, tmp, tmp2);
                        nonterm=ITEMS;
                        token=scanner.Scan();
                        break;
                    default: Error();
                }
                break;
        }
    }
}

// Tables. Map of Table indexed by its name. (Builder)
Tables::~Tables()
{
    MTables::iterator i;
    for (i=_tables.begin();i!=_tables.end();i++)
    {
        delete i->second;
        i->second=NULL;
    }
}

// Add(name) creates new table (Table) and returns it.
Table *Tables::Add(string s)
{
    if (_tables.find(s)==_tables.end())
        return dynamic_cast<Table*>(_tables[s]=new Table(this, variables));
    else
        throw InstructionException("table already exists", s);
}

// Add(name, table) - useful for builtin tables
AbstractTable *&Tables::Add(string name, AbstractTable *table)
{
    if (_tables.find(name)==_tables.end())
        return _tables[name]=table;
    else
        throw InstructionException("table already exists", name);
}

// Returns appropriate table. Throws exception when table does not exist.
AbstractTable *&Tables::operator [](string index)
{
    if (_tables.find(index)!=_tables.end())
        return _tables[index];
    else
        throw InstructionException("not known table", index);
}

void Tables::Reset()
{
    MTables::iterator i;
    for (i=_tables.begin();i!=_tables.end();i++)
        i->second->Reset();
}

// Clears all tables from memory
void Tables::Clear()
{
    _tables.clear();
}

// AbstractTable - parent for Table and BuiltinTable
string AbstractTable::Decode(Section &data, Address addr, unsigned &size)
{
    size=0;
    return "";
}

// Table. Table with 256 items (TableItem). Item is indexed by a byte on data section.
Table::Table(Tables *t, Variables *v)
{
    tables=t;
    variables=v;
    for (int i=0;i<256;i++)
        _items[i]=NULL;
}

Table::~Table()
{
    for (int i=0;i<256;i++)
        if (_items[i]!=NULL)
        {
            for (int j=i+1;j<256;j++)
                if (_items[j]==_items[i])
                    _items[j]=NULL;
            delete _items[i];
            _items[i]=NULL;
        }
}

TableItem *Table::Add(unsigned mask, unsigned tag, string value, string length)
{
    TableItem *tableitem=new TableItem(*tables, *variables, value, length);
    bool filled=false;
    for (unsigned i=0;i<256;i++)
        if ((i&mask)==tag)
        {
            filled=true;
            _items[i]=tableitem;
        }
    if (!filled)
    {
        delete tableitem;
        return NULL;
    }
    else
        return tableitem;
}

// Decode actual byte. input: data and address, output: decoded string and size of decoded data
string Table::Decode(Section &data, Address addr, unsigned &size)
{
    TableItem *item=_items[data[addr]];
    if (item==NULL)
        throw Exception(string("item not defined for ")+uint2hex(data[addr])+" at address: "+uint2hex(addr)+"\n");
    else
        return _items[data[addr]]->Decode(data, addr, size);
}

// Resets all tables to their default values (nothing to do)
void Table::Reset()
{
}

// TableItem. An item of Table consisting of value and length array of decoded bytes
TableItem::TableItem(Tables &t, Variables &v, string value, string lengthstr) : tables(t), variables(v)
{
    TableItem::value=value;
    const char *c=lengthstr.c_str();
    bool digit=false;
    lengths.first_value=0;
    for (int i=0;i<26;i++)
        lengths.valid[i]=false;
    while (*c)
    {
        if (!digit)
            if (isdigit(*c))
            {
                digit=true;
                lengths.first_value=*c-'0';
            }
            else
            if (isalpha(*c))
                lengths.valid[lower(*c)-'a']=true;
            else;
        else
            if (isdigit(*c))
                lengths.first_value = lengths.first_value*10 + *c-'0';
            else
                digit=false;
        c++;
    }
}

void TableItem::Error(const char *c)
{
    throw InstructionException("unexpected character", c);
}

// Returns sum of values of all valid lengths
int TableItem::CountLength(unsigned lens[])
{
    unsigned result=lengths.first_value;
    for (int i=0;i<26;i++)
        if (lengths.valid[i])
            result+=lens[i];
    return result;
}

// Returns sum of values of lengths len (e.g. "1+b" returns 1+lens[2]; "" returns 0; "12CA" returns 12+lens[3]+lens[1])
int TableItem::CountLength(unsigned lens[], string len)
{
    unsigned result=0;
    unsigned i;
    for (i=0;i<len.length();i++)
        if (isdigit(len[i]))
            result=result*10+len[i]-'0';
        else
            break;
    for (;i<len.length();i++)
        if (isalpha(len[i]))
            result+=lens[lower(len[i])-'a'];
    return result;
}

// 1. N -> <t>
// 2. N -> <null>
// 3. N -> $ P
// 4. N -> <other> N            -- print character
// 5. P -> { V
// 6. P -> ( T
// 7. V -> N('}', '=') V1
// 8. V1 -> } N                 -- print variable value or set new
// 9. V1 -> = N('}') } N        -- set new value
// 10. T -> N(',') , N(')') ) N  -- table
// Decodes the text with others tables and variables. Fills the length array.
// lindex is actual index to length array. t is terminated character. Returns
// substituted string.
string TableItem::Norm(Section &data, Address addr, unsigned lens[], unsigned &lindex, const char *&c, char t)
{
    enum NonTerm { N, P, V, V1, T } nonterm=N;
    string result="";
    string tmp, tmp2;
    bool set;
    while (1)
        switch (nonterm) {
            case N:
                if (*c==0 || *c==t) //1. and 2.
                    return result;
                if (*c=='$') //3.
                    nonterm=P;
                else //4.
                {
                    result+=*c;
                    nonterm=N;
                }
                c++;
                break;
            case P:
                switch (*c) {
                    case '{': nonterm=V; break;
                    case '(': nonterm=T; break;
                    default: Error();
                }
                c++;
                break;
            case V:
                tmp=Norm(data, addr, lens, lindex, c, '}');
                nonterm=V1;
                break;
            case V1:
                switch (*c) {
                    case '}': break;
                    default: Error();
                }
                c++;
                nonterm=N;
                set=false;
                for (unsigned i=0;i<tmp.length();i++)
                    if (tmp[i]=='=')
                    {
                        variables[tmp.substr(0, i)].value=tmp.substr(i+1, tmp.length());
                        set=true;
                        break;
                    }
                if (!set)
                    result+=variables[tmp];
                break;
            case T:
                tmp=Norm(data, addr, lens, lindex, c, ',');
                if (*c!=',')
                    Error();
                c++;
                tmp2=Norm(data, addr, lens, lindex, c, ')');
                if (*c!=')')
                    Error();
                unsigned pos=CountLength(lens, tmp2);
                unsigned newsize;
                result+=tables[tmp]->Decode(data, addr+pos, newsize);
                lens[lindex++]=newsize;
                c++;
                nonterm=N;
                break;
        }
}

// Decode actual byte. input: data and address, output: decoded string and size of decoded data
string TableItem::Decode(Section &data, Address addr, unsigned &size)
{
    const char *c=value.c_str();
    unsigned lens[26]={0}; //lengths for subst. tables: a, b, c,..., z
    unsigned lindex=0; //actual index to lens
    string subst=Norm(data, addr, lens, lindex, c);
    size=CountLength(lens);
    return subst;
}

// Variables. Map of Variable indexed by its name. (Builder)

// Creates new variable
Variable &Variables::Add(string name, string defaultvalue)
{
    if (_variables.find(name)==_variables.end())
    {
        Variable v(defaultvalue);
        return _variables[name]=v;
    }
    else
        throw InstructionException("variable already exists", name);
}

// Returns appropriate variable, throws an exception if variable does not exist.
Variable &Variables::operator [](string index)
{
    if (_variables.find(index)!=_variables.end())
        return _variables[index];
    else
        throw InstructionException("not known variable", index);
}

// Resets all variables to their default value
void Variables::Reset()
{
    MVariables::iterator i;
    for (i=_variables.begin();i!=_variables.end();i++)
        i->second.Reset();
}

// Clears all variables from memory
void Variables::Clear()
{
    _variables.clear();
}

namespace BuiltinTables {

// load Little Endian Unsigned number
unsigned LEunumber(Section &data, Address addr, unsigned size)
{
    unsigned result=0; 
    for (unsigned i=0;i<size;i++)
        result |= data[addr+i]<<(i<<3);
    return result;
}

// load Little Endian Signed number
int LEsnumber(Section &data, Address addr, unsigned size)
{
    unsigned u=LEunumber(data, addr, size);
    int i=u;
    //sign extension
    unsigned sign=((u>>((size<<3)-1))&1);
    for (unsigned j=size<<3;j<sizeof(int)<<3;j++)
        i|=sign<<j;
    return i;
}

// load Big Endian Unsigned number
unsigned BEunumber(Section &data, Address addr, unsigned size)
{
    unsigned result=0; 
    for (unsigned i=0;i<size;i++)
        result = result<<8 | data[addr+i];
    return result;
}

// load Big Endian Signed number
int BEsnumber(Section &data, Address addr, unsigned size)
{
    unsigned u=BEunumber(data, addr, size);
    int i=u;
    //sign extension
    unsigned sign=((u>>((size<<3)-1))&1);
    for (unsigned j=size<<3;j<sizeof(int)<<3;j++)
        i|=sign<<j;
    return i;
}

string imm2str(unsigned value, bool onlydecimal=false)
{
    char *hex[16]={"0","1","2","3","4","5","6","7","8","9","a","b","c","d","e","f"};
    if (value==0) return "0";
    string result;
    if (!onlydecimal)
    { //hexadecimal value
        if (value<10) return string(hex[value]);
        while (value)
        {
            result = string(hex[value&0xf]) + result;
            value>>=4;
        }
        result = string("0x")+result;
    }
    else //onlydecimal value
    {
        unsigned i=1;
        unsigned value10=value/10;
        while (i<=value10) i*=10;
        while (value>0)
        {
            result += string(hex[value/i]);
            value -= (value/i)*i;
            i/=10;
        }
    }
    return result;
}

string Ib::Decode(Section &data, Address addr, unsigned &size)
{
    return imm2str(LEunumber(data, addr, size=1));
}

string Iw::Decode(Section &data, Address addr, unsigned &size)
{
    return imm2str(LEunumber(data, addr, size=2));
}

string Id::Decode(Section &data, Address addr, unsigned &size)
{
    unsigned number=LEunumber(data, addr, size=4);
    if (decinfo.binfile!=NULL && decinfo.binfile->ScanAddress(number))
    {
        symbols->checkaddress(number);
        if (decinfo.onlyname)
            return (*symbols)[number];
        else
            return (*symbols)[number]+"("+uint2hex(number)+")";
    }
    return imm2str(number);
}

string Ibw::Decode(Section &data, Address addr, unsigned &size)
{
    return imm2str((unsigned)(LEsnumber(data, addr, size=1)) & 0xffff, true);
}

string Ibd::Decode(Section &data, Address addr, unsigned &size)
{
    return imm2str((unsigned)(LEsnumber(data, addr, size=1)), true);
}

string SIb::Decode(Section &data, Address addr, unsigned &size)
{
    int i=LEsnumber(data, addr, size=1);
    return (i<0) ? string("-")+imm2str(-i) : imm2str(i);
}

string SIw::Decode(Section &data, Address addr, unsigned &size)
{
    int i=LEsnumber(data, addr, size=2);
    return (i<0) ? string("-")+imm2str(-i) : imm2str(i);
}

string SId::Decode(Section &data, Address addr, unsigned &size)
{
    int i=LEsnumber(data, addr, size=4);
    unsigned number=static_cast<unsigned>(i);
    if (decinfo.binfile!=NULL && decinfo.binfile->ScanAddress(number))
    {
        symbols->checkaddress(number);
        if (decinfo.onlyname)
            return (*symbols)[number];
        else
            return (*symbols)[number]+"("+uint2hex(number)+")";
    }
    return (i<0) ? string("-")+imm2str(-i) : imm2str(i);
}

string SIbw::Decode(Section &data, Address addr, unsigned &size)
{
    int i=static_cast<int>((unsigned)(LEsnumber(data, addr, size=1)) & 0xffff);
    return (i<0) ? string("-")+imm2str(-i, true) : imm2str(i, true);
}

string SIbd::Decode(Section &data, Address addr, unsigned &size)
{
    int i=LEsnumber(data, addr, size=1);
    return (i<0) ? string("-")+imm2str(-i, true) : imm2str(i, true);
}

string Jb::Decode(Section &data, Address addr, unsigned &size)
{
    unsigned a=addr+LEsnumber(data, addr, size=1)+1;
    symbols->checkaddress(a);
    if (decinfo.onlyname)
        return (*symbols)[a];
    else
        return (*symbols)[a]+"("+uint2hex(a)+")";
}

string Jw::Decode(Section &data, Address addr, unsigned &size)
{
    unsigned a=addr+LEsnumber(data, addr, size=2)+2;
    symbols->checkaddress(a);
    if (decinfo.onlyname)
        return (*symbols)[a];
    else
        return (*symbols)[a]+"("+uint2hex(a)+")";
}

string Jd::Decode(Section &data, Address addr, unsigned &size)
{
    unsigned a=addr+LEsnumber(data, addr, size=4)+4;
    symbols->checkaddress(a);
    if (decinfo.onlyname)
        return (*symbols)[a];
    else
        return (*symbols)[a]+"("+uint2hex(a)+")";
}

string Apw::Decode(Section &data, Address addr, unsigned &size)
{
    unsigned ofs=LEsnumber(data, addr, size=2);
    unsigned seg=LEsnumber(data, addr+2, size=2);
    return uint2hex(seg, "")+":"+uint2hex(ofs, "");
}

string Apd::Decode(Section &data, Address addr, unsigned &size)
{
    unsigned ofs=LEsnumber(data, addr, size=4);
    unsigned seg=LEsnumber(data, addr+4, size=2);
    return uint2hex(seg, "")+":"+uint2hex(ofs, "");
}

string Aw::Decode(Section &data, Address addr, unsigned &size)
{
    unsigned a=LEunumber(data, addr, size=2);
    symbols->checkaddress(a);
    if (decinfo.onlyname)
        return (*symbols)[a];
    else
        return (*symbols)[a]+"("+uint2hex(a)+")";
}

string Ad::Decode(Section &data, Address addr, unsigned &size)
{
    unsigned a=LEunumber(data, addr, size=4);
    symbols->checkaddress(a);
    if (decinfo.onlyname)
        return (*symbols)[a];
    else
        return (*symbols)[a]+"("+uint2hex(a)+")";
}

string BIb::Decode(Section &data, Address addr, unsigned &size)
{
    return imm2str(BEunumber(data, addr, size=1));
}

string BIw::Decode(Section &data, Address addr, unsigned &size)
{
    return imm2str(BEunumber(data, addr, size=2));
}

string BId::Decode(Section &data, Address addr, unsigned &size)
{
    unsigned number=BEunumber(data, addr, size=4);
    if (decinfo.binfile!=NULL && decinfo.binfile->ScanAddress(number))
    {
        symbols->checkaddress(number);
        if (decinfo.onlyname)
            return (*symbols)[number];
        else
            return (*symbols)[number]+"("+uint2hex(number)+")";
    }
    return imm2str(number);
}

string BIbw::Decode(Section &data, Address addr, unsigned &size)
{
    return imm2str((unsigned)(BEsnumber(data, addr, size=1)) & 0xffff);
}

string BIbd::Decode(Section &data, Address addr, unsigned &size)
{
    return imm2str((unsigned)(BEsnumber(data, addr, size=1)));
}

string SBIb::Decode(Section &data, Address addr, unsigned &size)
{
    int i=BEsnumber(data, addr, size=1);
    return (i<0) ? string("-")+imm2str(-i) : imm2str(i);
}

string SBIw::Decode(Section &data, Address addr, unsigned &size)
{
    int i=BEsnumber(data, addr, size=2);
    return (i<0) ? string("-")+imm2str(-i) : imm2str(i);
}

string SBId::Decode(Section &data, Address addr, unsigned &size)
{
    int i=LEsnumber(data, addr, size=4);
    unsigned number=static_cast<unsigned>(i);
    if (decinfo.binfile!=NULL && decinfo.binfile->ScanAddress(number))
    {
        symbols->checkaddress(number);
        if (decinfo.onlyname)
            return (*symbols)[number];
        else
            return (*symbols)[number]+"("+uint2hex(number)+")";
    }
    return (i<0) ? string("-")+imm2str(-i) : imm2str(i);
}

string SBIbw::Decode(Section &data, Address addr, unsigned &size)
{
    int i=static_cast<int>((unsigned)(BEsnumber(data, addr, size=1)) & 0xffff);
    return (i<0) ? string("-")+imm2str(-i) : imm2str(i);
}

string SBIbd::Decode(Section &data, Address addr, unsigned &size)
{
    int i=BEsnumber(data, addr, size=1);
    return (i<0) ? string("-")+imm2str(-i) : imm2str(i);
}

string BJb::Decode(Section &data, Address addr, unsigned &size)
{
    unsigned a=addr+BEsnumber(data, addr, size=1)+1;
    symbols->checkaddress(a);
    if (decinfo.onlyname)
        return (*symbols)[a];
    else
        return (*symbols)[a]+"("+uint2hex(a)+")";
}

string BJw::Decode(Section &data, Address addr, unsigned &size)
{
    unsigned a=addr+BEsnumber(data, addr, size=2)+2;
    symbols->checkaddress(a);
    if (decinfo.onlyname)
        return (*symbols)[a];
    else
        return (*symbols)[a]+"("+uint2hex(a)+")";
}

string BJd::Decode(Section &data, Address addr, unsigned &size)
{
    unsigned a=addr+BEsnumber(data, addr, size=4)+4;
    symbols->checkaddress(a);
    if (decinfo.onlyname)
        return (*symbols)[a];
    else
        return (*symbols)[a]+"("+uint2hex(a)+")";
}

string BApw::Decode(Section &data, Address addr, unsigned &size)
{
    unsigned ofs=BEsnumber(data, addr, size=2);
    unsigned seg=BEsnumber(data, addr+2, size=2);
    return uint2hex(seg, "")+":"+uint2hex(ofs, "");
}

string BApd::Decode(Section &data, Address addr, unsigned &size)
{
    unsigned ofs=BEsnumber(data, addr, size=4);
    unsigned seg=BEsnumber(data, addr+4, size=2);
    return uint2hex(seg, "")+":"+uint2hex(ofs, "");
}

string BAw::Decode(Section &data, Address addr, unsigned &size)
{
    unsigned a=BEunumber(data, addr, size=2);
    symbols->checkaddress(a);
    if (decinfo.onlyname)
        return (*symbols)[a];
    else
        return (*symbols)[a]+"("+uint2hex(a)+")";
}

string BAd::Decode(Section &data, Address addr, unsigned &size)
{
    unsigned a=BEunumber(data, addr, size=4);
    symbols->checkaddress(a);
    if (decinfo.onlyname)
        return (*symbols)[a];
    else
        return (*symbols)[a]+"("+uint2hex(a)+")";
}

} //namespace BuiltinTables