database_ghidra.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 __DATABASE_GHIDRA__
#define __DATABASE_GHIDRA__
 
#include "database.hh"
#include "ghidra_arch.hh"
 
class ScopeGhidra : public Scope {
  ArchitectureGhidra *ghidra;       
  mutable ScopeInternal *cache;     
  mutable RangeList holes;      
  vector<int4> spacerange;      
  partmap<Address,uint4> flagbaseDefault;   
  mutable bool cacheDirty;      
  Symbol *dump2Cache(Document *doc) const;          
  Symbol *removeQuery(const Address &addr) const;       
  void processHole(const Element *el) const;            
  Scope *reresolveScope(uint8 id) const;    
  virtual void addRange(AddrSpace *spc,uintb first,uintb last);
  virtual void removeRange(AddrSpace *spc,uintb first,uintb last) {
    throw LowlevelError("remove_range should not be performed on ghidra scope");
  }
  virtual Scope *buildSubScope(uint8 id,const string &nm);
  virtual void addSymbolInternal(Symbol *sym) { throw LowlevelError("add_symbol_internal unimplemented"); }
  virtual SymbolEntry *addMapInternal(Symbol *sym,uint4 exfl,const Address &addr,int4 off,int4 sz,
                      const RangeList &uselim) { throw LowlevelError("addMap unimplemented"); }
  virtual SymbolEntry *addDynamicMapInternal(Symbol *sym,uint4 exfl,uint8 hash,int4 off,int4 sz,
                         const RangeList &uselim) { throw LowlevelError("addMap unimplemented"); }
public:
  ScopeGhidra(ArchitectureGhidra *g);   
 
  void lockDefaultProperties(void) { flagbaseDefault = ghidra->symboltab->getProperties(); cacheDirty = false; }
  virtual ~ScopeGhidra(void);
  virtual void clear(void);
  virtual SymbolEntry *addSymbol(const string &name,Datatype *ct,
                 const Address &addr,const Address &usepoint);
  virtual string buildVariableName(const Address &addr,
                   const Address &pc,
                   Datatype *ct,int4 &index,uint4 flags) const {
    return cache->buildVariableName(addr,pc,ct,index,flags); }
  virtual string buildUndefinedName(void) const { return cache->buildUndefinedName(); }
  virtual void setAttribute(Symbol *sym,uint4 attr) { cache->setAttribute(sym,attr); }
  virtual void clearAttribute(Symbol *sym,uint4 attr) { cache->clearAttribute(sym,attr); }
  virtual void setDisplayFormat(Symbol *sym,uint4 attr) { cache->setDisplayFormat(sym,attr); }
 
  virtual void adjustCaches(void) { cache->adjustCaches(); }
  virtual SymbolEntry *findAddr(const Address &addr,const Address &usepoint) const;
  virtual SymbolEntry *findContainer(const Address &addr,int4 size,
                    const Address &usepoint) const;
  virtual SymbolEntry *findClosestFit(const Address &addr,int4 size,
                     const Address &usepoint) const {
    throw LowlevelError("findClosestFit unimplemented"); }
  virtual Funcdata *findFunction(const Address &addr) const;
  virtual ExternRefSymbol *findExternalRef(const Address &addr) const;
  virtual LabSymbol *findCodeLabel(const Address &addr) const;
  virtual Funcdata *resolveExternalRefFunction(ExternRefSymbol *sym) const;
 
  virtual SymbolEntry *findOverlap(const Address &addr,int4 size) const { throw LowlevelError("findOverlap unimplemented"); }
  virtual void findByName(const string &name,vector<Symbol *> &res) const { throw LowlevelError("findByName unimplemented"); }
  virtual bool isNameUsed(const string &nm,const Scope *op2) const { throw LowlevelError("isNameUsed unimplemented"); }
 
  virtual MapIterator begin(void) const { throw LowlevelError("begin unimplemented"); }
  virtual MapIterator end(void) const { throw LowlevelError("end unimplemented"); }
  virtual list<SymbolEntry>::const_iterator beginDynamic(void) const { throw LowlevelError("beginDynamic unimplemented"); }
  virtual list<SymbolEntry>::const_iterator endDynamic(void) const { throw LowlevelError("endDynamic unimplemented"); }
  virtual list<SymbolEntry>::iterator beginDynamic(void) { throw LowlevelError("beginDynamic unimplemented"); }
  virtual list<SymbolEntry>::iterator endDynamic(void) { throw LowlevelError("endDynamic unimplemented"); }
  virtual void clearCategory(int4 cat) { throw LowlevelError("clearCategory unimplemented"); }
  virtual void clearUnlockedCategory(int4 cat) { throw LowlevelError("clearUnlockedCategory unimplemented"); }
  virtual void clearUnlocked(void) { throw LowlevelError("clearUnlocked unimplemented"); }
  virtual void restrictScope(Funcdata *f) { throw LowlevelError("restrictScope unimplemented"); }
  virtual void removeSymbolMappings(Symbol *symbol) { throw LowlevelError("removeSymbolMappings unimplemented"); }
  virtual void removeSymbol(Symbol *symbol) { throw LowlevelError("removeSymbol unimplemented"); }
  virtual void renameSymbol(Symbol *sym,const string &newname) { throw LowlevelError("renameSymbol unimplemented"); }
  virtual void retypeSymbol(Symbol *sym,Datatype *ct) { throw LowlevelError("retypeSymbol unimplemented"); }
  virtual string makeNameUnique(const string &nm) const { throw LowlevelError("makeNameUnique unimplemented"); }
  virtual void saveXml(ostream &s) const { throw LowlevelError("saveXml unimplemented"); }
  virtual void restoreXml(const Element *el) { throw LowlevelError("restoreXml unimplemented"); }
  virtual void printEntries(ostream &s) const { throw LowlevelError("printEntries unimplemented"); }
  virtual int4 getCategorySize(int4 cat) const { throw LowlevelError("getCategorySize unimplemented"); }
  virtual Symbol *getCategorySymbol(int4 cat,int4 ind) const { throw LowlevelError("getCategorySymbol unimplemented"); }
  virtual void setCategory(Symbol *sym,int4 cat,int4 ind) { throw LowlevelError("setCategory unimplemented"); }
};
 
class ScopeGhidraNamespace : public ScopeInternal {
  friend class ScopeGhidra;
  ArchitectureGhidra *ghidra;       
protected:
  virtual SymbolEntry *addMapInternal(Symbol *sym,uint4 exfl,const Address &addr,int4 off,int4 sz,
                      const RangeList &uselim);
public:
  ScopeGhidraNamespace(uint8 id,const string &nm,ArchitectureGhidra *g)
    : ScopeInternal(id,nm,g) { ghidra = g; }        
 
  virtual bool isNameUsed(const string &nm,const Scope *op2) const;
};
 
#endif