contrib/llvm/tools/lli/RemoteTarget.h

   1 //===- RemoteTarget.h - LLVM Remote process JIT execution ----------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // Definition of the RemoteTarget class which executes JITed code in a
  11 // separate address range from where it was built.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #ifndef REMOTEPROCESS_H
  16 #define REMOTEPROCESS_H
  17
  18 #include "llvm/ADT/SmallVector.h"
  19 #include "llvm/ADT/StringRef.h"
  20 #include "llvm/Support/DataTypes.h"
  21 #include "llvm/Support/Memory.h"
  22 #include <stdlib.h>
  23 #include <string>
  24
  25 namespace llvm {
  26
  27 class RemoteTarget {
  28   std::string ErrorMsg;
  29   bool IsRunning;
  30
  31   SmallVector<sys::MemoryBlock, 16> Allocations;
  32
  33 public:
  34   StringRef getErrorMsg() const { return ErrorMsg; }
  35
  36   /// Allocate space in the remote target address space.
  37   ///
  38   /// @param      Size      Amount of space, in bytes, to allocate.
  39   /// @param      Alignment Required minimum alignment for allocated space.
  40   /// @param[out] Address   Remote address of the allocated memory.
  41   ///
  42   /// @returns False on success. On failure, ErrorMsg is updated with
  43   ///          descriptive text of the encountered error.
  44   virtual bool allocateSpace(size_t Size,
  45                              unsigned Alignment,
  46                              uint64_t &Address);
  47
  48   /// Load data into the target address space.
  49   ///
  50   /// @param      Address   Destination address in the target process.
  51   /// @param      Data      Source address in the host process.
  52   /// @param      Size      Number of bytes to copy.
  53   ///
  54   /// @returns False on success. On failure, ErrorMsg is updated with
  55   ///          descriptive text of the encountered error.
  56   virtual bool loadData(uint64_t Address,
  57                         const void *Data,
  58                         size_t Size);
  59
  60   /// Load code into the target address space and prepare it for execution.
  61   ///
  62   /// @param      Address   Destination address in the target process.
  63   /// @param      Data      Source address in the host process.
  64   /// @param      Size      Number of bytes to copy.
  65   ///
  66   /// @returns False on success. On failure, ErrorMsg is updated with
  67   ///          descriptive text of the encountered error.
  68   virtual bool loadCode(uint64_t Address,
  69                         const void *Data,
  70                         size_t Size);
  71
  72   /// Execute code in the target process. The called function is required
  73   /// to be of signature int "(*)(void)".
  74   ///
  75   /// @param      Address   Address of the loaded function in the target
  76   ///                       process.
  77   /// @param[out] RetVal    The integer return value of the called function.
  78   ///
  79   /// @returns False on success. On failure, ErrorMsg is updated with
  80   ///          descriptive text of the encountered error.
  81   virtual bool executeCode(uint64_t Address,
  82                            int &RetVal);
  83
  84   /// Minimum alignment for memory permissions. Used to seperate code and
  85   /// data regions to make sure data doesn't get marked as code or vice
  86   /// versa.
  87   ///
  88   /// @returns Page alignment return value. Default of 4k.
  89   virtual unsigned getPageAlignment() { return 4096; }
  90
  91   /// Start the remote process.
  92   virtual void create();
  93
  94   /// Terminate the remote process.
  95   virtual void stop();
  96
  97   RemoteTarget() : ErrorMsg(""), IsRunning(false) {}
  98   virtual ~RemoteTarget() { if (IsRunning) stop(); }
  99
 100   // Create an instance of the system-specific remote target class.
 101   static RemoteTarget *createRemoteTarget();
 102   static RemoteTarget *createExternalRemoteTarget(std::string &ChildName);
 103   static bool hostSupportsExternalRemoteTarget();
 104 private:
 105   // Main processing function for the remote target process. Command messages
 106   // are received on file descriptor CmdFD and responses come back on OutFD.
 107   static void doRemoteTargeting(int CmdFD, int OutFD);
 108 };
 109
 110 } // end namespace llvm
 111
 112 #endif