Subversion Repositories QNX 8.QNX8 LLVM/Clang compiler suite

Rev

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

  1. //===- AllocationActions.h -- JITLink allocation support calls  -*- 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. // Structures for making memory allocation support calls.
  10. //
  11. //===----------------------------------------------------------------------===//
  12.  
  13. #ifndef LLVM_EXECUTIONENGINE_ORC_SHARED_ALLOCATIONACTIONS_H
  14. #define LLVM_EXECUTIONENGINE_ORC_SHARED_ALLOCATIONACTIONS_H
  15.  
  16. #include "llvm/ExecutionEngine/Orc/Shared/ExecutorAddress.h"
  17. #include "llvm/ExecutionEngine/Orc/Shared/WrapperFunctionUtils.h"
  18. #include "llvm/Support/Memory.h"
  19.  
  20. #include <vector>
  21.  
  22. namespace llvm {
  23. namespace orc {
  24. namespace shared {
  25.  
  26. /// A pair of WrapperFunctionCalls, one to be run at finalization time, one to
  27. /// be run at deallocation time.
  28. ///
  29. /// AllocActionCallPairs should be constructed for paired operations (e.g.
  30. /// __register_ehframe and __deregister_ehframe for eh-frame registration).
  31. /// See comments for AllocActions for execution ordering.
  32. ///
  33. /// For unpaired operations one or the other member can be left unused, as
  34. /// AllocationActionCalls with an FnAddr of zero will be skipped.
  35. struct AllocActionCallPair {
  36.   WrapperFunctionCall Finalize;
  37.   WrapperFunctionCall Dealloc;
  38. };
  39.  
  40. /// A vector of allocation actions to be run for this allocation.
  41. ///
  42. /// Finalize allocations will be run in order at finalize time. Dealloc
  43. /// actions will be run in reverse order at deallocation time.
  44. using AllocActions = std::vector<AllocActionCallPair>;
  45.  
  46. /// Returns the number of deallocaton actions in the given AllocActions array.
  47. ///
  48. /// This can be useful if clients want to pre-allocate room for deallocation
  49. /// actions with the rest of their memory.
  50. inline size_t numDeallocActions(const AllocActions &AAs) {
  51.   return llvm::count_if(
  52.       AAs, [](const AllocActionCallPair &P) { return !!P.Dealloc; });
  53. }
  54.  
  55. /// Run finalize actions.
  56. ///
  57. /// If any finalize action fails then the corresponding dealloc actions will be
  58. /// run in reverse order (not including the deallocation action for the failed
  59. /// finalize action), and the error for the failing action will be returned.
  60. ///
  61. /// If all finalize actions succeed then a vector of deallocation actions will
  62. /// be returned. The dealloc actions should be run by calling
  63. /// runDeallocationActions. If this function succeeds then the AA argument will
  64. /// be cleared before the function returns.
  65. Expected<std::vector<WrapperFunctionCall>>
  66. runFinalizeActions(AllocActions &AAs);
  67.  
  68. /// Run deallocation actions.
  69. /// Dealloc actions will be run in reverse order (from last element of DAs to
  70. /// first).
  71. Error runDeallocActions(ArrayRef<WrapperFunctionCall> DAs);
  72.  
  73. using SPSAllocActionCallPair =
  74.     SPSTuple<SPSWrapperFunctionCall, SPSWrapperFunctionCall>;
  75.  
  76. template <>
  77. class SPSSerializationTraits<SPSAllocActionCallPair,
  78.                              AllocActionCallPair> {
  79.   using AL = SPSAllocActionCallPair::AsArgList;
  80.  
  81. public:
  82.   static size_t size(const AllocActionCallPair &AAP) {
  83.     return AL::size(AAP.Finalize, AAP.Dealloc);
  84.   }
  85.  
  86.   static bool serialize(SPSOutputBuffer &OB,
  87.                         const AllocActionCallPair &AAP) {
  88.     return AL::serialize(OB, AAP.Finalize, AAP.Dealloc);
  89.   }
  90.  
  91.   static bool deserialize(SPSInputBuffer &IB,
  92.                           AllocActionCallPair &AAP) {
  93.     return AL::deserialize(IB, AAP.Finalize, AAP.Dealloc);
  94.   }
  95. };
  96.  
  97. } // end namespace shared
  98. } // end namespace orc
  99. } // end namespace llvm
  100.  
  101. #endif // LLVM_EXECUTIONENGINE_ORC_SHARED_ALLOCATIONACTIONS_H
  102.