Minor tweak to libstdc++ testsuite helper type
[official-gcc.git] / liboffloadmic / runtime / ofldbegin.cpp
blob49d40509c97b52bacb39a78f1807acc551cb1ac9
1 /*
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
6 are met:
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.
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
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);
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
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)
71 OFFLOAD_TARGET_MAIN();
72 return 0;
75 #pragma weak MAIN__
76 extern "C" int MAIN__(void)
78 OFFLOAD_TARGET_MAIN();
79 return 0;
81 #endif // HOST_LIBRARY
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 };
90 // list element for the current module
91 static FuncList::Node __offload_entry_node = {
92 { &__offload_entry_table_start + 1, -1 },
93 0, 0
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 };
103 // list element for the current module
104 static FuncList::Node __offload_func_node = {
105 { &__offload_func_table_start + 1, -1 },
106 0, 0
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 };
116 // list element for the current module
117 static VarList::Node __offload_var_node = {
118 { &__offload_var_table_start + 1 },
119 0, 0
122 #ifdef MYO_SUPPORT
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 };
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
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 };
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
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 };
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
169 // The functions and variables needed for a built-in
170 // remote function entry for vtable initialization on MIC
172 #if !HOST_LIBRARY
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",
183 // t_start->varName,
184 // (void *)(t_start->sharedAddr),
185 // ((void **)(t_start->sharedAddr))[0]);
186 t_start++;
189 __offload_myo_shared_init_table_process(
190 &__offload_myo_init_table_start + 1);
191 return MYO_SUCCESS;
193 #endif // !HOST_LIBRARY
195 static void vtable_initializer()
199 #if !HOST_LIBRARY
200 static MyoError vtable_initializer_wrapper()
202 __offload_myoAcquire();
203 __offload_init_vtables();
204 __offload_myoRelease();
205 return MYO_SUCCESS;
207 #endif
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)
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
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 },
237 0, 0
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();
247 #ifndef TARGET_WINNT
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()
259 bool success;
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);
269 #if HOST_LIBRARY
270 success = __offload_register_image(&__offload_target_image);
271 if (!success)
273 return;
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))
286 atexit(offload_fini);
287 #ifdef TARGET_WINNT
288 } else {
289 atexit(offload_fini_so);
290 #endif
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
303 #ifndef TARGET_WINNT
304 static void offload_fini_so() __attribute__((destructor(101)));
305 #endif // TARGET_WINNT
307 static void offload_fini()
309 #if HOST_LIBRARY
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);
322 #if HOST_LIBRARY
323 if(!__offload_target_image_is_executable(&__offload_target_image)) {
324 __offload_unregister_image(&__offload_target_image);
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