cpool.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 __CPOOL__
#define __CPOOL__
 
#include "type.hh"
 
class CPoolRecord {
public:
  enum {
    primitive=0,    
    string_literal=1,   
    class_reference=2,  
    pointer_method=3,   
    pointer_field=4,    
    array_length=5, 
    instance_of=6,  
    check_cast=7    
  };
  enum {
    is_constructor = 0x1,   
    is_destructor = 0x2     
  };
private:
  friend class ConstantPool;
  uint4 tag;        
  uint4 flags;      
  string token;     
  uintb value;      
  Datatype *type;   
  uint1 *byteData;  
  int4 byteDataLen; 
public:
  CPoolRecord(void) { type = (Datatype *)0; byteData = (uint1 *)0; }        
  ~CPoolRecord(void) { if (byteData != (uint1 *)0) delete [] byteData; }    
  uint4 getTag(void) const { return tag; }                  
  const string &getToken(void) const { return token; }              
  const uint1 *getByteData(void) const { return byteData; }         
  int4 getByteDataLength(void) const { return byteDataLen; }            
  Datatype *getType(void) const { return type; }                
  uintb getValue(void) const { return value; }                  
  bool isConstructor(void) const { return ((flags & is_constructor)!=0); }  
  bool isDestructor(void) const { return ((flags & is_destructor)!=0); }    
  void saveXml(ostream &s) const;                       
  void restoreXml(const Element *el,TypeFactory &typegrp);          
};
 
class ConstantPool {
  virtual CPoolRecord *createRecord(const vector<uintb> &refs)=0;
public:
  virtual ~ConstantPool() {}    
 
  virtual const CPoolRecord *getRecord(const vector<uintb> &refs) const=0;
 
  void putRecord(const vector<uintb> &refs,uint4 tag,const string &tok,Datatype *ct);
 
  const CPoolRecord *restoreXmlRecord(const vector<uintb> &refs,const Element *el,TypeFactory &typegrp);
 
  virtual bool empty(void) const=0;     
  virtual void clear(void)=0;           
 
  virtual void saveXml(ostream &s) const=0;
 
  virtual void restoreXml(const Element *el,TypeFactory &typegrp)=0;
};
 
class ConstantPoolInternal : public ConstantPool {
 
  class CheapSorter {
  public:
    uintb a;            
    uintb b;            
    CheapSorter(void) { a = 0; b = 0; } 
    CheapSorter(const CheapSorter &op2) { a = op2.a; b = op2.b; }   
    CheapSorter(const vector<uintb> &refs) { a = refs[0]; b = (refs.size() > 1) ? refs[1] : 0; } 
 
    bool operator<(const CheapSorter &op2) const {
      if (a != op2.a) return (a<op2.a);
      return (b < op2.b);
    }
 
    void apply(vector<uintb> &refs) const { refs.push_back(a); refs.push_back(b); }
 
    void saveXml(ostream &s) const;     
    void restoreXml(const Element *el);     
  };
  map<CheapSorter,CPoolRecord> cpoolMap;    
  virtual CPoolRecord *createRecord(const vector<uintb> &refs);
public:
  virtual const CPoolRecord *getRecord(const vector<uintb> &refs) const;
  virtual bool empty(void) const { return cpoolMap.empty(); }
  virtual void clear(void) { cpoolMap.clear(); }
  virtual void saveXml(ostream &s) const;
  virtual void restoreXml(const Element *el,TypeFactory &typegrp);
};
 
#endif