Candidate release of source code.

Ghidra/Features/Decompiler/src/decompile/cpp/codedata.hh

@@ -0,0 +1,195 @@
+/* ###
+ * 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_CODEDATA__
+#define __CPUI_CODEDATA__
+
+#include "ifacedecomp.hh"
+
+class IfaceCodeDataCapability : public IfaceCapability {
+  static IfaceCodeDataCapability ifaceCodeDataCapability;	// Singleton instance
+  IfaceCodeDataCapability(void);	// Singleton
+  IfaceCodeDataCapability(const IfaceCodeDataCapability &op2);	// Not implemented
+  IfaceCodeDataCapability &operator=(const IfaceCodeDataCapability &op2);	// Not implemented
+public:
+  virtual void registerCommands(IfaceStatus *status);
+};
+
+class CodeDataAnalysis;		// Forward declaration
+
+class CodeUnit {
+public:
+  enum {
+    fallthru = 1,
+    jump = 2,
+    call = 4,
+    notcode = 8,
+    hit_by_fallthru = 16,
+    hit_by_jump = 32,
+    hit_by_call = 64,
+    errantstart = 128,
+    targethit = 256,
+    thunkhit = 512
+  };
+  uint4 flags;
+  int4 size;
+};
+
+struct DisassemblyResult {
+  bool success;
+  int4 length;
+  uint4 flags;
+  Address jumpaddress;
+  uintb targethit;
+};
+
+
+class DisassemblyEngine : public PcodeEmit {
+  const Translate *trans;
+  vector<Address> jumpaddr;
+  set<uintb> targetoffsets;
+  OpCode lastop;
+  bool hascall;
+  bool hitsaddress;
+  uintb targethit;
+public:
+  void init(const Translate *t);
+  virtual void dump(const Address &addr,OpCode opc,VarnodeData *outvar,VarnodeData *vars,int4 isize);
+  void disassemble(const Address &addr,DisassemblyResult &res);
+  void addTarget(const Address &addr) { targetoffsets.insert( addr.getOffset() ); }
+};
+
+class TargetHit {
+public:
+  Address funcstart;		// Starting address of function making target call
+  Address codeaddr;		// Address of instruction refering to target call
+  Address thunkaddr;		// The target call
+  uint4 mask;			// Mask associated with this target
+  bool operator<(const TargetHit &op2) const { return (funcstart < op2.funcstart); }
+};
+
+struct TargetFeature {
+  string name;			// Name of the target function
+  uint4 featuremask;		// id of this target for ORing into a mask
+};
+
+struct AddrLink {
+  Address a;
+  Address b;
+  AddrLink(Address i) { a = i; b=Address(); }
+  AddrLink(Address i,Address j) { a=i; b=j; }
+  bool operator<(const AddrLink &op2) const {
+    if (a != op2.a) return (a < op2.a);
+    return (b < op2.b);
+  }
+};
+
+class CodeDataAnalysis : public IfaceData {
+public:
+  int4 alignment;		// Alignment of instructions
+  Architecture *glb;
+  DisassemblyEngine disengine;
+  RangeList modelhits;
+  map<Address,CodeUnit> codeunit;
+  map<AddrLink,uint4> fromto_crossref;
+  map<AddrLink,uint4> tofrom_crossref;
+  list<map<Address,CodeUnit>::iterator> taintlist;
+  list<Address> unlinkedstarts;
+  list<TargetHit> targethits;
+  map<Address,TargetFeature> targets;
+  virtual ~CodeDataAnalysis(void) {}
+  void init(Architecture *g);
+  void pushTaintAddress(const Address &addr);
+  void processTaint(void);
+  Address commitCodeVec(const Address &addr,vector<CodeUnit> &codevec,map<AddrLink,uint4> &fromto_vec);
+  void clearHitBy(void);
+  void clearCrossRefs(const Address &addr,const Address &endaddr);
+  void clearCodeUnits(const Address &addr,const Address &endaddr);
+  void addTarget(const string &nm,const Address &addr,uint4 mask);
+  int4 getNumTargets(void) const { return targets.size(); }
+  Address disassembleBlock(const Address &addr,const Address &endaddr);
+  void disassembleRange(const Range &range);
+  void disassembleRangeList(const RangeList &rangelist);
+  void findNotCodeUnits(void);
+  void markFallthruHits(void);
+  void markCrossHits(void);
+  void addTargetHit(const Address &codeaddr,uintb targethit);
+  void resolveThunkHit(const Address &codeaddr,uintb targethit);
+  void findUnlinked(void);
+  bool checkErrantStart(map<Address,CodeUnit>::iterator iter);
+  bool repairJump(const Address &addr,int4 max);
+  void findOffCut(void);
+  Address findFunctionStart(const Address &addr) const;
+  const list<TargetHit> &getTargetHits(void) const { return targethits; }
+  void dumpModelHits(ostream &s) const;
+  void dumpCrossRefs(ostream &s) const;
+  void dumpFunctionStarts(ostream &s) const;
+  void dumpUnlinked(ostream &s) const;
+  void dumpTargetHits(ostream &s) const;
+  void runModel(void);
+};
+
+class IfaceCodeDataCommand : public IfaceCommand {
+protected:
+  IfaceStatus *status;
+  IfaceDecompData *dcp;
+  CodeDataAnalysis *codedata;
+public:
+  virtual void setData(IfaceStatus *root,IfaceData *data);
+  virtual string getModule(void) const { return "codedata"; }
+  virtual IfaceData *createData(void) { return new CodeDataAnalysis(); }
+};
+
+class IfcCodeDataInit : public IfaceCodeDataCommand {
+public:
+  virtual void execute(istream &s);
+};
+
+class IfcCodeDataTarget : public IfaceCodeDataCommand {
+public:
+  virtual void execute(istream &s);
+};
+
+class IfcCodeDataRun : public IfaceCodeDataCommand {
+public:
+  virtual void execute(istream &s);
+};
+
+class IfcCodeDataDumpModelHits : public IfaceCodeDataCommand {
+public:
+  virtual void execute(istream &s);
+};
+
+class IfcCodeDataDumpCrossRefs : public IfaceCodeDataCommand {
+public:
+  virtual void execute(istream &s);
+};
+
+class IfcCodeDataDumpStarts : public IfaceCodeDataCommand {
+public:
+  virtual void execute(istream &s);
+};
+
+class IfcCodeDataDumpUnlinked : public IfaceCodeDataCommand {
+public:
+  virtual void execute(istream &s);
+};
+
+class IfcCodeDataDumpTargetHits : public IfaceCodeDataCommand {
+public:
+  virtual void execute(istream &s);
+};
+
+#endif