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 "IR/SEG/SEGMapBase.h"
#include "IR/SEG/SymbolicExprGraph.h"
#include "Language/Spec/Memory.h"
 
using namespace llvm;
 
class SEGOperandNode;
class SEGLoadMemNode;
class SEGStoreMemNode;
class CFGReachabilityAnalysis;
class ControlDependenceAnalysis;
class DebugInfoAnalysis;
class FalconAA;
class FunctionPropertyPass;
class TypeInference;
class AADriver;
 
class SymbolicExprGraphBuilder : public ModulePass, public SEGMapBase {
public:
  static char ID;
  SymbolicExprGraphBuilder();
  ~SymbolicExprGraphBuilder();
 
  void getAnalysisUsage(AnalysisUsage &) const;
 
  bool runOnModule(Module &);
 
  SymbolicExprGraph *getOrCreateSymbolicExprGraph(Function *F);
 
  SEGOperandNode *getNode(Value *val);
 
  std::vector<std::pair<Value *, SEGRegionNode *>>
  loadPtrAt(Value *Ptr, pp_offset_t Off, Instruction *Loc);
 
  std::unordered_set<pp_offset_t> getAllocStoredZeroOff(Value *Alloc,
                                                        Instruction *Loc) const;
 
  std::set<Value *> getEscapeAllocSites(Function *Func) const;
 
  Value *getEscapeToAlloc(Function *Func, Function *Callee, Value *CalleeObj,
                          Instruction *CS) const;
 
private:
  CFGReachabilityAnalysis *CRA = nullptr;
  ControlDependenceAnalysis *CDGs = nullptr;
 
  TSDataLayout *TSDL = nullptr;
  DebugInfoAnalysis *DIA = nullptr;
  FalconAA *Falcon = nullptr;
  AADriver *AA = nullptr;
  FunctionPropertyPass *FPP = nullptr;
  TypeInference *INFER = nullptr;
 
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);
};
 
#endif