221 lines
7.7 KiB
C++
221 lines
7.7 KiB
C++
/*
|
|
* File: ast.h
|
|
* Purpose: definition of the abstract syntax tree ADT.
|
|
* Date: September 1993
|
|
* (C) Cristina Cifuentes
|
|
*/
|
|
#pragma once
|
|
#include <cstring>
|
|
#include <list>
|
|
#include <boost/range/iterator_range.hpp>
|
|
#include "Enums.h"
|
|
static const int operandSize=20;
|
|
/* The following definitions and types define the Conditional Expression
|
|
* attributed syntax tree, as defined by the following EBNF:
|
|
CondExp ::= CondTerm AND CondTerm | CondTerm
|
|
CondTerm ::= (CondFactor op CondFactor)
|
|
CondFactor ::= Identifier | ! CondFactor
|
|
Identifier ::= globalVar | register | localVar | parameter | constant
|
|
op ::= <= | < | = | != | > | >=
|
|
*/
|
|
/* High-level BOOLEAN conditions for iJB..iJNS icodes */
|
|
static const condOp condOpJCond[12] = {LESS, LESS_EQUAL, GREATER_EQUAL, GREATER,
|
|
EQUAL, NOT_EQUAL, LESS, GREATER_EQUAL,
|
|
LESS_EQUAL, GREATER, GREATER_EQUAL, LESS};
|
|
struct AstIdent;
|
|
struct Function;
|
|
struct STKFRAME;
|
|
struct LOCAL_ID;
|
|
struct ICODE;
|
|
struct LLInst;
|
|
struct ID;
|
|
typedef std::list<ICODE>::iterator iICODE;
|
|
typedef boost::iterator_range<iICODE> rICODE;
|
|
#include "IdentType.h"
|
|
|
|
/* Expression data type */
|
|
struct COND_EXPR
|
|
{
|
|
public:
|
|
condNodeType m_type; /* Conditional Expression Node Type */
|
|
public:
|
|
static bool insertSubTreeLongReg(COND_EXPR *exp, COND_EXPR *&tree, int longIdx);
|
|
static bool insertSubTreeReg(COND_EXPR *&tree, COND_EXPR *_expr, eReg regi, const LOCAL_ID *locsym);
|
|
static bool insertSubTreeReg(AstIdent *&tree, COND_EXPR *_expr, eReg regi, const LOCAL_ID *locsym);
|
|
public:
|
|
virtual COND_EXPR *clone() const;
|
|
void release();
|
|
COND_EXPR(condNodeType t=UNKNOWN_OP) : m_type(t)
|
|
{
|
|
|
|
}
|
|
virtual ~COND_EXPR();
|
|
public:
|
|
virtual std::string walkCondExpr (Function * pProc, int* numLoc) const=0;
|
|
virtual COND_EXPR *inverse() const=0; // return new COND_EXPR that is invarse of this
|
|
virtual bool xClear(rICODE range_to_check, iICODE lastBBinst, const LOCAL_ID &locId)=0;
|
|
virtual COND_EXPR *insertSubTreeReg(COND_EXPR *_expr, eReg regi, const LOCAL_ID *locsym)=0;
|
|
virtual COND_EXPR *insertSubTreeLongReg(COND_EXPR *_expr, int longIdx)=0;
|
|
virtual hlType expType(Function *pproc) const;
|
|
virtual int hlTypeSize(Function *pproc) const=0;
|
|
virtual void performLongRemoval(eReg regi, LOCAL_ID *locId) {}
|
|
};
|
|
struct UnaryOperator : public COND_EXPR
|
|
{
|
|
UnaryOperator(condNodeType t=UNKNOWN_OP) : COND_EXPR(t),unaryExp(nullptr) {}
|
|
COND_EXPR *unaryExp;
|
|
virtual COND_EXPR *inverse() const
|
|
{
|
|
if (m_type == NEGATION) //TODO: memleak here
|
|
{
|
|
return unaryExp->clone();
|
|
}
|
|
return this->clone();
|
|
}
|
|
virtual COND_EXPR *clone() const
|
|
{
|
|
UnaryOperator *newExp = new UnaryOperator(*this);
|
|
newExp->unaryExp = unaryExp->clone();
|
|
return newExp;
|
|
}
|
|
virtual bool xClear(rICODE range_to_check, iICODE lastBBinst, const LOCAL_ID &locs);
|
|
static UnaryOperator *Create(condNodeType t, COND_EXPR *sub_expr)
|
|
{
|
|
UnaryOperator *newExp = new UnaryOperator();
|
|
newExp->m_type = t;
|
|
newExp->unaryExp = sub_expr;
|
|
return (newExp);
|
|
}
|
|
~UnaryOperator()
|
|
{
|
|
delete unaryExp;
|
|
unaryExp=nullptr;
|
|
}
|
|
public:
|
|
int hlTypeSize(Function *pproc) const;
|
|
virtual std::string walkCondExpr(Function *pProc, int *numLoc) const;
|
|
virtual COND_EXPR *insertSubTreeReg(COND_EXPR *_expr, eReg regi, const LOCAL_ID *locsym);
|
|
virtual hlType expType(Function *pproc) const;
|
|
virtual COND_EXPR *insertSubTreeLongReg(COND_EXPR *_expr, int longIdx);
|
|
};
|
|
|
|
struct BinaryOperator : public COND_EXPR
|
|
{
|
|
condOp m_op;
|
|
COND_EXPR *m_lhs;
|
|
COND_EXPR *m_rhs;
|
|
BinaryOperator(condOp o) : COND_EXPR(BOOLEAN_OP)
|
|
{
|
|
m_op = o;
|
|
m_lhs=m_rhs=nullptr;
|
|
}
|
|
BinaryOperator(condOp o,COND_EXPR *l,COND_EXPR *r) : COND_EXPR(BOOLEAN_OP)
|
|
{
|
|
m_op = o;
|
|
m_lhs=l;
|
|
m_rhs=r;
|
|
}
|
|
~BinaryOperator()
|
|
{
|
|
assert(m_lhs!=m_rhs || m_lhs==nullptr);
|
|
delete m_lhs;
|
|
delete m_rhs;
|
|
}
|
|
static BinaryOperator *Create(condOp o,COND_EXPR *l,COND_EXPR *r)
|
|
{
|
|
BinaryOperator *res = new BinaryOperator(o);
|
|
res->m_lhs = l;
|
|
res->m_rhs = r;
|
|
return res;
|
|
}
|
|
static BinaryOperator *LogicAnd(COND_EXPR *l,COND_EXPR *r)
|
|
{
|
|
return new BinaryOperator(DBL_AND,l,r);
|
|
}
|
|
static BinaryOperator *And(COND_EXPR *l,COND_EXPR *r)
|
|
{
|
|
return new BinaryOperator(AND,l,r);
|
|
}
|
|
static BinaryOperator *Or(COND_EXPR *l,COND_EXPR *r)
|
|
{
|
|
return new BinaryOperator(OR,l,r);
|
|
}
|
|
static BinaryOperator *LogicOr(COND_EXPR *l,COND_EXPR *r)
|
|
{
|
|
return new BinaryOperator(DBL_OR,l,r);
|
|
}
|
|
static BinaryOperator *CreateAdd(COND_EXPR *l,COND_EXPR *r);
|
|
void changeBoolOp(condOp newOp);
|
|
virtual COND_EXPR *inverse() const;
|
|
virtual COND_EXPR *clone() const;
|
|
virtual bool xClear(rICODE range_to_check, iICODE lastBBinst, const LOCAL_ID &locs);
|
|
virtual COND_EXPR *insertSubTreeReg(COND_EXPR *_expr, eReg regi, const LOCAL_ID *locsym);
|
|
virtual COND_EXPR *insertSubTreeLongReg(COND_EXPR *_expr, int longIdx);
|
|
const COND_EXPR *lhs() const
|
|
{
|
|
return const_cast<const COND_EXPR *>(const_cast<BinaryOperator *>(this)->lhs());
|
|
}
|
|
const COND_EXPR *rhs() const
|
|
{
|
|
return const_cast<const COND_EXPR *>(const_cast<BinaryOperator *>(this)->rhs());
|
|
}
|
|
|
|
COND_EXPR *lhs()
|
|
{
|
|
assert(m_type==BOOLEAN_OP);
|
|
return m_lhs;
|
|
}
|
|
COND_EXPR *rhs()
|
|
{
|
|
assert(m_type==BOOLEAN_OP);
|
|
return m_rhs;
|
|
}
|
|
condOp op() const { return m_op;}
|
|
/* Changes the boolean conditional operator at the root of this expression */
|
|
void op(condOp o) { m_op=o;}
|
|
std::string walkCondExpr (Function * pProc, int* numLoc) const;
|
|
public:
|
|
hlType expType(Function *pproc) const;
|
|
int hlTypeSize(Function *pproc) const;
|
|
};
|
|
struct AstIdent : public UnaryOperator
|
|
{
|
|
AstIdent() : UnaryOperator(IDENTIFIER)
|
|
{
|
|
memset(&ident,0,sizeof(ident));
|
|
}
|
|
virtual COND_EXPR *clone() const
|
|
{
|
|
return new AstIdent(*this);
|
|
}
|
|
IDENTTYPE ident; /* for IDENTIFIER */
|
|
static AstIdent * RegIdx(int idx, regType reg_type);
|
|
static AstIdent * Kte(uint32_t kte, uint8_t size);
|
|
static AstIdent * Loc(int off, LOCAL_ID *localId);
|
|
static AstIdent * Reg(eReg regi, uint32_t icodeFlg, LOCAL_ID *locsym);
|
|
static AstIdent * LongIdx(int idx);
|
|
static AstIdent * Other(eReg seg, eReg regi, int16_t off);
|
|
static AstIdent * idParam(int off, const STKFRAME *argSymtab);
|
|
static AstIdent * idLong(LOCAL_ID *localId, opLoc sd, iICODE pIcode, hlFirst f, iICODE ix, operDu du, LLInst &atOffset);
|
|
static AstIdent * idFunc(Function *pproc, STKFRAME *args);
|
|
static AstIdent * idID(const ID *retVal, LOCAL_ID *locsym, iICODE ix_);
|
|
static COND_EXPR * id(const LLInst &ll_insn, opLoc sd, Function *pProc, iICODE ix_, ICODE &duIcode, operDu du);
|
|
|
|
virtual int hlTypeSize(Function *pproc) const;
|
|
virtual hlType expType(Function *pproc) const;
|
|
virtual void performLongRemoval(eReg regi, LOCAL_ID *locId);
|
|
virtual std::string walkCondExpr(Function *pProc, int *numLoc) const;
|
|
virtual COND_EXPR *insertSubTreeReg(COND_EXPR *_expr, eReg regi, const LOCAL_ID *locsym);
|
|
virtual COND_EXPR *insertSubTreeLongReg(COND_EXPR *_expr, int longIdx);
|
|
virtual bool xClear(rICODE range_to_check, iICODE lastBBinst, const LOCAL_ID &locId);
|
|
protected:
|
|
eReg otherLongRegi (eReg regi, int idx, LOCAL_ID *locTbl);
|
|
|
|
};
|
|
struct GlobalVariable : public AstIdent
|
|
{
|
|
static AstIdent *Create(int16_t segValue, int16_t off);
|
|
};
|
|
struct Constant : public COND_EXPR
|
|
{};
|