mirror of
https://github.com/NationalSecurityAgency/ghidra.git
synced 2025-10-04 18:29:37 +02:00
GP-3680 Add case label tokens
This commit is contained in:
caheckman
parent
c072972153
commit
fe2f993e11
15 changed files with 415 additions and 138 deletions
|
|
@ -1260,6 +1260,14 @@ void BlockGraph::printRaw(ostream &s) const
|
|||
(*iter)->printRaw(s);
|
||||
}
|
||||
|
||||
PcodeOp *BlockGraph::firstOp(void) const
|
||||
|
||||
{
|
||||
if (getSize() == 0)
|
||||
return (PcodeOp *)0;
|
||||
return getBlock(0)->firstOp();
|
||||
}
|
||||
|
||||
FlowBlock *BlockGraph::nextFlowAfter(const FlowBlock *bl) const
|
||||
|
||||
{
|
||||
|
|
@ -2255,6 +2263,13 @@ Address BlockBasic::getStop(void) const
|
|||
return range->getLastAddr();
|
||||
}
|
||||
|
||||
PcodeOp *BlockBasic::firstOp(void) const
|
||||
|
||||
{
|
||||
if (op.empty()) return (PcodeOp *)0;
|
||||
return (PcodeOp *)op.front();
|
||||
}
|
||||
|
||||
PcodeOp *BlockBasic::lastOp(void) const
|
||||
|
||||
{
|
||||
|
|
|
|||
|
|
@ -175,6 +175,7 @@ public:
|
|||
virtual void printRaw(ostream &s) const {} ///< Print raw instructions contained in \b this FlowBlock
|
||||
virtual void emit(PrintLanguage *lng) const; ///<Emit the instructions in \b this FlowBlock as structured code
|
||||
virtual const FlowBlock *getExitLeaf(void) const { return (const FlowBlock *)0; } ///< Get the FlowBlock to which \b this block exits
|
||||
virtual PcodeOp *firstOp(void) const { return (PcodeOp *)0; } ///< Get the first PcodeOp executed by \b this FlowBlock
|
||||
virtual PcodeOp *lastOp(void) const { return (PcodeOp *)0; } ///< Get the last PcodeOp executed by \b this FlowBlock
|
||||
virtual bool negateCondition(bool toporbottom); ///< Flip the condition computed by \b this
|
||||
virtual bool preferComplement(Funcdata &data); ///< Rearrange \b this hierarchy to simplify boolean expressions
|
||||
|
|
@ -307,6 +308,7 @@ public:
|
|||
virtual void printTree(ostream &s,int4 level) const;
|
||||
virtual void printRaw(ostream &s) const;
|
||||
virtual void emit(PrintLanguage *lng) const { lng->emitBlockGraph(this); }
|
||||
virtual PcodeOp *firstOp(void) const;
|
||||
virtual FlowBlock *nextFlowAfter(const FlowBlock *bl) const;
|
||||
virtual void finalTransform(Funcdata &data);
|
||||
virtual void finalizePrinting(Funcdata &data) const;
|
||||
|
|
@ -400,6 +402,7 @@ public:
|
|||
virtual void printRaw(ostream &s) const;
|
||||
virtual void emit(PrintLanguage *lng) const { lng->emitBlockBasic(this); }
|
||||
virtual const FlowBlock *getExitLeaf(void) const { return this; }
|
||||
virtual PcodeOp *firstOp(void) const;
|
||||
virtual PcodeOp *lastOp(void) const;
|
||||
virtual bool negateCondition(bool toporbottom);
|
||||
virtual FlowBlock *getSplitPoint(void);
|
||||
|
|
@ -440,6 +443,7 @@ public:
|
|||
virtual void printRaw(ostream &s) const { copy->printRaw(s); }
|
||||
virtual void emit(PrintLanguage *lng) const { lng->emitBlockCopy(this); }
|
||||
virtual const FlowBlock *getExitLeaf(void) const { return this; }
|
||||
virtual PcodeOp *firstOp(void) const { return copy->firstOp(); }
|
||||
virtual PcodeOp *lastOp(void) const { return copy->lastOp(); }
|
||||
virtual bool negateCondition(bool toporbottom) { bool res = copy->negateCondition(true); FlowBlock::negateCondition(toporbottom); return res; }
|
||||
virtual FlowBlock *getSplitPoint(void) { return copy->getSplitPoint(); }
|
||||
|
|
|
|||
|
|
@ -244,6 +244,19 @@ void EmitMarkup::tagLabel(const string &name,syntax_highlight hl,const AddrSpace
|
|||
encoder->closeElement(ELEM_LABEL);
|
||||
}
|
||||
|
||||
void EmitMarkup::tagCaseLabel(const string &name,syntax_highlight hl,const PcodeOp *op,uintb value)
|
||||
|
||||
{
|
||||
encoder->openElement(ELEM_VALUE);
|
||||
if (hl != no_color)
|
||||
encoder->writeUnsignedInteger(ATTRIB_COLOR,hl);
|
||||
encoder->writeUnsignedInteger(ATTRIB_OFF, value);
|
||||
if (op != (const PcodeOp *)0)
|
||||
encoder->writeUnsignedInteger(ATTRIB_OPREF, op->getTime());
|
||||
encoder->writeString(ATTRIB_CONTENT,name);
|
||||
encoder->closeElement(ELEM_VALUE);
|
||||
}
|
||||
|
||||
void EmitMarkup::print(const string &data,syntax_highlight hl)
|
||||
|
||||
{
|
||||
|
|
@ -357,6 +370,9 @@ void TokenSplit::print(Emit *emit) const
|
|||
case label_t: // tagLabel
|
||||
emit->tagLabel(tok,hl,ptr_second.spc,off);
|
||||
break;
|
||||
case case_t: // tagCaseLabel
|
||||
emit->tagCaseLabel(tok, hl, op, off);
|
||||
break;
|
||||
case synt_t: // print
|
||||
emit->print(tok,hl);
|
||||
break;
|
||||
|
|
@ -448,6 +464,9 @@ void TokenSplit::printDebug(ostream &s) const
|
|||
case label_t: // tagLabel
|
||||
s << "label_t";
|
||||
break;
|
||||
case case_t: // tagCaseLabel
|
||||
s << "case_t";
|
||||
break;
|
||||
case synt_t: // print
|
||||
s << "synt_t";
|
||||
break;
|
||||
|
|
@ -1011,6 +1030,15 @@ void EmitPrettyPrint::tagLabel(const string &name,syntax_highlight hl,const Addr
|
|||
scan();
|
||||
}
|
||||
|
||||
void EmitPrettyPrint::tagCaseLabel(const string &name,syntax_highlight hl,const PcodeOp *op,uintb value)
|
||||
|
||||
{
|
||||
checkstring();
|
||||
TokenSplit &tok( tokqueue.push() );
|
||||
tok.tagCaseLabel(name, hl, op, value);
|
||||
scan();
|
||||
}
|
||||
|
||||
void EmitPrettyPrint::print(const string &data,syntax_highlight hl)
|
||||
|
||||
{
|
||||
|
|
|
|||
|
|
@ -292,6 +292,15 @@ public:
|
|||
/// \param off is the offset of the code address being labeled
|
||||
virtual void tagLabel(const string &name,syntax_highlight hl,const AddrSpace *spc,uintb off)=0;
|
||||
|
||||
/// \brief Emit a \e case label constant
|
||||
///
|
||||
/// A string describing the \e switch variable value is emitted and starting PcodeOp of the \e case block.
|
||||
/// \param name is the character data of the value
|
||||
/// \param hl indicates how the value should be highlighted
|
||||
/// \param op is the first PcodeOp in the \e case block
|
||||
/// \param value is the raw integer value underlying the switch value
|
||||
virtual void tagCaseLabel(const string &name,syntax_highlight hl,const PcodeOp *op,uintb value)=0;
|
||||
|
||||
/// \brief Emit other (more unusual) syntax as part of source code generation
|
||||
///
|
||||
/// This method is used to emit syntax not covered by the other methods, such as
|
||||
|
|
@ -473,6 +482,7 @@ public:
|
|||
virtual void tagField(const string &name,syntax_highlight hl,const Datatype *ct,int4 off,const PcodeOp *op);
|
||||
virtual void tagComment(const string &name,syntax_highlight hl,const AddrSpace *spc,uintb off);
|
||||
virtual void tagLabel(const string &name,syntax_highlight hl,const AddrSpace *spc,uintb off);
|
||||
virtual void tagCaseLabel(const string &name,syntax_highlight hl,const PcodeOp *op,uintb value);
|
||||
virtual void print(const string &data,syntax_highlight hl=no_color);
|
||||
virtual int4 openParen(const string &paren,int4 id=0);
|
||||
virtual void closeParen(const string &paren,int4 id);
|
||||
|
|
@ -522,6 +532,8 @@ public:
|
|||
*s << name; }
|
||||
virtual void tagLabel(const string &name,syntax_highlight hl,const AddrSpace *spc,uintb off) {
|
||||
*s << name; }
|
||||
virtual void tagCaseLabel(const string &name,syntax_highlight hl,const PcodeOp *op,uintb value) {
|
||||
*s << name; }
|
||||
virtual void print(const string &data,syntax_highlight hl=no_color) {
|
||||
*s << data; }
|
||||
virtual int4 openParen(const string &paren,int4 id=0) {
|
||||
|
|
@ -584,6 +596,7 @@ public:
|
|||
field_t, ///< A field name for a structured data-type
|
||||
comm_t, ///< Part of a comment block
|
||||
label_t, ///< A code label
|
||||
case_t, ///< A case label
|
||||
synt_t, ///< Other unspecified syntax
|
||||
opar_t, ///< Open parenthesis
|
||||
cpar_t, ///< Close parenthesis
|
||||
|
|
@ -774,6 +787,16 @@ public:
|
|||
tok = name; size = tok.size(); ptr_second.spc=s; off=o;
|
||||
tagtype=label_t; delimtype=tokenstring; hl=h; }
|
||||
|
||||
/// \brief Create a \e case label token
|
||||
///
|
||||
/// \param name is the character data of the label
|
||||
/// \param h indicates how the label should be highlighted
|
||||
/// \param inOp is the first PcodeOp in the \e case block
|
||||
/// \param intValue is the constant value underlying the case label
|
||||
void tagCaseLabel(const string &name,EmitMarkup::syntax_highlight h,const PcodeOp *inOp,uintb intValue) {
|
||||
tok = name; size = tok.size(); op = inOp; off = intValue;
|
||||
tagtype=case_t; delimtype=tokenstring; hl=h; }
|
||||
|
||||
/// \brief Create a token for other (more unusual) syntax in source code
|
||||
///
|
||||
/// \param data is the character data of the syntax being emitted
|
||||
|
|
@ -1019,6 +1042,7 @@ public:
|
|||
virtual void tagField(const string &name,syntax_highlight hl,const Datatype *ct,int4 off,const PcodeOp *op);
|
||||
virtual void tagComment(const string &name,syntax_highlight hl,const AddrSpace *spc,uintb off);
|
||||
virtual void tagLabel(const string &name,syntax_highlight hl,const AddrSpace *spc,uintb off);
|
||||
virtual void tagCaseLabel(const string &name,syntax_highlight hl,const PcodeOp *op,uintb value);
|
||||
virtual void print(const string &data,syntax_highlight hl=no_color);
|
||||
virtual int4 openParen(const string &paren,int4 id=0);
|
||||
virtual void closeParen(const string &paren,int4 id);
|
||||
|
|
|
|||
|
|
@ -324,7 +324,7 @@ void PrintC::pushTypeEnd(const Datatype *ct)
|
|||
else if (ct->getMetatype()==TYPE_ARRAY) {
|
||||
const TypeArray *ctarray = (const TypeArray *)ct;
|
||||
ct = ctarray->getBase();
|
||||
push_integer(ctarray->numElements(),4,false,
|
||||
push_integer(ctarray->numElements(),4,false,syntax,
|
||||
(const Varnode *)0,(const PcodeOp *)0);
|
||||
}
|
||||
else if (ct->getMetatype()==TYPE_CODE) {
|
||||
|
|
@ -967,7 +967,7 @@ void PrintC::opPtrsub(const PcodeOp *op)
|
|||
pushAtom(Atom(fieldname,fieldtoken,EmitMarkup::no_color,ct,fieldid,op));
|
||||
}
|
||||
if (arrayvalue)
|
||||
push_integer(0,4,false,(Varnode *)0,op);
|
||||
push_integer(0,4,false,syntax,(Varnode *)0,op);
|
||||
}
|
||||
}
|
||||
else if (ct->getMetatype() == TYPE_SPACEBASE) {
|
||||
|
|
@ -1009,7 +1009,7 @@ void PrintC::opPtrsub(const PcodeOp *op)
|
|||
}
|
||||
}
|
||||
if (arrayvalue)
|
||||
push_integer(0,4,false,(Varnode *)0,op);
|
||||
push_integer(0,4,false,syntax,(Varnode *)0,op);
|
||||
}
|
||||
else if (ct->getMetatype() == TYPE_ARRAY) {
|
||||
if (in1const != 0) {
|
||||
|
|
@ -1040,7 +1040,7 @@ void PrintC::opPtrsub(const PcodeOp *op)
|
|||
if (ptrel != (TypePointerRel *)0)
|
||||
pushTypePointerRel(op);
|
||||
pushVn(in0,op,m);
|
||||
push_integer(0,4,false,(Varnode *)0,op);
|
||||
push_integer(0,4,false,syntax,(Varnode *)0,op);
|
||||
}
|
||||
else { // EMIT (* )[0]
|
||||
pushOp(&subscript,op);
|
||||
|
|
@ -1048,7 +1048,7 @@ void PrintC::opPtrsub(const PcodeOp *op)
|
|||
if (ptrel != (TypePointerRel *)0)
|
||||
pushTypePointerRel(op);
|
||||
pushVn(in0,op,m);
|
||||
push_integer(0,4,false,(Varnode *)0,op);
|
||||
push_integer(0,4,false,syntax,(Varnode *)0,op);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -1198,9 +1198,10 @@ void PrintC::opExtractOp(const PcodeOp *op)
|
|||
/// \param val is the given integer value
|
||||
/// \param sz is the size (in bytes) to associate with the integer
|
||||
/// \param sign is set to \b true if the integer should be treated as a signed value
|
||||
/// \param tag is the type of token to associate with the integer
|
||||
/// \param vn is the Varnode holding the value
|
||||
/// \param op is the PcodeOp using the value
|
||||
void PrintC::push_integer(uintb val,int4 sz,bool sign,
|
||||
void PrintC::push_integer(uintb val,int4 sz,bool sign,tagtype tag,
|
||||
const Varnode *vn,const PcodeOp *op)
|
||||
{
|
||||
bool print_negsign;
|
||||
|
|
@ -1279,10 +1280,7 @@ void PrintC::push_integer(uintb val,int4 sz,bool sign,
|
|||
if (force_sized_token)
|
||||
t << sizeSuffix;
|
||||
|
||||
if (vn==(const Varnode *)0)
|
||||
pushAtom(Atom(t.str(),syntax,EmitMarkup::const_color,op));
|
||||
else
|
||||
pushAtom(Atom(t.str(),vartoken,EmitMarkup::const_color,op,vn));
|
||||
pushAtom(Atom(t.str(),tag,EmitMarkup::const_color,op,vn,val));
|
||||
}
|
||||
|
||||
/// \brief Push a constant with a floating-point data-type to the RPN stack
|
||||
|
|
@ -1292,9 +1290,10 @@ void PrintC::push_integer(uintb val,int4 sz,bool sign,
|
|||
/// is decided upon, and the constant is pushed as a single token.
|
||||
/// \param val is the given encoded floating-point value
|
||||
/// \param sz is the size (in bytes) of the encoded value
|
||||
/// \param tag is the type of token to associate with the float
|
||||
/// \param vn is the Varnode holding the value
|
||||
/// \param op is the PcodeOp using the value
|
||||
void PrintC::push_float(uintb val,int4 sz,const Varnode *vn,const PcodeOp *op)
|
||||
void PrintC::push_float(uintb val,int4 sz,tagtype tag,const Varnode *vn,const PcodeOp *op)
|
||||
{
|
||||
string token;
|
||||
|
||||
|
|
@ -1345,10 +1344,7 @@ void PrintC::push_float(uintb val,int4 sz,const Varnode *vn,const PcodeOp *op)
|
|||
}
|
||||
}
|
||||
}
|
||||
if (vn==(const Varnode *)0)
|
||||
pushAtom(Atom(token,syntax,EmitMarkup::const_color,op));
|
||||
else
|
||||
pushAtom(Atom(token,vartoken,EmitMarkup::const_color,op,vn));
|
||||
pushAtom(Atom(token,tag,EmitMarkup::const_color,op,vn,val));
|
||||
}
|
||||
|
||||
void PrintC::printUnicode(ostream &s,int4 onechar) const
|
||||
|
|
@ -1410,16 +1406,16 @@ void PrintC::pushType(const Datatype *ct)
|
|||
/// A single Atom representing the boolean value is emitted
|
||||
/// \param val is the boolean value (non-zero for \b true)
|
||||
/// \param ct is the data-type associated with the value
|
||||
/// \param tag is the type of token to associate with the boolean value
|
||||
/// \param vn is the Varnode holding the value
|
||||
/// \param op is the PcodeOp using the value
|
||||
void PrintC::pushBoolConstant(uintb val,const TypeBase *ct,
|
||||
const Varnode *vn,
|
||||
const PcodeOp *op)
|
||||
void PrintC::pushBoolConstant(uintb val,const TypeBase *ct,tagtype tag,
|
||||
const Varnode *vn,const PcodeOp *op)
|
||||
{
|
||||
if (val != 0)
|
||||
pushAtom(Atom(KEYWORD_TRUE,vartoken,EmitMarkup::const_color,op,vn));
|
||||
pushAtom(Atom(KEYWORD_TRUE,tag,EmitMarkup::const_color,op,vn,val));
|
||||
else
|
||||
pushAtom(Atom(KEYWORD_FALSE,vartoken,EmitMarkup::const_color,op,vn));
|
||||
pushAtom(Atom(KEYWORD_FALSE,tag,EmitMarkup::const_color,op,vn,val));
|
||||
}
|
||||
|
||||
/// \brief Return \b true if this language requires a prefix when expressing \e wide characters
|
||||
|
|
@ -1524,9 +1520,10 @@ void PrintC::resetDefaultsPrintC(void)
|
|||
/// Handle unicode, wide characters, etc. Characters come in with the compiler's raw encoding.
|
||||
/// \param val is the constant value
|
||||
/// \param ct is data-type attached to the value
|
||||
/// \param tag is the type of token to associate with the character
|
||||
/// \param vn is the Varnode holding the value
|
||||
/// \param op is the PcodeOp using the value
|
||||
void PrintC::pushCharConstant(uintb val,const Datatype *ct,const Varnode *vn,const PcodeOp *op)
|
||||
void PrintC::pushCharConstant(uintb val,const Datatype *ct,tagtype tag,const Varnode *vn,const PcodeOp *op)
|
||||
|
||||
{
|
||||
uint4 displayFormat = 0;
|
||||
|
|
@ -1546,7 +1543,7 @@ void PrintC::pushCharConstant(uintb val,const Datatype *ct,const Varnode *vn,con
|
|||
}
|
||||
if (displayFormat != 0 && displayFormat != Symbol::force_char) {
|
||||
if (!castStrategy->caresAboutCharRepresentation(vn, op)) {
|
||||
push_integer(val, ct->getSize(), isSigned, vn, op);
|
||||
push_integer(val, ct->getSize(), isSigned, tag, vn, op);
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
|
@ -1556,7 +1553,7 @@ void PrintC::pushCharConstant(uintb val,const Datatype *ct,const Varnode *vn,con
|
|||
// unicode code-point. Its either part of a multi-byte UTF-8 encoding or an unknown
|
||||
// code-page value. In either case, we print as an integer or an escape sequence.
|
||||
if (displayFormat != Symbol::force_hex && displayFormat != Symbol::force_char) {
|
||||
push_integer(val, 1, isSigned, vn, op);
|
||||
push_integer(val, 1, isSigned, tag, vn, op);
|
||||
return;
|
||||
}
|
||||
displayFormat = Symbol::force_hex; // Fallthru but force a hex representation
|
||||
|
|
@ -1574,7 +1571,7 @@ void PrintC::pushCharConstant(uintb val,const Datatype *ct,const Varnode *vn,con
|
|||
else
|
||||
printUnicode(t,(int4)val);
|
||||
t << '\'';
|
||||
pushAtom(Atom(t.str(),vartoken,EmitMarkup::const_color,op,vn));
|
||||
pushAtom(Atom(t.str(),tag,EmitMarkup::const_color,op,vn,val));
|
||||
}
|
||||
|
||||
/// \brief Push an enumerated value to the RPN stack
|
||||
|
|
@ -1583,11 +1580,11 @@ void PrintC::pushCharConstant(uintb val,const Datatype *ct,const Varnode *vn,con
|
|||
/// enumeration or where the value cannot be expressed using named elements
|
||||
/// \param val is the enumerated value being pushed
|
||||
/// \param ct is the enumerated data-type attached to the value
|
||||
/// \param tag is the type of token to associate with the value
|
||||
/// \param vn is the Varnode holding the value
|
||||
/// \param op is the PcodeOp using the value
|
||||
void PrintC::pushEnumConstant(uintb val,const TypeEnum *ct,
|
||||
const Varnode *vn,
|
||||
const PcodeOp *op)
|
||||
void PrintC::pushEnumConstant(uintb val,const TypeEnum *ct,tagtype tag,
|
||||
const Varnode *vn,const PcodeOp *op)
|
||||
{
|
||||
vector<string> valnames;
|
||||
|
||||
|
|
@ -1598,10 +1595,10 @@ void PrintC::pushEnumConstant(uintb val,const TypeEnum *ct,
|
|||
for(int4 i=valnames.size()-1;i>0;--i)
|
||||
pushOp(&enum_cat,op);
|
||||
for(int4 i=0;i<valnames.size();++i)
|
||||
pushAtom(Atom(valnames[i],vartoken,EmitMarkup::const_color,op,vn));
|
||||
pushAtom(Atom(valnames[i],tag,EmitMarkup::const_color,op,vn,val));
|
||||
}
|
||||
else {
|
||||
push_integer(val,ct->getSize(),false,vn,op);
|
||||
push_integer(val,ct->getSize(),false,tag,vn,op);
|
||||
// ostringstream s;
|
||||
// s << "BAD_ENUM(0x" << hex << val << ")";
|
||||
// pushAtom(Atom(s.str(),vartoken,EmitMarkup::const_color,op,vn));
|
||||
|
|
@ -1650,8 +1647,7 @@ bool PrintC::pushPtrCharConstant(uintb val,const TypePointer *ct,const Varnode *
|
|||
/// \param op is the PcodeOp using the value
|
||||
/// \return \b true if a name was pushed to the RPN stack, return \b false otherwise
|
||||
bool PrintC::pushPtrCodeConstant(uintb val,const TypePointer *ct,
|
||||
const Varnode *vn,
|
||||
const PcodeOp *op)
|
||||
const Varnode *vn,const PcodeOp *op)
|
||||
{
|
||||
AddrSpace *spc = glb->getDefaultCodeSpace();
|
||||
Funcdata *fd = (Funcdata *)0;
|
||||
|
|
@ -1664,7 +1660,7 @@ bool PrintC::pushPtrCodeConstant(uintb val,const TypePointer *ct,
|
|||
return false;
|
||||
}
|
||||
|
||||
void PrintC::pushConstant(uintb val,const Datatype *ct,
|
||||
void PrintC::pushConstant(uintb val,const Datatype *ct,tagtype tag,
|
||||
const Varnode *vn,
|
||||
const PcodeOp *op)
|
||||
{
|
||||
|
|
@ -1672,25 +1668,25 @@ void PrintC::pushConstant(uintb val,const Datatype *ct,
|
|||
switch(ct->getMetatype()) {
|
||||
case TYPE_UINT:
|
||||
if (ct->isCharPrint())
|
||||
pushCharConstant(val,(TypeChar *)ct,vn,op);
|
||||
pushCharConstant(val,(TypeChar *)ct,tag,vn,op);
|
||||
else if (ct->isEnumType())
|
||||
pushEnumConstant(val,(TypeEnum *)ct,vn,op);
|
||||
pushEnumConstant(val,(TypeEnum *)ct,tag,vn,op);
|
||||
else
|
||||
push_integer(val,ct->getSize(),false,vn,op);
|
||||
push_integer(val,ct->getSize(),false,tag,vn,op);
|
||||
return;
|
||||
case TYPE_INT:
|
||||
if (ct->isCharPrint())
|
||||
pushCharConstant(val,(TypeChar *)ct,vn,op);
|
||||
pushCharConstant(val,(TypeChar *)ct,tag,vn,op);
|
||||
else if (ct->isEnumType())
|
||||
pushEnumConstant(val,(TypeEnum *)ct,vn,op);
|
||||
pushEnumConstant(val,(TypeEnum *)ct,tag,vn,op);
|
||||
else
|
||||
push_integer(val,ct->getSize(),true,vn,op);
|
||||
push_integer(val,ct->getSize(),true,tag,vn,op);
|
||||
return;
|
||||
case TYPE_UNKNOWN:
|
||||
push_integer(val,ct->getSize(),false,vn,op);
|
||||
push_integer(val,ct->getSize(),false,tag,vn,op);
|
||||
return;
|
||||
case TYPE_BOOL:
|
||||
pushBoolConstant(val,(const TypeBase *)ct,vn,op);
|
||||
pushBoolConstant(val,(const TypeBase *)ct,tag,vn,op);
|
||||
return;
|
||||
case TYPE_VOID:
|
||||
clear();
|
||||
|
|
@ -1712,7 +1708,7 @@ void PrintC::pushConstant(uintb val,const Datatype *ct,
|
|||
}
|
||||
break;
|
||||
case TYPE_FLOAT:
|
||||
push_float(val,ct->getSize(),vn,op);
|
||||
push_float(val,ct->getSize(),tag,vn,op);
|
||||
return;
|
||||
case TYPE_SPACEBASE:
|
||||
case TYPE_CODE:
|
||||
|
|
@ -1731,7 +1727,7 @@ void PrintC::pushConstant(uintb val,const Datatype *ct,
|
|||
pushMod();
|
||||
if (!isSet(force_dec))
|
||||
setMod(force_hex);
|
||||
push_integer(val,ct->getSize(),false,vn,op);
|
||||
push_integer(val,ct->getSize(),false,tag,vn,op);
|
||||
popMod();
|
||||
}
|
||||
|
||||
|
|
@ -1765,14 +1761,14 @@ bool PrintC::pushEquate(uintb val,int4 sz,const EquateSymbol *sym,const Varnode
|
|||
if (modval == val) {
|
||||
pushOp(&binary_plus,(const PcodeOp *)0);
|
||||
pushSymbol(sym,vn,op);
|
||||
push_integer(1, sz, false, (const Varnode *)0, (const PcodeOp *)0);
|
||||
push_integer(1, sz, false, syntax, (const Varnode *)0, (const PcodeOp *)0);
|
||||
return true;
|
||||
}
|
||||
modval = (baseval - 1) & mask;
|
||||
if (modval == val) {
|
||||
pushOp(&binary_minus,(const PcodeOp *)0);
|
||||
pushSymbol(sym,vn,op);
|
||||
push_integer(1, sz, false, (const Varnode *)0, (const PcodeOp *)0);
|
||||
push_integer(1, sz, false, syntax, (const Varnode *)0, (const PcodeOp *)0);
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
|
|
@ -2092,8 +2088,7 @@ void PrintC::emitEnumDefinition(const TypeEnum *ct)
|
|||
emit->spaces(1);
|
||||
emit->print(EQUALSIGN,EmitMarkup::no_color);
|
||||
emit->spaces(1);
|
||||
push_integer((*iter).first,ct->getSize(),sign,(Varnode *)0,
|
||||
(PcodeOp *)0);
|
||||
push_integer((*iter).first,ct->getSize(),sign,syntax,(Varnode *)0,(PcodeOp *)0);
|
||||
recurse();
|
||||
emit->print(SEMICOLON);
|
||||
++iter;
|
||||
|
|
@ -3087,12 +3082,15 @@ void PrintC::emitSwitchCase(int4 casenum,const BlockSwitch *switchbl)
|
|||
int4 i,num;
|
||||
uintb val;
|
||||
const Datatype *ct;
|
||||
const PcodeOp *op;
|
||||
|
||||
ct = switchbl->getSwitchType();
|
||||
op = switchbl->getCaseBlock(casenum)->firstOp();
|
||||
|
||||
if (switchbl->isDefaultCase(casenum)) {
|
||||
val = switchbl->getLabel(casenum,0);
|
||||
emit->tagLine();
|
||||
emit->print(KEYWORD_DEFAULT,EmitMarkup::keyword_color);
|
||||
emit->tagCaseLabel(KEYWORD_DEFAULT, EmitMarkup::keyword_color, op, val);
|
||||
emit->print(COLON);
|
||||
}
|
||||
else {
|
||||
|
|
@ -3102,7 +3100,7 @@ void PrintC::emitSwitchCase(int4 casenum,const BlockSwitch *switchbl)
|
|||
emit->tagLine();
|
||||
emit->print(KEYWORD_CASE,EmitMarkup::keyword_color);
|
||||
emit->spaces(1);
|
||||
pushConstant(val,ct,(Varnode *)0,(PcodeOp *)0);
|
||||
pushConstant(val,ct,casetoken,(Varnode *)0,op);
|
||||
recurse();
|
||||
emit->print(COLON);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -159,12 +159,12 @@ protected:
|
|||
void emitSymbolScope(const Symbol *symbol); ///< Emit tokens resolving a symbol's scope
|
||||
virtual void pushTypeStart(const Datatype *ct,bool noident); ///< Push part of a data-type declaration onto the RPN stack, up to the identifier
|
||||
virtual void pushTypeEnd(const Datatype *ct); ///< Push the tail ends of a data-type declaration onto the RPN stack
|
||||
void pushBoolConstant(uintb val,const TypeBase *ct,const Varnode *vn,
|
||||
const PcodeOp *op);
|
||||
void pushCharConstant(uintb val,const Datatype *ct,const Varnode *vn,
|
||||
const PcodeOp *op);
|
||||
void pushEnumConstant(uintb val,const TypeEnum *ct,const Varnode *vn,
|
||||
const PcodeOp *op);
|
||||
void pushBoolConstant(uintb val,const TypeBase *ct,tagtype tag,const Varnode *vn,
|
||||
const PcodeOp *op);
|
||||
void pushCharConstant(uintb val,const Datatype *ct,tagtype tag,const Varnode *vn,
|
||||
const PcodeOp *op);
|
||||
void pushEnumConstant(uintb val,const TypeEnum *ct,tagtype tag,const Varnode *vn,
|
||||
const PcodeOp *op);
|
||||
virtual bool pushPtrCharConstant(uintb val,const TypePointer *ct,const Varnode *vn,
|
||||
const PcodeOp *op);
|
||||
bool pushPtrCodeConstant(uintb val,const TypePointer *ct,const Varnode *vn,
|
||||
|
|
@ -196,10 +196,10 @@ protected:
|
|||
bool printCharacterConstant(ostream &s,const Address &addr,Datatype *charType) const;
|
||||
int4 getHiddenThisSlot(const PcodeOp *op,FuncProto *fc); ///< Get position of "this" pointer needing to be hidden
|
||||
void resetDefaultsPrintC(void); ///< Set default values for options specific to PrintC
|
||||
virtual void pushConstant(uintb val,const Datatype *ct,
|
||||
virtual void pushConstant(uintb val,const Datatype *ct,tagtype tag,
|
||||
const Varnode *vn,const PcodeOp *op);
|
||||
virtual bool pushEquate(uintb val,int4 sz,const EquateSymbol *sym,
|
||||
const Varnode *vn,const PcodeOp *op);
|
||||
const Varnode *vn,const PcodeOp *op);
|
||||
virtual void pushAnnotation(const Varnode *vn,const PcodeOp *op);
|
||||
virtual void pushSymbol(const Symbol *sym,const Varnode *vn,const PcodeOp *op);
|
||||
virtual void pushUnnamedLocation(const Address &addr,
|
||||
|
|
@ -209,10 +209,10 @@ protected:
|
|||
virtual void pushMismatchSymbol(const Symbol *sym,int4 off,int4 sz,
|
||||
const Varnode *vn,const PcodeOp *op);
|
||||
virtual void pushImpliedField(const Varnode *vn,const PcodeOp *op);
|
||||
virtual void push_integer(uintb val,int4 sz,bool sign,
|
||||
virtual void push_integer(uintb val,int4 sz,bool sign,tagtype tag,
|
||||
const Varnode *vn,
|
||||
const PcodeOp *op);
|
||||
virtual void push_float(uintb val,int4 sz,const Varnode *vn,
|
||||
virtual void push_float(uintb val,int4 sz,tagtype tag,const Varnode *vn,
|
||||
const PcodeOp *op);
|
||||
virtual void printUnicode(ostream &s,int4 onechar) const;
|
||||
virtual void pushType(const Datatype *ct);
|
||||
|
|
|
|||
|
|
@ -234,7 +234,7 @@ void PrintJava::opLoad(const PcodeOp *op)
|
|||
pushOp(&subscript,op);
|
||||
pushVn(op->getIn(1),op,m);
|
||||
if (printArrayRef)
|
||||
push_integer(0,4,false,(Varnode *)0,op);
|
||||
push_integer(0,4,false,syntax,(Varnode *)0,op);
|
||||
}
|
||||
|
||||
void PrintJava::opStore(const PcodeOp *op)
|
||||
|
|
@ -245,7 +245,7 @@ void PrintJava::opStore(const PcodeOp *op)
|
|||
if (needZeroArray(op->getIn(1))) {
|
||||
pushOp(&subscript,op);
|
||||
pushVn(op->getIn(1),op,m);
|
||||
push_integer(0,4,false,(Varnode *)0,op);
|
||||
push_integer(0,4,false,syntax,(Varnode *)0,op);
|
||||
pushVn(op->getIn(2),op,mods);
|
||||
}
|
||||
else {
|
||||
|
|
|
|||
|
|
@ -223,7 +223,7 @@ void PrintLanguage::pushVnExplicit(const Varnode *vn,const PcodeOp *op)
|
|||
return;
|
||||
}
|
||||
if (vn->isConstant()) {
|
||||
pushConstant(vn->getOffset(),vn->getHighTypeReadFacing(op),vn,op);
|
||||
pushConstant(vn->getOffset(),vn->getHighTypeReadFacing(op),vartoken,vn,op);
|
||||
return;
|
||||
}
|
||||
pushSymbolDetail(vn,op,true);
|
||||
|
|
@ -394,6 +394,9 @@ void PrintLanguage::emitAtom(const Atom &atom)
|
|||
case fieldtoken:
|
||||
emit->tagField(atom.name,atom.highlight,atom.ptr_second.ct,atom.offset,atom.op);
|
||||
break;
|
||||
case casetoken:
|
||||
emit->tagCaseLabel(atom.name, atom.highlight, atom.op, atom.ptr_second.intValue);
|
||||
break;
|
||||
case blanktoken:
|
||||
break; // Print nothing
|
||||
}
|
||||
|
|
|
|||
|
|
@ -167,6 +167,7 @@ public:
|
|||
optoken, ///< Emit atom as operator
|
||||
typetoken, ///< Emit atom as operator
|
||||
fieldtoken, ///< Emit atom as structure field
|
||||
casetoken, ///< Emit atom as a \e case label
|
||||
blanktoken ///< For anonymous types
|
||||
};
|
||||
|
||||
|
|
@ -215,6 +216,7 @@ public:
|
|||
const Varnode *vn; ///< A Varnode associated with the token
|
||||
const Funcdata *fd; ///< A function associated with the token
|
||||
const Datatype *ct; ///< A type associated with the token
|
||||
uintb intValue; ///< An integer value associated with the token
|
||||
} ptr_second; ///< Other meta-data associated with the token
|
||||
int4 offset; ///< The offset (within the parent structure) for a \e field token
|
||||
|
||||
|
|
@ -241,6 +243,19 @@ public:
|
|||
/// \brief Construct a token for a function name
|
||||
Atom(const string &nm,tagtype t,EmitMarkup::syntax_highlight hl,const PcodeOp *o,const Funcdata *f)
|
||||
: name(nm) { type=t; highlight = hl; op = o; ptr_second.fd = f; }
|
||||
|
||||
/// \brief Construct a token with an associated PcodeOp, Varnode, and constant value
|
||||
Atom(const string &nm,tagtype t,EmitMarkup::syntax_highlight hl,const PcodeOp *o,const Varnode *v,uintb intValue)
|
||||
: name(nm) {
|
||||
type=t;
|
||||
highlight = hl;
|
||||
if (t==casetoken)
|
||||
ptr_second.intValue = intValue;
|
||||
else
|
||||
ptr_second.vn = v;
|
||||
op = o;
|
||||
}
|
||||
|
||||
};
|
||||
private:
|
||||
string name; ///< The name of the high-level language
|
||||
|
|
@ -308,9 +323,10 @@ protected:
|
|||
/// The value is ultimately emitted based on its data-type and other associated mark-up
|
||||
/// \param val is the value of the constant
|
||||
/// \param ct is the data-type of the constant
|
||||
/// \param tag is the type of token associated with the constant
|
||||
/// \param vn is the Varnode holding the constant (optional)
|
||||
/// \param op is the PcodeOp using the constant (optional)
|
||||
virtual void pushConstant(uintb val,const Datatype *ct,
|
||||
virtual void pushConstant(uintb val,const Datatype *ct,tagtype tag,
|
||||
const Varnode *vn,const PcodeOp *op)=0;
|
||||
|
||||
/// \brief Push a constant marked up by and EquateSymbol onto the RPN stack
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue