KModule.h

Go to the documentation of this file.

//===-- KModule.h -----------------------------------------------*- C++ -*-===//
//
//                     The KLEE Symbolic Virtual Machine
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
 
#ifndef KLEE_KMODULE_H
#define KLEE_KMODULE_H
 
#include "klee/Config/Version.h"
#include "klee/Core/Interpreter.h"
 
#include "llvm/ADT/ArrayRef.h"
 
#include <map>
#include <memory>
#include <set>
#include <vector>
 
namespace llvm {
  class BasicBlock;
  class Constant;
  class Function;
  class Instruction;
  class Module;
  class DataLayout;
}
 
namespace klee {
  struct Cell;
  class Executor;
  class Expr;
  class InterpreterHandler;
  class InstructionInfoTable;
  struct KInstruction;
  class KModule;
  template<class T> class ref;
 
  struct KFunction {
    llvm::Function *function;
 
    unsigned numArgs, numRegisters;
 
    unsigned numInstructions;
    KInstruction **instructions;
 
    std::map<llvm::BasicBlock*, unsigned> basicBlockEntry;
 
    bool trackCoverage;
 
  public:
    explicit KFunction(llvm::Function*, KModule *);
    KFunction(const KFunction &) = delete;
    KFunction &operator=(const KFunction &) = delete;
 
    ~KFunction();
 
    unsigned getArgRegister(unsigned index) { return index; }
  };
 
 
  class KConstant {
  public:
    llvm::Constant* ct;
 
    unsigned id;
 
    KInstruction *ki;
 
    KConstant(llvm::Constant*, unsigned, KInstruction*);
  };
 
 
  class KModule {
  public:
    std::unique_ptr<llvm::Module> module;
    std::unique_ptr<llvm::DataLayout> targetData;
 
    // Our shadow versions of LLVM structures.
    std::vector<std::unique_ptr<KFunction>> functions;
    std::map<llvm::Function*, KFunction*> functionMap;
 
    // Functions which escape (may be called indirectly)
    // XXX change to KFunction
    std::set<llvm::Function*> escapingFunctions;
 
    std::unique_ptr<InstructionInfoTable> infos;
 
    std::vector<llvm::Constant*> constants;
    std::map<const llvm::Constant *, std::unique_ptr<KConstant>> constantMap;
    KConstant* getKConstant(const llvm::Constant *c);
 
    std::unique_ptr<Cell[]> constantTable;
 
    // Functions which are part of KLEE runtime
    std::set<const llvm::Function*> internalFunctions;
 
  private:
    // Mark function with functionName as part of the KLEE runtime
    void addInternalFunction(const char* functionName);
 
  public:
    KModule() = default;
 
    //
    void optimiseAndPrepare(const Interpreter::ModuleOptions &opts,
                            llvm::ArrayRef<const char *>);
 
    // FIXME: ihandler should not be here
    void manifest(InterpreterHandler *ih, bool forceSourceOutput);
 
    bool link(std::vector<std::unique_ptr<llvm::Module>> &modules,
              const std::string &entryPoint);
 
    void instrument(const Interpreter::ModuleOptions &opts);
 
    unsigned getConstantID(llvm::Constant *c, KInstruction* ki);
 
    void checkModule();
  };
} // End klee namespace
 
#endif /* KLEE_KMODULE_H */