Ghidra-Decompiler-Analysis-Engine-Document/architecture_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_ARCHITECTURE__

#define __CPUI_ARCHITECTURE__


#include "capability.hh"

#include "varmap.hh"

#include "action.hh"

#include "database.hh"

#include "pcodeinject.hh"

#include "fspec.hh"

#include "translate.hh"

#include "loadimage.hh"

#include "globalcontext.hh"

#include "comment.hh"

#include "stringmanage.hh"

#include "userop.hh"

#include "options.hh"

#include "transform.hh"

#include "prefersplit.hh"


#ifdef CPUI_STATISTICS

class Statistics {

  uintb numfunc;

  uintb numvar;

  uintb coversum;

  uintb coversumsq;

  uintb lastcastcount;

  uintb castcount;

  uintb castcountsq;

  //void process_cover(const Funcdata &data);

  void process_cast(const Funcdata &data);

public:

  Statistics(void);

  ~Statistics(void);

  void countCast(void) { castcount += 1; }

  void process(const Funcdata &fd);

  void printResults(ostream &s);

};


#endif


class Architecture;


class ArchitectureCapability : public CapabilityPoint {

  static const uint4 majorversion;

  static const uint4 minorversion;

  static vector<ArchitectureCapability *> thelist;

protected:

  string name;

public:

  const string &getName(void) const { return name; }

  virtual void initialize(void);


  virtual Architecture *buildArchitecture(const string &filename,const string &target,ostream *estream)=0;


  virtual bool isFileMatch(const string &filename) const=0;


  virtual bool isXmlMatch(Document *doc) const=0;


  static ArchitectureCapability *findCapability(const string &filename);

  static ArchitectureCapability *findCapability(Document *doc);

  static ArchitectureCapability *getCapability(const string &name);

  static void sortCapabilities(void);

  static uint4 getMajorVersion(void) { return majorversion; }

  static uint4 getMinorVersion(void) { return minorversion; }

};


class Architecture : public AddrSpaceManager {

public:

  string archid;


                // Configuration data

  int4 trim_recurse_max;

  int4 max_implied_ref;

  int4 max_term_duplication;

  int4 max_basetype_size;

  int4 min_funcsymbol_size;

  bool aggressive_ext_trim;

  bool readonlypropagate;

  bool infer_pointers;

  bool analyze_for_loops;

  vector<AddrSpace *> inferPtrSpaces;

  int4 funcptr_align;

  uint4 flowoptions;

  uint4 max_instructions;

  int4 alias_block_level;

  vector<Rule *> extra_pool_rules;


  Database *symboltab;

  ContextDatabase *context;

  map<string,ProtoModel *> protoModels;

  ProtoModel *defaultfp;

  VarnodeData defaultReturnAddr;

  ProtoModel *evalfp_current;

  ProtoModel *evalfp_called;

  TypeFactory *types;

  const Translate *translate;

  LoadImage *loader;

  PcodeInjectLibrary *pcodeinjectlib;

  RangeList nohighptr;

  CommentDatabase *commentdb;

  StringManager *stringManager;

  ConstantPool *cpool;

  PrintLanguage *print;

  vector<PrintLanguage *> printlist;

  OptionDatabase *options;

  vector<TypeOp *> inst;

  UserOpManage userops;

  vector<PreferSplitRecord> splitrecords;

  vector<LanedRegister> lanerecords;

  ActionDatabase allacts;

  bool loadersymbols_parsed;

#ifdef CPUI_STATISTICS

  Statistics *stats;

#endif

#ifdef OPACTION_DEBUG

  ostream *debugstream;

#endif

  Architecture(void);

  void init(DocumentStorage &store);

  void resetDefaultsInternal(void);

  void resetDefaults(void);

  ProtoModel *getModel(const string &nm) const;

  bool hasModel(const string &nm) const;

  bool highPtrPossible(const Address &loc,int4 size) const;

  AddrSpace *getSpaceBySpacebase(const Address &loc,int4 size) const;

  const LanedRegister *getLanedRegister(const Address &loc,int4 size) const;

  int4 getMinimumLanedRegisterSize(void) const;

  void setDefaultModel(const string &nm);

  void clearAnalysis(Funcdata *fd);

  void readLoaderSymbols(const string &delim);

  void collectBehaviors(vector<OpBehavior *> &behave) const;

  SegmentOp *getSegmentOp(AddrSpace *spc) const;

  void setPrototype(const PrototypePieces &pieces);

  void setPrintLanguage(const string &nm);

  void globalify(void);

  void restoreFlowOverride(const Element *el);

  virtual ~Architecture(void);


  virtual string getDescription(void) const { return archid; }


  virtual void printMessage(const string &message) const=0;

  virtual void saveXml(ostream &s) const;

  virtual void restoreXml(DocumentStorage &store);

  virtual void nameFunction(const Address &addr,string &name) const;

#ifdef OPACTION_DEBUG

  void setDebugStream(ostream *s) { debugstream = s; }

  void printDebug(const string &message) const { *debugstream << message << endl; }

#endif

protected:

  void addSpacebase(AddrSpace *basespace,const string &nm,const VarnodeData &ptrdata,

            int4 truncSize,bool isreversejustified,bool stackGrowth);

  void addNoHighPtr(const Range &rng);


  // Factory routines for building this architecture

  virtual Scope *buildDatabase(DocumentStorage &store);


  virtual Translate *buildTranslator(DocumentStorage &store)=0;


  virtual void buildLoader(DocumentStorage &store)=0;


  virtual PcodeInjectLibrary *buildPcodeInjectLibrary(void)=0;


  virtual void buildTypegrp(DocumentStorage &store);

  virtual void buildCommentDB(DocumentStorage &store);

  virtual void buildStringManager(DocumentStorage &store);

  virtual void buildConstantPool(DocumentStorage &store);

  virtual void buildInstructions(DocumentStorage &store);

  virtual void buildAction(DocumentStorage &store);

  virtual void buildContext(DocumentStorage &store);


  virtual void buildSpecFile(DocumentStorage &store)=0;


  virtual void modifySpaces(Translate *trans)=0;


  virtual void postSpecFile(void);


  virtual void resolveArchitecture(void)=0;


  void restoreFromSpec(DocumentStorage &store);

  void fillinReadOnlyFromLoader(void);

  void initializeSegments();

  void cacheAddrSpaceProperties(void);


  void parseProcessorConfig(DocumentStorage &store);

  void parseCompilerConfig(DocumentStorage &store);

  void parseExtraRules(DocumentStorage &store);


  void parseDynamicRule(const Element *el);

  ProtoModel *parseProto(const Element *el);

  void parseProtoEval(const Element *el);

  void parseDefaultProto(const Element *el);

  void parseGlobal(const Element *el);

  void addOtherSpace(void);

  void parseReadOnly(const Element *el);

  void parseVolatile(const Element *el);

  void parseReturnAddress(const Element *el);

  void parseIncidentalCopy(const Element *el);

  void parseLaneSizes(const Element *el);

  void parseStackPointer(const Element *el);

  void parseDeadcodeDelay(const Element *el);

  void parseInferPtrBounds(const Element *el);

  void parseFuncPtrAlign(const Element *el);

  void parseSpacebase(const Element *el);

  void parseNoHighPtr(const Element *el);

  void parsePreferSplit(const Element *el);

  void parseAggressiveTrim(const Element *el);

};


class SegmentedResolver : public AddressResolver {

  Architecture *glb;

  AddrSpace *spc;

  SegmentOp *segop;

public:

  SegmentedResolver(Architecture *g,AddrSpace *sp,SegmentOp *sop) { glb=g; spc=sp; segop=sop; }

  virtual Address resolve(uintb val,int4 sz,const Address &point,uintb &fullEncoding);

};


inline bool Architecture::highPtrPossible(const Address &loc,int4 size) const {

  if (loc.getSpace()->getType() == IPTR_INTERNAL) return false;

  return !nohighptr.inRange(loc,size);

}


#endif