database.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_DATABASE__
#define __CPUI_DATABASE__

#include "variable.hh"
#include "partmap.hh"
#include "rangemap.hh"

class Architecture;
class Funcdata;
class Scope;
class Database;
class Symbol;
class PrintLanguage;

class SymbolEntry {
  friend class Scope;
  Symbol *symbol;       
  uint4 extraflags;     
  Address addr;         
  uint8 hash;           
  int4 offset;          
  int4 size;            
  RangeList uselimit;       
  SymbolEntry(Symbol *sym); 
public:
  class EntryInitData {
    friend class SymbolEntry;
    AddrSpace *space;       
    Symbol *symbol;     
    uint4 extraflags;       
    int4 offset;        
    const RangeList &uselimit;  
  public:
    EntryInitData(Symbol *sym,uint4 exfl,AddrSpace *spc,int4 off,const RangeList &ul)
      : uselimit(ul) { symbol = sym; extraflags=exfl; space = spc; offset = off; }  
  };

  class EntrySubsort {
    friend class SymbolEntry;
    int4 useindex;          
    uintb useoffset;            
  public:
    EntrySubsort(const Address &addr) {
      useindex = addr.getSpace()->getIndex(); useoffset = addr.getOffset(); }   
    EntrySubsort(void) { useindex=0; useoffset=0; }             

    EntrySubsort(bool val) {
      if (val) { useindex=0xffff; } // Greater than any real values
      else { useindex=0; useoffset=0; } // Less than any real values
    }
    EntrySubsort(const EntrySubsort &op2) {
      useindex = op2.useindex;
      useoffset = op2.useoffset;
    }
    bool operator<(const EntrySubsort &op2) {
      if (useindex != op2.useindex)
    return (useindex < op2.useindex);
      return (useoffset < op2.useoffset);
    }
  };
  typedef uintb linetype;       
  typedef EntrySubsort subsorttype; 
  typedef EntryInitData inittype;   

  SymbolEntry(void) {}          
  SymbolEntry(Symbol *sym,uint4 exfl,uint8 h,int4 off,int4 sz,const RangeList &rnglist);    
  bool isPiece(void) const { return ((extraflags&(Varnode::precislo|Varnode::precishi))!=0); }  
  bool isDynamic(void) const { return addr.isInvalid(); }       
  bool isInvalid(void) const { return (addr.isInvalid() && (hash==0)); }    
  uint4 getAllFlags(void) const;                    
  int4 getOffset(void) const { return offset; }             
  uintb getFirst(void) const { return addr.getOffset(); }       
  uintb getLast(void) const { return (addr.getOffset()+size-1); }   
  subsorttype getSubsort(void) const;                   
  void initialize(const EntryInitData &data,uintb a,uintb b);       
  Symbol *getSymbol(void) const { return symbol; }          
  const Address &getAddr(void) const { return addr; }           
  uint8 getHash(void) const { return hash; }                
  int4 getSize(void) const { return size; }             
  bool inUse(const Address &usepoint) const;                
  const RangeList &getUseLimit(void) const { return uselimit; }     
  Address getFirstUseAddress(void) const;               
  void setUseLimit(const RangeList &uselim) { uselimit = uselim; }  
  bool isAddrTied(void) const;                      
  bool updateType(Varnode *vn) const;                   
  Datatype *getSizedType(const Address &addr,int4 sz) const;        
  void printEntry(ostream &s) const;                    
  void saveXml(ostream &s) const;                   
  List::const_iterator restoreXml(List::const_iterator iter,const AddrSpaceManager *manage);    
};
typedef rangemap<SymbolEntry> EntryMap;         

class Symbol {
  friend class Scope;
  friend class ScopeInternal;
  friend class SymbolCompareName;
protected:
  Scope *scope;         
  string name;          
  Datatype *type;       
  uint4 nameDedup;      
  uint4 flags;          
                // only typelock,namelock,readonly,externref
                // addrtied, persist inherited from scope
  uint4 dispflags;      
  int2 category;        
  uint2 catindex;       
  uint8 symbolId;       
  vector<list<SymbolEntry>::iterator> mapentry; 
  uint4 wholeCount;     
  virtual ~Symbol(void) {}  
  void setDisplayFormat(uint4 val); 
  void checkSizeTypeLock(void); 
public:
  enum {
    force_hex = 1,      
    force_dec = 2,      
    force_oct = 3,      
    force_bin = 4,      
    force_char = 5,     
    size_typelock = 8,          
    isolate = 16,       
    merge_problems = 32     
  };
  Symbol(Scope *sc,const string &nm,Datatype *ct)
  { scope=sc; name=nm; nameDedup=0; type=ct; flags=0; dispflags=0; category=-1; symbolId=0; wholeCount=0; }

  Symbol(Scope *sc) { scope=sc; nameDedup=0; flags=0; dispflags=0; category=-1; symbolId = 0; wholeCount=0; }

  const string &getName(void) const { return name; }        
  Datatype *getType(void) const { return type; }        
  uint8 getId(void) const { return symbolId; }          
  uint4 getFlags(void) const { return flags; }          
  uint4 getDisplayFormat(void) const { return (dispflags & 7); }    
  int2 getCategory(void) const { return category; }     
  uint2 getCategoryIndex(void) const { return catindex; }   
  bool isTypeLocked(void) const { return ((flags&Varnode::typelock)!=0); }  
  bool isNameLocked(void) const { return ((flags&Varnode::namelock)!=0); }  
  bool isSizeTypeLocked(void) const { return ((dispflags & size_typelock)!=0); }    
  bool isIndirectStorage(void) const { return ((flags&Varnode::indirectstorage)!=0); }  
  bool isHiddenReturn(void) const { return ((flags&Varnode::hiddenretparm)!=0); }   
  bool isNameUndefined(void) const;             
  bool isMultiEntry(void) const { return (wholeCount > 1); }    
  bool hasMergeProblems(void) const { return ((dispflags & merge_problems)!=0); } 
  void setMergeProblems(void) { dispflags |= merge_problems; }  
  bool isIsolated(void) const { return ((dispflags & isolate)!=0); }    
  void setIsolated(bool val);                   
  Scope *getScope(void) const { return scope; }         
  SymbolEntry *getFirstWholeMap(void) const;            
  SymbolEntry *getMapEntry(const Address &addr) const;      
  int4 numEntries(void) const { return mapentry.size(); }   
  SymbolEntry *getMapEntry(int4 i) const { return &(*mapentry[i]); }    
  int4 getMapEntryPosition(const SymbolEntry *entry) const; 
  int4 getResolutionDepth(const Scope *useScope) const;     
  void saveXmlHeader(ostream &s) const;             
  void restoreXmlHeader(const Element *el);         
  void saveXmlBody(ostream &s) const;               
  void restoreXmlBody(List::const_iterator iter);       
  virtual void saveXml(ostream &s) const;           
  virtual void restoreXml(const Element *el);           
  virtual int4 getBytesConsumed(void) const;            
  static uint8 ID_BASE;                     
};

inline void Symbol::setDisplayFormat(uint4 val)

{
  dispflags &= 0xfffffff8;
  dispflags |= val;
}

inline uint4 SymbolEntry::getAllFlags(void) const {
  return extraflags | symbol->getFlags();
}

inline bool SymbolEntry::isAddrTied(void) const {
  return ((symbol->getFlags()&Varnode::addrtied)!=0);
}

class FunctionSymbol : public Symbol {
  Funcdata *fd;             
  int4 consumeSize;         
  virtual ~FunctionSymbol(void);
  void buildType(void);         
public:
  FunctionSymbol(Scope *sc,const string &nm,int4 size); 
  FunctionSymbol(Scope *sc,int4 size);          
  Funcdata *getFunction(void);              
  virtual void saveXml(ostream &s) const;
  virtual void restoreXml(const Element *el);
  virtual int4 getBytesConsumed(void) const { return consumeSize; }
};

class EquateSymbol : public Symbol {
  uintb value;              
public:
  EquateSymbol(Scope *sc) : Symbol(sc) { value = 0; category = 1; } 
  uintb getValue(void) const { return value; }              
  bool isValueClose(uintb op2Value,int4 size) const;            
  virtual void saveXml(ostream &s) const;
  virtual void restoreXml(const Element *el);
};

class LabSymbol : public Symbol {
  void buildType(void);     
public:
  LabSymbol(Scope *sc,const string &nm);    
  LabSymbol(Scope *sc);             
  virtual void saveXml(ostream &s) const;
  virtual void restoreXml(const Element *el);
};

class ExternRefSymbol : public Symbol {
  Address refaddr;          
  void buildNameType(void);     
  virtual ~ExternRefSymbol(void) {}
public:
  ExternRefSymbol(Scope *sc,const Address &ref,const string &nm);   
  ExternRefSymbol(Scope *sc) : Symbol(sc) {}                
  const Address &getRefAddr(void) const { return refaddr; }     
  virtual void saveXml(ostream &s) const;
  virtual void restoreXml(const Element *el);
};

class SymbolCompareName {
public:
  bool operator()(const Symbol *sym1,const Symbol *sym2) const {
    int4 comp = sym1->name.compare(sym2->name);
    if (comp < 0) return true;
    if (comp > 0) return false;
    return (sym1->nameDedup < sym2->nameDedup);
  }
};
typedef set<Symbol *,SymbolCompareName> SymbolNameTree;     

class MapIterator {
  const vector<EntryMap *> *map;        
  vector<EntryMap *>::const_iterator curmap;    
  list<SymbolEntry>::const_iterator curiter;    
public:
  MapIterator(void) { map = (const vector<EntryMap *> *)0; }    

  MapIterator(const vector<EntryMap *> *m,
           vector<EntryMap *>::const_iterator cm,
           list<SymbolEntry>::const_iterator ci) {
    map = m; curmap = cm; curiter = ci;
  }

  MapIterator(const MapIterator &op2) {
    map = op2.map; curmap = op2.curmap; curiter = op2.curiter;
  }
  const SymbolEntry *operator*(void) const { return &(*curiter); }  
  MapIterator &operator++(void);                    
  MapIterator operator++(int4 i);                   

  MapIterator &operator=(const MapIterator &op2) {
    map = op2.map;
    curmap = op2.curmap;
    curiter = op2.curiter;
    return *this;
  }

  bool operator==(const MapIterator &op2) const {
    if (curmap != op2.curmap) return false;
    if (curmap == map->end()) return true;
    return (curiter==op2.curiter);
  }

  bool operator!=(const MapIterator &op2) const {
    if (curmap != op2.curmap) return true;
    if (curmap == map->end()) return false;
    return (curiter!=op2.curiter);
  }
};

class ScopeKey {
  string name;          
  uintb dedupId;        
public:
  ScopeKey(const string &nm,uint4 id) { name = nm; dedupId = id; }  
  bool operator<(const ScopeKey &op2) const;                
};
typedef map<ScopeKey,Scope *> ScopeMap;     

class Scope {
  friend class Database;
  friend class ScopeCompare;
  RangeList rangetree;              
  Scope *parent;                
  ScopeMap children;                
  void attachScope(Scope *child);       
  void detachScope(ScopeMap::iterator iter);    
  void assignId(uint4 val) { uniqueId = val; }  

protected:
  Architecture *glb;                
  string name;                  
  Funcdata *fd;                 
  uint4 uniqueId;               
  static const Scope *stackAddr(const Scope *scope1,
                     const Scope *scope2,
                     const Address &addr,
                     const Address &usepoint,
                     SymbolEntry **addrmatch);
  static const Scope *stackContainer(const Scope *scope1,
                      const Scope *scope2,
                      const Address &addr,int4 size,
                      const Address &usepoint,
                      SymbolEntry **addrmatch);
  static const Scope *stackClosestFit(const Scope *scope1,
                       const Scope *scope2,
                       const Address &addr,int4 size,
                       const Address &usepoint,
                       SymbolEntry **addrmatch);
  static const Scope *stackFunction(const Scope *scope1,
                     const Scope *scope2,
                     const Address &addr,
                     Funcdata **addrmatch);
  static const Scope *stackExternalRef(const Scope *scope1,
                        const Scope *scope2,
                        const Address &addr,
                        ExternRefSymbol **addrmatch);
  static const Scope *stackCodeLabel(const Scope *scope1,
                      const Scope *scope2,
                      const Address &addr,
                      LabSymbol **addrmatch);

  const RangeList &getRangeTree(void) const { return rangetree; }   
  virtual void restrictScope(Funcdata *f);              

  // These add/remove range are for scope \b discovery, i.e. we may
  // know an address belongs to a certain scope, without knowing any symbol
  virtual void addRange(AddrSpace *spc,uintb first,uintb last);     
  virtual void removeRange(AddrSpace *spc,uintb first,uintb last);  

  virtual void addSymbolInternal(Symbol *sym)=0;

  virtual SymbolEntry *addMapInternal(Symbol *sym,uint4 exfl,const Address &addr,int4 off,int4 sz,
                      const RangeList &uselim)=0;


  virtual SymbolEntry *addDynamicMapInternal(Symbol *sym,uint4 exfl,uint8 hash,int4 off,int4 sz,
                         const RangeList &uselim)=0;
  SymbolEntry *addMap(const SymbolEntry &entry);    
  void setSymbolId(Symbol *sym,uint8 id) const { sym->symbolId = id; }  
public:
#ifdef OPACTION_DEBUG
  mutable bool debugon;
  void turnOnDebug(void) const { debugon = true; }
  void turnOffDebug(void) const { debugon = false; }
#endif
  Scope(const string &nm,Architecture *g) {
    name = nm; glb = g; parent = (Scope *)0; fd = (Funcdata *)0; uniqueId = 0;
#ifdef OPACTION_DEBUG
    debugon = false;
#endif
  }
  virtual ~Scope(void);                     
  virtual MapIterator begin(void) const=0;          
  virtual MapIterator end(void) const=0;            
  virtual list<SymbolEntry>::const_iterator beginDynamic(void) const=0; 
  virtual list<SymbolEntry>::const_iterator endDynamic(void) const=0;   
  virtual list<SymbolEntry>::iterator beginDynamic(void)=0; 
  virtual list<SymbolEntry>::iterator endDynamic(void)=0;   
  virtual void clear(void)=0;                   
  virtual void clearCategory(int4 cat)=0;           
  virtual void clearUnlocked(void)=0;               
  virtual void clearUnlockedCategory(int4 cat)=0;       

  virtual bool inScope(const Address &addr,int4 size, const Address &usepoint) const {
    return rangetree.inRange(addr,size); }

  virtual void removeSymbolMappings(Symbol *symbol)=0;  
  virtual void removeSymbol(Symbol *symbol)=0;      
  virtual void renameSymbol(Symbol *sym,const string &newname)=0;   

  virtual void retypeSymbol(Symbol *sym,Datatype *ct)=0;
  virtual void setAttribute(Symbol *sym,uint4 attr)=0;      
  virtual void clearAttribute(Symbol *sym,uint4 attr)=0;    
  virtual void setDisplayFormat(Symbol *sym,uint4 attr)=0;  

  // Find routines only search the scope itself

  virtual SymbolEntry *findAddr(const Address &addr,const Address &usepoint) const=0;

  virtual SymbolEntry *findContainer(const Address &addr,int4 size,
                         const Address &usepoint) const=0;

  virtual SymbolEntry *findClosestFit(const Address &addr,int4 size,
                     const Address &usepoint) const=0;

  virtual Funcdata *findFunction(const Address &addr) const=0;

  virtual ExternRefSymbol *findExternalRef(const Address &addr) const=0;

  virtual LabSymbol *findCodeLabel(const Address &addr) const=0;

  virtual SymbolEntry *findOverlap(const Address &addr,int4 size) const=0;

  virtual void findByName(const string &name,vector<Symbol *> &res) const=0;

  virtual bool isNameUsed(const string &name) const=0;

  virtual Funcdata *resolveExternalRefFunction(ExternRefSymbol *sym) const=0;

  virtual string buildVariableName(const Address &addr,
                   const Address &pc,
                   Datatype *ct,int4 &index,uint4 flags) const=0;

  virtual string buildUndefinedName(void) const=0;

  virtual string makeNameUnique(const string &nm) const=0;

  virtual void saveXml(ostream &s) const=0;     
  virtual void restoreXml(const Element *el)=0;     
  virtual void printEntries(ostream &s) const=0;    

  virtual int4 getCategorySize(int4 cat) const=0;

  virtual Symbol *getCategorySymbol(int4 cat,int4 ind) const=0;

  virtual void setCategory(Symbol *sym,int4 cat,int4 ind)=0;

  virtual SymbolEntry *addSymbol(const string &name,Datatype *ct,
                 const Address &addr,const Address &usepoint);

  const string &getName(void) const { return name; }        
  bool isGlobal(void) const { return (fd == (Funcdata *)0); }   

  // The main global querying routines
  void queryByName(const string &name,vector<Symbol *> &res) const; 
  Funcdata *queryFunction(const string &name) const;            
  SymbolEntry *queryByAddr(const Address &addr,
               const Address &usepoint) const;      
  SymbolEntry *queryContainer(const Address &addr,int4 size,
                  const Address &usepoint) const;       
  SymbolEntry *queryProperties(const Address &addr,int4 size,
                   const Address &usepoint,uint4 &flags) const; 
  Funcdata *queryFunction(const Address &addr) const;           
  Funcdata *queryExternalRefFunction(const Address &addr) const;    
  LabSymbol *queryCodeLabel(const Address &addr) const;         

  Scope *resolveScope(const string &name) const;            
  Scope *discoverScope(const Address &addr,int4 sz,const Address &usepoint);    
  ScopeMap::const_iterator childrenBegin() const { return children.begin(); }   
  ScopeMap::const_iterator childrenEnd() const { return children.end(); }   
  void saveXmlRecursive(ostream &s,bool onlyGlobal) const;      
  void overrideSizeLockType(Symbol *sym,Datatype *ct);          
  void resetSizeLockType(Symbol *sym);              
  bool isSubScope(const Scope *scp) const;          
  string getFullName(void) const;               
  void getNameSegments(vector<string> &vec) const;      
  void getScopePath(vector<Scope *> &vec) const;        
  bool isNameUsed(const string &nm,const Scope *op2) const; 
  const Scope *findDistinguishingScope(const Scope *op2) const; 
  Architecture *getArch(void) const { return glb; }     
  Scope *getParent(void) const { return parent; }       
  Symbol *addSymbol(const string &name,Datatype *ct);       
  SymbolEntry *addMapPoint(Symbol *sym,const Address &addr,
               const Address &usepoint);        
  Symbol *addMapSym(const Element *el);             
  FunctionSymbol *addFunction(const Address &addr,const string &nm);
  ExternRefSymbol *addExternalRef(const Address &addr,const Address &refaddr,const string &nm);
  LabSymbol *addCodeLabel(const Address &addr,const string &nm);
  Symbol *addDynamicSymbol(const string &nm,Datatype *ct,const Address &caddr,uint8 hash);
  string buildDefaultName(Symbol *sym,int4 &base,Varnode *vn) const;    
  bool isReadOnly(const Address &addr,int4 size,const Address &usepoint) const;
  void printBounds(ostream &s) const { rangetree.printBounds(s); }  
};

class ScopeInternal : public Scope {
  void processHole(const Element *el);
  void insertNameTree(Symbol *sym);
  SymbolNameTree::const_iterator findFirstByName(const string &name) const;
protected:
  virtual void addSymbolInternal(Symbol *sym);
  virtual SymbolEntry *addMapInternal(Symbol *sym,uint4 exfl,const Address &addr,int4 off,int4 sz,const RangeList &uselim);
  virtual SymbolEntry *addDynamicMapInternal(Symbol *sym,uint4 exfl,uint8 hash,int4 off,int4 sz,
                         const RangeList &uselim);
  SymbolNameTree nametree;          
  vector<EntryMap *> maptable;          
  vector<vector<Symbol *> > category;       
  list<SymbolEntry> dynamicentry;       
  SymbolNameTree multiEntrySet;         
  uint8 nextUniqueId;               
public:
  ScopeInternal(const string &nm,Architecture *g);  
  virtual void clear(void);
  virtual void categorySanity(void);            
  virtual void clearCategory(int4 cat);
  virtual void clearUnlocked(void);
  virtual void clearUnlockedCategory(int4 cat);
  virtual ~ScopeInternal(void);
  virtual MapIterator begin(void) const;
  virtual MapIterator end(void) const;
  virtual list<SymbolEntry>::const_iterator beginDynamic(void) const;
  virtual list<SymbolEntry>::const_iterator endDynamic(void) const;
  virtual list<SymbolEntry>::iterator beginDynamic(void);
  virtual list<SymbolEntry>::iterator endDynamic(void);
  virtual void removeSymbolMappings(Symbol *symbol);
  virtual void removeSymbol(Symbol *symbol);
  virtual void renameSymbol(Symbol *sym,const string &newname);
  virtual void retypeSymbol(Symbol *sym,Datatype *ct);
  virtual void setAttribute(Symbol *sym,uint4 attr);
  virtual void clearAttribute(Symbol *sym,uint4 attr);
  virtual void setDisplayFormat(Symbol *sym,uint4 attr);

  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;
  virtual Funcdata *findFunction(const Address &addr) const;
  virtual ExternRefSymbol *findExternalRef(const Address &addr) const;
  virtual LabSymbol *findCodeLabel(const Address &addr) const;
  virtual SymbolEntry *findOverlap(const Address &addr,int4 size) const;

  virtual void findByName(const string &name,vector<Symbol *> &res) const;
  virtual bool isNameUsed(const string &name) const;
  virtual Funcdata *resolveExternalRefFunction(ExternRefSymbol *sym) const;

  virtual string buildVariableName(const Address &addr,
                   const Address &pc,
                   Datatype *ct,int4 &index,uint4 flags) const;
  virtual string buildUndefinedName(void) const;
  virtual string makeNameUnique(const string &nm) const;
  virtual void saveXml(ostream &s) const;
  virtual void restoreXml(const Element *el);
  virtual void printEntries(ostream &s) const;
  virtual int4 getCategorySize(int4 cat) const;
  virtual Symbol *getCategorySymbol(int4 cat,int4 ind) const;
  virtual void setCategory(Symbol *sym,int4 cat,int4 ind);
  void assignDefaultNames(int4 &base);      
  set<Symbol *>::const_iterator beginMultiEntry(void) const { return multiEntrySet.begin(); }   
  set<Symbol *>::const_iterator endMultiEntry(void) const { return multiEntrySet.end(); }   
  static void savePathXml(ostream &s,const vector<string> &vec);    
  static void restorePathXml(vector<string> &vec,const Element *el);    
};

class ScopeMapper {
  friend class Database;
  class NullSubsort {
  public:
    NullSubsort(void) {}                    
    NullSubsort(bool val) {}                    
    NullSubsort(const NullSubsort &op2) {}          
    bool operator<(const NullSubsort &op2) { return false; }    
  };
public:
  typedef Address linetype;     
  typedef NullSubsort subsorttype;  
  typedef Scope *inittype;      
private:
  Scope *scope;         
  Address first;        
  Address last;         
public:
  ScopeMapper(void) {}      
  Address getFirst(void) const { return first; }        
  Address getLast(void) const { return last; }          
  NullSubsort getSubsort(void) const { return NullSubsort(); }  
  Scope *getScope(void) const { return scope; }         
  void initialize(const inittype &data,const Address &f,const Address &l) {
    scope = data; first = f; last = l; }    
};
typedef rangemap<ScopeMapper> ScopeResolve;     

class Database {
  Architecture *glb;            
  Scope *globalscope;           
  ScopeResolve resolvemap;      
  partmap<Address,uint4> flagbase;  
  uint4 nextScopeId;            
  void clearResolve(Scope *scope);  
  void clearResolveRecursive(Scope *scope); 
  void fillResolve(Scope *scope);   
  static void parseParentTag(const Element *el,string &name,vector<string> &parnames);
public:
  Database(Architecture *g) { glb=g; globalscope=(Scope *)0; flagbase.defaultValue()=0; nextScopeId=1; }    
  ~Database(void);                      
  Architecture *getArch(void) const { return glb; }     
  void attachScope(Scope *newscope,Scope *parent);      
  void deleteScope(Scope *scope);               
  void deleteSubScopes(Scope *scope);               
  void clearUnlocked(Scope *scope);             
  void setRange(Scope *scope,const RangeList &rlist);       
  void addRange(Scope *scope,AddrSpace *spc,uintb first,uintb last);    
  void removeRange(Scope *scope,AddrSpace *spc,uintb first,uintb last); 
  Scope *getGlobalScope(void) const { return globalscope; } 
  Scope *resolveScope(const vector<string> &subnames) const;    
  Scope *resolveScopeSymbolName(const string &fullname,const string &delim,string &basename,Scope *start) const;
  const Scope *mapScope(const Scope *qpoint,const Address &addr,const Address &usepoint) const;
  Scope *mapScope(Scope *qpoint,const Address &addr,const Address &usepoint);
  uint4 getProperty(const Address &addr) const { return flagbase.getValue(addr); }  
  void setPropertyRange(uint4 flags,const Range &range);    
  void setProperties(const partmap<Address,uint4> &newflags) { flagbase = newflags; }   
  const partmap<Address,uint4> &getProperties(void) const { return flagbase; }  
  void saveXml(ostream &s) const;               
  void restoreXml(const Element *el);               
  void restoreXmlScope(const Element *el,Scope *new_scope); 
};

#endif