Subversion Repositories QNX 8.QNX8 LLVM/Clang compiler suite

Rev

Blame | Last modification | View Log | Download | RSS feed

  1. //===- EPCGenericMemoryAccess.h - Generic EPC MemoryAccess impl -*- C++ -*-===//
  2. //
  3. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
  4. // See https://llvm.org/LICENSE.txt for license information.
  5. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
  6. //
  7. //===----------------------------------------------------------------------===//
  8. //
  9. // Implements ExecutorProcessControl::MemoryAccess by making calls to
  10. // ExecutorProcessControl::callWrapperAsync.
  11. //
  12. // This simplifies the implementaton of new ExecutorProcessControl instances,
  13. // as this implementation will always work (at the cost of some performance
  14. // overhead for the calls).
  15. //
  16. //===----------------------------------------------------------------------===//
  17.  
  18. #ifndef LLVM_EXECUTIONENGINE_ORC_EPCGENERICMEMORYACCESS_H
  19. #define LLVM_EXECUTIONENGINE_ORC_EPCGENERICMEMORYACCESS_H
  20.  
  21. #include "llvm/ExecutionEngine/Orc/Core.h"
  22.  
  23. namespace llvm {
  24. namespace orc {
  25.  
  26. class EPCGenericMemoryAccess : public ExecutorProcessControl::MemoryAccess {
  27. public:
  28.   /// Function addresses for memory access.
  29.   struct FuncAddrs {
  30.     ExecutorAddr WriteUInt8s;
  31.     ExecutorAddr WriteUInt16s;
  32.     ExecutorAddr WriteUInt32s;
  33.     ExecutorAddr WriteUInt64s;
  34.     ExecutorAddr WriteBuffers;
  35.   };
  36.  
  37.   /// Create an EPCGenericMemoryAccess instance from a given set of
  38.   /// function addrs.
  39.   EPCGenericMemoryAccess(ExecutorProcessControl &EPC, FuncAddrs FAs)
  40.       : EPC(EPC), FAs(FAs) {}
  41.  
  42.   void writeUInt8sAsync(ArrayRef<tpctypes::UInt8Write> Ws,
  43.                         WriteResultFn OnWriteComplete) override {
  44.     using namespace shared;
  45.     EPC.callSPSWrapperAsync<void(SPSSequence<SPSMemoryAccessUInt8Write>)>(
  46.         FAs.WriteUInt8s, std::move(OnWriteComplete), Ws);
  47.   }
  48.  
  49.   void writeUInt16sAsync(ArrayRef<tpctypes::UInt16Write> Ws,
  50.                          WriteResultFn OnWriteComplete) override {
  51.     using namespace shared;
  52.     EPC.callSPSWrapperAsync<void(SPSSequence<SPSMemoryAccessUInt16Write>)>(
  53.         FAs.WriteUInt16s, std::move(OnWriteComplete), Ws);
  54.   }
  55.  
  56.   void writeUInt32sAsync(ArrayRef<tpctypes::UInt32Write> Ws,
  57.                          WriteResultFn OnWriteComplete) override {
  58.     using namespace shared;
  59.     EPC.callSPSWrapperAsync<void(SPSSequence<SPSMemoryAccessUInt32Write>)>(
  60.         FAs.WriteUInt32s, std::move(OnWriteComplete), Ws);
  61.   }
  62.  
  63.   void writeUInt64sAsync(ArrayRef<tpctypes::UInt64Write> Ws,
  64.                          WriteResultFn OnWriteComplete) override {
  65.     using namespace shared;
  66.     EPC.callSPSWrapperAsync<void(SPSSequence<SPSMemoryAccessUInt64Write>)>(
  67.         FAs.WriteUInt64s, std::move(OnWriteComplete), Ws);
  68.   }
  69.  
  70.   void writeBuffersAsync(ArrayRef<tpctypes::BufferWrite> Ws,
  71.                          WriteResultFn OnWriteComplete) override {
  72.     using namespace shared;
  73.     EPC.callSPSWrapperAsync<void(SPSSequence<SPSMemoryAccessBufferWrite>)>(
  74.         FAs.WriteBuffers, std::move(OnWriteComplete), Ws);
  75.   }
  76.  
  77. private:
  78.   ExecutorProcessControl &EPC;
  79.   FuncAddrs FAs;
  80. };
  81.  
  82. } // end namespace orc
  83. } // end namespace llvm
  84.  
  85. #endif // LLVM_EXECUTIONENGINE_ORC_EPCGENERICMEMORYACCESS_H
  86.