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
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
|
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
* This file is part of the LibreOffice project.
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*
* This file incorporates work covered by the following license notice:
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed
* with this work for additional information regarding copyright
* ownership. The ASF licenses this file to you under the Apache
* License, Version 2.0 (the "License"); you may not use this file
* except in compliance with the License. You may obtain a copy of
* the License at http://www.apache.org/licenses/LICENSE-2.0 .
*/
#pragma once
#include <rtl/alloc.h>
#include <rtl/ustring.hxx>
#include <sal/types.h>
#include <typelib/typedescription.hxx>
#include <memory>
#include <mutex>
#include <unordered_map>
/*See: http://people.redhat.com/drepper/selinux-mem.html*/
#if defined(LINUX) || defined(OPENBSD) || defined(FREEBSD) \
|| defined(NETBSD) || defined(DRAGONFLY) || defined (ANDROID) \
|| defined(HAIKU)
#define USE_DOUBLE_MMAP
#endif
namespace bridges::cpp_uno::shared {
/** Hand out vtable structures for interface type descriptions.
*/
class VtableFactory {
public:
// This structure is not defined in the generic part, but instead has to be
// defined individually for each CPP--UNO bridge:
/** A vtable slot.
*/
struct Slot;
/** A raw vtable block.
*/
struct Block {
/** The start of the raw vtable block.
It points to the start of the allocated memory block, whereas the
vtable pointer typically points some bytes into the block (e.g.,
skipping an RTTI pointer, see mapBlockToVtable). Also, the block
contains any generated code snippets, after the vtable itself.
*/
void * start;
#ifdef USE_DOUBLE_MMAP
/** When separately mmapping the block for writing and executing
exec points to the same memory as start, except start is used
exclusively for writing and exec for executing
*/
void * exec;
/** File handle for the underlying anonymous file
*/
int fd;
#endif
/** The size of the raw vtable block, in bytes.
*/
sal_Size size;
};
/** The vtable structure corresponding to an interface type.
*/
struct Vtables {
/** The number of blocks/vtables.
*/
sal_Int32 count;
/** An array of blocks, representing the multiple vtables of a
(multiple-inheritance) type.
<p>A block is a raw vtable. It points to the start of the allocated
memory block, whereas the vtable pointer typically points some bytes
into the block (e.g., skipping an RTTI pointer, see
mapBlockToVtable). Also, the block contains any generated code
snippets, after the vtable itself.</p>
*/
std::unique_ptr<Block[]> blocks;
Vtables()
: count(0)
{
}
};
VtableFactory();
~VtableFactory();
/** Given an interface type description, return its corresponding vtable
structure.
*/
const Vtables& getVtables(typelib_InterfaceTypeDescription * type);
// This function is not defined in the generic part, but instead has to be
// defined individually for each CPP--UNO bridge:
/** Given a pointer to a block, turn it into a vtable pointer.
*/
static Slot * mapBlockToVtable(void * block);
private:
class GuardedBlocks;
friend class GuardedBlocks;
class BaseOffset;
VtableFactory(VtableFactory const &) = delete;
VtableFactory& operator =(const VtableFactory&) = delete;
bool createBlock(Block &block, sal_Int32 slotCount) const;
void freeBlock(Block const & block) const;
sal_Int32 createVtables(
GuardedBlocks & blocks, BaseOffset const & baseOffset,
typelib_InterfaceTypeDescription * type, sal_Int32 vtableNumber,
typelib_InterfaceTypeDescription * mostDerived, bool includePrimary)
const;
// This function is not defined in the generic part, but instead has to be
// defined individually for each CPP--UNO bridge:
/** Calculate the size of a raw vtable block.
@param slotCount the number of virtual function slots the returned
vtable block shall support (if there are any platform-specific slots,
like an RTTI pointer, or a pointer to a destructor, they are not covered
by slotCount)
@return the size of the raw vtable block, in bytes
*/
static std::size_t getBlockSize(sal_Int32 slotCount);
// This function is not defined in the generic part, but instead has to be
// defined individually for each CPP--UNO bridge:
/** Initialize a raw vtable block.
@param block the start address of the raw vtable block
@param slotCount the number of slots
@param vtableNumber zero-based count across all the most derived type's
vtables (for vtable's "offset to top" slot)
@param type non-null most derived type (for vtable's "typeinfo pointer"
slot)
@return a pointer past the last vtable slot
*/
static Slot * initializeBlock(
void * block, sal_Int32 slotCount, sal_Int32 vtableNumber,
typelib_InterfaceTypeDescription * type);
// This function is not defined in the generic part, but instead has to be
// defined individually for each CPP--UNO bridge:
/** Fill the vtable slots corresponding to all local (i.e., not inherited)
functions of a given interface type (and generate any necessary code
snippets for them).
@param slots on input, points past the vtable slot to be filled with
the last virtual function local to the given type; on output, points to
the vtable slot filled with the first virtual function local to the
given type
@param code points to the start of the area where code snippets can be
generated
@param writetoexecdiff when the same code area is mapped twice, once for
writing for code-generation, and once for code-execution, then this
records the offset from a writable address to its executable address
@param type the interface type description for which to generate vtable
slots
@param functionOffset the function offset of the first vtable slot
(typically coded into the code snippet for that vtable slot)
@param functionCount the number of vtable slots to fill (the number of
local functions of the given type, passed in so that it doesn't need to
be recomputed)
@param vtableOffset the offset of this vtable (needed to adjust the
this pointer, typically coded into the code snippets for all the filled
vtable slots)
@return a pointer to the remaining code snippet area
*/
static unsigned char * addLocalFunctions(
Slot ** slots, unsigned char * code,
#ifdef USE_DOUBLE_MMAP
sal_PtrDiff writetoexecdiff,
#endif
typelib_InterfaceTypeDescription const * type, sal_Int32 functionOffset,
sal_Int32 functionCount, sal_Int32 vtableOffset);
// This function is not defined in the generic part, but instead has to be
// defined individually for each CPP--UNO bridge:
/** Flush all the generated code snippets of a vtable, on platforms that
require it.
@param begin points to the start of the code snippet area
@param end points behind the end of the code snippet area
*/
static void flushCode(
unsigned char const * begin, unsigned char const * end);
typedef std::unordered_map< OUString, Vtables > Map;
std::mutex m_mutex;
Map m_map;
rtl_arena_type * m_arena;
};
}
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
