Details | Last modification | View Log | RSS feed
| Rev | Author | Line No. | Line |
|---|---|---|---|
| 14 | pmbaty | 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 |