SymbolicExprGraphBuilder.h

/*
 * SEG construction wrapper.
 *
 * Author: Fan Gang, qingkai
 */
 
#ifndef IR_SEG_SYMBOLICEXPRGRAPHBUILDER_H
#define IR_SEG_SYMBOLICEXPRGRAPHBUILDER_H
 
#include <llvm/IR/Function.h>
#include <llvm/IR/Operator.h>
#include <llvm/Pass.h>
#include <mutex>
#include <string>
#include <unordered_map>
 
#include "Analysis/Bitcode/TSDataLayout.h"
#include "Analysis/CallGraph/CBCallGraph.h"
#include "IR/SEG/SEGMapBase.h"
#include "IR/SEG/SymbolicExprGraph.h"
 
using namespace llvm;
 
class SEGOperandNode;
class SEGLoadMemNode;
class SEGStoreMemNode;
class CFGReachabilityAnalysis;
class ControlDependenceAnalysis;
class DebugInfoAnalysis;
class FalconAA;
class FunctionPropertyPass;
class TypeInference;
 
namespace FalconPlus {
class FalconAA;
}
 
class SymbolicExprGraphBuilder : public ModulePass, public SEGMapBase {
public:
  static char ID;
  SymbolicExprGraphBuilder();
  ~SymbolicExprGraphBuilder();
 
  void getAnalysisUsage(AnalysisUsage &) const;
 
  bool runOnModule(Module &);
 
  SymbolicExprGraph *getSymbolicExprGraph(Function *F) override;
 
  SymbolicExprGraph *getSymbolicExprGraph(WrappedFunction *F) override;
 
  SEGOperandNode *getNode(Value *val);
 
private:
  CFGReachabilityAnalysis *CRA = nullptr;
  ControlDependenceAnalysis *CDGs = nullptr;
 
  TSDataLayout *TSDL = nullptr;
  DebugInfoAnalysis *DIA = nullptr;
  FalconAA *Falcon = nullptr;
  FalconPlus::FalconAA *FalconPlus = nullptr;
  FunctionPropertyPass *FPP = nullptr;
  TypeInference *INFER = nullptr;
 
  std::vector<SymbolicExprGraph *> SEGVector;
 
private:
  typedef std::unordered_map<Value *, kvec<SEGLoadMemNode *>>
      ValueLoadMemNodesMapTy;
  typedef std::unordered_map<Value *, kvec<SEGStoreMemNode *>>
      ValueStoreMemNodesMapTy;
 
  void matchLoadStore(SymbolicExprGraph *, ValueLoadMemNodesMapTy *,
                      ValueStoreMemNodesMapTy *);
 
  void labelBackEdge(Module &M);
 
  SymbolicExprGraph *buildSymbolicExprGraph(Function &F);
 
  void modelIntrinsics(CallSite CS, SymbolicExprGraph *G);
 
  void modelInstruction(Instruction &I, BasicBlock *, SymbolicExprGraph *G);
 
  SEGOperandNode *modelConstantExpr(ConstantExpr *CE, SymbolicExprGraph *G);
 
  SEGOpcodeNode *modelGEPOperator(GEPOperator *GEP, BasicBlock *B,
                                  SymbolicExprGraph *G);
 
  SEGOpcodeNode::CodeKind getOpcode(int LLVMInstOpcode, int Predicate = 0);
 
  SEGOperandNode *findOrCreateNode(SymbolicExprGraph *SEG, Value *V);
 
  void storePersistentSEG(Module &M, CBCallGraph &CBCG);
};
 
#endif