Ghidra-Decompiler-Analysis-Engine-Document/op_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 __CPUI_OP__

#define __CPUI_OP__


#include "typeop.hh"


class IopSpace : public AddrSpace {

public:

  IopSpace(AddrSpaceManager *m,const Translate *t,const string &nm,int4 ind);

  virtual void saveXmlAttributes(ostream &s,uintb offset) const { s << " space=\"iop\""; }

  virtual void saveXmlAttributes(ostream &s,uintb offset,int4 size) const { s << " space=\"iop\""; }

  virtual void printRaw(ostream &s,uintb offset) const;

  virtual void saveXml(ostream &s) const;

  virtual void restoreXml(const Element *el);

};


class PcodeOp {

  friend class BlockBasic; // Just insert_before, insert_after, setOrder

  friend class Funcdata;

  friend class PcodeOpBank;

  friend class VarnodeBank;    // Only uses setInput

public:

  enum {

    startbasic = 1,

    branch = 2,

    call = 4,

    returns = 0x8,

    nocollapse = 0x10,

    dead = 0x20,

    marker = 0x40,

    booloutput = 0x80,

    boolean_flip = 0x100,

    fallthru_true = 0x200,

    indirect_source = 0x400,

    coderef = 0x800,

    startmark = 0x1000,

    mark = 0x2000,

    commutative = 0x4000,

    unary = 0x8000,

    binary = 0x10000,

    special = 0x20000,

    ternary = 0x40000,

    splittingbranch = 0x80000,

    nonprinting = 0x100000,

    halt = 0x200000,

    badinstruction = 0x400000,

    unimplemented = 0x800000,

    noreturn = 0x1000000,

    missing = 0x2000000,

    spacebase_ptr = 0x4000000,

    indirect_creation = 0x8000000,

    calculated_bool = 0x10000000,

    has_callspec = 0x20000000,

    ptrflow = 0x40000000,

    indirect_store = 0x80000000

  };

  enum {

    special_prop = 1,

    special_print = 2,

    modified = 4,

    warning = 8,

    incidental_copy = 0x10,

    is_cpool_transformed = 0x20

  };

private:

  TypeOp *opcode;

  mutable uint4 flags;

  mutable uint4 addlflags;

  SeqNum start;

  BlockBasic *parent;

  list<PcodeOp *>::iterator basiciter;

  list<PcodeOp *>::iterator insertiter;

  list<PcodeOp *>::iterator codeiter;

  Varnode *output;

  vector<Varnode *> inrefs;


  // Only used by Funcdata

  void setOpcode(TypeOp *t_op);

  void setOutput(Varnode *vn) { output = vn; }

  void clearInput(int4 slot) { inrefs[slot] = (Varnode *)0; }

  void setInput(Varnode *vn,int4 slot) { inrefs[slot] = vn; }

  void setFlag(uint4 fl) { flags |= fl; }

  void clearFlag(uint4 fl) { flags &= ~fl; }

  void setAdditionalFlag(uint4 fl) { addlflags |= fl; }

  void clearAdditionalFlag(uint4 fl) { addlflags &= ~fl; }

  void flipFlag(uint4 fl) { flags ^= fl; }

  void setNumInputs(int4 num);

  void removeInput(int4 slot);

  void insertInput(int4 slot);

  void setOrder(uintm ord) { start.setOrder(ord); }

  void setParent(BlockBasic *p) { parent = p; }

  void setBasicIter(list<PcodeOp *>::iterator iter) { basiciter = iter; }


public:

  PcodeOp(int4 s,const SeqNum &sq);

  ~PcodeOp(void) {}

  int4 numInput(void) const { return inrefs.size(); }

  Varnode *getOut(void) { return output; }

  const Varnode *getOut(void) const { return (const Varnode *) output; }

  Varnode *getIn(int4 slot) { return inrefs[slot]; }

  const Varnode *getIn(int4 slot) const { return (const Varnode *) inrefs[slot]; }

  const BlockBasic *getParent(void) const { return (const BlockBasic *) parent; }

  BlockBasic *getParent(void) { return parent; }

  const Address &getAddr(void) const { return start.getAddr(); }

  uintm getTime(void) const { return start.getTime(); }

  const SeqNum &getSeqNum(void) const { return start; }

  list<PcodeOp *>::iterator getInsertIter(void) const { return insertiter; }

  list<PcodeOp *>::iterator getBasicIter(void) const { return basiciter; }

  int4 getSlot(const Varnode *vn) const { int4 i,n; n=inrefs.size(); for(i=0;i<n;++i) if (inrefs[i]==vn) break; return i; }

  int4 getRepeatSlot(const Varnode *vn,int4 firstSlot,list<PcodeOp *>::const_iterator iter) const;

  uint4 getEvalType(void) const { return (flags&(PcodeOp::unary|PcodeOp::binary|PcodeOp::special|PcodeOp::ternary)); }

  uint4 getHaltType(void) const { return (flags&(PcodeOp::halt|PcodeOp::badinstruction|PcodeOp::unimplemented|

                          PcodeOp::noreturn|PcodeOp::missing)); }

  bool isDead(void) const { return ((flags&PcodeOp::dead)!=0); }

  bool isAssignment(void) const { return (output!=(Varnode *)0); }

  bool isCall(void) const { return ((flags&PcodeOp::call)!=0); }

  bool isCallWithoutSpec(void) const { return ((flags&(PcodeOp::call|PcodeOp::has_callspec))==PcodeOp::call); }

  bool isMarker(void) const { return ((flags&PcodeOp::marker)!=0); }

  bool isIndirectCreation(void) const { return ((flags&PcodeOp::indirect_creation)!=0); }

  bool isIndirectStore(void) const { return ((flags&PcodeOp::indirect_store)!=0); }

  bool notPrinted(void) const { return ((flags&(PcodeOp::marker|PcodeOp::nonprinting|PcodeOp::noreturn))!=0); }

  bool isBoolOutput(void) const { return ((flags&PcodeOp::booloutput)!=0); }

  bool isBranch(void) const { return ((flags&PcodeOp::branch)!=0); }

  bool isCallOrBranch(void) const { return ((flags&(PcodeOp::branch|PcodeOp::call))!=0); }

  bool isFlowBreak(void) const { return ((flags&(PcodeOp::branch|PcodeOp::returns))!=0); }

  bool isBooleanFlip(void) const { return ((flags&PcodeOp::boolean_flip)!=0); }

  bool isFallthruTrue(void) const { return ((flags&PcodeOp::fallthru_true)!=0); }

  bool isCodeRef(void) const { return ((flags&PcodeOp::coderef)!=0); }

  bool isInstructionStart(void) const { return ((flags&PcodeOp::startmark)!=0); }

  bool isBlockStart(void) const { return ((flags&PcodeOp::startbasic)!=0); }

  bool isModified(void) const { return ((addlflags&PcodeOp::modified)!=0); }

  bool isMark(void) const { return ((flags&PcodeOp::mark)!=0); }

  void setMark(void) const { flags |= PcodeOp::mark; }

  bool isWarning(void) const { return ((addlflags&PcodeOp::warning)!=0); }

  void clearMark(void) const { flags &= ~PcodeOp::mark; }

  bool isIndirectSource(void) const { return ((flags&PcodeOp::indirect_source)!=0); }

  void setIndirectSource(void) { flags |= PcodeOp::indirect_source; }

  void clearIndirectSource(void) { flags &= ~PcodeOp::indirect_source; }

  bool isPtrFlow(void) const { return ((flags&PcodeOp::ptrflow)!=0); }

  void setPtrFlow(void) { flags |= PcodeOp::ptrflow; }

  bool isSplitting(void) const { return ((flags&PcodeOp::splittingbranch)!=0); }

  bool doesSpecialPropagation(void) const { return ((addlflags&PcodeOp::special_prop)!=0); }

  bool doesSpecialPrinting(void) const { return ((addlflags&PcodeOp::special_print)!=0); }

  bool isIncidentalCopy(void) const { return ((addlflags&PcodeOp::incidental_copy)!=0); }

  bool isCalculatedBool(void) const { return ((flags&(PcodeOp::calculated_bool|PcodeOp::booloutput))!=0); }

  bool isCpoolTransformed(void) const { return ((addlflags&PcodeOp::is_cpool_transformed)!=0); }

  bool isCollapsible(void) const;

  bool usesSpacebasePtr(void) const { return ((flags&PcodeOp::spacebase_ptr)!=0); }

  uintm getCseHash(void) const;

  bool isCseMatch(const PcodeOp *op) const;

  bool isMoveable(const PcodeOp *point) const;

  TypeOp *getOpcode(void) const { return opcode; }

  OpCode code(void) const { return opcode->getOpcode(); }

  bool isCommutative(void) const { return ((flags & PcodeOp::commutative)!=0); }

  uintb collapse(bool &markedInput) const;

  void collapseConstantSymbol(Varnode *newConst) const;

  PcodeOp *nextOp(void) const;

  PcodeOp *previousOp(void) const;

  PcodeOp *target(void) const;

  uintb getNZMaskLocal(bool cliploop) const;

  int4 compareOrder(const PcodeOp *bop) const;

  void printRaw(ostream &s) const { opcode->printRaw(s,this); }

  const string &getOpName(void) const { return opcode->getName(); }

  void printDebug(ostream &s) const;

  void saveXml(ostream &s) const;

  static PcodeOp *getOpFromConst(const Address &addr) { return (PcodeOp *)(uintp)addr.getOffset(); }


  Datatype *outputTypeLocal(void) const { return opcode->getOutputLocal(this); }

  Datatype *inputTypeLocal(int4 slot) const { return opcode->getInputLocal(this,slot); }

  bool markExplicitUnsigned(int4 slot) { return opcode->markExplicitUnsigned(this,slot); }

  bool inheritsSign(void) const { return opcode->inheritsSign(); }

};


struct PcodeOpNode {

  PcodeOp *op;

  int4 slot;

  PcodeOpNode(void) { op = (PcodeOp *)0; slot = 0; }

  PcodeOpNode(PcodeOp *o,int4 s) { op = o; slot = s; }

};


typedef map<SeqNum,PcodeOp *> PcodeOpTree;


class PcodeOpBank {

  PcodeOpTree optree;

  list<PcodeOp *> deadlist;

  list<PcodeOp *> alivelist;

  list<PcodeOp *> storelist;

  list<PcodeOp *> loadlist;

  list<PcodeOp *> returnlist;

  list<PcodeOp *> useroplist;

  list<PcodeOp *> deadandgone;

  uintm uniqid;

  void addToCodeList(PcodeOp *op);

  void removeFromCodeList(PcodeOp *op);

  void clearCodeLists(void);

public:

  void clear(void);

  PcodeOpBank(void) { uniqid = 0; }

  ~PcodeOpBank(void) { clear(); }

  void setUniqId(uintm val) { uniqid = val; }

  uintm getUniqId(void) const { return uniqid; }

  PcodeOp *create(int4 inputs,const Address &pc);

  PcodeOp *create(int4 inputs,const SeqNum &sq);

  void destroy(PcodeOp *op);

  void destroyDead(void);

  void changeOpcode(PcodeOp *op,TypeOp *newopc);

  void markAlive(PcodeOp *op);

  void markDead(PcodeOp *op);

  void insertAfterDead(PcodeOp *op,PcodeOp *prev);

  void moveSequenceDead(PcodeOp *firstop,PcodeOp *lastop,PcodeOp *prev);

  void markIncidentalCopy(PcodeOp *firstop,PcodeOp *lastop);

  bool empty(void) const { return optree.empty(); }

  PcodeOp *target(const Address &addr) const;

  PcodeOp *findOp(const SeqNum &num) const;

  PcodeOp *fallthru(const PcodeOp *op) const;


  PcodeOpTree::const_iterator beginAll(void) const { return optree.begin(); }


  PcodeOpTree::const_iterator endAll(void) const { return optree.end(); }


  PcodeOpTree::const_iterator begin(const Address &addr) const;


  PcodeOpTree::const_iterator end(const Address &addr) const;


  list<PcodeOp *>::const_iterator beginAlive(void) const { return alivelist.begin(); }


  list<PcodeOp *>::const_iterator endAlive(void) const { return alivelist.end(); }


  list<PcodeOp *>::const_iterator beginDead(void) const { return deadlist.begin(); }


  list<PcodeOp *>::const_iterator endDead(void) const { return deadlist.end(); }


  list<PcodeOp *>::const_iterator begin(OpCode opc) const;


  list<PcodeOp *>::const_iterator end(OpCode opc) const;

};


extern int4 functionalEqualityLevel(Varnode *vn1,Varnode *vn2,Varnode **res1,Varnode **res2);

extern bool functionalEquality(Varnode *vn1,Varnode *vn2);

extern bool functionalDifference(Varnode *vn1,Varnode *vn2,int4 depth);


#endif