cover.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_COVER__
#define __CPUI_COVER__
 
#include "type.hh"
 
class PcodeOp;
class FlowBlock;
class Varnode;
 
class CoverBlock {
  const PcodeOp *start;     
  const PcodeOp *stop;      
public:
  CoverBlock(void) { start = (const PcodeOp *)0; stop = (const PcodeOp *)0; }   
  static uintm getUIndex(const PcodeOp *op);                    
  const PcodeOp *getStart(void) const { return start; }             
  const PcodeOp *getStop(void) const { return stop; }               
  void clear(void) { start = (const PcodeOp *)0; stop = (const PcodeOp *)0; }   
  void setAll(void) {
    start = (const PcodeOp *)0; stop = (const PcodeOp *)1; }            
  void setBegin(const PcodeOp *begin) {
    start = begin; if (stop==(const PcodeOp *)0) stop = (const PcodeOp *)1; }   
  void setEnd(const PcodeOp *end) { stop = end; }               
  int4 intersect(const CoverBlock &op2) const;                  
  bool empty(void) const {
    return ((start==(const PcodeOp *)0)&&(stop==(const PcodeOp *)0)); }     
  bool contain(const PcodeOp *point) const;                 
  int4 boundary(const PcodeOp *point) const;                    
  void merge(const CoverBlock &op2);                    
  void print(ostream &s) const;                     
};
 
class Cover {
  map<int4,CoverBlock> cover;           
  static const CoverBlock emptyBlock;       
  void addRefRecurse(const FlowBlock *bl);  
public:
  void clear(void) { cover.clear(); }       
  int4 compareTo(const Cover &op2) const;   
  const CoverBlock &getCoverBlock(int4 i) const;    
  int4 intersect(const Cover &op2) const;   
  int4 intersectByBlock(int4 blk,const Cover &op2) const;   
  void intersectList(vector<int4> &listout,const Cover &op2,int4 level) const;
  bool contain(const PcodeOp *op,int4 max) const;
  int4 containVarnodeDef(const Varnode *vn) const;
  void merge(const Cover &op2);         
  void rebuild(const Varnode *vn);      
  void addDefPoint(const Varnode *vn);      
  void addRefPoint(const PcodeOp *ref,const Varnode *vn);   
  //  void remove_refpoint(const PcodeOp *ref,const Varnode *vn) {
  //    rebuild(vn); }      // Cheap but inefficient
  void print(ostream &s) const;         
  map<int4,CoverBlock>::const_iterator begin(void) const { return cover.begin(); }  
  map<int4,CoverBlock>::const_iterator end(void) const { return cover.end(); }      
};
 
#endif