//===- ExecutionEngine.h - Abstract Execution Engine Interface --*- C++ -*-===//
// 
//                     The LLVM Compiler Infrastructure
//
// This file was developed by the LLVM research group and is distributed under
// the University of Illinois Open Source License. See LICENSE.TXT for details.
// 
//===----------------------------------------------------------------------===//
//
// This file defines the abstract interface that implements execution support
// for LLVM.
//
//===----------------------------------------------------------------------===//

#ifndef EXECUTION_ENGINE_H
#define EXECUTION_ENGINE_H

#include <vector>
#include <string>
#include <map>
#include <cassert>
class Constant;
class Function;
union GenericValue;
class GlobalValue;
class Module;
class ModuleProvider;
class TargetData;
class Type;

class ExecutionEngine {
  Module &CurMod;
  const TargetData *TD;

protected:
  ModuleProvider *MP;
  // GlobalAddress - A mapping between LLVM global values and their actualized
  // version...
  std::map<const GlobalValue*, void *> GlobalAddress;

  void setTargetData(const TargetData &td) {
    TD = &td;
  }

public:
  ExecutionEngine(ModuleProvider *P);
  ExecutionEngine(Module *M);
  virtual ~ExecutionEngine();
  
  Module &getModule() const { return CurMod; }
  const TargetData &getTargetData() const { return *TD; }

  /// run - Start execution with the specified function, arguments, and
  ///       environment.
  ///
  virtual GenericValue run(Function *F,
                           const std::vector<GenericValue> &ArgValues) = 0;

  static ExecutionEngine *create(ModuleProvider *MP, bool ForceInterpreter);

  void addGlobalMapping(const Function *F, void *Addr) {
    void *&CurVal = GlobalAddress[(const GlobalValue*)F];
    assert(CurVal == 0 && "GlobalMapping already established!");
    CurVal = Addr;
  }

  // getPointerToGlobalIfAvailable - This returns the address of the specified
  // global value if it is available, otherwise it returns null.
  //
  void *getPointerToGlobalIfAvailable(const GlobalValue *GV) {
    std::map<const GlobalValue*, void*>::iterator I = GlobalAddress.find(GV);
    return I != GlobalAddress.end() ? I->second : 0;
  }

  // getPointerToGlobal - This returns the address of the specified global
  // value.  This may involve code generation if it's a function.
  //
  void *getPointerToGlobal(const GlobalValue *GV);

  // getPointerToFunction - The different EE's represent function bodies in
  // different ways.  They should each implement this to say what a function
  // pointer should look like.
  //
  virtual void *getPointerToFunction(Function *F) = 0;

  void StoreValueToMemory(GenericValue Val, GenericValue *Ptr, const Type *Ty);
  void InitializeMemory(const Constant *Init, void *Addr);

protected:
  void emitGlobals();
  GenericValue getConstantValue(const Constant *C);
  GenericValue LoadValueFromMemory(GenericValue *Ptr, const Type *Ty);
};

#endif
