1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
|
// AsmJit - Complete JIT Assembler for C++ Language.
// Copyright (c) 2008-2010, Petr Kobalicek <kobalicek.petr@gmail.com>
//
// Permission is hereby granted, free of charge, to any person
// obtaining a copy of this software and associated documentation
// files (the "Software"), to deal in the Software without
// restriction, including without limitation the rights to use,
// copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following
// conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
// OTHER DEALINGS IN THE SOFTWARE.
// [Guard]
#ifndef _ASMJIT_MEMORYMANAGER_H
#define _ASMJIT_MEMORYMANAGER_H
// [Dependencies]
#include "Build.h"
#include "Defs.h"
// [Api-Begin]
#include "ApiBegin.h"
// [Debug]
// #define ASMJIT_MEMORY_MANAGER_DUMP
namespace AsmJit {
//! @addtogroup AsmJit_MemoryManagement
//! @{
// ============================================================================
// [AsmJit::MemoryManager]
// ============================================================================
//! @brief Virtual memory manager interface.
//!
//! This class is pure virtual. You can get default virtual memory manager using
//! @c getGlobal() method. If you want to create more memory managers with same
//! functionality as global memory manager use @c VirtualMemoryManager class.
struct ASMJIT_API MemoryManager
{
// --------------------------------------------------------------------------
// [Construction / Destruction]
// --------------------------------------------------------------------------
//! @brief Create memory manager instance.
MemoryManager() ASMJIT_NOTHROW;
//! @brief Destroy memory manager instance, this means also to free all memory
//! blocks.
virtual ~MemoryManager() ASMJIT_NOTHROW;
// --------------------------------------------------------------------------
// [Interface]
// --------------------------------------------------------------------------
//! @brief Allocate a @a size bytes of virtual memory.
//!
//! Note that if you are implementing your own virtual memory manager then you
//! can quitly ignore type of allocation. This is mainly for AsmJit to memory
//! manager that allocated memory will be never freed.
virtual void* alloc(sysuint_t size, uint32_t type = MEMORY_ALLOC_FREEABLE) ASMJIT_NOTHROW = 0;
//! @brief Free previously allocated memory at a given @a address.
virtual bool free(void* address) ASMJIT_NOTHROW = 0;
//! @brief Free some tail memory.
virtual bool shrink(void* address, sysuint_t used) ASMJIT_NOTHROW = 0;
//! @brief Free all allocated memory.
virtual void freeAll() ASMJIT_NOTHROW = 0;
//! @brief Get how many bytes are currently used.
virtual sysuint_t getUsedBytes() ASMJIT_NOTHROW = 0;
//! @brief Get how many bytes are currently allocated.
virtual sysuint_t getAllocatedBytes() ASMJIT_NOTHROW = 0;
//! @brief Get global memory manager instance.
//!
//! Global instance is instance of @c VirtualMemoryManager class. Global memory
//! manager is used by default by @ref Assembler::make() and @ref Compiler::make()
//! methods.
static MemoryManager* getGlobal() ASMJIT_NOTHROW;
};
//! @brief Reference implementation of memory manager that uses
//! @ref AsmJit::VirtualMemory class to allocate chunks of virtual memory
//! and bit arrays to manage it.
struct ASMJIT_API VirtualMemoryManager : public MemoryManager
{
// --------------------------------------------------------------------------
// [Construction / Destruction]
// --------------------------------------------------------------------------
//! @brief Create a @c VirtualMemoryManager instance.
VirtualMemoryManager() ASMJIT_NOTHROW;
#if defined(ASMJIT_WINDOWS)
//! @brief Create a @c VirtualMemoryManager instance for process @a hProcess.
//!
//! This is specialized version of constructor available only for windows and
//! usable to alloc/free memory of different process.
VirtualMemoryManager(HANDLE hProcess) ASMJIT_NOTHROW;
#endif // ASMJIT_WINDOWS
//! @brief Destroy the @c VirtualMemoryManager instance, this means also to
//! free all blocks.
virtual ~VirtualMemoryManager() ASMJIT_NOTHROW;
// --------------------------------------------------------------------------
// [Interface]
// --------------------------------------------------------------------------
virtual void* alloc(sysuint_t size, uint32_t type = MEMORY_ALLOC_FREEABLE) ASMJIT_NOTHROW;
virtual bool free(void* address) ASMJIT_NOTHROW;
virtual bool shrink(void* address, sysuint_t used) ASMJIT_NOTHROW;
virtual void freeAll() ASMJIT_NOTHROW;
virtual sysuint_t getUsedBytes() ASMJIT_NOTHROW;
virtual sysuint_t getAllocatedBytes() ASMJIT_NOTHROW;
// --------------------------------------------------------------------------
// [Virtual Memory Manager Specific]
// --------------------------------------------------------------------------
//! @brief Get whether to keep allocated memory after memory manager is
//! destroyed.
//!
//! @sa @c setKeepVirtualMemory().
bool getKeepVirtualMemory() const ASMJIT_NOTHROW;
//! @brief Set whether to keep allocated memory after memory manager is
//! destroyed.
//!
//! This method is usable when patching code of remote process. You need to
//! allocate process memory, store generated assembler into it and patch the
//! method you want to redirect (into your code). This method affects only
//! VirtualMemoryManager destructor. After destruction all internal
//! structures are freed, only the process virtual memory remains.
//!
//! @note Memory allocated with MEMORY_ALLOC_PERMANENT is always kept.
//!
//! @sa @c getKeepVirtualMemory().
void setKeepVirtualMemory(bool keepVirtualMemory) ASMJIT_NOTHROW;
// --------------------------------------------------------------------------
// [Debug]
// --------------------------------------------------------------------------
#if defined(ASMJIT_MEMORY_MANAGER_DUMP)
//! @brief Dump memory manager tree into file.
//!
//! Generated output is using DOT language (from graphviz package).
void dump(const char* fileName);
#endif // ASMJIT_MEMORY_MANAGER_DUMP
// --------------------------------------------------------------------------
// [Members]
// --------------------------------------------------------------------------
protected:
//! @brief Pointer to private data hidden from the public API.
void* _d;
};
//! @}
} // AsmJit namespace
// [Api-End]
#include "ApiEnd.h"
// [Guard]
#endif // _ASMJIT_MEMORYMANAGER_H
|
