Ghidra-Decompiler-Analysis-Engine-Document/printc_8hh_source.html

/* ###

 * 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 __PRINTC__

#define __PRINTC__


#include "printlanguage.hh"

#include "comment.hh"


class FuncProto;

class JumpTable;


class PrintCCapability : public PrintLanguageCapability {

  static PrintCCapability printCCapability;

  PrintCCapability(void);

  PrintCCapability(const PrintCCapability &op2);

  PrintCCapability &operator=(const PrintCCapability &op);

public:

  virtual PrintLanguage *buildLanguage(Architecture *glb);

};


struct PartialSymbolEntry {

  const OpToken *token;

  const TypeField *field;

  const Datatype *parent;

  string fieldname;

  EmitXml::syntax_highlight hilite;

};


class PrintC : public PrintLanguage {

protected:

  static OpToken hidden;

  static OpToken scope;

  static OpToken object_member;

  static OpToken pointer_member;

  static OpToken subscript;

  static OpToken function_call;

  static OpToken bitwise_not;

  static OpToken boolean_not;

  static OpToken unary_minus;

  static OpToken unary_plus;

  static OpToken addressof;

  static OpToken dereference;

  static OpToken typecast;

  static OpToken multiply;

  static OpToken divide;

  static OpToken modulo;

  static OpToken binary_plus;

  static OpToken binary_minus;

  static OpToken shift_left;

  static OpToken shift_right;

  static OpToken shift_sright;

  static OpToken less_than;

  static OpToken less_equal;

  static OpToken greater_than;

  static OpToken greater_equal;

  static OpToken equal;

  static OpToken not_equal;

  static OpToken bitwise_and;

  static OpToken bitwise_xor;

  static OpToken bitwise_or;

  static OpToken boolean_and;

  static OpToken boolean_or;

  static OpToken boolean_xor;

  static OpToken assignment;

  static OpToken comma;

  static OpToken new_op;

  static OpToken multequal;

  static OpToken divequal;

  static OpToken remequal;

  static OpToken plusequal;

  static OpToken minusequal;

  static OpToken leftequal;

  static OpToken rightequal;

  static OpToken andequal;

  static OpToken orequal;

  static OpToken xorequal;

  static OpToken type_expr_space;

  static OpToken type_expr_nospace;

  static OpToken ptr_expr;

  static OpToken array_expr;

  static OpToken enum_cat;

  bool option_NULL;

  bool option_inplace_ops;

  bool option_convention;

  bool option_nocasts;

  bool option_unplaced;

  bool option_hide_exts;

  string nullToken;

  CommentSorter commsorter;


  // Routines that are specific to C/C++

  void buildTypeStack(const Datatype *ct,vector<const Datatype *> &typestack);

  void pushPrototypeInputs(const FuncProto *proto);

  void pushSymbolScope(const Symbol *symbol);

  void emitSymbolScope(const Symbol *symbol);

  virtual void pushTypeStart(const Datatype *ct,bool noident);

  virtual void pushTypeEnd(const Datatype *ct);

  void pushBoolConstant(uintb val,const TypeBase *ct,const Varnode *vn,

              const PcodeOp *op);

  void pushCharConstant(uintb val,const TypeChar *ct,const Varnode *vn,

              const PcodeOp *op);

  void pushEnumConstant(uintb val,const TypeEnum *ct,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,

               const PcodeOp *op);

  virtual bool doEmitWideCharPrefix(void) const;


  bool checkArrayDeref(const Varnode *vn) const;

  void emitStructDefinition(const TypeStruct *ct);

  void emitEnumDefinition(const TypeEnum *ct);

  void emitPrototypeOutput(const FuncProto *proto,const Funcdata *fd);

  void emitPrototypeInputs(const FuncProto *proto);

  void emitGlobalVarDeclsRecursive(Scope *scope);

  void emitLocalVarDecls(const Funcdata *fd);

  void emitStatement(const PcodeOp *inst);

  bool emitInplaceOp(const PcodeOp *op);

  void emitGotoStatement(const FlowBlock *bl,const FlowBlock *exp_bl,uint4 type);

  void emitSwitchCase(int4 casenum,const BlockSwitch *switchbl);

  void emitLabel(const FlowBlock *bl);

  void emitLabelStatement(const FlowBlock *bl);

  void emitAnyLabelStatement(const FlowBlock *bl);

  void emitCommentGroup(const PcodeOp *inst);

  void emitCommentBlockTree(const FlowBlock *bl);

  void emitCommentFuncHeader(const Funcdata *fd);

  void emitForLoop(const BlockWhileDo *bl);

  void opFunc(const PcodeOp *op);

  void opTypeCast(const PcodeOp *op);

  void opHiddenFunc(const PcodeOp *op);

  bool printCharacterConstant(ostream &s,const Address &addr,Datatype *charType) const;

  int4 getHiddenThisSlot(const PcodeOp *op,FuncProto *fc);

  void resetDefaultsPrintC(void);

  virtual void pushConstant(uintb val,const Datatype *ct,

                const Varnode *vn,const PcodeOp *op);

  virtual bool pushEquate(uintb val,int4 sz,const EquateSymbol *sym,

                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,

                   const Varnode *vn,const PcodeOp *op);

  virtual void pushPartialSymbol(const Symbol *sym,int4 off,int4 sz,

                 const Varnode *vn,const PcodeOp *op,Datatype *outtype);

  virtual void pushMismatchSymbol(const Symbol *sym,int4 off,int4 sz,

                  const Varnode *vn,const PcodeOp *op);

  virtual void push_integer(uintb val,int4 sz,bool sign,

                const Varnode *vn,

                const PcodeOp *op);

  virtual void push_float(uintb val,int4 sz,const Varnode *vn,

              const PcodeOp *op);

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

  virtual void pushType(const Datatype *ct);

  virtual string genericFunctionName(const Address &addr);

  virtual string genericTypeName(const Datatype *ct);


  virtual void emitExpression(const PcodeOp *op);

  virtual void emitVarDecl(const Symbol *sym);

  virtual void emitVarDeclStatement(const Symbol *sym);

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

  virtual void emitFunctionDeclaration(const Funcdata *fd);

  virtual void emitTypeDefinition(const Datatype *ct);

  virtual bool checkPrintNegation(const Varnode *vn);

public:

  PrintC(Architecture *g,const string &nm="c-language");

  void setNULLPrinting(bool val) { option_NULL = val; }

  void setInplaceOps(bool val) { option_inplace_ops = val; }

  void setConvention(bool val) { option_convention = val; }

  void setNoCastPrinting(bool val) { option_nocasts = val; }

  void setCStyleComments(void) { setCommentDelimeter("/* "," */",false); }

  void setCPlusPlusStyleComments(void) { setCommentDelimeter("// ","",true); }

  void setDisplayUnplaced(bool val) { option_unplaced = val; }

  void setHideImpliedExts(bool val) { option_hide_exts = val; }

  virtual ~PrintC(void) {}

  virtual void resetDefaults(void);

  virtual void adjustTypeOperators(void);

  virtual void setCommentStyle(const string &nm);

  virtual void docTypeDefinitions(const TypeFactory *typegrp);

  virtual void docAllGlobals(void);

  virtual void docSingleGlobal(const Symbol *sym);

  virtual void docFunction(const Funcdata *fd);


  virtual void emitBlockBasic(const BlockBasic *bb);

  virtual void emitBlockGraph(const BlockGraph *bl);

  virtual void emitBlockCopy(const BlockCopy *bl);

  virtual void emitBlockGoto(const BlockGoto *bl);

  virtual void emitBlockLs(const BlockList *bl);

  virtual void emitBlockCondition(const BlockCondition *bl);

  virtual void emitBlockIf(const BlockIf *bl);

  virtual void emitBlockWhileDo(const BlockWhileDo *bl);

  virtual void emitBlockDoWhile(const BlockDoWhile *bl);

  virtual void emitBlockInfLoop(const BlockInfLoop *bl);

  virtual void emitBlockSwitch(const BlockSwitch *bl);


  virtual void opCopy(const PcodeOp *op);

  virtual void opLoad(const PcodeOp *op);

  virtual void opStore(const PcodeOp *op);

  virtual void opBranch(const PcodeOp *op);

  virtual void opCbranch(const PcodeOp *op);

  virtual void opBranchind(const PcodeOp *op);

  virtual void opCall(const PcodeOp *op);

  virtual void opCallind(const PcodeOp *op);

  virtual void opCallother(const PcodeOp *op);

  virtual void opConstructor(const PcodeOp *op,bool withNew);

  virtual void opReturn(const PcodeOp *op);

  virtual void opIntEqual(const PcodeOp *op) { opBinary(&equal,op); }

  virtual void opIntNotEqual(const PcodeOp *op) { opBinary(&not_equal,op); }

  virtual void opIntSless(const PcodeOp *op) { opBinary(&less_than,op); }

  virtual void opIntSlessEqual(const PcodeOp *op) { opBinary(&less_equal,op); }

  virtual void opIntLess(const PcodeOp *op) { opBinary(&less_than,op); }

  virtual void opIntLessEqual(const PcodeOp *op) { opBinary(&less_equal,op); }

  virtual void opIntZext(const PcodeOp *op,const PcodeOp *readOp);

  virtual void opIntSext(const PcodeOp *op,const PcodeOp *readOp);

  virtual void opIntAdd(const PcodeOp *op) { opBinary(&binary_plus,op); }

  virtual void opIntSub(const PcodeOp *op) { opBinary(&binary_minus,op); }

  virtual void opIntCarry(const PcodeOp *op) { opFunc(op); }

  virtual void opIntScarry(const PcodeOp *op) { opFunc(op); }

  virtual void opIntSborrow(const PcodeOp *op) { opFunc(op); }

  virtual void opInt2Comp(const PcodeOp *op) { opUnary(&unary_minus,op); }

  virtual void opIntNegate(const PcodeOp *op) { opUnary(&bitwise_not,op); }

  virtual void opIntXor(const PcodeOp *op) { opBinary(&bitwise_xor,op); }

  virtual void opIntAnd(const PcodeOp *op) { opBinary(&bitwise_and,op); }

  virtual void opIntOr(const PcodeOp *op) { opBinary(&bitwise_or,op); }

  virtual void opIntLeft(const PcodeOp *op) { opBinary(&shift_left,op); }

  virtual void opIntRight(const PcodeOp *op) { opBinary(&shift_right,op); }

  virtual void opIntSright(const PcodeOp *op) { opBinary(&shift_sright,op); }

  virtual void opIntMult(const PcodeOp *op) { opBinary(&multiply,op); }

  virtual void opIntDiv(const PcodeOp *op) { opBinary(&divide,op); }

  virtual void opIntSdiv(const PcodeOp *op) { opBinary(&divide,op); }

  virtual void opIntRem(const PcodeOp *op) { opBinary(&modulo,op); }

  virtual void opIntSrem(const PcodeOp *op) { opBinary(&modulo,op); }

  virtual void opBoolNegate(const PcodeOp *op);

  virtual void opBoolXor(const PcodeOp *op) { opBinary(&boolean_xor,op); }

  virtual void opBoolAnd(const PcodeOp *op) { opBinary(&boolean_and,op); }

  virtual void opBoolOr(const PcodeOp *op) { opBinary(&boolean_or,op); }

  virtual void opFloatEqual(const PcodeOp *op) { opBinary(&equal,op); }

  virtual void opFloatNotEqual(const PcodeOp *op) { opBinary(&not_equal,op); }

  virtual void opFloatLess(const PcodeOp *op) { opBinary(&less_than,op); }

  virtual void opFloatLessEqual(const PcodeOp *op) { opBinary(&less_equal,op); }

  virtual void opFloatNan(const PcodeOp *op) { opFunc(op); }

  virtual void opFloatAdd(const PcodeOp *op) { opBinary(&binary_plus,op); }

  virtual void opFloatDiv(const PcodeOp *op) { opBinary(&divide,op); }

  virtual void opFloatMult(const PcodeOp *op) { opBinary(&multiply,op); }

  virtual void opFloatSub(const PcodeOp *op) { opBinary(&binary_minus,op); }

  virtual void opFloatNeg(const PcodeOp *op) { opUnary(&unary_minus,op); }

  virtual void opFloatAbs(const PcodeOp *op) { opFunc(op); }

  virtual void opFloatSqrt(const PcodeOp *op) { opFunc(op); }

  virtual void opFloatInt2Float(const PcodeOp *op) { opTypeCast(op); }

  virtual void opFloatFloat2Float(const PcodeOp *op) { opTypeCast(op); }

  virtual void opFloatTrunc(const PcodeOp *op) { opTypeCast(op); }

  virtual void opFloatCeil(const PcodeOp *op) { opFunc(op); }

  virtual void opFloatFloor(const PcodeOp *op) { opFunc(op); }

  virtual void opFloatRound(const PcodeOp *op) { opFunc(op); }

  virtual void opMultiequal(const PcodeOp *op) {}

  virtual void opIndirect(const PcodeOp *op) {}

  virtual void opPiece(const PcodeOp *op) { opFunc(op); }

  virtual void opSubpiece(const PcodeOp *op);

  virtual void opCast(const PcodeOp *op) { opTypeCast(op); }

  virtual void opPtradd(const PcodeOp *op);

  virtual void opPtrsub(const PcodeOp *op);

  virtual void opSegmentOp(const PcodeOp *op);

  virtual void opCpoolRefOp(const PcodeOp *op);

  virtual void opNewOp(const PcodeOp *op);

  virtual void opInsertOp(const PcodeOp *op);

  virtual void opExtractOp(const PcodeOp *op);

  virtual void opPopcountOp(const PcodeOp *op) { opFunc(op); }

};


#endif