merge.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_MERGE__
#define __CPUI_MERGE__
 
 
#include "op.hh"
 
class HighEdge {
  friend class Merge;
  HighVariable *a;      
  HighVariable *b;      
public:
  bool operator<(const HighEdge &op2) const { if (a==op2.a) return (b<op2.b); return (a<op2.a); }
  HighEdge(HighVariable *c,HighVariable *d) { a=c; b=d; } 
};
 
class BlockVarnode {
  int4 index;       
  Varnode *vn;      
public:
  void set(Varnode *v);     
  bool operator<(const BlockVarnode &op2) const { return (index < op2.index); } 
  Varnode *getVarnode(void) const { return vn; } 
  int4 getIndex(void) const { return index; }    
  static int4 findFront(int4 blocknum,const vector<BlockVarnode> &list);
};
 
class Funcdata;
 
class Merge {
  Funcdata &data;       
  map<HighEdge,bool> highedgemap; 
  vector<PcodeOp *> copyTrims;  
  bool updateHigh(HighVariable *a); 
  void purgeHigh(HighVariable *high); 
  bool blockIntersection(HighVariable *a,HighVariable *b,int4 blk);
  static bool mergeTestRequired(HighVariable *high_out,HighVariable *high_in);
  static bool mergeTestAdjacent(HighVariable *high_out,HighVariable *high_in);
  static bool mergeTestSpeculative(HighVariable *high_out,HighVariable *high_in);
  static bool mergeTestBasic(Varnode *vn);
  static void findSingleCopy(HighVariable *high,vector<Varnode *> &singlelist);
  static bool compareHighByBlock(const HighVariable *a,const HighVariable *b);
  static bool compareCopyByInVarnode(PcodeOp *op1,PcodeOp *op2);
  static bool shadowedVarnode(const Varnode *vn);
  static void findAllIntoCopies(HighVariable *high,vector<PcodeOp *> &copyIns,bool filterTemps);
  void collectCovering(vector<Varnode *> &vlist,HighVariable *high,PcodeOp *op);
  bool collectCorrectable(const vector<Varnode *> &vlist,list<PcodeOp *> &oplist,vector<int4> &slotlist,
               PcodeOp *op);
  PcodeOp *allocateCopyTrim(Varnode *inVn,Datatype *ct,const Address &addr);
  void snipReads(Varnode *vn,list<PcodeOp *> &markedop);
  void snipIndirect(PcodeOp *indop);
  void eliminateIntersect(Varnode *vn,const vector<BlockVarnode> &blocksort);
  void unifyAddress(VarnodeLocSet::const_iterator startiter,VarnodeLocSet::const_iterator enditer);
  void trimOpOutput(PcodeOp *op);
  void trimOpInput(PcodeOp *op,int4 slot);
  void mergeRangeMust(VarnodeLocSet::const_iterator startiter,VarnodeLocSet::const_iterator enditer);
  void mergeOp(PcodeOp *op);
  void mergeIndirect(PcodeOp *indop);
  void mergeLinear(vector<HighVariable *> &highvec);
  bool merge(HighVariable *high1,HighVariable *high2,bool isspeculative);
  bool checkCopyPair(HighVariable *high,PcodeOp *domOp,PcodeOp *subOp);
  void buildDominantCopy(HighVariable *high,vector<PcodeOp *> &copy,int4 pos,int4 size);
  void markRedundantCopies(HighVariable *high,vector<PcodeOp *> &copy,int4 pos,int4 size);
  void processHighDominantCopy(HighVariable *high);
  void processHighRedundantCopy(HighVariable *high);
public:
  Merge(Funcdata &fd) : data(fd) {} 
  bool intersection(HighVariable *a,HighVariable *b);
  bool inflateTest(Varnode *a,HighVariable *high);
  void inflate(Varnode *a,HighVariable *high);
  bool mergeTest(HighVariable *high,vector<HighVariable *> &tmplist);
 
  void mergeOpcode(OpCode opc);
  void mergeByDatatype(VarnodeLocSet::const_iterator startiter,VarnodeLocSet::const_iterator enditer);
  void mergeAddrTied(void);
  void mergeMarker(void);
  void mergeAdjacent(void);
  void mergeMultiEntry(void);
  bool hideShadows(HighVariable *high);
  void processCopyTrims(void);
  void markInternalCopies(void);
#ifdef MERGEMULTI_DEBUG
  void verifyHighCovers(void);
#endif
};
 
inline bool Merge::compareHighByBlock(const HighVariable *a,const HighVariable *b)
 
{
  int4 result = a->wholecover.compareTo(b->wholecover);
  if ( result == 0 ) {
    Varnode *v1 = a->getInstance( 0 );
    Varnode *v2 = b->getInstance( 0 );
    
    if ( v1->getAddr() == v2->getAddr() ) {
      PcodeOp *def1 = v1->getDef();
      PcodeOp *def2 = v2->getDef();
      if ( def1 == (PcodeOp *) 0 ) {
    return true;
      }
      else if ( def2 == (PcodeOp *) 0 ) {
    return false;
      }
      return (def1->getAddr() < def2->getAddr());
    }
    return (v1->getAddr() < v2->getAddr());
  }
  return (result < 0);
}
 
#endif