architecture.hh

Go to the documentation of this file.

/* ###
 * 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 "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 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;      
  vector<AddrSpace *> inferPtrSpaces;   
  int4 funcptr_align;       
  uint4 flowoptions;            
  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;   
  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); 
  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(void);             
  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 *buildGlobalScope(void);            

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