Ghidra-Decompiler-Analysis-Engine-Document/flow_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_FLOW__

#define __CPUI_FLOW__


#include "funcdata.hh"


class FlowInfo {

public:

  enum { ignore_outofbounds = 1,

     ignore_unimplemented = 2,

     error_outofbounds = 4,

     error_unimplemented = 8,

     error_reinterpreted = 0x10,

     error_toomanyinstructions = 0x20,

     unimplemented_present = 0x40,

     baddata_present = 0x80,

     outofbounds_present = 0x100,

     reinterpreted_present = 0x200,

     toomanyinstructions_present = 0x400,

     possible_unreachable = 0x1000,

     flow_forinline = 0x2000,

     record_jumploads = 0x4000

 };

private:

  struct VisitStat {

    SeqNum seqnum;

    int4 size;

  };

  Architecture *glb;

  Funcdata &data;

  PcodeOpBank &obank;

  BlockGraph &bblocks;

  vector<FuncCallSpecs *> &qlst;

  PcodeEmitFd emitter;

  vector<Address> unprocessed;

  vector<Address> addrlist;

  vector<PcodeOp *> tablelist;

  vector<PcodeOp *> injectlist;

  map<Address,VisitStat> visited;

  list<PcodeOp *> block_edge1;

  list<PcodeOp *> block_edge2;

  uint4 insn_count;

  uint4 insn_max;

  Address baddr;

  Address eaddr;

  Address minaddr;

  Address maxaddr;

  bool flowoverride_present;

  uint4 flags;

  Funcdata *inline_head;

  set<Address> *inline_recursion;

  set<Address> inline_base;

  bool hasPossibleUnreachable(void) const { return ((flags & possible_unreachable)!=0); }

  void setPossibleUnreachable(void) { flags |= possible_unreachable; }

  void clearProperties(void);

  bool seenInstruction(const Address &addr) const {

    return (visited.find(addr) != visited.end()); }

  PcodeOp *fallthruOp(PcodeOp *op) const;

  void newAddress(PcodeOp *from,const Address &to);

  void deleteRemainingOps(list<PcodeOp *>::const_iterator oiter);

  PcodeOp *xrefControlFlow(list<PcodeOp *>::const_iterator oiter,bool &startbasic,bool &isfallthru,FuncCallSpecs *fc);

  bool processInstruction(const Address &curaddr,bool &startbasic);

  void fallthru(void);

  PcodeOp *findRelTarget(PcodeOp *op,Address &res) const;

  void findUnprocessed(void);

  void dedupUnprocessed(void);

  void fillinBranchStubs(void);

  void collectEdges(void);

  void splitBasic(void);

  void connectBasic(void);

  bool setFallthruBound(Address &bound);

  void handleOutOfBounds(const Address &fromaddr,const Address &toaddr);

  PcodeOp *artificialHalt(const Address &addr,uint4 flag);

  void reinterpreted(const Address &addr);

  bool checkForFlowModification(FuncCallSpecs &fspecs);

  void queryCall(FuncCallSpecs &fspecs);

  bool setupCallSpecs(PcodeOp *op,FuncCallSpecs *fc);

  bool setupCallindSpecs(PcodeOp *op,bool tryoverride,FuncCallSpecs *fc);

  void xrefInlinedBranch(PcodeOp *op);

  void doInjection(InjectPayload *payload,InjectContext &icontext,PcodeOp *op,FuncCallSpecs *fc);

  void injectUserOp(PcodeOp *op);

  bool inlineSubFunction(FuncCallSpecs *fc);

  bool injectSubFunction(FuncCallSpecs *fc);

  void checkContainedCall(void);

  void checkMultistageJumptables(void);

  void deleteCallSpec(FuncCallSpecs *fc);

  void truncateIndirectJump(PcodeOp *op,int4 failuremode);

  static bool isInArray(vector<PcodeOp *> &array,PcodeOp *op);

public:

  FlowInfo(Funcdata &d,PcodeOpBank &o,BlockGraph &b,vector<FuncCallSpecs *> &q);

  FlowInfo(Funcdata &d,PcodeOpBank &o,BlockGraph &b,vector<FuncCallSpecs *> &q,const FlowInfo *op2);

  void setRange(const Address &b,const Address &e) { baddr = b; eaddr = e; }

  void setMaximumInstructions(uint4 max) { insn_max = max; }

  void setFlags(uint4 val) { flags |= val; }

  void clearFlags(uint4 val) { flags &= ~val; }

  PcodeOp *target(const Address &addr) const;

  PcodeOp *branchTarget(PcodeOp *op) const;

  void generateOps(void);

  void generateBlocks(void);

  bool testHardInlineRestrictions(Funcdata *inlinefd,PcodeOp *op,Address &retaddr);

  bool checkEZModel(void) const;

  void injectPcode(void);

  void forwardRecursion(const FlowInfo &op2);

  void inlineClone(const FlowInfo &inlineflow,const Address &retaddr);

  void inlineEZClone(const FlowInfo &inlineflow,const Address &calladdr);

  int4 getSize(void) const { return (int4)(maxaddr.getOffset() - minaddr.getOffset()); }

  bool hasInject(void) const { return !injectlist.empty(); }

  bool hasUnimplemented(void) const { return ((flags & unimplemented_present)!=0); }

  bool hasBadData(void) const { return ((flags & baddata_present)!=0); }

  bool hasOutOfBounds(void) const { return ((flags & outofbounds_present)!=0); }

  bool hasReinterpreted(void) const { return ((flags & reinterpreted_present)!=0); }

  bool hasTooManyInstructions(void) const { return ((flags & toomanyinstructions_present)!=0); }

  bool isFlowForInline(void) const { return ((flags & flow_forinline)!=0); }

  bool doesJumpRecord(void) const { return ((flags & record_jumploads)!=0); }

};


#endif