|
111
|
1 /*
|
|
|
2 Copyright (c) 2014-2016 Intel Corporation. All Rights Reserved.
|
|
|
3
|
|
|
4 Redistribution and use in source and binary forms, with or without
|
|
|
5 modification, are permitted provided that the following conditions
|
|
|
6 are met:
|
|
|
7
|
|
|
8 * Redistributions of source code must retain the above copyright
|
|
|
9 notice, this list of conditions and the following disclaimer.
|
|
|
10 * Redistributions in binary form must reproduce the above copyright
|
|
|
11 notice, this list of conditions and the following disclaimer in the
|
|
|
12 documentation and/or other materials provided with the distribution.
|
|
|
13 * Neither the name of Intel Corporation nor the names of its
|
|
|
14 contributors may be used to endorse or promote products derived
|
|
|
15 from this software without specific prior written permission.
|
|
|
16
|
|
|
17 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
|
18 "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
|
19 LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
|
20 A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|
|
21 HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
|
22 SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
|
23 LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
|
24 DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
|
25 THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
|
26 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
|
27 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
28 */
|
|
|
29
|
|
|
30
|
|
|
31 #if HOST_LIBRARY
|
|
|
32 #include "offload_table.h"
|
|
|
33 #ifdef MYO_SUPPORT
|
|
|
34 #include "offload_myo_host.h"
|
|
|
35 #endif // MYO_SUPPORT
|
|
|
36 #else
|
|
|
37 #include "compiler_if_target.h"
|
|
|
38 #include "offload_target.h"
|
|
|
39 #ifdef MYO_SUPPORT
|
|
|
40 #include "offload_myo_target.h"
|
|
|
41 #endif // MYO_SUPPORT
|
|
|
42 #endif // HOST_LIBRARY
|
|
|
43
|
|
|
44 // Initializes library and registers specified offload image.
|
|
|
45 // Don't use this declarations from offload_host.h as offload_table.h
|
|
|
46 // is used instead of it. Using offload_host.h contradicts with
|
|
|
47 // STL library compiled with VS2010.
|
|
|
48 extern "C" bool __offload_register_image(const void* image);
|
|
|
49 extern "C" void __offload_unregister_image(const void* image);
|
|
|
50 extern "C" bool __offload_target_image_is_executable(const void *image);
|
|
|
51
|
|
|
52 #ifdef TARGET_WINNT
|
|
|
53 #define ALLOCATE(name) __declspec(allocate(name))
|
|
|
54 #define DLL_LOCAL
|
|
|
55 #else // TARGET_WINNT
|
|
|
56 #define ALLOCATE(name) __attribute__((section(name)))
|
|
|
57 #define DLL_LOCAL __attribute__((visibility("hidden")))
|
|
|
58 #endif // TARGET_WINNT
|
|
|
59
|
|
|
60 #if HOST_LIBRARY
|
|
|
61 // the host program/shared library should always have __offload_target_image
|
|
|
62 // symbol defined. This symbol specifies the beginning of the target program
|
|
|
63 // image.
|
|
|
64 extern "C" DLL_LOCAL const void* __offload_target_image;
|
|
|
65 #else // HOST_LIBRARY
|
|
|
66 // Define a weak main which would be used on target side in case usere's
|
|
|
67 // source file containing main does not have offload code.
|
|
|
68 #pragma weak main
|
|
|
69 int main(void)
|
|
|
70 {
|
|
|
71 OFFLOAD_TARGET_MAIN();
|
|
|
72 return 0;
|
|
|
73 }
|
|
|
74
|
|
|
75 #pragma weak MAIN__
|
|
|
76 extern "C" int MAIN__(void)
|
|
|
77 {
|
|
|
78 OFFLOAD_TARGET_MAIN();
|
|
|
79 return 0;
|
|
|
80 }
|
|
|
81 #endif // HOST_LIBRARY
|
|
|
82
|
|
|
83 // offload section prolog
|
|
|
84 ALLOCATE(OFFLOAD_ENTRY_TABLE_SECTION_START)
|
|
|
85 #ifdef TARGET_WINNT
|
|
|
86 __declspec(align(sizeof(FuncTable::Entry)))
|
|
|
87 #endif // TARGET_WINNT
|
|
|
88 static FuncTable::Entry __offload_entry_table_start = { 0 };
|
|
|
89
|
|
|
90 // list element for the current module
|
|
|
91 static FuncList::Node __offload_entry_node = {
|
|
|
92 { &__offload_entry_table_start + 1, -1 },
|
|
|
93 0, 0
|
|
|
94 };
|
|
|
95
|
|
|
96 // offload fp section prolog
|
|
|
97 ALLOCATE(OFFLOAD_FUNC_TABLE_SECTION_START)
|
|
|
98 #ifdef TARGET_WINNT
|
|
|
99 __declspec(align(sizeof(FuncTable::Entry)))
|
|
|
100 #endif // TARGET_WINNT
|
|
|
101 static FuncTable::Entry __offload_func_table_start = { 0 };
|
|
|
102
|
|
|
103 // list element for the current module
|
|
|
104 static FuncList::Node __offload_func_node = {
|
|
|
105 { &__offload_func_table_start + 1, -1 },
|
|
|
106 0, 0
|
|
|
107 };
|
|
|
108
|
|
|
109 // offload fp section prolog
|
|
|
110 ALLOCATE(OFFLOAD_VAR_TABLE_SECTION_START)
|
|
|
111 #ifdef TARGET_WINNT
|
|
|
112 __declspec(align(sizeof(VarTable::Entry)))
|
|
|
113 #endif // TARGET_WINNT
|
|
|
114 static VarTable::Entry __offload_var_table_start = { 0 };
|
|
|
115
|
|
|
116 // list element for the current module
|
|
|
117 static VarList::Node __offload_var_node = {
|
|
|
118 { &__offload_var_table_start + 1 },
|
|
|
119 0, 0
|
|
|
120 };
|
|
|
121
|
|
|
122 #ifdef MYO_SUPPORT
|
|
|
123
|
|
|
124 // offload myo shared var section prolog
|
|
|
125 // first element is empty
|
|
|
126 ALLOCATE(OFFLOAD_MYO_SHARED_TABLE_SECTION_START)
|
|
|
127 #ifdef TARGET_WINNT
|
|
|
128 __declspec(align(sizeof(SharedTableEntry)))
|
|
|
129 #endif // TARGET_WINNT
|
|
|
130 static MYOVarTable::Entry __offload_myo_shared_var_start = { 0 };
|
|
|
131
|
|
|
132 // list element for the current module
|
|
|
133 // table entry pointer skips the empty first entry
|
|
|
134 static MYOVarTableList::Node __offload_myo_shared_var_node = {
|
|
|
135 { &__offload_myo_shared_var_start + 1 },
|
|
|
136 0, 0
|
|
|
137 };
|
|
|
138
|
|
|
139 // offload myo shared vtable section prolog
|
|
|
140 // first element is empty
|
|
|
141 ALLOCATE(OFFLOAD_MYO_SHARED_VTABLE_SECTION_START)
|
|
|
142 #ifdef TARGET_WINNT
|
|
|
143 __declspec(align(sizeof(SharedTableEntry)))
|
|
|
144 #endif // TARGET_WINNT
|
|
|
145 static MYOVarTable::Entry __offload_myo_shared_vtable_start = { 0 };
|
|
|
146
|
|
|
147 // list element for the current module
|
|
|
148 // table entry pointer skips the empty first entry
|
|
|
149 static MYOVarTableList::Node __offload_myo_shared_vtable_node = {
|
|
|
150 { &__offload_myo_shared_vtable_start + 1 },
|
|
|
151 0, 0
|
|
|
152 };
|
|
|
153
|
|
|
154 // offload myo shared var init section prolog
|
|
|
155 // first element is empty
|
|
|
156 ALLOCATE(OFFLOAD_MYO_SHARED_INIT_TABLE_SECTION_START)
|
|
|
157 #ifdef TARGET_WINNT
|
|
|
158 __declspec(align(sizeof(InitTableEntry)))
|
|
|
159 #endif // TARGET_WINNT
|
|
|
160 static MYOInitTable::Entry __offload_myo_init_table_start = { 0 };
|
|
|
161
|
|
|
162 // list element for the current module
|
|
|
163 // table entry pointer skips the empty first entry
|
|
|
164 static MYOInitTableList::Node __offload_myo_init_table_node = {
|
|
|
165 { &__offload_myo_init_table_start + 1 },
|
|
|
166 0, 0
|
|
|
167 };
|
|
|
168
|
|
|
169 // The functions and variables needed for a built-in
|
|
|
170 // remote function entry for vtable initialization on MIC
|
|
|
171
|
|
|
172 #if !HOST_LIBRARY
|
|
|
173 MyoError __offload_init_vtables(void)
|
|
|
174 {
|
|
|
175 SharedTableEntry *t_start;
|
|
|
176
|
|
|
177 //OFFLOAD_DEBUG_TRACE(3, "%s\n", __func__);
|
|
|
178 t_start = &__offload_myo_shared_vtable_start + 1;
|
|
|
179 //OFFLOAD_DEBUG_TRACE(3, "%s(%p)\n", __func__, t_start);
|
|
|
180 while (t_start->varName != 0) {
|
|
|
181 //OFFLOAD_DEBUG_TRACE(4,
|
|
|
182 // "myo shared vtable \"%s\" &myo_ptr = %p myo_ptr = %p\n",
|
|
|
183 // t_start->varName,
|
|
|
184 // (void *)(t_start->sharedAddr),
|
|
|
185 // ((void **)(t_start->sharedAddr))[0]);
|
|
|
186 t_start++;
|
|
|
187 }
|
|
|
188
|
|
|
189 __offload_myo_shared_init_table_process(
|
|
|
190 &__offload_myo_init_table_start + 1);
|
|
|
191 return MYO_SUCCESS;
|
|
|
192 }
|
|
|
193 #endif // !HOST_LIBRARY
|
|
|
194
|
|
|
195 static void vtable_initializer()
|
|
|
196 {
|
|
|
197 }
|
|
|
198
|
|
|
199 #if !HOST_LIBRARY
|
|
|
200 static MyoError vtable_initializer_wrapper()
|
|
|
201 {
|
|
|
202 __offload_myoAcquire();
|
|
|
203 __offload_init_vtables();
|
|
|
204 __offload_myoRelease();
|
|
|
205 return MYO_SUCCESS;
|
|
|
206 }
|
|
|
207 #endif
|
|
|
208
|
|
|
209 static void* __offload_vtable_initializer_thunk_ptr = 0;
|
|
|
210
|
|
|
211 // offload myo fptr section prolog
|
|
|
212 // first element is pre-initialized to the MIC vtable initializer
|
|
|
213 ALLOCATE(OFFLOAD_MYO_FPTR_TABLE_SECTION_START)
|
|
|
214 #ifdef TARGET_WINNT
|
|
|
215 __declspec(align(sizeof(FptrTableEntry)))
|
|
|
216 #endif // TARGET_WINNT
|
|
|
217 static MYOFuncTable::Entry __offload_myo_fptr_table_start = {
|
|
|
218 #if HOST_LIBRARY
|
|
|
219 "--vtable_initializer--",
|
|
|
220 (void*)&vtable_initializer,
|
|
|
221 (void*)&__offload_vtable_initializer_thunk_ptr,
|
|
|
222 #ifdef TARGET_WINNT
|
|
|
223 // Dummy to pad up to 32 bytes
|
|
|
224 0
|
|
|
225 #endif // TARGET_WINNT
|
|
|
226 #else // HOST_LIBRARY
|
|
|
227 "--vtable_initializer--",
|
|
|
228 (void*)&vtable_initializer,
|
|
|
229 (void*)&vtable_initializer_wrapper,
|
|
|
230 &__offload_vtable_initializer_thunk_ptr,
|
|
|
231 #endif // HOST_LIBRARY
|
|
|
232 };
|
|
|
233
|
|
|
234 // list element for the current module
|
|
|
235 static MYOFuncTableList::Node __offload_myo_fptr_table_node = {
|
|
|
236 { &__offload_myo_fptr_table_start },
|
|
|
237 0, 0
|
|
|
238 };
|
|
|
239
|
|
|
240 #endif // MYO_SUPPORT
|
|
|
241
|
|
|
242 // init/fini code which adds/removes local lookup data to/from the global list
|
|
|
243
|
|
|
244 static void offload_fini();
|
|
|
245 static void offload_fini_so();
|
|
|
246
|
|
|
247 #ifndef TARGET_WINNT
|
|
|
248 static void offload_init() __attribute__((constructor(101)));
|
|
|
249 #else // TARGET_WINNT
|
|
|
250 static void offload_init();
|
|
|
251
|
|
|
252 // Place offload initialization before user constructors
|
|
|
253 ALLOCATE(OFFLOAD_CRTINIT_SECTION_START)
|
|
|
254 static void (*addressof_offload_init)() = offload_init;
|
|
|
255 #endif // TARGET_WINNT
|
|
|
256
|
|
|
257 static void offload_init()
|
|
|
258 {
|
|
|
259 bool success;
|
|
|
260
|
|
|
261 // Set offload version
|
|
|
262 __offload_set_version(OFFLOAD_VERSION_17);
|
|
|
263
|
|
|
264 // register offload tables
|
|
|
265 __offload_register_tables(&__offload_entry_node,
|
|
|
266 &__offload_func_node,
|
|
|
267 &__offload_var_node);
|
|
|
268
|
|
|
269 #if HOST_LIBRARY
|
|
|
270 success = __offload_register_image(&__offload_target_image);
|
|
|
271 if (!success)
|
|
|
272 {
|
|
|
273 return;
|
|
|
274 }
|
|
|
275 #endif // HOST_LIBRARY
|
|
|
276 #ifdef MYO_SUPPORT
|
|
|
277 #if HOST_LIBRARY
|
|
|
278 // If this was the main program register main atexit routine
|
|
|
279 if (__offload_myoProcessTables(
|
|
|
280 &__offload_target_image,
|
|
|
281 &__offload_myo_init_table_node,
|
|
|
282 &__offload_myo_shared_var_node,
|
|
|
283 &__offload_myo_shared_vtable_node,
|
|
|
284 &__offload_myo_fptr_table_node))
|
|
|
285 {
|
|
|
286 atexit(offload_fini);
|
|
|
287 #ifdef TARGET_WINNT
|
|
|
288 } else {
|
|
|
289 atexit(offload_fini_so);
|
|
|
290 #endif
|
|
|
291 }
|
|
|
292 #else // HOST_LIBRARY
|
|
|
293 __offload_myoProcessTables(
|
|
|
294 &__offload_myo_init_table_start + 1,
|
|
|
295 &__offload_myo_shared_var_start + 1,
|
|
|
296 &__offload_myo_shared_vtable_start + 1,
|
|
|
297 &__offload_myo_fptr_table_start
|
|
|
298 );
|
|
|
299 #endif // HOST_LIBRARY
|
|
|
300 #endif // MYO_SUPPORT
|
|
|
301 }
|
|
|
302
|
|
|
303 #ifndef TARGET_WINNT
|
|
|
304 static void offload_fini_so() __attribute__((destructor(101)));
|
|
|
305 #endif // TARGET_WINNT
|
|
|
306
|
|
|
307 static void offload_fini()
|
|
|
308 {
|
|
|
309 #if HOST_LIBRARY
|
|
|
310 __offload_unregister_image(&__offload_target_image);
|
|
|
311 #endif // HOST_LIBRARY
|
|
|
312 }
|
|
|
313
|
|
|
314 static void offload_fini_so()
|
|
|
315 {
|
|
|
316 // Offload and MYO tables need to be removed from list
|
|
|
317 // to prevent invalid accesses after dlclose
|
|
|
318 // Remove offload tables
|
|
|
319 __offload_unregister_tables(&__offload_entry_node,
|
|
|
320 &__offload_func_node,
|
|
|
321 &__offload_var_node);
|
|
|
322 #if HOST_LIBRARY
|
|
|
323 if(!__offload_target_image_is_executable(&__offload_target_image)) {
|
|
|
324 __offload_unregister_image(&__offload_target_image);
|
|
|
325 }
|
|
|
326 #endif
|
|
|
327 #ifdef MYO_SUPPORT
|
|
|
328 #if HOST_LIBRARY
|
|
|
329 // Remove MYO tables
|
|
|
330 __offload_myoRemoveTables(
|
|
|
331 &__offload_myo_init_table_node,
|
|
|
332 &__offload_myo_shared_var_node,
|
|
|
333 &__offload_myo_shared_vtable_node,
|
|
|
334 &__offload_myo_fptr_table_node);
|
|
|
335 #endif // HOST_LIBRARY
|
|
|
336 #endif // MYO_SUPPORT
|
|
|
337 }
|
