godzil/dcc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Extracted commonalities between SYM and STKSYM into SymbolCommon and

Browse Source 
between SYMTAB and STKFRAME into SymbolTableCommon<STKSYM>
This commit is contained in:
Artur K 2012-03-13 01:22:13 +01:00
parent d3e62a99aa
commit 902a5ec3d8
15 changed files with 311 additions and 290 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

29
include/StackFrame.h
View File

@ -3,39 +3,22 @@
#include <cstring> #include <cstring>
#include "types.h" #include "types.h"
#include "Enums.h" #include "Enums.h"
struct COND_EXPR; #include "symtab.h"
/* STACK FRAME */
struct STKSYM
{
COND_EXPR *actual; /* Expression tree of actual parameter */
COND_EXPR *regs; /* For register arguments only */
int16_t off; /* Immediate off from BP (+:args, -:params) */
uint8_t regOff; /* Offset is a register (e.g. SI, DI) */
int size; /* Size */
hlType type; /* Probable type */
eDuVal duVal; /* DEF, USE, VAL */
boolT hasMacro; /* This type needs a macro */
char macro[10]; /* Macro name */
char name[10]; /* Name for this symbol/argument */
bool invalid; /* Boolean: invalid entry in formal arg list*/
STKSYM()
{
memset(this,0,sizeof(STKSYM));
}
};
struct STKFRAME struct STKFRAME : public SymbolTableCommon<STKSYM>
{ {
std::vector<STKSYM> sym; //std::vector<STKSYM> sym;
//STKSYM * sym; /* Symbols */ //STKSYM * sym; /* Symbols */
int16_t m_minOff; /* Initial offset in stack frame*/ int16_t m_minOff; /* Initial offset in stack frame*/
int16_t maxOff; /* Maximum offset in stack frame*/ int16_t maxOff; /* Maximum offset in stack frame*/
int cb; /* Number of bytes in arguments */ int cb; /* Number of bytes in arguments */
int numArgs; /* No. of arguments in the table*/ int numArgs; /* No. of arguments in the table*/
void adjustForArgType(int numArg_, hlType actType_); void adjustForArgType(int numArg_, hlType actType_);
STKFRAME() : sym(0),m_minOff(0),maxOff(0),cb(0),numArgs(0) STKFRAME() : m_minOff(0),maxOff(0),cb(0),numArgs(0)
{ {
} }
size_t getLocVar(int off); size_t getLocVar(int off);
public:
void updateFrameOff(int16_t off, int size, uint16_t duFlag);
}; };

24
include/dcc.h
View File

@ -21,27 +21,6 @@
#include "Procedure.h" #include "Procedure.h"
#include "BasicBlock.h" #include "BasicBlock.h"
typedef llvm::iplist<Function> FunctionListType;
typedef FunctionListType lFunction;
typedef lFunction::iterator ilFunction;
/* SYMBOL TABLE */
struct SYM
{
SYM() : label(0),size(0),flg(0),type(TYPE_UNKNOWN)
{
}
char name[10]; /* New name for this variable */
uint32_t label; /* physical address (20 bit) */
int size; /* maximum size */
uint32_t flg; /* SEG_IMMED, IMPURE, WORD_OFF */
hlType type; /* probable type */
eDuVal duVal; /* DEF, USE, VAL */
};
typedef std::vector<SYM> SYMTAB;
/* CALL GRAPH NODE */ /* CALL GRAPH NODE */
struct CALL_GRAPH struct CALL_GRAPH
{ {
@ -134,7 +113,6 @@ extern STATS stats; /* Icode statistics */
/**** Global function prototypes ****/ /**** Global function prototypes ****/
void FrontEnd(char *filename, CALL_GRAPH * *); /* frontend.c */ void FrontEnd(char *filename, CALL_GRAPH * *); /* frontend.c */
void *allocMem(int cb); /* frontend.c */
void udm(void); /* udm.c */ void udm(void); /* udm.c */
void freeCFG(BB * cfg); /* graph.c */ void freeCFG(BB * cfg); /* graph.c */
@ -167,7 +145,7 @@ hlType expType (const COND_EXPR *, Function *);
/* Exported functions from hlicode.c */ /* Exported functions from hlicode.c */
std::string writeCall (Function *, STKFRAME *, Function *, int *); std::string writeCall (Function *, STKFRAME &, Function *, int *);
char *writeJcond (const HLTYPE &, Function *, int *); char *writeJcond (const HLTYPE &, Function *, int *);
char *writeJcondInv (HLTYPE, Function *, int *); char *writeJcondInv (HLTYPE, Function *, int *);

8
include/locident.h
View File

@ -65,7 +65,7 @@ struct ID
frameType loc; /* Frame location */ frameType loc; /* Frame location */
bool hasMacro; /* Identifier requires a macro */ bool hasMacro; /* Identifier requires a macro */
char macro[10]; /* Macro for this identifier */ char macro[10]; /* Macro for this identifier */
char name[20]; /* Identifier's name */ std::string name; /* Identifier's name */
union { /* Different types of identifiers */ union { /* Different types of identifiers */
eReg regi; /* For TYPE_BYTE(uint16_t)_(UN)SIGN registers */ eReg regi; /* For TYPE_BYTE(uint16_t)_(UN)SIGN registers */
struct { /* For TYPE_BYTE(uint16_t)_(UN)SIGN on the stack */ struct { /* For TYPE_BYTE(uint16_t)_(UN)SIGN on the stack */
@ -95,9 +95,9 @@ struct ID
} }
void setLocalName(int i) void setLocalName(int i)
{ {
// char buf[32]; char buf[32];
//sprintf (buf, "loc%ld", i); sprintf (buf, "loc%ld", i);
//name=buf; name=buf;
} }
}; };

70
include/symtab.h
View File

@ -12,6 +12,76 @@ struct TypeContainer;
/* * * * * * * * * * * * * * * * * */ /* * * * * * * * * * * * * * * * * */
/* Symbol table structs and protos */ /* Symbol table structs and protos */
/* * * * * * * * * * * * * * * * * */ /* * * * * * * * * * * * * * * * * */
struct SymbolCommon
{
std::string name; /* New name for this variable/symbol/argument */
int size; /* Size/maximum size */
hlType type; /* probable type */
eDuVal duVal; /* DEF, USE, VAL */
SymbolCommon() : size(0),type(TYPE_UNKNOWN)
{}
};
struct SYM : public SymbolCommon
{
SYM() : label(0),flg(0)
{
}
int32_t label; /* physical address (20 bit) */
uint32_t flg; /* SEG_IMMED, IMPURE, WORD_OFF */
};
/* STACK FRAME */
struct STKSYM : public SymbolCommon
{
COND_EXPR *actual; /* Expression tree of actual parameter */
COND_EXPR *regs; /* For register arguments only */
int16_t label; /* Immediate off from BP (+:args, -:params) */
uint8_t regOff; /* Offset is a register (e.g. SI, DI) */
bool hasMacro; /* This type needs a macro */
std::string macro; /* Macro name */
bool invalid; /* Boolean: invalid entry in formal arg list*/
STKSYM()
{
actual=regs=0;
label=0;
regOff=0;
invalid=hasMacro = false;
}
void setArgName(int i)
{
char buf[32];
sprintf (buf, "arg%ld", i);
name = buf;
}
};
template<class T>
class SymbolTableCommon : public std::vector<T>
{
public:
typedef typename std::vector<T>::iterator iterator;
typedef typename std::vector<T>::const_iterator const_iterator;
iterator findByLabel(int lab)
{
auto iter = std::find_if(this->begin(),this->end(),
[lab](T &s)->bool {return s.label==lab;});
return iter;
}
const_iterator findByLabel(int lab) const
{
auto iter = std::find_if(this->begin(),this->end(),
[lab](const T &s)->bool {return s.label==lab;});
return iter;
}
};
/* SYMBOL TABLE */
class SYMTAB : public SymbolTableCommon<SYM>
{
public:
void updateSymType(uint32_t symbol, const TypeContainer &tc);
SYM *updateGlobSym(uint32_t operand, int size, uint16_t duFlag, bool &inserted_new);
};
struct Function; struct Function;
struct SYMTABLE struct SYMTABLE
{ {

27
src/ast.cpp
View File

@ -183,7 +183,7 @@ COND_EXPR *COND_EXPR::idLoc(int off, LOCAL_ID *localId)
if (i == localId->csym()) if (i == localId->csym())
printf ("Error, cannot find local var\n"); printf ("Error, cannot find local var\n");
newExp->expr.ident.idNode.localIdx = i; newExp->expr.ident.idNode.localIdx = i;
sprintf (localId->id_arr[i].name, "loc%ld", i); localId->id_arr[i].setLocalName(i);
return (newExp); return (newExp);
} }
@ -192,15 +192,13 @@ COND_EXPR *COND_EXPR::idLoc(int off, LOCAL_ID *localId)
COND_EXPR *COND_EXPR::idParam(int off, const STKFRAME * argSymtab) COND_EXPR *COND_EXPR::idParam(int off, const STKFRAME * argSymtab)
{ {
COND_EXPR *newExp; COND_EXPR *newExp;
size_t i;
newExp = new COND_EXPR(IDENTIFIER); newExp = new COND_EXPR(IDENTIFIER);
newExp->expr.ident.idType = PARAM; newExp->expr.ident.idType = PARAM;
for (i = 0; i < argSymtab->sym.size(); i++) auto iter=argSymtab->findByLabel(off);
if (argSymtab->sym[i].off == off) if (iter == argSymtab->end())
break; printf ("Error, cannot find argument var\n");
if (i == argSymtab->sym.size()) printf ("Error, cannot find argument var\n"); newExp->expr.ident.idNode.localIdx = distance(argSymtab->begin(),iter);
newExp->expr.ident.idNode.localIdx = i;
return (newExp); return (newExp);
} }
@ -489,7 +487,7 @@ int hlTypeSize (const COND_EXPR *expr, Function * pproc)
case LOCAL_VAR: case LOCAL_VAR:
return (hlSize[pproc->localId.id_arr[expr->expr.ident.idNode.localIdx].type]); return (hlSize[pproc->localId.id_arr[expr->expr.ident.idNode.localIdx].type]);
case PARAM: case PARAM:
return (hlSize[pproc->args.sym[expr->expr.ident.idNode.paramIdx].type]); return (hlSize[pproc->args[expr->expr.ident.idNode.paramIdx].type]);
case GLOB_VAR_IDX: case GLOB_VAR_IDX:
return (hlSize[pproc->localId.id_arr[expr->expr.ident.idNode.idxGlbIdx].type]); return (hlSize[pproc->localId.id_arr[expr->expr.ident.idNode.idxGlbIdx].type]);
case CONSTANT: case CONSTANT:
@ -552,7 +550,7 @@ hlType expType (const COND_EXPR *expr, Function * pproc)
case LOCAL_VAR: case LOCAL_VAR:
return (pproc->localId.id_arr[expr->expr.ident.idNode.localIdx].type); return (pproc->localId.id_arr[expr->expr.ident.idNode.localIdx].type);
case PARAM: case PARAM:
return (pproc->args.sym[expr->expr.ident.idNode.paramIdx].type); return (pproc->args[expr->expr.ident.idNode.paramIdx].type);
case GLOB_VAR_IDX: case GLOB_VAR_IDX:
return (pproc->localId.id_arr[expr->expr.ident.idNode.idxGlbIdx].type); return (pproc->localId.id_arr[expr->expr.ident.idNode.idxGlbIdx].type);
case CONSTANT: case CONSTANT:
@ -708,7 +706,7 @@ string walkCondExpr (const COND_EXPR* expr, Function * pProc, int* numLoc)
id = &pProc->localId.id_arr[expr->expr.ident.idNode.regiIdx]; id = &pProc->localId.id_arr[expr->expr.ident.idNode.regiIdx];
if (id->name[0] == '\0') /* no name */ if (id->name[0] == '\0') /* no name */
{ {
sprintf (id->name, "loc%ld", ++(*numLoc)); id->setLocalName(++(*numLoc));
codeOut <<TypeContainer::typeName(id->type)<< " "<<id->name<<"; "; codeOut <<TypeContainer::typeName(id->type)<< " "<<id->name<<"; ";
codeOut <<"/* "<<Machine_X86::regName(id->id.regi)<<" */\n"; codeOut <<"/* "<<Machine_X86::regName(id->id.regi)<<" */\n";
} }
@ -723,7 +721,7 @@ string walkCondExpr (const COND_EXPR* expr, Function * pProc, int* numLoc)
break; break;
case PARAM: case PARAM:
psym = &pProc->args.sym[expr->expr.ident.idNode.paramIdx]; psym = &pProc->args[expr->expr.ident.idNode.paramIdx];
if (psym->hasMacro) if (psym->hasMacro)
o << psym->macro<<"("<<psym->name<< ")"; o << psym->macro<<"("<<psym->name<< ")";
else else
@ -752,12 +750,12 @@ string walkCondExpr (const COND_EXPR* expr, Function * pProc, int* numLoc)
o << id->name; o << id->name;
else if (id->loc == REG_FRAME) else if (id->loc == REG_FRAME)
{ {
sprintf (id->name, "loc%ld", ++(*numLoc)); id->setLocalName(++(*numLoc));
codeOut <<TypeContainer::typeName(id->type)<< " "<<id->name<<"; "; codeOut <<TypeContainer::typeName(id->type)<< " "<<id->name<<"; ";
codeOut <<"/* "<<Machine_X86::regName(id->id.longId.h) << ":" << codeOut <<"/* "<<Machine_X86::regName(id->id.longId.h) << ":" <<
Machine_X86::regName(id->id.longId.l) << " */\n"; Machine_X86::regName(id->id.longId.l) << " */\n";
o << id->name; o << id->name;
pProc->localId.propLongId (id->id.longId.l,id->id.longId.h, id->name); pProc->localId.propLongId (id->id.longId.l,id->id.longId.h, id->name.c_str());
} }
else /* GLB_FRAME */ else /* GLB_FRAME */
{ {
@ -769,7 +767,7 @@ string walkCondExpr (const COND_EXPR* expr, Function * pProc, int* numLoc)
break; break;
case FUNCTION: case FUNCTION:
o << writeCall (expr->expr.ident.idNode.call.proc,expr->expr.ident.idNode.call.args, pProc, numLoc); o << writeCall (expr->expr.ident.idNode.call.proc,*expr->expr.ident.idNode.call.args, pProc, numLoc);
break; break;
case OTHER: case OTHER:
@ -786,7 +784,6 @@ string walkCondExpr (const COND_EXPR* expr, Function * pProc, int* numLoc)
break; break;
} }
cCode.appendDecl(codeOut.str()); cCode.appendDecl(codeOut.str());
return outStr.str(); return outStr.str();
} }

92
src/backend.cpp
View File

@ -94,35 +94,39 @@ char *cChar (uint8_t c)
* Note: to get to the value of the variable: * Note: to get to the value of the variable:
* com file: prog.Image[operand] * com file: prog.Image[operand]
* exe file: prog.Image[operand+0x100] */ * exe file: prog.Image[operand+0x100] */
static void printGlobVar (std::ostream &ostr,SYM * psym);
static void printGlobVar (SYM * psym) static void printGlobVar (SYM * psym)
{
std::ostringstream ostr;
printGlobVar(ostr,psym);
cCode.appendDecl(ostr.str());
}
static void printGlobVar (std::ostream &ostr,SYM * psym)
{ {
int j; int j;
uint32_t relocOp = prog.fCOM ? psym->label : psym->label + 0x100; uint32_t relocOp = prog.fCOM ? psym->label : psym->label + 0x100;
switch (psym->size) switch (psym->size)
{ {
case 1: cCode.appendDecl( "uint8_t\t%s = %ld;\n", case 1:
psym->name, prog.Image[relocOp]); ostr << "uint8_t\t"<<psym->name<<" = "<<prog.Image[relocOp]<<";\n";
break; break;
case 2: cCode.appendDecl( "uint16_t\t%s = %ld;\n", case 2:
psym->name, LH(prog.Image+relocOp)); ostr << "uint16_t\t"<<psym->name<<" = "<<LH(prog.Image+relocOp)<<";\n";
break; break;
case 4: if (psym->type == TYPE_PTR) /* pointer */ case 4: if (psym->type == TYPE_PTR) /* pointer */
cCode.appendDecl( "uint16_t\t*%s = %ld;\n", ostr << "uint16_t *\t"<<psym->name<<" = "<<LH(prog.Image+relocOp)<<";\n";
psym->name, LH(prog.Image+relocOp));
else /* char */ else /* char */
cCode.appendDecl( ostr << "char\t"<<psym->name<<"[4] = \""<<
"char\t%s[4] = \"%c%c%c%c\";\n", prog.Image[relocOp]<<prog.Image[relocOp+1]<<
psym->name, prog.Image[relocOp], prog.Image[relocOp+2]<<prog.Image[relocOp+3]<<";\n";
prog.Image[relocOp+1], prog.Image[relocOp+2],
prog.Image[relocOp+3]);
break; break;
default: default:
{ {
ostringstream strContents; ostringstream strContents;
for (j=0; j < psym->size; j++) for (j=0; j < psym->size; j++)
strContents << cChar(prog.Image[relocOp + j]); strContents << cChar(prog.Image[relocOp + j]);
cCode.appendDecl( "char\t*%s = \"%s\";\n", psym->name, strContents.str().c_str()); ostr << "char\t*"<<psym->name<<" = \""<<strContents.str()<<"\";\n";
} }
} }
} }
@ -133,32 +137,31 @@ static void printGlobVar (SYM * psym)
* initialization. */ * initialization. */
static void writeGlobSymTable() static void writeGlobSymTable()
{ {
char type[10]; std::ostringstream ostr;
if (not symtab.empty()) if (symtab.empty())
{ return;
cCode.appendDecl( "/* Global variables */\n"); ostr<<"/* Global variables */\n";
for (SYM &sym : symtab) for (SYM &sym : symtab)
{ {
if (sym.duVal.isUSE_VAL()) /* first used */ if (sym.duVal.isUSE_VAL()) /* first used */
printGlobVar (&sym); printGlobVar (ostr,&sym);
else { /* first defined */ else { /* first defined */
switch (sym.size) { switch (sym.size) {
case 1: strcpy (type, "uint8_t\t"); break; case 1: ostr<<"uint8_t\t"; break;
case 2: strcpy (type, "int\t"); break; case 2: ostr<<"int\t"; break;
case 4: if (sym.type == TYPE_PTR) case 4: if (sym.type == TYPE_PTR)
strcpy (type, "int\t*"); ostr<<"int\t*";
else else
strcpy (type, "char\t*"); ostr<<"char\t*";
break; break;
default: strcpy (type, "char\t*"); default: ostr<<"char\t*";
} }
cCode.appendDecl( "%s%s;\t/* size = %ld */\n", ostr<<sym.name<<";\t/* size = "<<sym.size<<" */\n";
type, sym.name, sym.size);
} }
} }
cCode.appendDecl( "\n"); ostr<< "\n";
} cCode.appendDecl( ostr.str() );
} }
@ -202,7 +205,7 @@ static void emitFwdGotoLabel (ICODE * pt, int indLevel)
void Function::codeGen (std::ostream &fs) void Function::codeGen (std::ostream &fs)
{ {
int numLoc; int numLoc;
ostringstream buf; ostringstream ostr;
//STKFRAME * args; /* Procedure arguments */ //STKFRAME * args; /* Procedure arguments */
//char buf[200], /* Procedure's definition */ //char buf[200], /* Procedure's definition */
// arg[30]; /* One argument */ // arg[30]; /* One argument */
@ -211,22 +214,21 @@ void Function::codeGen (std::ostream &fs)
/* Write procedure/function header */ /* Write procedure/function header */
newBundle (&cCode); newBundle (&cCode);
if (flg & PROC_IS_FUNC) /* Function */ if (flg & PROC_IS_FUNC) /* Function */
cCode.appendDecl( "\n%s %s (", hlTypes[retVal.type],name.c_str()); ostr<< "\n"<<TypeContainer::typeName(retVal.type)<<" "<<name<<" (";
else /* Procedure */ else /* Procedure */
cCode.appendDecl( "\nvoid %s (", name.c_str()); ostr<< "\nvoid "<<name<<" (";
/* Write arguments */ /* Write arguments */
for (size_t i = 0; i < args.sym.size(); i++) for (size_t i = 0; i < args.size(); i++)
{ {
if (args.sym[i].invalid == false) if ( args[i].invalid )
{ continue;
buf<<hlTypes[args.sym[i].type]<<" "<<args.sym[i].name; ostr<<hlTypes[args[i].type]<<" "<<args[i].name;
if (i < (args.sym.size() - 1)) if (i < (args.size() - 1))
buf<<", "; ostr<<", ";
} }
} ostr<<")\n";
buf<<")\n"; cCode.appendDecl( ostr.str() );
cCode.appendDecl( buf.str() );
/* Write comments */ /* Write comments */
writeProcComments(); writeProcComments();
@ -238,27 +240,25 @@ void Function::codeGen (std::ostream &fs)
for (ID &refId : localId ) for (ID &refId : localId )
{ {
/* Output only non-invalidated entries */ /* Output only non-invalidated entries */
if (refId.illegal == false) if ( refId.illegal )
{ continue;
if (refId.loc == REG_FRAME) if (refId.loc == REG_FRAME)
{ {
/* Register variables are assigned to a local variable */ /* Register variables are assigned to a local variable */
if (((flg & SI_REGVAR) && (refId.id.regi == rSI)) || if (((flg & SI_REGVAR) && (refId.id.regi == rSI)) ||
((flg & DI_REGVAR) && (refId.id.regi == rDI))) ((flg & DI_REGVAR) && (refId.id.regi == rDI)))
{ {
sprintf (refId.name, "loc%ld", ++numLoc); refId.setLocalName(++numLoc);
cCode.appendDecl( "int %s;\n", refId.name); cCode.appendDecl( "int %s;\n", refId.name.c_str());
} }
/* Other registers are named when they are first used in /* Other registers are named when they are first used in
* the output C code, and appended to the proc decl. */ * the output C code, and appended to the proc decl. */
} }
else if (refId.loc == STK_FRAME) else if (refId.loc == STK_FRAME)
{ {
/* Name local variables and output appropriate type */ /* Name local variables and output appropriate type */
sprintf (refId.name, "loc%ld", ++numLoc); refId.setLocalName(++numLoc);
cCode.appendDecl( "%s %s;\n",hlTypes[refId.type], refId.name); cCode.appendDecl( "%s %s;\n",hlTypes[refId.type], refId.name.c_str());
}
} }
} }
} }

4
src/chklib.cpp
View File

@ -480,10 +480,10 @@ bool LibCheck(Function & pProc)
the appropriate field */ the appropriate field */
arg = pFunc[i].firstArg; arg = pFunc[i].firstArg;
pProc.args.numArgs = pFunc[i].numArg; pProc.args.numArgs = pFunc[i].numArg;
pProc.args.sym.resize(pFunc[i].numArg); pProc.args.resize(pFunc[i].numArg);
for (j=0; j < pFunc[i].numArg; j++) for (j=0; j < pFunc[i].numArg; j++)
{ {
pProc.args.sym[j].type = pArg[arg++]; pProc.args[j].type = pArg[arg++];
} }
if (pFunc[i].typ != TYPE_UNKNOWN) if (pFunc[i].typ != TYPE_UNKNOWN)
{ {

2
src/comwrite.cpp
View File

@ -204,7 +204,7 @@ void Function::writeProcComments(std::ostream &ostr)
ostr << "/* Uses register arguments:\n"; ostr << "/* Uses register arguments:\n";
for (i = 0; i < this->args.numArgs; i++) for (i = 0; i < this->args.numArgs; i++)
{ {
psym = &this->args.sym[i]; psym = &this->args[i];
ostr << " * "<<psym->name<<" = "; ostr << " * "<<psym->name<<" = ";
if (psym->regs->expr.ident.idType == REGISTER) if (psym->regs->expr.ident.idType == REGISTER)
{ {

16
src/dataflow.cpp
View File

@ -75,12 +75,8 @@ ExpStack g_exp_stk;
* is in the stack frame provided. */ * is in the stack frame provided. */
size_t STKFRAME::getLocVar(int off) size_t STKFRAME::getLocVar(int off)
{ {
size_t i; auto iter=findByLabel(off);
return distance(begin(),iter);
for (i = 0; i < sym.size(); i++)
if (sym[i].off == off)
break;
return (i);
} }
@ -686,11 +682,11 @@ static int processCArg (Function * pp, Function * pProc, ICODE * picode, int num
if (pp->args.numArgs > 0) if (pp->args.numArgs > 0)
if (pp->flg & PROC_VARARG) if (pp->flg & PROC_VARARG)
{ {
if (numArgs < pp->args.sym.size()) if (numArgs < pp->args.size())
adjustActArgType (_exp, pp->args.sym[numArgs].type, pProc); adjustActArgType (_exp, pp->args[numArgs].type, pProc);
} }
else else
adjustActArgType (_exp, pp->args.sym[numArgs].type, pProc); adjustActArgType (_exp, pp->args[numArgs].type, pProc);
} }
else /* user function */ else /* user function */
{ {
@ -774,7 +770,7 @@ void Function::processHliCall(COND_EXPR *_exp, iICODE picode)
if (pp->flg & PROC_ISLIB) /* library function */ if (pp->flg & PROC_ISLIB) /* library function */
{ {
if (pp->args.numArgs > 0) if (pp->args.numArgs > 0)
adjustActArgType(_exp, pp->args.sym[numArgs].type, this); adjustActArgType(_exp, pp->args[numArgs].type, this);
res = picode->newStkArg (_exp, (llIcode)picode->ll()->getOpcode(), this); res = picode->newStkArg (_exp, (llIcode)picode->ll()->getOpcode(), this);
} }
else /* user function */ else /* user function */

20
src/hlicode.cpp
View File

@ -487,20 +487,20 @@ COND_EXPR *COND_EXPR::inverse () const
/* Returns the string that represents the procedure call of tproc (ie. with /* Returns the string that represents the procedure call of tproc (ie. with
* actual parameters) */ * actual parameters) */
std::string writeCall (Function * tproc, STKFRAME * args, Function * pproc, int *numLoc) std::string writeCall (Function * tproc, STKFRAME & args, Function * pproc, int *numLoc)
{ {
int i; /* counter of # arguments */ int i; /* counter of # arguments */
string condExp; string condExp;
ostringstream s; ostringstream ostr;
s<<tproc->name<<" ("; ostr<<tproc->name<<" (";
for (i = 0; i < args->sym.size(); i++) for(const STKSYM &sym : args)
{ {
s << walkCondExpr (args->sym[i].actual, pproc, numLoc); ostr << walkCondExpr (sym.actual, pproc, numLoc);
if (i < (args->sym.size() - 1)) if((&sym)!=&(args.back()))
s << ", "; ostr << ", ";
} }
s << ")"; ostr << ")";
return s.str(); return ostr.str();
} }
@ -547,7 +547,7 @@ string AssignType::writeOut(Function *pProc, int *numLoc)
string CallType::writeOut(Function *pProc, int *numLoc) string CallType::writeOut(Function *pProc, int *numLoc)
{ {
ostringstream ostr; ostringstream ostr;
ostr << writeCall (proc, args, pProc,numLoc); ostr << writeCall (proc, *args, pProc,numLoc);
ostr << ";\n"; ostr << ";\n";
return ostr.str(); return ostr.str();
} }

2
src/idioms.cpp
View File

@ -204,7 +204,7 @@ void Function::findIdioms()
} }
/* Check if number of parameter bytes match their calling convention */ /* Check if number of parameter bytes match their calling convention */
if ((flg & PROC_HLL) && (!args.sym.empty())) if ((flg & PROC_HLL) && (!args.empty()))
{ {
args.m_minOff += (flg & PROC_FAR ? 4 : 2); args.m_minOff += (flg & PROC_FAR ? 4 : 2);
delta = args.maxOff - args.m_minOff; delta = args.maxOff - args.m_minOff;

31
src/locident.cpp
View File

@ -420,28 +420,23 @@ eReg otherLongRegi (eReg regi, int idx, LOCAL_ID *locTbl)
* long register identifier. */ * long register identifier. */
void LOCAL_ID::propLongId (uint8_t regL, uint8_t regH, const char *name) void LOCAL_ID::propLongId (uint8_t regL, uint8_t regH, const char *name)
{ {
int i; for (ID &rid : id_arr)
ID *_id;
for (i = 0; i < id_arr.size(); i++)
{ {
_id = &id_arr[i]; if (rid.typeBitsize()!=16)
if (_id->typeBitsize()==16) continue;
if ( (rid.id.regi != regL) and (rid.id.regi != regH) )
continue;
// otherwise at least 1 is ok
rid.name = name;
rid.hasMacro = true;
rid.illegal = true;
if (rid.id.regi == regL)
{ {
if (_id->id.regi == regL) strcpy (rid.macro, "LO");
{
strcpy (_id->name, name);
strcpy (_id->macro, "LO");
_id->hasMacro = true;
_id->illegal = true;
} }
else if (_id->id.regi == regH) else // if (rid.id.regi == regH)
{ {
strcpy (_id->name, name); strcpy (rid.macro, "HI");
strcpy (_id->macro, "HI");
_id->hasMacro = true;
_id->illegal = true;
}
} }
} }
} }

123
src/parser.cpp
View File

@ -14,7 +14,7 @@ using namespace std;
//static void FollowCtrl (Function * pProc, CALL_GRAPH * pcallGraph, STATE * pstate); //static void FollowCtrl (Function * pProc, CALL_GRAPH * pcallGraph, STATE * pstate);
static boolT process_JMP (ICODE * pIcode, STATE * pstate, CALL_GRAPH * pcallGraph); static boolT process_JMP (ICODE * pIcode, STATE * pstate, CALL_GRAPH * pcallGraph);
static void setBits(int16_t type, uint32_t start, uint32_t len); static void setBits(int16_t type, uint32_t start, uint32_t len);
static SYM * updateGlobSym(uint32_t operand, int size, uint16_t duFlag); //static SYM * updateGlobSym(uint32_t operand, int size, uint16_t duFlag,bool &created);
static void process_MOV(LLInst &ll, STATE * pstate); static void process_MOV(LLInst &ll, STATE * pstate);
static SYM * lookupAddr (LLOperand *pm, STATE * pstate, int size, uint16_t duFlag); static SYM * lookupAddr (LLOperand *pm, STATE * pstate, int size, uint16_t duFlag);
void interactDis(Function * initProc, int ic); void interactDis(Function * initProc, int ic);
@ -718,77 +718,32 @@ static void process_MOV(LLInst & ll, STATE * pstate)
} }
/* Type of the symbol according to the number of bytes it uses */
static hlType cbType[] = {TYPE_UNKNOWN, TYPE_BYTE_UNSIGN, TYPE_WORD_SIGN,
TYPE_UNKNOWN, TYPE_LONG_SIGN};
/* Creates an entry in the global symbol table (symtab) if the variable
* is not there yet. If it is part of the symtab, the size of the variable
* is checked and updated if the old size was less than the new size (ie.
* the maximum size is always saved). */
static SYM * updateGlobSym (uint32_t operand, int size, uint16_t duFlag)
{
int i;
/* Check for symbol in symbol table */
for (i = 0; i < symtab.size(); i++)
if (symtab[i].label == operand)
{
if (symtab[i].size < size)
symtab[i].size = size;
break;
}
/* New symbol, not in symbol table */
if (i == symtab.size())
{
SYM v;
sprintf (v.name, "var%05lX", operand);
v.label = operand;
v.size = size;
v.type = cbType[size];
if (duFlag == eDuVal::USE) /* must already have init value */
{
v.duVal.use =1; // USEVAL;
v.duVal.val =1;
}
else
{
v.duVal.setFlags(duFlag);
}
symtab.push_back(v);
}
return (&symtab[i]);
}
/* Updates the offset entry to the stack frame table (arguments), /* Updates the offset entry to the stack frame table (arguments),
* and returns a pointer to such entry. */ * and returns a pointer to such entry. */
static void updateFrameOff (STKFRAME * ps, int16_t off, int size, uint16_t duFlag) void STKFRAME::updateFrameOff ( int16_t off, int _size, uint16_t duFlag)
{ {
int i; int i;
/* Check for symbol in stack frame table */ /* Check for symbol in stack frame table */
for (i = 0; i < ps->sym.size(); i++) auto iter=findByLabel(off);
if(iter!=end())
{ {
if (ps->sym[i].off == off) if (iter->size < _size)
{ {
if (ps->sym[i].size < size) iter->size = _size;
{
ps->sym[i].size = size;
}
break;
} }
} }
else
/* New symbol, not in table */
if (i == ps->sym.size())
{ {
char nm[16];
STKSYM new_sym; STKSYM new_sym;
sprintf (new_sym.name, "arg%ld", i);
new_sym.off = off; sprintf (nm, "arg%ld", size());
new_sym.size = size; new_sym.name = nm;
new_sym.type = cbType[size]; new_sym.label= off;
new_sym.size = _size;
new_sym.type = TypeContainer::defaultTypeForSize(_size);
if (duFlag == eDuVal::USE) /* must already have init value */ if (duFlag == eDuVal::USE) /* must already have init value */
{ {
new_sym.duVal.use=1; new_sym.duVal.use=1;
@ -798,13 +753,13 @@ static void updateFrameOff (STKFRAME * ps, int16_t off, int size, uint16_t duFla
{ {
new_sym.duVal.setFlags(duFlag); new_sym.duVal.setFlags(duFlag);
} }
ps->sym.push_back(new_sym); push_back(new_sym);
ps->numArgs++; this->numArgs++;
} }
/* Save maximum argument offset */ /* Save maximum argument offset */
if ((uint32_t)ps->maxOff < (off + (uint32_t)size)) if ((uint32_t)this->maxOff < (off + (uint32_t)_size))
ps->maxOff = off + (int16_t)size; this->maxOff = off + (int16_t)_size;
} }
@ -815,29 +770,26 @@ static void updateFrameOff (STKFRAME * ps, int16_t off, int size, uint16_t duFla
static SYM * lookupAddr (LLOperand *pm, STATE *pstate, int size, uint16_t duFlag) static SYM * lookupAddr (LLOperand *pm, STATE *pstate, int size, uint16_t duFlag)
{ {
int i; int i;
SYM * psym; SYM * psym=nullptr;
uint32_t operand; uint32_t operand;
bool created_new=false;
if (pm->regi != rUNDEF)
return nullptr; // register or indexed
if (pm->regi == 0)
{
/* Global var */ /* Global var */
if (pm->segValue) { /* there is a value in the seg field */ if (pm->segValue) /* there is a value in the seg field */
{
operand = opAdr (pm->segValue, pm->off); operand = opAdr (pm->segValue, pm->off);
psym = updateGlobSym (operand, size, duFlag); psym = symtab.updateGlobSym (operand, size, duFlag,created_new);
/* Check for out of bounds */
if (psym->label >= (uint32_t)prog.cbImage)
return (NULL);
return (psym);
} }
else if (pstate->f[pm->seg]) { /* new value */ else if (pstate->f[pm->seg]) /* new value */
{
pm->segValue = pstate->r[pm->seg]; pm->segValue = pstate->r[pm->seg];
operand = opAdr(pm->segValue, pm->off); operand = opAdr(pm->segValue, pm->off);
i = symtab.size(); psym = symtab.updateGlobSym (operand, size, duFlag,created_new);
psym = updateGlobSym (operand, size, duFlag);
/* Flag new memory locations that are segment values */ /* Flag new memory locations that are segment values */
if (symtab.size() > i) if (created_new)
{ {
if (size == 4) if (size == 4)
operand += 2; /* High uint16_t */ operand += 2; /* High uint16_t */
@ -847,14 +799,11 @@ static SYM * lookupAddr (LLOperand *pm, STATE *pstate, int size, uint16_t duFlag
break; break;
} }
} }
}
/* Check for out of bounds */ /* Check for out of bounds */
if (psym->label >= (uint32_t)prog.cbImage) if (psym && (psym->label>=0) and (psym->label < (uint32_t)prog.cbImage))
return (NULL); return psym;
return (psym); return nullptr;
}
}
return (NULL);
} }
@ -944,7 +893,7 @@ static void use (opLoc d, ICODE & pIcode, Function * pProc, STATE * pstate, int
if (pm->regi == INDEX_BP) /* indexed on bp */ if (pm->regi == INDEX_BP) /* indexed on bp */
{ {
if (pm->off >= 2) if (pm->off >= 2)
updateFrameOff (&pProc->args, pm->off, size, eDuVal::USE); pProc->args.updateFrameOff ( pm->off, size, eDuVal::USE);
else if (pm->off < 0) else if (pm->off < 0)
pProc->localId.newByteWordStk (TYPE_WORD_SIGN, pm->off, 0); pProc->localId.newByteWordStk (TYPE_WORD_SIGN, pm->off, 0);
} }
@ -991,7 +940,7 @@ static void def (opLoc d, ICODE & pIcode, Function * pProc, STATE * pstate, int
if (pm->regi == INDEX_BP) /* indexed on bp */ if (pm->regi == INDEX_BP) /* indexed on bp */
{ {
if (pm->off >= 2) if (pm->off >= 2)
updateFrameOff (&pProc->args, pm->off, size, eDEF); pProc->args.updateFrameOff ( pm->off, size, eDEF);
else if (pm->off < 0) else if (pm->off < 0)
pProc->localId.newByteWordStk (TYPE_WORD_SIGN, pm->off, 0); pProc->localId.newByteWordStk (TYPE_WORD_SIGN, pm->off, 0);
} }
@ -1016,7 +965,7 @@ static void def (opLoc d, ICODE & pIcode, Function * pProc, STATE * pstate, int
{ {
setBits(BM_DATA, psym->label, (uint32_t)size); setBits(BM_DATA, psym->label, (uint32_t)size);
pIcode.ll()->setFlags(SYM_DEF); pIcode.ll()->setFlags(SYM_DEF);
pIcode.ll()->caseTbl.numEntries = psym - &symtab[0]; pIcode.ll()->caseTbl.numEntries = distance(&symtab[0],psym);
} }
} }

80
src/procs.cpp
View File

@ -132,7 +132,7 @@ void Function::newRegArg(iICODE picode, iICODE ticode)
/* Check if register argument already on the formal argument list */ /* Check if register argument already on the formal argument list */
regExist = false; regExist = false;
for(STKSYM &tgt_sym : target_stackframe->sym) for(STKSYM &tgt_sym : *target_stackframe)
{ {
if (type == REGISTER) if (type == REGISTER)
{ {
@ -158,7 +158,9 @@ void Function::newRegArg(iICODE picode, iICODE ticode)
if (regExist == false) if (regExist == false)
{ {
STKSYM newsym; STKSYM newsym;
sprintf (newsym.name, "arg%ld", target_stackframe->sym.size());
newsym.setArgName(target_stackframe->size());
if (type == REGISTER) if (type == REGISTER)
{ {
if (regL < rAL) if (regL < rAL)
@ -171,23 +173,22 @@ void Function::newRegArg(iICODE picode, iICODE ticode)
newsym.type = TYPE_BYTE_SIGN; newsym.type = TYPE_BYTE_SIGN;
newsym.regs = COND_EXPR::idRegIdx(tidx, BYTE_REG); newsym.regs = COND_EXPR::idRegIdx(tidx, BYTE_REG);
} }
sprintf (tproc->localId.id_arr[tidx].name, "arg%ld", target_stackframe->sym.size()); tproc->localId.id_arr[tidx].name = newsym.name;
} }
else if (type == LONG_VAR) else if (type == LONG_VAR)
{ {
newsym.regs = COND_EXPR::idLongIdx (tidx); newsym.regs = COND_EXPR::idLongIdx (tidx);
newsym.type = TYPE_LONG_SIGN; newsym.type = TYPE_LONG_SIGN;
sprintf (tproc->localId.id_arr[tidx].name, "arg%ld", target_stackframe->sym.size()); tproc->localId.id_arr[tidx].name = newsym.name;
tproc->localId.propLongId (regL, regH, tproc->localId.propLongId (regL, regH, tproc->localId.id_arr[tidx].name.c_str());
tproc->localId.id_arr[tidx].name);
} }
target_stackframe->sym.push_back(newsym); target_stackframe->push_back(newsym);
target_stackframe->numArgs++; target_stackframe->numArgs++;
} }
/* Do ps (actual arguments) */ /* Do ps (actual arguments) */
STKSYM newsym; STKSYM newsym;
sprintf (newsym.name, "arg%ld", call_args_stackframe->sym.size()); newsym.setArgName(call_args_stackframe->size());
newsym.actual = picode->hl()->asgn.rhs; newsym.actual = picode->hl()->asgn.rhs;
newsym.regs = lhs; newsym.regs = lhs;
/* Mask off high and low register(s) in picode */ /* Mask off high and low register(s) in picode */
@ -207,15 +208,15 @@ void Function::newRegArg(iICODE picode, iICODE ticode)
newsym.type = TYPE_LONG_SIGN; newsym.type = TYPE_LONG_SIGN;
break; break;
} }
call_args_stackframe->sym.push_back(newsym); call_args_stackframe->push_back(newsym);
call_args_stackframe->numArgs++; call_args_stackframe->numArgs++;
} }
/** Inserts the new expression (ie. the actual parameter) on the argument /** Inserts the new expression (ie. the actual parameter) on the argument
* list. * list.
* @return TRUE if it was a near call that made use of a segment register. * @return true if it was a near call that made use of a segment register.
* FALSE elsewhere * false elsewhere
*/ */
bool CallType::newStkArg(COND_EXPR *exp, llIcode opcode, Function * pproc) bool CallType::newStkArg(COND_EXPR *exp, llIcode opcode, Function * pproc)
{ {
@ -239,7 +240,7 @@ bool CallType::newStkArg(COND_EXPR *exp, llIcode opcode, Function * pproc)
/* Place register argument on the argument list */ /* Place register argument on the argument list */
STKSYM newsym; STKSYM newsym;
newsym.actual = exp; newsym.actual = exp;
args->sym.push_back(newsym); args->push_back(newsym);
args->numArgs++; args->numArgs++;
return false; return false;
} }
@ -249,8 +250,8 @@ bool CallType::newStkArg(COND_EXPR *exp, llIcode opcode, Function * pproc)
* argument list of picode. */ * argument list of picode. */
void CallType::placeStkArg (COND_EXPR *exp, int pos) void CallType::placeStkArg (COND_EXPR *exp, int pos)
{ {
args->sym[pos].actual = exp; (*args)[pos].actual = exp;
sprintf (args->sym[pos].name, "arg%ld", pos); (*args)[pos].setArgName(pos);
} }
@ -317,35 +318,32 @@ void STKFRAME::adjustForArgType(int numArg_, hlType actType_)
hlType forType; hlType forType;
STKSYM * psym, * nsym; STKSYM * psym, * nsym;
int off, i; int off, i;
/* Find stack offset for this argument */
off = m_minOff;
for (i = 0; i < numArg_; i++)
{
if(i>=sym.size())
{
break; //TODO: verify
}
off += sym[i].size;
}
/* Find formal argument */
if (numArg_ < sym.size())
{
psym = &sym[numArg_];
i = numArg_;
//auto iter=std::find_if(sym.begin(),sym.end(),[off](STKSYM &s)->bool {s.off==off;});
auto iter=std::find_if(sym.begin()+numArg_,sym.end(),[off](STKSYM &s)->bool {s.off==off;});
if(iter==sym.end()) // symbol not found
return;
psym = &(*iter);
}
/* If formal argument does not exist, do not create new ones, just /* If formal argument does not exist, do not create new ones, just
* ignore actual argument * ignore actual argument
*/ */
else if(numArg_>size())
return; return;
/* Find stack offset for this argument */
off = m_minOff;
i=0;
for(STKSYM &s : *this) // walk formal arguments upto numArg_
{
if(i>=numArg_)
break;
off+=s.size;
i++;
}
/* Find formal argument */
//psym = &at(numArg_);
//i = numArg_;
//auto iter=std::find_if(sym.begin(),sym.end(),[off](STKSYM &s)->bool {s.off==off;});
auto iter=std::find_if(begin()+numArg_,end(),[off](STKSYM &s)->bool {s.label==off;});
if(iter==end()) // symbol not found
return;
psym = &(*iter);
forType = psym->type; forType = psym->type;
if (forType != actType_) if (forType != actType_)
{ {
@ -364,11 +362,11 @@ void STKFRAME::adjustForArgType(int numArg_, hlType actType_)
psym->type = actType_; psym->type = actType_;
psym->size = 4; psym->size = 4;
nsym = psym + 1; nsym = psym + 1;
sprintf (nsym->macro, "HI"); nsym->macro = "HI";
sprintf (psym->macro, "LO"); psym->macro = "LO";
nsym->hasMacro = true; nsym->hasMacro = true;
psym->hasMacro = true; psym->hasMacro = true;
sprintf (nsym->name, "%s", psym->name); nsym->name = psym->name;
nsym->invalid = true; nsym->invalid = true;
numArgs--; numArgs--;
} }

55
src/symtab.cpp
View File

@ -137,3 +137,58 @@ boolT readVal(std::ostringstream &symName, uint32_t symOff, Function * symProc)
{ {
return false; // no symbolic names for now return false; // no symbolic names for now
} }
/* Updates the type of the symbol in the symbol table. The size is updated
* if necessary (0 means no update necessary). */
void SYMTAB::updateSymType (uint32_t symbol,const TypeContainer &tc)
{
int i;
auto iter=findByLabel(symbol);
if(iter==end())
return;
iter->type = tc.m_type;
if (tc.m_size != 0)
iter->size = tc.m_size;
}
/* Creates an entry in the global symbol table (symtab) if the variable
* is not there yet. If it is part of the symtab, the size of the variable
* is checked and updated if the old size was less than the new size (ie.
* the maximum size is always saved). */
//TODO: SYMTAB::updateGlobSym should be renamed to insertOrUpdateSym
SYM * SYMTAB::updateGlobSym (uint32_t operand, int size, uint16_t duFlag,bool &inserted_new)
{
/* Check for symbol in symbol table */
auto iter = findByLabel(operand);
if(iter!=end())
{
if(iter->size<size)
iter->size = size;
inserted_new=false;
return &(*iter);
}
/* New symbol, not in symbol table */
SYM v;
char buf[32]={};
sprintf (buf, "var%05X", operand);
v.name = buf;
v.label = operand;
v.size = size;
v.type = TypeContainer::defaultTypeForSize(size);
if (duFlag == eDuVal::USE) /* must already have init value */
{
v.duVal.use =1; // USEVAL;
v.duVal.val =1;
}
else
{
v.duVal.setFlags(duFlag);
}
push_back(v);
inserted_new=true;
return (&back());
}
//template<> class SymbolTableCommon<SYM>;
//template<> class SymbolTableCommon<STKSYM>;