printlanguage.hh

Go to the documentation of this file.

/* ###
 * IP: GHIDRA
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 * 
 *      http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#ifndef __PRINT_LANGUAGE__
#define __PRINT_LANGUAGE__

#include "capability.hh"
#include "cast.hh"
#include "prettyprint.hh"

class PrintLanguage;

class PrintLanguageCapability : public CapabilityPoint {
  static vector<PrintLanguageCapability *> thelist; 
protected:
  string name;          
  bool isdefault;       
public:
  const string &getName(void) const { return name; }    
  virtual void initialize(void);

  virtual PrintLanguage *buildLanguage(Architecture *glb)=0;

  static PrintLanguageCapability *getDefault(void); 
  static PrintLanguageCapability *findCapability(const string &name);   
};

class BlockGraph;
class BlockBasic;
class BlockList;
class BlockCopy;
class BlockGoto;
class BlockIf;
class BlockCondition;
class BlockWhileDo;
class BlockDoWhile;
class BlockInfLoop;
class BlockSwitch;
class Scope;
class Symbol;
class EquateSymbol;
class Comment;

class OpToken {
public:
  enum tokentype {
    binary,         
    unary_prefix,       
    postsurround,       
    presurround,        
    space,          
    hiddenfunction      
  };
  const char *print;        
  int4 stage;           
  int4 precedence;      
  bool associative;     
  tokentype type;       
  int4 spacing;         
  int4 bump;            
  OpToken *negate;      
};

class PrintLanguage {
public:
  enum modifiers {
    force_hex = 1,      
    force_dec = 2,          
    bestfit = 4,            
    force_scinote = 8,      
    force_pointer = 0x10,   
    print_load_value = 0x20,    
    print_store_value = 0x40,   
    no_branch = 0x80,       
    only_branch = 0x100,    
    comma_separate = 0x200, 
    flat = 0x400,       
    falsebranch = 0x800,    
    nofallthru = 0x1000,        
    negatetoken = 0x2000,   
    hide_thisparam = 0x4000 
  };
  enum tagtype {
    syntax,         
    vartoken,           
    functoken,          
    optoken,            
    typetoken,          
    fieldtoken,         
    blanktoken          
  };

  struct ReversePolish {
    const OpToken *tok;     
    int4 visited;       
    bool paren;         
    const PcodeOp *op;      
    int4 id;            
    mutable int4 id2;       
  };

  struct NodePending {
    const Varnode *vn;      
    const PcodeOp *op;      
    uint4 vnmod;        

    NodePending(const Varnode *v,const PcodeOp *o,uint4 m) {
      vn = v; op = o; vnmod = m; }
  };

  struct Atom {
    const string &name;     
    tagtype type;       
    EmitXml::syntax_highlight highlight;    
    const PcodeOp *op;      
    union {
      const Varnode *vn;    
      const Funcdata *fd;   
      const Datatype *ct;   
    } ptr_second;       
    int4 offset;            

    Atom(const string &nm,tagtype t,EmitXml::syntax_highlight hl)
      : name(nm) { type = t; highlight = hl; }

    Atom(const string &nm,tagtype t,EmitXml::syntax_highlight hl,const Datatype *c)
      : name(nm) { type = t; highlight = hl; ptr_second.ct = c; }

    Atom(const string &nm,tagtype t,EmitXml::syntax_highlight hl,const Datatype *c,int4 off)
      : name(nm) { type = t; highlight = hl; ptr_second.ct = c; offset = off; }

    Atom(const string &nm,tagtype t,EmitXml::syntax_highlight hl,const PcodeOp *o)
      : name(nm) { type = t; highlight = hl; op = o; }

    Atom(const string &nm,tagtype t,EmitXml::syntax_highlight hl,const PcodeOp *o,const Varnode *v)
      : name(nm) { type=t; highlight = hl; ptr_second.vn = v; op = o; }

    Atom(const string &nm,tagtype t,EmitXml::syntax_highlight hl,const PcodeOp *o,const Funcdata *f)
      : name(nm) { type=t; highlight = hl; op = o; ptr_second.fd = f; }
  };
private:
  string name;              
  vector<uint4> modstack;       
  vector<Scope *> scopestack;       
  Scope *curscope;          
  vector<ReversePolish> revpol;     
  vector<NodePending> nodepend;     
  int4 pending;             
  int4 line_commentindent;      
  string commentstart;          
  string commentend;            
protected:
  Architecture *glb;            
  CastStrategy *castStrategy;       
  EmitXml *emit;            
  uint4 mods;               
  uint4 instr_comment_type;     
  uint4 head_comment_type;      
#ifdef CPUI_DEBUG
  bool isStackEmpty(void) const { return (nodepend.empty()&&revpol.empty()); }  
  bool isModStackEmpty(void) const { return modstack.empty(); }         
#endif
  // Routines that are probably consistent across languages
  bool isSet(uint4 m) const { return ((mods & m)!=0); }             
  void pushScope(Scope *sc) { scopestack.push_back(sc); curscope = sc; }    
  void popScope(void) { scopestack.pop_back(); curscope = scopestack.back(); }  
  void pushMod(void) { modstack.push_back(mods); }              
  void popMod(void) { mods = modstack.back(); modstack.pop_back(); }        
  void setMod(uint4 m) { mods |= m; }                       
  void unsetMod(uint4 m) { mods &= ~m; }                    
  void pushOp(const OpToken *tok,const PcodeOp *op);            
  void pushAtom(const Atom &atom);                  
  void pushVnImplied(const Varnode *vn,const PcodeOp *op,uint4 m);  
  void pushVnExplicit(const Varnode *vn,const PcodeOp *op);     
  void pushVnLHS(const Varnode *vn,const PcodeOp *op);          

  bool parentheses(const OpToken *op2); 
  void emitOp(const ReversePolish &entry);              
  void emitAtom(const Atom &atom);                  
  static bool unicodeNeedsEscape(int4 codepoint);           
  static void writeUtf8(ostream &s,int4 codepoint);         
  static int4 readUtf16(const uint1 *buf,bool bigend);          
  static int4 getCodepoint(const uint1 *buf,int4 charsize,bool bigend,int4 &skip);
  bool escapeCharacterData(ostream &s,const uint1 *buf,int4 count,int4 charsize,bool bigend) const;
  void recurse(void);                           
  void opBinary(const OpToken *tok,const PcodeOp *op);          
  void opUnary(const OpToken *tok,const PcodeOp *op);           
  int4 getPending(void) const { return pending; }           

  virtual void printUnicode(ostream &s,int4 onechar) const=0;

  virtual void pushType(const Datatype *ct)=0;

  virtual void pushConstant(uintb val,const Datatype *ct,
                const Varnode *vn,const PcodeOp *op)=0;

  virtual bool pushEquate(uintb val,int4 sz,const EquateSymbol *sym,const Varnode *vn,const PcodeOp *op)=0;

  virtual void pushAnnotation(const Varnode *vn,const PcodeOp *op)=0;

  virtual void pushSymbol(const Symbol *sym,const Varnode *vn,
              const PcodeOp *op)=0;

  virtual void pushUnnamedLocation(const Address &addr,
                   const Varnode *vn,const PcodeOp *op)=0;

  virtual void pushPartialSymbol(const Symbol *sym,int4 off,int4 sz,
                 const Varnode *vn,const PcodeOp *op,Datatype *outtype)=0;

  virtual void pushMismatchSymbol(const Symbol *sym,int4 off,int4 sz,
                  const Varnode *vn,const PcodeOp *op)=0;

  virtual void emitLineComment(int4 indent,const Comment *comm);    

  virtual void emitVarDecl(const Symbol *sym)=0;

  virtual void emitVarDeclStatement(const Symbol *sym)=0;

  virtual bool emitScopeVarDecls(const Scope *scope,int4 cat)=0;

  virtual void emitExpression(const PcodeOp *op)=0;

  virtual void emitFunctionDeclaration(const Funcdata *fd)=0;

  virtual bool checkPrintNegation(const Varnode *vn)=0;
public:
  PrintLanguage(Architecture *g,const string &nm);          
  virtual ~PrintLanguage(void);                     
  const string &getName(void) const { return name; }            
  CastStrategy *getCastStrategy(void) const { return castStrategy; }    
  ostream *getOutputStream(void) const { return emit->getOutputStream(); }  
  void setOutputStream(ostream *t) { emit->setOutputStream(t); }    
  void setScope(Scope *sc) { curscope = sc; }               
  void setMaxLineSize(int4 mls) { emit->setMaxLineSize(mls); }      
  void setIndentIncrement(int4 inc) { emit->setIndentIncrement(inc); }  
  void setLineCommentIndent(int4 val);                  
  void setCommentDelimeter(const string &start,const string &stop,
               bool usecommentfill);            
  uint4 getInstructionComment(void) const { return instr_comment_type; }    
  void setInstructionComment(uint4 val) { instr_comment_type = val; }   
  uint4 getHeaderComment(void) const { return head_comment_type; }  
  void setHeaderComment(uint4 val) { head_comment_type = val; }     
  bool emitsXml(void) const { return emit->emitsXml(); }        
  void setXML(bool val);                        
  void setFlat(bool val);                       

  virtual void adjustTypeOperators(void)=0;             
  virtual void clear(void);                     
  virtual void setIntegerFormat(const string &nm);          

  virtual void setCommentStyle(const string &nm)=0;

  virtual bool isCharacterConstant(const uint1 *buf,int4 size,int4 charsize) const=0;

  virtual void docTypeDefinitions(const TypeFactory *typegrp)=0;

  virtual void docAllGlobals(void)=0;

  virtual void docSingleGlobal(const Symbol *sym)=0;

  virtual void docFunction(const Funcdata *fd)=0;

  virtual void emitBlockBasic(const BlockBasic *bb)=0;          
  virtual void emitBlockGraph(const BlockGraph *bl)=0;          
  virtual void emitBlockCopy(const BlockCopy *bl)=0;            
  virtual void emitBlockGoto(const BlockGoto *bl)=0;            
  virtual void emitBlockLs(const BlockList *bl)=0;          
  virtual void emitBlockCondition(const BlockCondition *bl)=0;      
  virtual void emitBlockIf(const BlockIf *bl)=0;            
  virtual void emitBlockWhileDo(const BlockWhileDo *bl)=0;      
  virtual void emitBlockDoWhile(const BlockDoWhile *bl)=0;      
  virtual void emitBlockInfLoop(const BlockInfLoop *bl)=0;      
  virtual void emitBlockSwitch(const BlockSwitch *bl)=0;        

  virtual void opCopy(const PcodeOp *op)=0;             
  virtual void opLoad(const PcodeOp *op)=0;             
  virtual void opStore(const PcodeOp *op)=0;                
  virtual void opBranch(const PcodeOp *op)=0;               
  virtual void opCbranch(const PcodeOp *op)=0;              
  virtual void opBranchind(const PcodeOp *op)=0;            
  virtual void opCall(const PcodeOp *op)=0;             
  virtual void opCallind(const PcodeOp *op)=0;              
  virtual void opCallother(const PcodeOp *op)=0;            
  virtual void opConstructor(const PcodeOp *op,bool withNew)=0;     
  virtual void opReturn(const PcodeOp *op)=0;               
  virtual void opIntEqual(const PcodeOp *op)=0;             
  virtual void opIntNotEqual(const PcodeOp *op)=0;          
  virtual void opIntSless(const PcodeOp *op)=0;             
  virtual void opIntSlessEqual(const PcodeOp *op)=0;            
  virtual void opIntLess(const PcodeOp *op)=0;              
  virtual void opIntLessEqual(const PcodeOp *op)=0;         
  virtual void opIntZext(const PcodeOp *op,const PcodeOp *readOp)=0;    
  virtual void opIntSext(const PcodeOp *op,const PcodeOp *readOp)=0;    
  virtual void opIntAdd(const PcodeOp *op)=0;               
  virtual void opIntSub(const PcodeOp *op)=0;               
  virtual void opIntCarry(const PcodeOp *op)=0;             
  virtual void opIntScarry(const PcodeOp *op)=0;            
  virtual void opIntSborrow(const PcodeOp *op)=0;           
  virtual void opInt2Comp(const PcodeOp *op)=0;             
  virtual void opIntNegate(const PcodeOp *op)=0;            
  virtual void opIntXor(const PcodeOp *op)=0;               
  virtual void opIntAnd(const PcodeOp *op)=0;               
  virtual void opIntOr(const PcodeOp *op)=0;                
  virtual void opIntLeft(const PcodeOp *op)=0;              
  virtual void opIntRight(const PcodeOp *op)=0;             
  virtual void opIntSright(const PcodeOp *op)=0;            
  virtual void opIntMult(const PcodeOp *op)=0;              
  virtual void opIntDiv(const PcodeOp *op)=0;               
  virtual void opIntSdiv(const PcodeOp *op)=0;              
  virtual void opIntRem(const PcodeOp *op)=0;               
  virtual void opIntSrem(const PcodeOp *op)=0;              
  virtual void opBoolNegate(const PcodeOp *op)=0;           
  virtual void opBoolXor(const PcodeOp *op)=0;              
  virtual void opBoolAnd(const PcodeOp *op)=0;              
  virtual void opBoolOr(const PcodeOp *op)=0;               
  virtual void opFloatEqual(const PcodeOp *op)=0;           
  virtual void opFloatNotEqual(const PcodeOp *op)=0;            
  virtual void opFloatLess(const PcodeOp *op)=0;            
  virtual void opFloatLessEqual(const PcodeOp *op)=0;           
  virtual void opFloatNan(const PcodeOp *op)=0;             
  virtual void opFloatAdd(const PcodeOp *op)=0;             
  virtual void opFloatDiv(const PcodeOp *op)=0;             
  virtual void opFloatMult(const PcodeOp *op)=0;            
  virtual void opFloatSub(const PcodeOp *op)=0;             
  virtual void opFloatNeg(const PcodeOp *op)=0;             
  virtual void opFloatAbs(const PcodeOp *op)=0;             
  virtual void opFloatSqrt(const PcodeOp *op)=0;            
  virtual void opFloatInt2Float(const PcodeOp *op)=0;           
  virtual void opFloatFloat2Float(const PcodeOp *op)=0;         
  virtual void opFloatTrunc(const PcodeOp *op)=0;           
  virtual void opFloatCeil(const PcodeOp *op)=0;            
  virtual void opFloatFloor(const PcodeOp *op)=0;           
  virtual void opFloatRound(const PcodeOp *op)=0;           
  virtual void opMultiequal(const PcodeOp *op)=0;           
  virtual void opIndirect(const PcodeOp *op)=0;             
  virtual void opPiece(const PcodeOp *op)=0;                
  virtual void opSubpiece(const PcodeOp *op)=0;             
  virtual void opCast(const PcodeOp *op)=0;             
  virtual void opPtradd(const PcodeOp *op)=0;               
  virtual void opPtrsub(const PcodeOp *op)=0;               
  virtual void opSegmentOp(const PcodeOp *op)=0;            
  virtual void opCpoolRefOp(const PcodeOp *op)=0;           
  virtual void opNewOp(const PcodeOp *op)=0;                
  virtual void opInsertOp(const PcodeOp *op)=0;             
  virtual void opExtractOp(const PcodeOp *op)=0;            
  virtual void opPopcountOp(const PcodeOp *op)=0;           

  static int4 mostNaturalBase(uintb val);           
  static void formatBinary(ostream &s,uintb val);       
};

#endif