type.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_TYPE__
#define __CPUI_TYPE__

#include "address.hh"

extern void print_data(ostream &s,uint1 *buffer,int4 size,const Address &baseaddr);
//extern void print_char(ostream &s,int4 onechar);
//extern bool print_string(ostream &s,uint1 *buffer,int4 size);

enum type_metatype {
  TYPE_VOID = 10,       
  TYPE_SPACEBASE = 9,       
  TYPE_UNKNOWN = 8,     
  TYPE_INT = 7,         
  TYPE_UINT = 6,        
  TYPE_BOOL = 5,        
  TYPE_CODE = 4,        
  TYPE_FLOAT = 3,       

  TYPE_PTR = 2,         
  TYPE_ARRAY = 1,       
  TYPE_STRUCT = 0       
};

extern void metatype2string(type_metatype metatype,string &res);

extern type_metatype string2metatype(const string &metastring);

class Architecture;     // Forward declarations
class Scope;
class TypeFactory;
struct DatatypeCompare;

class Datatype {
protected:
  enum {
    coretype = 1,       
    // Bits above the first bit are considered a sub-metatype
    // If the metatypes are equal, we compare on sub-metatype
    // Currently this is only used to order int, char, and enum
    // The order of the sub-metatype is reversed so that
    // char comes before int1
    chartype = 2,       
    enumtype = 4,       
    poweroftwo = 8,     
    utf16 = 16,         
    utf32 = 32          
  };
  friend class TypeFactory;
  friend struct DatatypeCompare;
  int4 size;            
  string name;          
  type_metatype metatype;   
  uint4 flags;          
  uint8 id;         
  void restoreXmlBasic(const Element *el);  
  virtual void restoreXml(const Element *el,TypeFactory &typegrp);  
  static uint8 hashName(const string &nm);  
public:
  Datatype(const Datatype &op) { size = op.size; name=op.name; metatype=op.metatype; flags=op.flags; id=op.id; }
  Datatype(int4 s,type_metatype m) { size=s; metatype=m; flags=0; id=0; }
  Datatype(int4 s,type_metatype m,const string &n) { name=n; size=s; metatype=m; flags=0; id=0; }
  virtual ~Datatype(void) {}    
  bool isCoreType(void) const { return ((flags&coretype)!=0); } 
  bool isCharPrint(void) const { return ((flags&(chartype|utf16|utf32))!=0); }  
  bool isEnumType(void) const { return ((flags&enumtype)!=0); }     
  bool isPowerOfTwo(void) const { return ((flags&poweroftwo)!=0); } 
  bool isASCII(void) const { return ((flags&chartype)!=0); }    
  bool isUTF16(void) const { return ((flags&utf16)!=0); }   
  bool isUTF32(void) const { return ((flags&utf32)!=0); }   
  uint4 getInheritable(void) const { return (flags & coretype); }   
  type_metatype getMetatype(void) const { return metatype; }    
  uint8 getId(void) const { return id; }            
  int4 getSize(void) const { return size; }         
  const string &getName(void) const { return name; }        
  virtual void printRaw(ostream &s) const;          
  virtual Datatype *getSubType(uintb off,uintb *newoff) const; 
  virtual int4 numDepend(void) const { return 0; }  
  virtual Datatype *getDepend(int4 index) const { return (Datatype *)0; }   
  virtual void printNameBase(ostream &s) const { if (!name.empty()) s<<name[0]; } 
  virtual int4 compare(const Datatype &op,int4 level) const; 
  virtual int4 compareDependency(const Datatype &op) const; 
  virtual Datatype *clone(void) const=0;    
  virtual void saveXml(ostream &s) const;   
  int4 typeOrder(const Datatype &op) const { if (this==&op) return 0; return compare(op,10); }  
  int4 typeOrderBool(const Datatype &op) const; 
  void saveXmlBasic(ostream &s) const;  
  void saveXmlRef(ostream &s) const;    
};

struct TypeField {
  int4 offset;          
  string name;          
  Datatype *type;       
  bool operator<(const TypeField &op2) const { return (offset < op2.offset); }  
};

struct DatatypeCompare {
  bool operator()(const Datatype *a,const Datatype *b) const {
    int4 res = a->compareDependency(*b);
    if (res != 0) return (res<0);
    return a->getId() < b->getId(); }
};

struct DatatypeNameCompare {
  bool operator()(const Datatype *a,const Datatype *b) const {
    int4 res = a->getName().compare( b->getName() );
    if (res != 0) return (res < 0);
    return a->getId() < b->getId(); }
};

typedef set<Datatype *,DatatypeCompare> DatatypeSet;

typedef set<Datatype *,DatatypeNameCompare> DatatypeNameSet;

class TypeBase : public Datatype {
protected:
  friend class TypeFactory;
public:
  TypeBase(const TypeBase &op) : Datatype(op) {}
  TypeBase(int4 s,type_metatype m) : Datatype(s,m) {}
  TypeBase(int4 s,type_metatype m,const string &n) : Datatype(s,m,n) {}
  virtual Datatype *clone(void) const { return new TypeBase(*this); }
};

class TypeChar : public TypeBase {
protected:
  friend class TypeFactory;
public:
  TypeChar(const TypeChar &op) : TypeBase(op) { flags |= Datatype::chartype; }
  TypeChar(const string &n) : TypeBase(1,TYPE_INT,n) { flags |= Datatype::chartype; }
  virtual Datatype *clone(void) const { return new TypeChar(*this); }
  virtual void saveXml(ostream &s) const;
};

class TypeUnicode : public TypeBase { // Unicode character type
  void setflags(void);  
protected:
  friend class TypeFactory;
  virtual void restoreXml(const Element *el,TypeFactory &typegrp);
public:
  TypeUnicode(void) : TypeBase(0,TYPE_INT) {} 
  TypeUnicode(const TypeUnicode &op) : TypeBase(op) {}  
  TypeUnicode(const string &nm,int4 sz,type_metatype m);    
  virtual Datatype *clone(void) const { return new TypeUnicode(*this); }
  virtual void saveXml(ostream &s) const;
};

class TypeVoid : public Datatype {
protected:
  friend class TypeFactory;
public:
  TypeVoid(const TypeVoid &op) : Datatype(op) { flags |= Datatype::coretype; }
  TypeVoid(void) : Datatype(0,TYPE_VOID,"void") { flags |= Datatype::coretype; }
  virtual Datatype *clone(void) const { return new TypeVoid(*this); }
  virtual void saveXml(ostream &s) const;
};

class TypePointer : public Datatype {
protected:
  friend class TypeFactory;
  Datatype *ptrto;      
  uint4 wordsize;               
  virtual void restoreXml(const Element *el,TypeFactory &typegrp);
  TypePointer(void) : Datatype(0,TYPE_PTR) { ptrto = (Datatype *)0; wordsize=1; }
public:
  TypePointer(const TypePointer &op) : Datatype(op) { ptrto = op.ptrto; wordsize=op.wordsize; }
  TypePointer(int4 s,Datatype *pt,uint4 ws) : Datatype(s,TYPE_PTR) { ptrto = pt; flags = ptrto->getInheritable(); wordsize=ws; }
  Datatype *getPtrTo(void) const { return ptrto; }  
  uint4 getWordSize(void) const { return wordsize; }    
  virtual void printRaw(ostream &s) const;
  virtual int4 numDepend(void) const { return 1; }
  virtual Datatype *getDepend(int4 index) const { return ptrto; }
  virtual void printNameBase(ostream &s) const { s << 'p'; ptrto->printNameBase(s); }
  virtual int4 compare(const Datatype &op,int4 level) const; // For tree structure
  virtual int4 compareDependency(const Datatype &op) const; // For tree structure
  virtual Datatype *clone(void) const { return new TypePointer(*this); }
  virtual void saveXml(ostream &s) const;
};

class TypeArray : public Datatype {
protected:
  friend class TypeFactory;
  Datatype *arrayof;        
  int4 arraysize;       
  virtual void restoreXml(const Element *el,TypeFactory &typegrp);
  TypeArray(void) : Datatype(0,TYPE_ARRAY) { arraysize = 0; arrayof = (Datatype *)0; }
public:
  TypeArray(const TypeArray &op) : Datatype(op) { arrayof = op.arrayof; arraysize = op.arraysize; }
  TypeArray(int4 n,Datatype *ao) : Datatype(n*ao->getSize(),TYPE_ARRAY) {
    arraysize = n; arrayof = ao; }
  Datatype *getBase(void) const { return arrayof; } 
  int4 numElements(void) const { return arraysize; }    
  Datatype *getSubEntry(int4 off,int4 sz,int4 *newoff,int4 *el) const;  
  virtual void printRaw(ostream &s) const;
  virtual Datatype *getSubType(uintb off,uintb *newoff) const;
  virtual int4 numDepend(void) const { return 1; }
  virtual Datatype *getDepend(int4 index) const { return arrayof; }
  virtual void printNameBase(ostream &s) const { s << 'a'; arrayof->printNameBase(s); }
  virtual int4 compare(const Datatype &op,int4 level) const; // For tree structure
  virtual int4 compareDependency(const Datatype &op) const; // For tree structure
  virtual Datatype *clone(void) const { return new TypeArray(*this); }
  virtual void saveXml(ostream &s) const;
};

class TypeEnum : public TypeBase {
protected:
  friend class TypeFactory;
  map<uintb,string> namemap;    
  vector<uintb> masklist;   
  void setNameMap(const map<uintb,string> &nmap);   
  virtual void restoreXml(const Element *el,TypeFactory &typegrp);
public:
  TypeEnum(const TypeEnum &op);
  TypeEnum(int4 s,type_metatype m) : TypeBase(s,m) { flags |= enumtype; }
  TypeEnum(int4 s,type_metatype m,const string &nm) : TypeBase(s,m,nm) { flags |= enumtype; }
  map<uintb,string>::const_iterator beginEnum(void) const { return namemap.begin(); }   
  map<uintb,string>::const_iterator endEnum(void) const { return namemap.end(); }   
  bool getMatches(uintb val,vector<string> &matchname) const;   
  virtual int4 compare(const Datatype &op,int4 level) const;
  virtual int4 compareDependency(const Datatype &op) const;
  virtual Datatype *clone(void) const { return new TypeEnum(*this); }
  virtual void saveXml(ostream &s) const;
};

class TypeStruct : public Datatype {
protected:
  friend class TypeFactory;
  vector<TypeField> field;          
  void setFields(const vector<TypeField> &fd);  
  int4 getFieldIter(int4 off) const;        
  virtual void restoreXml(const Element *el,TypeFactory &typegrp);
public:
  TypeStruct(const TypeStruct &op); 
  TypeStruct(const string &n) : Datatype(0,TYPE_STRUCT,n) {}    
  vector<TypeField>::const_iterator beginField(void) const { return field.begin(); }    
  vector<TypeField>::const_iterator endField(void) const { return field.end(); }    
  const TypeField *getField(int4 off,int4 sz,int4 *newoff) const;   
  virtual Datatype *getSubType(uintb off,uintb *newoff) const;
  virtual int4 numDepend(void) const { return field.size(); }
  virtual Datatype *getDepend(int4 index) const { return field[index].type; }
  virtual int4 compare(const Datatype &op,int4 level) const; // For tree structure
  virtual int4 compareDependency(const Datatype &op) const; // For tree structure
  virtual Datatype *clone(void) const { return new TypeStruct(*this); }
  virtual void saveXml(ostream &s) const;
};

class FuncProto;        // Forward declaration
class ProtoModel;

class TypeCode : public Datatype {
protected:
  friend class TypeFactory;
  FuncProto *proto;     
  void set(ProtoModel *model,
       Datatype *outtype,const vector<Datatype *> &intypes,
       bool dotdotdot,Datatype *voidtype);  
  virtual void restoreXml(const Element *el,TypeFactory &typegrp);
public:
  TypeCode(const TypeCode &op);     
  TypeCode(const string &nm);       
  int4 compareBasic(const TypeCode *op) const;  
  const FuncProto *getPrototype(void) const { return proto; }   
  void setProperties(bool hasThisPtr,bool isConstructor,bool isDestructor); 
  virtual ~TypeCode(void);
  virtual void printRaw(ostream &s) const;
  virtual int4 compare(const Datatype &op,int4 level) const;
  virtual int4 compareDependency(const Datatype &op) const;
  virtual Datatype *clone(void) const { return new TypeCode(*this); }
  virtual void saveXml(ostream &s) const;
};

class TypeSpacebase : public Datatype {
  friend class TypeFactory;
  AddrSpace *spaceid;       
  Address localframe;       
  Architecture *glb;        
  virtual void restoreXml(const Element *el,TypeFactory &typegrp);
public:
  TypeSpacebase(const TypeSpacebase &op) : Datatype(op) {
    spaceid = op.spaceid; localframe=op.localframe; glb=op.glb;
  }
  TypeSpacebase(AddrSpace *id,const Address &frame,Architecture *g)
    : Datatype(0,TYPE_SPACEBASE), localframe(frame) { spaceid = id; glb = g; }
  Scope *getMap(void) const;    
  Address getAddress(uintb off,int4 sz,const Address &point) const; 
  virtual Datatype *getSubType(uintb off,uintb *newoff) const;
  virtual int4 compare(const Datatype &op,int4 level) const;
  virtual int4 compareDependency(const Datatype &op) const; // For tree structure
  virtual Datatype *clone(void) const { return new TypeSpacebase(*this); }
  virtual void saveXml(ostream &s) const;
};

class TypeFactory {
  int4 sizeOfInt;       
  int4 align;           
  int4 enumsize;        
  type_metatype enumtype;   
  DatatypeSet tree;     
  DatatypeNameSet nametree; 
  Datatype *typecache[9][8];    
  Datatype *typecache10;    
  Datatype *typecache16;    
  Datatype *type_nochar;    
  Datatype *findNoName(Datatype &ct);   
  Datatype *findAdd(Datatype &ct);  
  void orderRecurse(vector<Datatype *> &deporder,DatatypeSet &mark,Datatype *ct) const; 
  Datatype *restoreXmlTypeNoRef(const Element *el,bool forcecore);  
  void clearCache(void);        
  TypeChar *getTypeChar(const string &n);   
  TypeUnicode *getTypeUnicode(const string &nm,int4 sz,type_metatype m);    
  TypeCode *getTypeCode(const string &n);   
protected:
  Architecture *glb;        
  Datatype *findByIdLocal(const string &nm,uint8 id) const; 
  virtual Datatype *findById(const string &n,uint8 id);     
public:
  TypeFactory(Architecture *g); 
  void setupSizes(void);    
  void clear(void);     
  void clearNoncore(void);  
  virtual ~TypeFactory(void);   
  void setStructAlign(int4 al) { align = al; }      
  int4 getStructAlign(void) const { return align; } 
  int4 getSizeOfInt(void) const { return sizeOfInt; }   
  Architecture *getArch(void) const { return glb; } 
  Datatype *findByName(const string &n);        
  Datatype *setName(Datatype *ct,const string &n);  
  bool setFields(vector<TypeField> &fd,TypeStruct *ot,int4 fixedsize);  
  bool setEnumValues(const vector<string> &namelist,
              const vector<uintb> &vallist,
              const vector<bool> &assignlist,
              TypeEnum *te);        
  Datatype *restoreXmlType(const Element *el);  
  Datatype *restoreXmlTypeWithCodeFlags(const Element *el,bool hasThisPtr,bool isConstructor,bool isDestructor);
  TypeVoid *getTypeVoid(void);                  
  Datatype *getBaseNoChar(int4 s,type_metatype m);      
  Datatype *getBase(int4 s,type_metatype m);            
  Datatype *getBase(int4 s,type_metatype m,const string &n);    
  TypeCode *getTypeCode(void);                  
  TypePointer *getTypePointer(int4 s,Datatype *pt,uint4 ws);    
  TypePointer *getTypePointerAbsolute(int4 s,Datatype *pt,uint4 ws);    
  TypePointer *getTypePointerNoDepth(int4 s,Datatype *pt,uint4 ws); 
  TypeArray *getTypeArray(int4 as,Datatype *ao);        
  TypeStruct *getTypeStruct(const string &n);           
  TypeEnum *getTypeEnum(const string &n);           
  TypeSpacebase *getTypeSpacebase(AddrSpace *id,const Address &addr);   
  TypeCode *getTypeCode(ProtoModel *model,Datatype *outtype,
            const vector<Datatype *> &intypes,
            bool dotdotdot);            
  void destroyType(Datatype *ct);               
  Datatype *downChain(Datatype *ptrtype,uintb &off);        
  Datatype *concretize(Datatype *ct);               
  void dependentOrder(vector<Datatype *> &deporder) const;  
  void saveXml(ostream &s) const;           
  void saveXmlCoreTypes(ostream &s) const;      
  void restoreXml(const Element *el);           
  void restoreXmlCoreTypes(const Element *el);      
  void parseDataOrganization(const Element *el);    
  void parseEnumConfig(const Element *el);      
  void setCoreType(const string &name,int4 size,type_metatype meta,bool chartp);    
  void cacheCoreTypes(void);                
};

inline int4 Datatype::typeOrderBool(const Datatype &op) const

{
  if (this == &op) return 0;
  if (metatype == TYPE_BOOL) return 1;      // Never prefer bool over other data-types
  if (op.metatype == TYPE_BOOL) return -1;
  return compare(op,10);
}

#endif