2 Copyright (c) 2014-2016 Intel Corporation. All Rights Reserved.
4 Redistribution and use in source and binary forms, with or without
5 modification, are permitted provided that the following conditions
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.
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.
32 #include "offload_table.h"
34 #include "offload_myo_host.h"
37 #include "compiler_if_target.h"
38 #include "offload_target.h"
40 #include "offload_myo_target.h"
42 #endif // HOST_LIBRARY
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
);
53 #define ALLOCATE(name) __declspec(allocate(name))
56 #define ALLOCATE(name) __attribute__((section(name)))
57 #define DLL_LOCAL __attribute__((visibility("hidden")))
58 #endif // TARGET_WINNT
61 // the host program/shared library should always have __offload_target_image
62 // symbol defined. This symbol specifies the beginning of the target program
64 extern "C" DLL_LOCAL
const void* __offload_target_image
;
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.
71 OFFLOAD_TARGET_MAIN();
76 extern "C" int MAIN__(void)
78 OFFLOAD_TARGET_MAIN();
81 #endif // HOST_LIBRARY
83 // offload section prolog
84 ALLOCATE(OFFLOAD_ENTRY_TABLE_SECTION_START
)
86 __declspec(align(sizeof(FuncTable::Entry
)))
87 #endif // TARGET_WINNT
88 static FuncTable::Entry __offload_entry_table_start
= { 0 };
90 // list element for the current module
91 static FuncList::Node __offload_entry_node
= {
92 { &__offload_entry_table_start
+ 1, -1 },
96 // offload fp section prolog
97 ALLOCATE(OFFLOAD_FUNC_TABLE_SECTION_START
)
99 __declspec(align(sizeof(FuncTable::Entry
)))
100 #endif // TARGET_WINNT
101 static FuncTable::Entry __offload_func_table_start
= { 0 };
103 // list element for the current module
104 static FuncList::Node __offload_func_node
= {
105 { &__offload_func_table_start
+ 1, -1 },
109 // offload fp section prolog
110 ALLOCATE(OFFLOAD_VAR_TABLE_SECTION_START
)
112 __declspec(align(sizeof(VarTable::Entry
)))
113 #endif // TARGET_WINNT
114 static VarTable::Entry __offload_var_table_start
= { 0 };
116 // list element for the current module
117 static VarList::Node __offload_var_node
= {
118 { &__offload_var_table_start
+ 1 },
124 // offload myo shared var section prolog
125 // first element is empty
126 ALLOCATE(OFFLOAD_MYO_SHARED_TABLE_SECTION_START
)
128 __declspec(align(sizeof(SharedTableEntry
)))
129 #endif // TARGET_WINNT
130 static MYOVarTable::Entry __offload_myo_shared_var_start
= { 0 };
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 },
139 // offload myo shared vtable section prolog
140 // first element is empty
141 ALLOCATE(OFFLOAD_MYO_SHARED_VTABLE_SECTION_START
)
143 __declspec(align(sizeof(SharedTableEntry
)))
144 #endif // TARGET_WINNT
145 static MYOVarTable::Entry __offload_myo_shared_vtable_start
= { 0 };
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 },
154 // offload myo shared var init section prolog
155 // first element is empty
156 ALLOCATE(OFFLOAD_MYO_SHARED_INIT_TABLE_SECTION_START
)
158 __declspec(align(sizeof(InitTableEntry
)))
159 #endif // TARGET_WINNT
160 static MYOInitTable::Entry __offload_myo_init_table_start
= { 0 };
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 },
169 // The functions and variables needed for a built-in
170 // remote function entry for vtable initialization on MIC
173 MyoError
__offload_init_vtables(void)
175 SharedTableEntry
*t_start
;
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",
184 // (void *)(t_start->sharedAddr),
185 // ((void **)(t_start->sharedAddr))[0]);
189 __offload_myo_shared_init_table_process(
190 &__offload_myo_init_table_start
+ 1);
193 #endif // !HOST_LIBRARY
195 static void vtable_initializer()
200 static MyoError
vtable_initializer_wrapper()
202 __offload_myoAcquire();
203 __offload_init_vtables();
204 __offload_myoRelease();
209 static void* __offload_vtable_initializer_thunk_ptr
= 0;
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
)
215 __declspec(align(sizeof(FptrTableEntry
)))
216 #endif // TARGET_WINNT
217 static MYOFuncTable::Entry __offload_myo_fptr_table_start
= {
219 "--vtable_initializer--",
220 (void*)&vtable_initializer
,
221 (void*)&__offload_vtable_initializer_thunk_ptr
,
223 // Dummy to pad up to 32 bytes
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
234 // list element for the current module
235 static MYOFuncTableList::Node __offload_myo_fptr_table_node
= {
236 { &__offload_myo_fptr_table_start
},
240 #endif // MYO_SUPPORT
242 // init/fini code which adds/removes local lookup data to/from the global list
244 static void offload_fini();
245 static void offload_fini_so();
248 static void offload_init() __attribute__((constructor(101)));
249 #else // TARGET_WINNT
250 static void offload_init();
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
257 static void offload_init()
261 // Set offload version
262 __offload_set_version(OFFLOAD_VERSION_17
);
264 // register offload tables
265 __offload_register_tables(&__offload_entry_node
,
266 &__offload_func_node
,
267 &__offload_var_node
);
270 success
= __offload_register_image(&__offload_target_image
);
275 #endif // 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
))
286 atexit(offload_fini
);
289 atexit(offload_fini_so
);
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
299 #endif // HOST_LIBRARY
300 #endif // MYO_SUPPORT
304 static void offload_fini_so() __attribute__((destructor(101)));
305 #endif // TARGET_WINNT
307 static void offload_fini()
310 __offload_unregister_image(&__offload_target_image
);
311 #endif // HOST_LIBRARY
314 static void offload_fini_so()
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
);
323 if(!__offload_target_image_is_executable(&__offload_target_image
)) {
324 __offload_unregister_image(&__offload_target_image
);
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