?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Run DCE after a LoopFlatten test to reduce spurious output [nfc]
[llvm-project.git] / openmp / runtime / src / thirdparty / ittnotify / ittnotify_static.cpp
blob48ffcb5e669dad52eee9287bbe6355fde6832e00
1
2 //===----------------------------------------------------------------------===//
3 //
4 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
5 // See https://llvm.org/LICENSE.txt for license information.
6 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
7 //
8 //===----------------------------------------------------------------------===//
9
10 #include "kmp_config.h" // INTEL_ITTNOTIFY_PREFIX definition
11 #include "ittnotify_config.h"
12
13 #if ITT_PLATFORM == ITT_PLATFORM_WIN
14 #if !defined(PATH_MAX)
15 #define PATH_MAX 512
16 #endif
17 #else /* ITT_PLATFORM!=ITT_PLATFORM_WIN */
18 #include <limits.h>
19 #include <dlfcn.h>
20 #include <errno.h>
21 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <stdarg.h>
25 #include <string.h>
26
27 #define INTEL_NO_MACRO_BODY
28 #define INTEL_ITTNOTIFY_API_PRIVATE
29 #include "ittnotify.h"
30 #include "legacy/ittnotify.h"
31
32 #include "disable_warnings.h"
33
34 static const char api_version[] = API_VERSION "\0\n@(#) $Revision$\n";
35
36 #define _N_(n) ITT_JOIN(INTEL_ITTNOTIFY_PREFIX, n)
37
38 #ifndef HAS_CPP_ATTR
39 #if defined(__cplusplus) && defined(__has_cpp_attribute)
40 #define HAS_CPP_ATTR(X) __has_cpp_attribute(X)
41 #else
42 #define HAS_CPP_ATTR(X) 0
43 #endif
44 #endif
45
46 #ifndef HAS_C_ATTR
47 #if defined(__STDC__) && defined(__has_c_attribute)
48 #define HAS_C_ATTR(X) __has_c_attribute(X)
49 #else
50 #define HAS_C_ATTR(X) 0
51 #endif
52 #endif
53
54 #ifndef HAS_GNU_ATTR
55 #if defined(__has_attribute)
56 #define HAS_GNU_ATTR(X) __has_attribute(X)
57 #else
58 #define HAS_GNU_ATTR(X) 0
59 #endif
60 #endif
61
62 #ifndef ITT_ATTRIBUTE_FALLTHROUGH
63 #if (HAS_CPP_ATTR(fallthrough) || HAS_C_ATTR(fallthrough)) && \
64 (__cplusplus >= 201703L || _MSVC_LANG >= 201703L)
65 #define ITT_ATTRIBUTE_FALLTHROUGH [[fallthrough]]
66 #elif HAS_CPP_ATTR(gnu::fallthrough)
67 #define ITT_ATTRIBUTE_FALLTHROUGH [[gnu::fallthrough]]
68 #elif HAS_CPP_ATTR(clang::fallthrough)
69 #define ITT_ATTRIBUTE_FALLTHROUGH [[clang::fallthrough]]
70 #elif HAS_GNU_ATTR(fallthrough) && !__INTEL_COMPILER
71 #define ITT_ATTRIBUTE_FALLTHROUGH __attribute__((fallthrough))
72 #else
73 #define ITT_ATTRIBUTE_FALLTHROUGH
74 #endif
75 #endif
76
77 #if ITT_OS == ITT_OS_WIN
78 static const char *ittnotify_lib_name = "libittnotify.dll";
79 #elif ITT_OS == ITT_OS_LINUX || ITT_OS == ITT_OS_FREEBSD
80 static const char *ittnotify_lib_name = "libittnotify.so";
81 #elif ITT_OS == ITT_OS_MAC
82 static const char *ittnotify_lib_name = "libittnotify.dylib";
83 #else
84 #error Unsupported or unknown OS.
85 #endif
86
87 #ifdef __ANDROID__
88 #include <android/log.h>
89 #include <stdio.h>
90 #include <unistd.h>
91 #include <sys/types.h>
92 #include <sys/stat.h>
93 #include <fcntl.h>
94 #include <linux/limits.h>
95
96 #ifdef ITT_ANDROID_LOG
97 #define ITT_ANDROID_LOG_TAG "INTEL_VTUNE_USERAPI"
98 #define ITT_ANDROID_LOGI(...) \
99 ((void)__android_log_print(ANDROID_LOG_INFO, ITT_ANDROID_LOG_TAG, \
100 __VA_ARGS__))
101 #define ITT_ANDROID_LOGW(...) \
102 ((void)__android_log_print(ANDROID_LOG_WARN, ITT_ANDROID_LOG_TAG, \
103 __VA_ARGS__))
104 #define ITT_ANDROID_LOGE(...) \
105 ((void)__android_log_print(ANDROID_LOG_ERROR, ITT_ANDROID_LOG_TAG, \
106 __VA_ARGS__))
107 #define ITT_ANDROID_LOGD(...) \
108 ((void)__android_log_print(ANDROID_LOG_DEBUG, ITT_ANDROID_LOG_TAG, \
109 __VA_ARGS__))
110 #else
111 #define ITT_ANDROID_LOGI(...)
112 #define ITT_ANDROID_LOGW(...)
113 #define ITT_ANDROID_LOGE(...)
114 #define ITT_ANDROID_LOGD(...)
115 #endif
116
117 /* default location of userapi collector on Android */
118 #define ANDROID_ITTNOTIFY_DEFAULT_PATH_MASK(x) \
119 "/data/data/com.intel.vtune/perfrun/lib" #x "/runtime/libittnotify.so"
120
121 #if ITT_ARCH == ITT_ARCH_IA32 || ITT_ARCH == ITT_ARCH_ARM
122 #define ANDROID_ITTNOTIFY_DEFAULT_PATH ANDROID_ITTNOTIFY_DEFAULT_PATH_MASK(32)
123 #else
124 #define ANDROID_ITTNOTIFY_DEFAULT_PATH ANDROID_ITTNOTIFY_DEFAULT_PATH_MASK(64)
125 #endif
126
127 #endif
128
129 #ifndef LIB_VAR_NAME
130 #if ITT_ARCH == ITT_ARCH_IA32 || ITT_ARCH == ITT_ARCH_ARM
131 #define LIB_VAR_NAME INTEL_LIBITTNOTIFY32
132 #else
133 #define LIB_VAR_NAME INTEL_LIBITTNOTIFY64
134 #endif
135 #endif /* LIB_VAR_NAME */
136
137 #define ITT_MUTEX_INIT_AND_LOCK(p) \
138 { \
139 if (PTHREAD_SYMBOLS) { \
140 if (!p.mutex_initialized) { \
141 if (__itt_interlocked_increment(&p.atomic_counter) == 1) { \
142 __itt_mutex_init(&p.mutex); \
143 p.mutex_initialized = 1; \
144 } else \
145 while (!p.mutex_initialized) \
146 __itt_thread_yield(); \
147 } \
148 __itt_mutex_lock(&p.mutex); \
149 } \
150 }
151
152 #define ITT_MODULE_OBJECT_VERSION 1
153
154 typedef int(__itt_init_ittlib_t)(const char *, __itt_group_id);
155
156 /* this define used to control initialization function name. */
157 #ifndef __itt_init_ittlib_name
158 ITT_EXTERN_C int _N_(init_ittlib)(const char *, __itt_group_id);
159 static __itt_init_ittlib_t *__itt_init_ittlib_ptr = _N_(init_ittlib);
160 #define __itt_init_ittlib_name __itt_init_ittlib_ptr
161 #endif /* __itt_init_ittlib_name */
162
163 typedef void(__itt_fini_ittlib_t)(void);
164
165 /* this define used to control finalization function name. */
166 #ifndef __itt_fini_ittlib_name
167 ITT_EXTERN_C void _N_(fini_ittlib)(void);
168 static __itt_fini_ittlib_t *__itt_fini_ittlib_ptr = _N_(fini_ittlib);
169 #define __itt_fini_ittlib_name __itt_fini_ittlib_ptr
170 #endif /* __itt_fini_ittlib_name */
171
172 extern __itt_global _N_(_ittapi_global);
173
174 /* building pointers to imported funcs */
175 #undef ITT_STUBV
176 #undef ITT_STUB
177 #define ITT_STUB(api, type, name, args, params, ptr, group, format) \
178 static type api ITT_VERSIONIZE(ITT_JOIN(_N_(name), _init)) args; \
179 typedef type api ITT_JOIN(_N_(name), _t) args; \
180 ITT_EXTERN_C_BEGIN ITT_JOIN(_N_(name), _t) * ITTNOTIFY_NAME(name) = \
181 ITT_VERSIONIZE(ITT_JOIN(_N_(name), _init)); \
182 ITT_EXTERN_C_END \
183 static type api ITT_VERSIONIZE(ITT_JOIN(_N_(name), _init)) args { \
184 if (!_N_(_ittapi_global).api_initialized && \
185 _N_(_ittapi_global).thread_list == NULL) \
186 __itt_init_ittlib_name(NULL, __itt_group_all); \
187 if (ITTNOTIFY_NAME(name) && \
188 ITTNOTIFY_NAME(name) != ITT_VERSIONIZE(ITT_JOIN(_N_(name), _init))) \
189 return ITTNOTIFY_NAME(name) params; \
190 else \
191 return (type)0; \
192 }
193
194 #define ITT_STUBV(api, type, name, args, params, ptr, group, format) \
195 static type api ITT_VERSIONIZE(ITT_JOIN(_N_(name), _init)) args; \
196 typedef type api ITT_JOIN(_N_(name), _t) args; \
197 ITT_EXTERN_C_BEGIN ITT_JOIN(_N_(name), _t) * ITTNOTIFY_NAME(name) = \
198 ITT_VERSIONIZE(ITT_JOIN(_N_(name), _init)); \
199 ITT_EXTERN_C_END \
200 static type api ITT_VERSIONIZE(ITT_JOIN(_N_(name), _init)) args { \
201 if (!_N_(_ittapi_global).api_initialized && \
202 _N_(_ittapi_global).thread_list == NULL) \
203 __itt_init_ittlib_name(NULL, __itt_group_all); \
204 if (ITTNOTIFY_NAME(name) && \
205 ITTNOTIFY_NAME(name) != ITT_VERSIONIZE(ITT_JOIN(_N_(name), _init))) \
206 ITTNOTIFY_NAME(name) params; \
207 else \
208 return; \
209 }
210
211 #undef __ITT_INTERNAL_INIT
212 #include "ittnotify_static.h"
213
214 #undef ITT_STUB
215 #undef ITT_STUBV
216 #define ITT_STUB(api, type, name, args, params, ptr, group, format) \
217 static type api ITT_VERSIONIZE(ITT_JOIN(_N_(name), _init)) args; \
218 typedef type api ITT_JOIN(_N_(name), _t) args; \
219 ITT_EXTERN_C_BEGIN ITT_JOIN(_N_(name), _t) * ITTNOTIFY_NAME(name) = \
220 ITT_VERSIONIZE(ITT_JOIN(_N_(name), _init)); \
221 ITT_EXTERN_C_END
222
223 #define ITT_STUBV(api, type, name, args, params, ptr, group, format) \
224 static type api ITT_VERSIONIZE(ITT_JOIN(_N_(name), _init)) args; \
225 typedef type api ITT_JOIN(_N_(name), _t) args; \
226 ITT_EXTERN_C_BEGIN ITT_JOIN(_N_(name), _t) * ITTNOTIFY_NAME(name) = \
227 ITT_VERSIONIZE(ITT_JOIN(_N_(name), _init)); \
228 ITT_EXTERN_C_END
229
230 #define __ITT_INTERNAL_INIT
231 #include "ittnotify_static.h"
232 #undef __ITT_INTERNAL_INIT
233
234 ITT_GROUP_LIST(group_list);
235
236 #pragma pack(push, 8)
237
238 typedef struct ___itt_group_alias {
239 const char *env_var;
240 __itt_group_id groups;
241 } __itt_group_alias;
242
243 static __itt_group_alias group_alias[] = {
244 {"KMP_FOR_TPROFILE",
245 (__itt_group_id)(__itt_group_control | __itt_group_thread |
246 __itt_group_sync | __itt_group_mark)},
247 {"KMP_FOR_TCHECK",
248 (__itt_group_id)(__itt_group_control | __itt_group_thread |
249 __itt_group_sync | __itt_group_fsync | __itt_group_mark |
250 __itt_group_suppress)},
251 {NULL, (__itt_group_none)},
252 {api_version,
253 (__itt_group_none)} /* !!! Just to avoid unused code elimination !!! */
254 };
255
256 #pragma pack(pop)
257
258 #if ITT_PLATFORM == ITT_PLATFORM_WIN
259 #if _MSC_VER
260 #pragma warning(push)
261 #pragma warning(disable : 4054) /* warning C4054: 'type cast' : from function \
262 pointer 'XXX' to data pointer 'void *' */
263 #endif
264 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
265
266 static __itt_api_info api_list[] = {
267 /* Define functions with static implementation */
268 #undef ITT_STUB
269 #undef ITT_STUBV
270 #define ITT_STUB(api, type, name, args, params, nameindll, group, format) \
271 {ITT_TO_STR(ITT_JOIN(__itt_, nameindll)), \
272 (void **)(void *)&ITTNOTIFY_NAME(name), \
273 (void *)(size_t)&ITT_VERSIONIZE(ITT_JOIN(_N_(name), _init)), \
274 (void *)(size_t)&ITT_VERSIONIZE(ITT_JOIN(_N_(name), _init)), \
275 (__itt_group_id)(group)},
276 #define ITT_STUBV ITT_STUB
277 #define __ITT_INTERNAL_INIT
278 #include "ittnotify_static.h"
279 #undef __ITT_INTERNAL_INIT
280 /* Define functions without static implementation */
281 #undef ITT_STUB
282 #undef ITT_STUBV
283 #define ITT_STUB(api, type, name, args, params, nameindll, group, format) \
284 {ITT_TO_STR(ITT_JOIN(__itt_, nameindll)), \
285 (void **)(void *)&ITTNOTIFY_NAME(name), \
286 (void *)(size_t)&ITT_VERSIONIZE(ITT_JOIN(_N_(name), _init)), NULL, \
287 (__itt_group_id)(group)},
288 #define ITT_STUBV ITT_STUB
289 #include "ittnotify_static.h"
290 {NULL, NULL, NULL, NULL, __itt_group_none}};
291
292 #if ITT_PLATFORM == ITT_PLATFORM_WIN
293 #if _MSC_VER
294 #pragma warning(pop)
295 #endif
296 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
297
298 /* static part descriptor which handles. all notification api attributes. */
299 __itt_global _N_(_ittapi_global) = {
300 ITT_MAGIC, /* identification info */
301 ITT_MAJOR,
302 ITT_MINOR,
303 API_VERSION_BUILD, /* version info */
304 0, /* api_initialized */
305 0, /* mutex_initialized */
306 0, /* atomic_counter */
307 MUTEX_INITIALIZER, /* mutex */
308 NULL, /* dynamic library handle */
309 NULL, /* error_handler */
310 NULL, /* dll_path_ptr */
311 (__itt_api_info *)&api_list, /* api_list_ptr */
312 NULL, /* next __itt_global */
313 NULL, /* thread_list */
314 NULL, /* domain_list */
315 NULL, /* string_list */
316 __itt_collection_normal, /* collection state */
317 NULL, /* counter_list */
318 0, /* ipt_collect_events */
319 NULL /* histogram_list */
320 };
321
322 typedef void(__itt_api_init_t)(__itt_global *, __itt_group_id);
323 typedef void(__itt_api_fini_t)(__itt_global *);
324
325 static __itt_domain dummy_domain;
326 /* ========================================================================= */
327
328 #ifdef ITT_NOTIFY_EXT_REPORT
329 ITT_EXTERN_C void _N_(error_handler)(__itt_error_code, va_list args);
330 #endif /* ITT_NOTIFY_EXT_REPORT */
331
332 #if ITT_PLATFORM == ITT_PLATFORM_WIN
333 #if _MSC_VER
334 #pragma warning(push)
335 #pragma warning( \
336 disable : 4055) /* warning C4055: 'type cast' : from data pointer 'void *' \
337 to function pointer 'XXX' */
338 #endif
339 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
340
341 static void __itt_report_error(int code, ...) {
342 va_list args;
343 va_start(args, code);
344 if (_N_(_ittapi_global).error_handler != NULL) {
345 __itt_error_handler_t *handler =
346 (__itt_error_handler_t *)(size_t)_N_(_ittapi_global).error_handler;
347 handler((__itt_error_code)code, args);
348 }
349 #ifdef ITT_NOTIFY_EXT_REPORT
350 _N_(error_handler)((__itt_error_code)code, args);
351 #endif /* ITT_NOTIFY_EXT_REPORT */
352 va_end(args);
353 }
354
355 #if ITT_PLATFORM == ITT_PLATFORM_WIN
356 #if _MSC_VER
357 #pragma warning(pop)
358 #endif
359 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
360
361 #if ITT_PLATFORM == ITT_PLATFORM_WIN
362 static __itt_domain *ITTAPI
363 ITT_VERSIONIZE(ITT_JOIN(_N_(domain_createW), _init))(const wchar_t *name) {
364 __itt_domain *h_tail = NULL, *h = NULL;
365
366 if (name == NULL) {
367 return NULL;
368 }
369
370 ITT_MUTEX_INIT_AND_LOCK(_N_(_ittapi_global));
371 if (_N_(_ittapi_global).api_initialized) {
372 if (ITTNOTIFY_NAME(domain_createW) &&
373 ITTNOTIFY_NAME(domain_createW) !=
374 ITT_VERSIONIZE(ITT_JOIN(_N_(domain_createW), _init))) {
375 __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
376 return ITTNOTIFY_NAME(domain_createW)(name);
377 } else {
378 __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
379 return &dummy_domain;
380 }
381 }
382 for (h_tail = NULL, h = _N_(_ittapi_global).domain_list; h != NULL;
383 h_tail = h, h = h->next) {
384 if (h->nameW != NULL && !wcscmp(h->nameW, name))
385 break;
386 }
387 if (h == NULL) {
388 NEW_DOMAIN_W(&_N_(_ittapi_global), h, h_tail, name);
389 }
390 if (PTHREAD_SYMBOLS)
391 __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
392 return h;
393 }
394
395 static __itt_domain *ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(domain_createA),
396 _init))(const char *name)
397 #else /* ITT_PLATFORM!=ITT_PLATFORM_WIN */
398 static __itt_domain *ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(domain_create),
399 _init))(const char *name)
400 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
401 {
402 __itt_domain *h_tail = NULL, *h = NULL;
403
404 if (name == NULL) {
405 return NULL;
406 }
407
408 ITT_MUTEX_INIT_AND_LOCK(_N_(_ittapi_global));
409 if (_N_(_ittapi_global).api_initialized) {
410 #if ITT_PLATFORM == ITT_PLATFORM_WIN
411 if (ITTNOTIFY_NAME(domain_createA) &&
412 ITTNOTIFY_NAME(domain_createA) !=
413 ITT_VERSIONIZE(ITT_JOIN(_N_(domain_createA), _init))) {
414 __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
415 return ITTNOTIFY_NAME(domain_createA)(name);
416 }
417 #else
418 if (ITTNOTIFY_NAME(domain_create) &&
419 ITTNOTIFY_NAME(domain_create) !=
420 ITT_VERSIONIZE(ITT_JOIN(_N_(domain_create), _init))) {
421 if (PTHREAD_SYMBOLS)
422 __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
423 return ITTNOTIFY_NAME(domain_create)(name);
424 }
425 #endif
426 else {
427 #if ITT_PLATFORM == ITT_PLATFORM_WIN
428 __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
429 #else
430 if (PTHREAD_SYMBOLS)
431 __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
432 #endif
433 return &dummy_domain;
434 }
435 }
436 for (h_tail = NULL, h = _N_(_ittapi_global).domain_list; h != NULL;
437 h_tail = h, h = h->next) {
438 if (h->nameA != NULL && !__itt_fstrcmp(h->nameA, name))
439 break;
440 }
441 if (h == NULL) {
442 NEW_DOMAIN_A(&_N_(_ittapi_global), h, h_tail, name);
443 }
444 if (PTHREAD_SYMBOLS)
445 __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
446 return h;
447 }
448
449 static void ITTAPI ITT_VERSIONIZE(ITT_JOIN(
450 _N_(module_load_with_sections), _init))(__itt_module_object *module_obj) {
451 if (!_N_(_ittapi_global).api_initialized &&
452 _N_(_ittapi_global).thread_list == NULL) {
453 __itt_init_ittlib_name(NULL, __itt_group_all);
454 }
455 if (ITTNOTIFY_NAME(module_load_with_sections) &&
456 ITTNOTIFY_NAME(module_load_with_sections) !=
457 ITT_VERSIONIZE(ITT_JOIN(_N_(module_load_with_sections), _init))) {
458 if (module_obj != NULL) {
459 module_obj->version = ITT_MODULE_OBJECT_VERSION;
460 ITTNOTIFY_NAME(module_load_with_sections)(module_obj);
461 }
462 }
463 }
464
465 static void ITTAPI ITT_VERSIONIZE(ITT_JOIN(
466 _N_(module_unload_with_sections), _init))(__itt_module_object *module_obj) {
467 if (!_N_(_ittapi_global).api_initialized &&
468 _N_(_ittapi_global).thread_list == NULL) {
469 __itt_init_ittlib_name(NULL, __itt_group_all);
470 }
471 if (ITTNOTIFY_NAME(module_unload_with_sections) &&
472 ITTNOTIFY_NAME(module_unload_with_sections) !=
473 ITT_VERSIONIZE(ITT_JOIN(_N_(module_unload_with_sections), _init))) {
474 if (module_obj != NULL) {
475 module_obj->version = ITT_MODULE_OBJECT_VERSION;
476 ITTNOTIFY_NAME(module_unload_with_sections)(module_obj);
477 }
478 }
479 }
480
481 #if ITT_PLATFORM == ITT_PLATFORM_WIN
482 static __itt_string_handle *ITTAPI ITT_VERSIONIZE(
483 ITT_JOIN(_N_(string_handle_createW), _init))(const wchar_t *name) {
484 __itt_string_handle *h_tail = NULL, *h = NULL;
485
486 if (name == NULL) {
487 return NULL;
488 }
489
490 ITT_MUTEX_INIT_AND_LOCK(_N_(_ittapi_global));
491 if (_N_(_ittapi_global).api_initialized) {
492 if (ITTNOTIFY_NAME(string_handle_createW) &&
493 ITTNOTIFY_NAME(string_handle_createW) !=
494 ITT_VERSIONIZE(ITT_JOIN(_N_(string_handle_createW), _init))) {
495 __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
496 return ITTNOTIFY_NAME(string_handle_createW)(name);
497 } else {
498 __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
499 return NULL;
500 }
501 }
502 for (h_tail = NULL, h = _N_(_ittapi_global).string_list; h != NULL;
503 h_tail = h, h = h->next) {
504 if (h->strW != NULL && !wcscmp(h->strW, name))
505 break;
506 }
507 if (h == NULL) {
508 NEW_STRING_HANDLE_W(&_N_(_ittapi_global), h, h_tail, name);
509 }
510 __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
511 return h;
512 }
513
514 static __itt_string_handle *ITTAPI
515 ITT_VERSIONIZE(ITT_JOIN(_N_(string_handle_createA), _init))(const char *name)
516 #else /* ITT_PLATFORM!=ITT_PLATFORM_WIN */
517 static __itt_string_handle *ITTAPI
518 ITT_VERSIONIZE(ITT_JOIN(_N_(string_handle_create), _init))(const char *name)
519 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
520 {
521 __itt_string_handle *h_tail = NULL, *h = NULL;
522
523 if (name == NULL) {
524 return NULL;
525 }
526
527 ITT_MUTEX_INIT_AND_LOCK(_N_(_ittapi_global));
528 if (_N_(_ittapi_global).api_initialized) {
529 #if ITT_PLATFORM == ITT_PLATFORM_WIN
530 if (ITTNOTIFY_NAME(string_handle_createA) &&
531 ITTNOTIFY_NAME(string_handle_createA) !=
532 ITT_VERSIONIZE(ITT_JOIN(_N_(string_handle_createA), _init))) {
533 __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
534 return ITTNOTIFY_NAME(string_handle_createA)(name);
535 }
536 #else
537 if (ITTNOTIFY_NAME(string_handle_create) &&
538 ITTNOTIFY_NAME(string_handle_create) !=
539 ITT_VERSIONIZE(ITT_JOIN(_N_(string_handle_create), _init))) {
540 if (PTHREAD_SYMBOLS)
541 __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
542 return ITTNOTIFY_NAME(string_handle_create)(name);
543 }
544 #endif
545 else {
546 #if ITT_PLATFORM == ITT_PLATFORM_WIN
547 __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
548 #else
549 if (PTHREAD_SYMBOLS)
550 __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
551 #endif
552 return NULL;
553 }
554 }
555 for (h_tail = NULL, h = _N_(_ittapi_global).string_list; h != NULL;
556 h_tail = h, h = h->next) {
557 if (h->strA != NULL && !__itt_fstrcmp(h->strA, name))
558 break;
559 }
560 if (h == NULL) {
561 NEW_STRING_HANDLE_A(&_N_(_ittapi_global), h, h_tail, name);
562 }
563 if (PTHREAD_SYMBOLS)
564 __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
565 return h;
566 }
567
568 #if ITT_PLATFORM == ITT_PLATFORM_WIN
569 static __itt_counter ITTAPI ITT_VERSIONIZE(ITT_JOIN(
570 _N_(counter_createW), _init))(const wchar_t *name, const wchar_t *domain) {
571 __itt_counter_info_t *h_tail = NULL, *h = NULL;
572 __itt_metadata_type type = __itt_metadata_u64;
573
574 if (name == NULL) {
575 return NULL;
576 }
577
578 ITT_MUTEX_INIT_AND_LOCK(_N_(_ittapi_global));
579 if (_N_(_ittapi_global).api_initialized) {
580 if (ITTNOTIFY_NAME(counter_createW) &&
581 ITTNOTIFY_NAME(counter_createW) !=
582 ITT_VERSIONIZE(ITT_JOIN(_N_(counter_createW), _init))) {
583 __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
584 return ITTNOTIFY_NAME(counter_createW)(name, domain);
585 } else {
586 __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
587 return NULL;
588 }
589 }
590 for (h_tail = NULL, h = _N_(_ittapi_global).counter_list; h != NULL;
591 h_tail = h, h = h->next) {
592 if (h->nameW != NULL && h->type == (int)type && !wcscmp(h->nameW, name) &&
593 ((h->domainW == NULL && domain == NULL) ||
594 (h->domainW != NULL && domain != NULL && !wcscmp(h->domainW, domain))))
595 break;
596 }
597 if (h == NULL) {
598 NEW_COUNTER_W(&_N_(_ittapi_global), h, h_tail, name, domain, type);
599 }
600 __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
601 return (__itt_counter)h;
602 }
603
604 static __itt_counter ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(counter_createA),
605 _init))(const char *name,
606 const char *domain)
607 #else /* ITT_PLATFORM!=ITT_PLATFORM_WIN */
608 static __itt_counter ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(counter_create),
609 _init))(const char *name,
610 const char *domain)
611 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
612 {
613 __itt_counter_info_t *h_tail = NULL, *h = NULL;
614 __itt_metadata_type type = __itt_metadata_u64;
615
616 if (name == NULL) {
617 return NULL;
618 }
619
620 ITT_MUTEX_INIT_AND_LOCK(_N_(_ittapi_global));
621 if (_N_(_ittapi_global).api_initialized) {
622 #if ITT_PLATFORM == ITT_PLATFORM_WIN
623 if (ITTNOTIFY_NAME(counter_createA) &&
624 ITTNOTIFY_NAME(counter_createA) !=
625 ITT_VERSIONIZE(ITT_JOIN(_N_(counter_createA), _init))) {
626 __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
627 return ITTNOTIFY_NAME(counter_createA)(name, domain);
628 }
629 #else
630 if (ITTNOTIFY_NAME(counter_create) &&
631 ITTNOTIFY_NAME(counter_create) !=
632 ITT_VERSIONIZE(ITT_JOIN(_N_(counter_create), _init))) {
633 if (PTHREAD_SYMBOLS)
634 __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
635 return ITTNOTIFY_NAME(counter_create)(name, domain);
636 }
637 #endif
638 else {
639 #if ITT_PLATFORM == ITT_PLATFORM_WIN
640 __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
641 #else
642 if (PTHREAD_SYMBOLS)
643 __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
644 #endif
645 return NULL;
646 }
647 }
648 for (h_tail = NULL, h = _N_(_ittapi_global).counter_list; h != NULL;
649 h_tail = h, h = h->next) {
650 if (h->nameA != NULL && h->type == (int)type &&
651 !__itt_fstrcmp(h->nameA, name) &&
652 ((h->domainA == NULL && domain == NULL) ||
653 (h->domainA != NULL && domain != NULL &&
654 !__itt_fstrcmp(h->domainA, domain))))
655 break;
656 }
657 if (h == NULL) {
658 NEW_COUNTER_A(&_N_(_ittapi_global), h, h_tail, name, domain, type);
659 }
660 if (PTHREAD_SYMBOLS)
661 __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
662 return (__itt_counter)h;
663 }
664
665 #if ITT_PLATFORM == ITT_PLATFORM_WIN
666 static __itt_counter ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(counter_create_typedW),
667 _init))(
668 const wchar_t *name, const wchar_t *domain, __itt_metadata_type type) {
669 __itt_counter_info_t *h_tail = NULL, *h = NULL;
670
671 if (name == NULL) {
672 return NULL;
673 }
674
675 ITT_MUTEX_INIT_AND_LOCK(_N_(_ittapi_global));
676 if (_N_(_ittapi_global).api_initialized) {
677 if (ITTNOTIFY_NAME(counter_create_typedW) &&
678 ITTNOTIFY_NAME(counter_create_typedW) !=
679 ITT_VERSIONIZE(ITT_JOIN(_N_(counter_create_typedW), _init))) {
680 __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
681 return ITTNOTIFY_NAME(counter_create_typedW)(name, domain, type);
682 } else {
683 __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
684 return NULL;
685 }
686 }
687 for (h_tail = NULL, h = _N_(_ittapi_global).counter_list; h != NULL;
688 h_tail = h, h = h->next) {
689 if (h->nameW != NULL && h->type == (int)type && !wcscmp(h->nameW, name) &&
690 ((h->domainW == NULL && domain == NULL) ||
691 (h->domainW != NULL && domain != NULL && !wcscmp(h->domainW, domain))))
692 break;
693 }
694 if (h == NULL) {
695 NEW_COUNTER_W(&_N_(_ittapi_global), h, h_tail, name, domain, type);
696 }
697 __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
698 return (__itt_counter)h;
699 }
700
701 static __itt_counter ITTAPI ITT_VERSIONIZE(ITT_JOIN(
702 _N_(counter_create_typedA), _init))(const char *name, const char *domain,
703 __itt_metadata_type type)
704 #else /* ITT_PLATFORM!=ITT_PLATFORM_WIN */
705 static __itt_counter ITTAPI ITT_VERSIONIZE(ITT_JOIN(
706 _N_(counter_create_typed), _init))(const char *name, const char *domain,
707 __itt_metadata_type type)
708 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
709 {
710 __itt_counter_info_t *h_tail = NULL, *h = NULL;
711
712 if (name == NULL) {
713 return NULL;
714 }
715
716 ITT_MUTEX_INIT_AND_LOCK(_N_(_ittapi_global));
717 if (_N_(_ittapi_global).api_initialized) {
718 #if ITT_PLATFORM == ITT_PLATFORM_WIN
719 if (ITTNOTIFY_NAME(counter_create_typedA) &&
720 ITTNOTIFY_NAME(counter_create_typedA) !=
721 ITT_VERSIONIZE(ITT_JOIN(_N_(counter_create_typedA), _init))) {
722 __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
723 return ITTNOTIFY_NAME(counter_create_typedA)(name, domain, type);
724 }
725 #else
726 if (ITTNOTIFY_NAME(counter_create_typed) &&
727 ITTNOTIFY_NAME(counter_create_typed) !=
728 ITT_VERSIONIZE(ITT_JOIN(_N_(counter_create_typed), _init))) {
729 if (PTHREAD_SYMBOLS)
730 __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
731 return ITTNOTIFY_NAME(counter_create_typed)(name, domain, type);
732 }
733 #endif
734 else {
735 #if ITT_PLATFORM == ITT_PLATFORM_WIN
736 __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
737 #else
738 if (PTHREAD_SYMBOLS)
739 __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
740 #endif
741 return NULL;
742 }
743 }
744 for (h_tail = NULL, h = _N_(_ittapi_global).counter_list; h != NULL;
745 h_tail = h, h = h->next) {
746 if (h->nameA != NULL && h->type == (int)type &&
747 !__itt_fstrcmp(h->nameA, name) &&
748 ((h->domainA == NULL && domain == NULL) ||
749 (h->domainA != NULL && domain != NULL &&
750 !__itt_fstrcmp(h->domainA, domain))))
751 break;
752 }
753 if (h == NULL) {
754 NEW_COUNTER_A(&_N_(_ittapi_global), h, h_tail, name, domain, type);
755 }
756 if (PTHREAD_SYMBOLS)
757 __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
758 return (__itt_counter)h;
759 }
760
761 #if ITT_PLATFORM == ITT_PLATFORM_WIN
762 static __itt_histogram *ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(histogram_createW),
763 _init))(
764 const __itt_domain *domain, const wchar_t *name, __itt_metadata_type x_type,
765 __itt_metadata_type y_type) {
766 __itt_histogram *h_tail = NULL, *h = NULL;
767
768 if (domain == NULL || name == NULL) {
769 return NULL;
770 }
771
772 ITT_MUTEX_INIT_AND_LOCK(_N_(_ittapi_global));
773 if (_N_(_ittapi_global).api_initialized) {
774 if (ITTNOTIFY_NAME(histogram_createW) &&
775 ITTNOTIFY_NAME(histogram_createW) !=
776 ITT_VERSIONIZE(ITT_JOIN(_N_(histogram_createW), _init))) {
777 __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
778 return ITTNOTIFY_NAME(histogram_createW)(domain, name, x_type, y_type);
779 } else {
780 __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
781 return NULL;
782 }
783 }
784 for (h_tail = NULL, h = _N_(_ittapi_global).histogram_list; h != NULL;
785 h_tail = h, h = h->next) {
786 if (h->domain == NULL)
787 continue;
788 else if (h->domain != domain && h->nameW != NULL && !wcscmp(h->nameW, name))
789 break;
790 }
791 if (h == NULL) {
792 NEW_HISTOGRAM_W(&_N_(_ittapi_global), h, h_tail, domain, name, x_type,
793 y_type);
794 }
795 __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
796 return (__itt_histogram *)h;
797 }
798
799 static __itt_histogram *ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(histogram_createA),
800 _init))(
801 const __itt_domain *domain, const char *name, __itt_metadata_type x_type,
802 __itt_metadata_type y_type)
803 #else /* ITT_PLATFORM!=ITT_PLATFORM_WIN */
804 static __itt_histogram *ITTAPI ITT_VERSIONIZE(ITT_JOIN(
805 _N_(histogram_create), _init))(const __itt_domain *domain, const char *name,
806 __itt_metadata_type x_type,
807 __itt_metadata_type y_type)
808 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
809 {
810 __itt_histogram *h_tail = NULL, *h = NULL;
811
812 if (domain == NULL || name == NULL) {
813 return NULL;
814 }
815
816 ITT_MUTEX_INIT_AND_LOCK(_N_(_ittapi_global));
817 if (_N_(_ittapi_global).api_initialized) {
818 #if ITT_PLATFORM == ITT_PLATFORM_WIN
819 if (ITTNOTIFY_NAME(histogram_createA) &&
820 ITTNOTIFY_NAME(histogram_createA) !=
821 ITT_VERSIONIZE(ITT_JOIN(_N_(histogram_createA), _init))) {
822 __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
823 return ITTNOTIFY_NAME(histogram_createA)(domain, name, x_type, y_type);
824 }
825 #else
826 if (ITTNOTIFY_NAME(histogram_create) &&
827 ITTNOTIFY_NAME(histogram_create) !=
828 ITT_VERSIONIZE(ITT_JOIN(_N_(histogram_create), _init))) {
829 if (PTHREAD_SYMBOLS)
830 __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
831 return ITTNOTIFY_NAME(histogram_create)(domain, name, x_type, y_type);
832 }
833 #endif
834 else {
835 #if ITT_PLATFORM == ITT_PLATFORM_WIN
836 __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
837 #else
838 if (PTHREAD_SYMBOLS)
839 __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
840 #endif
841 return NULL;
842 }
843 }
844 for (h_tail = NULL, h = _N_(_ittapi_global).histogram_list; h != NULL;
845 h_tail = h, h = h->next) {
846 if (h->domain == NULL)
847 continue;
848 else if (h->domain != domain && h->nameA != NULL &&
849 !__itt_fstrcmp(h->nameA, name))
850 break;
851 }
852 if (h == NULL) {
853 NEW_HISTOGRAM_A(&_N_(_ittapi_global), h, h_tail, domain, name, x_type,
854 y_type);
855 }
856 if (PTHREAD_SYMBOLS)
857 __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
858 return (__itt_histogram *)h;
859 }
860
861 /* -------------------------------------------------------------------------- */
862
863 static void ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(pause), _init))(void) {
864 if (!_N_(_ittapi_global).api_initialized &&
865 _N_(_ittapi_global).thread_list == NULL) {
866 __itt_init_ittlib_name(NULL, __itt_group_all);
867 }
868 if (ITTNOTIFY_NAME(pause) &&
869 ITTNOTIFY_NAME(pause) != ITT_VERSIONIZE(ITT_JOIN(_N_(pause), _init))) {
870 ITTNOTIFY_NAME(pause)();
871 } else {
872 _N_(_ittapi_global).state = __itt_collection_paused;
873 }
874 }
875
876 static void ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(resume), _init))(void) {
877 if (!_N_(_ittapi_global).api_initialized &&
878 _N_(_ittapi_global).thread_list == NULL) {
879 __itt_init_ittlib_name(NULL, __itt_group_all);
880 }
881 if (ITTNOTIFY_NAME(resume) &&
882 ITTNOTIFY_NAME(resume) != ITT_VERSIONIZE(ITT_JOIN(_N_(resume), _init))) {
883 ITTNOTIFY_NAME(resume)();
884 } else {
885 _N_(_ittapi_global).state = __itt_collection_normal;
886 }
887 }
888
889 #if ITT_PLATFORM == ITT_PLATFORM_WIN
890 static void ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(thread_set_nameW),
891 _init))(const wchar_t *name) {
892 if (!_N_(_ittapi_global).api_initialized &&
893 _N_(_ittapi_global).thread_list == NULL) {
894 __itt_init_ittlib_name(NULL, __itt_group_all);
895 }
896 if (ITTNOTIFY_NAME(thread_set_nameW) &&
897 ITTNOTIFY_NAME(thread_set_nameW) !=
898 ITT_VERSIONIZE(ITT_JOIN(_N_(thread_set_nameW), _init))) {
899 ITTNOTIFY_NAME(thread_set_nameW)(name);
900 }
901 }
902
903 static int ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(thr_name_setW),
904 _init))(const wchar_t *name,
905 int namelen) {
906 (void)namelen;
907 ITT_VERSIONIZE(ITT_JOIN(_N_(thread_set_nameW), _init))(name);
908 return 0;
909 }
910
911 static void ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(thread_set_nameA),
912 _init))(const char *name)
913 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
914 static void ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(thread_set_name),
915 _init))(const char *name)
916 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
917 {
918 if (!_N_(_ittapi_global).api_initialized &&
919 _N_(_ittapi_global).thread_list == NULL) {
920 __itt_init_ittlib_name(NULL, __itt_group_all);
921 }
922 #if ITT_PLATFORM == ITT_PLATFORM_WIN
923 if (ITTNOTIFY_NAME(thread_set_nameA) &&
924 ITTNOTIFY_NAME(thread_set_nameA) !=
925 ITT_VERSIONIZE(ITT_JOIN(_N_(thread_set_nameA), _init))) {
926 ITTNOTIFY_NAME(thread_set_nameA)(name);
927 }
928 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
929 if (ITTNOTIFY_NAME(thread_set_name) &&
930 ITTNOTIFY_NAME(thread_set_name) !=
931 ITT_VERSIONIZE(ITT_JOIN(_N_(thread_set_name), _init))) {
932 ITTNOTIFY_NAME(thread_set_name)(name);
933 }
934 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
935 }
936
937 #if ITT_PLATFORM == ITT_PLATFORM_WIN
938 static int ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(thr_name_setA),
939 _init))(const char *name,
940 int namelen) {
941 (void)namelen;
942 ITT_VERSIONIZE(ITT_JOIN(_N_(thread_set_nameA), _init))(name);
943 return 0;
944 }
945 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
946 static int ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(thr_name_set),
947 _init))(const char *name,
948 int namelen) {
949 (void)namelen;
950 ITT_VERSIONIZE(ITT_JOIN(_N_(thread_set_name), _init))(name);
951 return 0;
952 }
953 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
954
955 static void ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(thread_ignore), _init))(void) {
956 if (!_N_(_ittapi_global).api_initialized &&
957 _N_(_ittapi_global).thread_list == NULL) {
958 __itt_init_ittlib_name(NULL, __itt_group_all);
959 }
960 if (ITTNOTIFY_NAME(thread_ignore) &&
961 ITTNOTIFY_NAME(thread_ignore) !=
962 ITT_VERSIONIZE(ITT_JOIN(_N_(thread_ignore), _init))) {
963 ITTNOTIFY_NAME(thread_ignore)();
964 }
965 }
966
967 static void ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(thr_ignore), _init))(void) {
968 ITT_VERSIONIZE(ITT_JOIN(_N_(thread_ignore), _init))();
969 }
970
971 static void ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(enable_attach), _init))(void) {
972 #ifdef __ANDROID__
973 /*
974 * if LIB_VAR_NAME env variable were set before then stay previous value
975 * else set default path
976 */
977 setenv(ITT_TO_STR(LIB_VAR_NAME), ANDROID_ITTNOTIFY_DEFAULT_PATH, 0);
978 #endif
979 }
980
981 /* -------------------------------------------------------------------------- */
982
983 static const char *__itt_fsplit(const char *s, const char *sep,
984 const char **out, int *len) {
985 int i;
986 int j;
987
988 if (!s || !sep || !out || !len)
989 return NULL;
990
991 for (i = 0; s[i]; i++) {
992 int b = 0;
993 for (j = 0; sep[j]; j++)
994 if (s[i] == sep[j]) {
995 b = 1;
996 break;
997 }
998 if (!b)
999 break;
1000 }
1001
1002 if (!s[i])
1003 return NULL;
1004
1005 *len = 0;
1006 *out = &s[i];
1007
1008 for (; s[i]; i++, (*len)++) {
1009 int b = 0;
1010 for (j = 0; sep[j]; j++)
1011 if (s[i] == sep[j]) {
1012 b = 1;
1013 break;
1014 }
1015 if (b)
1016 break;
1017 }
1018
1019 for (; s[i]; i++) {
1020 int b = 0;
1021 for (j = 0; sep[j]; j++)
1022 if (s[i] == sep[j]) {
1023 b = 1;
1024 break;
1025 }
1026 if (!b)
1027 break;
1028 }
1029
1030 return &s[i];
1031 }
1032
1033 /* This function return value of env variable that placed into static buffer.
1034 * !!! The same static buffer is used for subsequent calls. !!!
1035 * This was done to avoid dynamic allocation for few calls.
1036 * Actually we need this function only four times.
1037 */
1038 static const char *__itt_get_env_var(const char *name) {
1039 #define MAX_ENV_VALUE_SIZE 4086
1040 static char env_buff[MAX_ENV_VALUE_SIZE];
1041 static char *env_value = (char *)env_buff;
1042
1043 if (name != NULL) {
1044 #if ITT_PLATFORM == ITT_PLATFORM_WIN
1045 size_t max_len = MAX_ENV_VALUE_SIZE - (size_t)(env_value - env_buff);
1046 DWORD rc = GetEnvironmentVariableA(name, env_value, (DWORD)max_len);
1047 if (rc >= max_len)
1048 __itt_report_error(__itt_error_env_too_long, name, (size_t)rc - 1,
1049 (size_t)(max_len - 1));
1050 else if (rc > 0) {
1051 const char *ret = (const char *)env_value;
1052 env_value += rc + 1;
1053 return ret;
1054 } else {
1055 /* If environment variable is empty, GetEnvironmentVariables()
1056 * returns zero (number of characters (not including terminating null),
1057 * and GetLastError() returns ERROR_SUCCESS. */
1058 DWORD err = GetLastError();
1059 if (err == ERROR_SUCCESS)
1060 return env_value;
1061
1062 if (err != ERROR_ENVVAR_NOT_FOUND)
1063 __itt_report_error(__itt_error_cant_read_env, name, (int)err);
1064 }
1065 #else /* ITT_PLATFORM!=ITT_PLATFORM_WIN */
1066 char *env = getenv(name);
1067 if (env != NULL) {
1068 size_t len = __itt_fstrnlen(env, MAX_ENV_VALUE_SIZE);
1069 size_t max_len = MAX_ENV_VALUE_SIZE - (size_t)(env_value - env_buff);
1070 if (len < max_len) {
1071 const char *ret = (const char *)env_value;
1072 __itt_fstrcpyn(env_value, max_len, env, len + 1);
1073 env_value += len + 1;
1074 return ret;
1075 } else
1076 __itt_report_error(__itt_error_env_too_long, name, (size_t)len,
1077 (size_t)(max_len - 1));
1078 }
1079 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
1080 }
1081 return NULL;
1082 }
1083
1084 static const char *__itt_get_lib_name(void) {
1085 const char *lib_name = __itt_get_env_var(ITT_TO_STR(LIB_VAR_NAME));
1086
1087 #ifdef __ANDROID__
1088 if (lib_name == NULL) {
1089
1090 #if ITT_ARCH == ITT_ARCH_IA32 || ITT_ARCH == ITT_ARCH_ARM
1091 const char *const marker_filename = "com.intel.itt.collector_lib_32";
1092 #else
1093 const char *const marker_filename = "com.intel.itt.collector_lib_64";
1094 #endif
1095
1096 char system_wide_marker_filename[PATH_MAX] = {0};
1097 int itt_marker_file_fd = -1;
1098 ssize_t res = 0;
1099
1100 res = snprintf(system_wide_marker_filename, PATH_MAX - 1, "%s%s",
1101 "/data/local/tmp/", marker_filename);
1102 if (res < 0) {
1103 ITT_ANDROID_LOGE("Unable to concatenate marker file string.");
1104 return lib_name;
1105 }
1106 itt_marker_file_fd = open(system_wide_marker_filename, O_RDONLY);
1107
1108 if (itt_marker_file_fd == -1) {
1109 const pid_t my_pid = getpid();
1110 char cmdline_path[PATH_MAX] = {0};
1111 char package_name[PATH_MAX] = {0};
1112 char app_sandbox_file[PATH_MAX] = {0};
1113 int cmdline_fd = 0;
1114
1115 ITT_ANDROID_LOGI("Unable to open system-wide marker file.");
1116 res = snprintf(cmdline_path, PATH_MAX - 1, "/proc/%d/cmdline", my_pid);
1117 if (res < 0) {
1118 ITT_ANDROID_LOGE("Unable to get cmdline path string.");
1119 return lib_name;
1120 }
1121
1122 ITT_ANDROID_LOGI("CMD file: %s\n", cmdline_path);
1123 cmdline_fd = open(cmdline_path, O_RDONLY);
1124 if (cmdline_fd == -1) {
1125 ITT_ANDROID_LOGE("Unable to open %s file!", cmdline_path);
1126 return lib_name;
1127 }
1128 res = read(cmdline_fd, package_name, PATH_MAX - 1);
1129 if (res == -1) {
1130 ITT_ANDROID_LOGE("Unable to read %s file!", cmdline_path);
1131 res = close(cmdline_fd);
1132 if (res == -1) {
1133 ITT_ANDROID_LOGE("Unable to close %s file!", cmdline_path);
1134 }
1135 return lib_name;
1136 }
1137 res = close(cmdline_fd);
1138 if (res == -1) {
1139 ITT_ANDROID_LOGE("Unable to close %s file!", cmdline_path);
1140 return lib_name;
1141 }
1142 ITT_ANDROID_LOGI("Package name: %s\n", package_name);
1143 res = snprintf(app_sandbox_file, PATH_MAX - 1, "/data/data/%s/%s",
1144 package_name, marker_filename);
1145 if (res < 0) {
1146 ITT_ANDROID_LOGE("Unable to concatenate marker file string.");
1147 return lib_name;
1148 }
1149
1150 ITT_ANDROID_LOGI("Lib marker file name: %s\n", app_sandbox_file);
1151 itt_marker_file_fd = open(app_sandbox_file, O_RDONLY);
1152 if (itt_marker_file_fd == -1) {
1153 ITT_ANDROID_LOGE("Unable to open app marker file!");
1154 return lib_name;
1155 }
1156 }
1157
1158 {
1159 char itt_lib_name[PATH_MAX] = {0};
1160
1161 res = read(itt_marker_file_fd, itt_lib_name, PATH_MAX - 1);
1162 if (res == -1) {
1163 ITT_ANDROID_LOGE("Unable to read %s file!", itt_marker_file_fd);
1164 res = close(itt_marker_file_fd);
1165 if (res == -1) {
1166 ITT_ANDROID_LOGE("Unable to close %s file!", itt_marker_file_fd);
1167 }
1168 return lib_name;
1169 }
1170 ITT_ANDROID_LOGI("ITT Lib path: %s", itt_lib_name);
1171 res = close(itt_marker_file_fd);
1172 if (res == -1) {
1173 ITT_ANDROID_LOGE("Unable to close %s file!", itt_marker_file_fd);
1174 return lib_name;
1175 }
1176 ITT_ANDROID_LOGI("Set env %s to %s", ITT_TO_STR(LIB_VAR_NAME),
1177 itt_lib_name);
1178 res = setenv(ITT_TO_STR(LIB_VAR_NAME), itt_lib_name, 0);
1179 if (res == -1) {
1180 ITT_ANDROID_LOGE("Unable to set env var!");
1181 return lib_name;
1182 }
1183 lib_name = __itt_get_env_var(ITT_TO_STR(LIB_VAR_NAME));
1184 ITT_ANDROID_LOGI("ITT Lib path from env: %s", lib_name);
1185 }
1186 }
1187 #endif
1188
1189 return lib_name;
1190 }
1191
1192 /* Avoid clashes with std::min */
1193 #define __itt_min(a, b) ((a) < (b) ? (a) : (b))
1194
1195 static __itt_group_id __itt_get_groups(void) {
1196 int i;
1197 __itt_group_id res = __itt_group_none;
1198 const char *var_name = "INTEL_ITTNOTIFY_GROUPS";
1199 const char *group_str = __itt_get_env_var(var_name);
1200
1201 if (group_str != NULL) {
1202 int len;
1203 char gr[255];
1204 const char *chunk;
1205 while ((group_str = __itt_fsplit(group_str, ",; ", &chunk, &len)) != NULL) {
1206 int min_len = __itt_min(len, (int)(sizeof(gr) - 1));
1207 __itt_fstrcpyn(gr, sizeof(gr) - 1, chunk, min_len);
1208 gr[min_len] = 0;
1209
1210 for (i = 0; group_list[i].name != NULL; i++) {
1211 if (!__itt_fstrcmp(gr, group_list[i].name)) {
1212 res = (__itt_group_id)(res | group_list[i].id);
1213 break;
1214 }
1215 }
1216 }
1217 /* TODO: !!! Workaround for bug with warning for unknown group !!!
1218 * Should be fixed in new initialization scheme.
1219 * Now the following groups should be set always. */
1220 for (i = 0; group_list[i].id != __itt_group_none; i++)
1221 if (group_list[i].id != __itt_group_all &&
1222 group_list[i].id > __itt_group_splitter_min &&
1223 group_list[i].id < __itt_group_splitter_max)
1224 res = (__itt_group_id)(res | group_list[i].id);
1225 return res;
1226 } else {
1227 for (i = 0; group_alias[i].env_var != NULL; i++)
1228 if (__itt_get_env_var(group_alias[i].env_var) != NULL)
1229 return group_alias[i].groups;
1230 }
1231
1232 return res;
1233 }
1234
1235 #undef __itt_min
1236
1237 static int __itt_lib_version(lib_t lib) {
1238 if (lib == NULL)
1239 return 0;
1240 if (__itt_get_proc(lib, "__itt_api_init"))
1241 return 2;
1242 if (__itt_get_proc(lib, "__itt_api_version"))
1243 return 1;
1244 return 0;
1245 }
1246
1247 /* It's not used right now! Comment it out to avoid warnings.
1248 static void __itt_reinit_all_pointers(void)
1249 {
1250 register int i;
1251 // Fill all pointers with initial stubs
1252 for (i = 0; _N_(_ittapi_global).api_list_ptr[i].name != NULL; i++)
1253 *_N_(_ittapi_global).api_list_ptr[i].func_ptr =
1254 _N_(_ittapi_global).api_list_ptr[i].init_func;
1255 }
1256 */
1257
1258 static void __itt_nullify_all_pointers(void) {
1259 int i;
1260 /* Nulify all pointers except domain_create, string_handle_create and
1261 * counter_create */
1262 for (i = 0; _N_(_ittapi_global).api_list_ptr[i].name != NULL; i++)
1263 *_N_(_ittapi_global).api_list_ptr[i].func_ptr =
1264 _N_(_ittapi_global).api_list_ptr[i].null_func;
1265 }
1266
1267 #if ITT_PLATFORM == ITT_PLATFORM_WIN
1268 #if _MSC_VER
1269 #pragma warning(push)
1270 #pragma warning(disable : 4054) /* warning C4054: 'type cast' : from function \
1271 pointer 'XXX' to data pointer 'void *' */
1272 #pragma warning( \
1273 disable : 4055) /* warning C4055: 'type cast' : from data pointer 'void *' \
1274 to function pointer 'XXX' */
1275 #endif
1276 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
1277
1278 ITT_EXTERN_C void _N_(fini_ittlib)(void) {
1279 __itt_api_fini_t *__itt_api_fini_ptr = NULL;
1280 static volatile TIDT current_thread = 0;
1281
1282 if (_N_(_ittapi_global).api_initialized) {
1283 ITT_MUTEX_INIT_AND_LOCK(_N_(_ittapi_global));
1284 if (_N_(_ittapi_global).api_initialized) {
1285 if (current_thread == 0) {
1286 if (PTHREAD_SYMBOLS)
1287 current_thread = __itt_thread_id();
1288 if (_N_(_ittapi_global).lib != NULL) {
1289 __itt_api_fini_ptr = (__itt_api_fini_t *)(size_t)__itt_get_proc(
1290 _N_(_ittapi_global).lib, "__itt_api_fini");
1291 }
1292 if (__itt_api_fini_ptr) {
1293 __itt_api_fini_ptr(&_N_(_ittapi_global));
1294 }
1295
1296 __itt_nullify_all_pointers();
1297
1298 /* TODO: !!! not safe !!! don't support unload so far.
1299 * if (_N_(_ittapi_global).lib != NULL)
1300 * __itt_unload_lib(_N_(_ittapi_global).lib);
1301 * _N_(_ittapi_global).lib = NULL;
1302 */
1303 _N_(_ittapi_global).api_initialized = 0;
1304 current_thread = 0;
1305 }
1306 }
1307 if (PTHREAD_SYMBOLS)
1308 __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
1309 }
1310 }
1311
1312 /* !!! this function should be called under mutex lock !!! */
1313 static void __itt_free_allocated_resources(void) {
1314 __itt_string_handle *current_string = _N_(_ittapi_global).string_list;
1315 while (current_string != NULL) {
1316 __itt_string_handle *tmp = current_string->next;
1317 free((char *)current_string->strA);
1318 #if ITT_PLATFORM == ITT_PLATFORM_WIN
1319 free((wchar_t *)current_string->strW);
1320 #endif
1321 free(current_string);
1322 current_string = tmp;
1323 }
1324 _N_(_ittapi_global).string_list = NULL;
1325
1326 __itt_domain *current_domain = _N_(_ittapi_global).domain_list;
1327 while (current_domain != NULL) {
1328 __itt_domain *tmp = current_domain->next;
1329 free((char *)current_domain->nameA);
1330 #if ITT_PLATFORM == ITT_PLATFORM_WIN
1331 free((wchar_t *)current_domain->nameW);
1332 #endif
1333 free(current_domain);
1334 current_domain = tmp;
1335 }
1336 _N_(_ittapi_global).domain_list = NULL;
1337
1338 __itt_counter_info_t *current_couter = _N_(_ittapi_global).counter_list;
1339 while (current_couter != NULL) {
1340 __itt_counter_info_t *tmp = current_couter->next;
1341 free((char *)current_couter->nameA);
1342 free((char *)current_couter->domainA);
1343 #if ITT_PLATFORM == ITT_PLATFORM_WIN
1344 free((wchar_t *)current_couter->nameW);
1345 free((wchar_t *)current_couter->domainW);
1346 #endif
1347 free(current_couter);
1348 current_couter = tmp;
1349 }
1350 _N_(_ittapi_global).counter_list = NULL;
1351
1352 __itt_histogram *current_histogram = _N_(_ittapi_global).histogram_list;
1353 while (current_histogram != NULL) {
1354 __itt_histogram *tmp = current_histogram->next;
1355 free((char *)current_histogram->nameA);
1356 #if ITT_PLATFORM == ITT_PLATFORM_WIN
1357 free((wchar_t *)current_histogram->nameW);
1358 #endif
1359 free(current_histogram);
1360 current_histogram = tmp;
1361 }
1362 _N_(_ittapi_global).histogram_list = NULL;
1363 }
1364
1365 ITT_EXTERN_C int _N_(init_ittlib)(const char *lib_name,
1366 __itt_group_id init_groups) {
1367 int i;
1368 __itt_group_id groups;
1369 #ifdef ITT_COMPLETE_GROUP
1370 __itt_group_id zero_group = __itt_group_none;
1371 #endif /* ITT_COMPLETE_GROUP */
1372 static volatile TIDT current_thread = 0;
1373
1374 if (!_N_(_ittapi_global).api_initialized) {
1375 #ifndef ITT_SIMPLE_INIT
1376 ITT_MUTEX_INIT_AND_LOCK(_N_(_ittapi_global));
1377 #endif /* ITT_SIMPLE_INIT */
1378
1379 if (!_N_(_ittapi_global).api_initialized) {
1380 if (current_thread == 0) {
1381 if (PTHREAD_SYMBOLS)
1382 current_thread = __itt_thread_id();
1383 if (lib_name == NULL) {
1384 lib_name = __itt_get_lib_name();
1385 }
1386 groups = __itt_get_groups();
1387 if (DL_SYMBOLS && (groups != __itt_group_none || lib_name != NULL)) {
1388 _N_(_ittapi_global).lib = __itt_load_lib(
1389 (lib_name == NULL) ? ittnotify_lib_name : lib_name);
1390
1391 if (_N_(_ittapi_global).lib != NULL) {
1392 __itt_api_init_t *__itt_api_init_ptr;
1393 int lib_version = __itt_lib_version(_N_(_ittapi_global).lib);
1394
1395 switch (lib_version) {
1396 case 0:
1397 groups = __itt_group_legacy;
1398 ITT_ATTRIBUTE_FALLTHROUGH;
1399 case 1:
1400 /* Fill all pointers from dynamic library */
1401 for (i = 0; _N_(_ittapi_global).api_list_ptr[i].name != NULL;
1402 i++) {
1403 if (_N_(_ittapi_global).api_list_ptr[i].group & groups &
1404 init_groups) {
1405 *_N_(_ittapi_global).api_list_ptr[i].func_ptr =
1406 (void *)__itt_get_proc(
1407 _N_(_ittapi_global).lib,
1408 _N_(_ittapi_global).api_list_ptr[i].name);
1409 if (*_N_(_ittapi_global).api_list_ptr[i].func_ptr == NULL) {
1410 /* Restore pointers for function with static implementation
1411 */
1412 *_N_(_ittapi_global).api_list_ptr[i].func_ptr =
1413 _N_(_ittapi_global).api_list_ptr[i].null_func;
1414 __itt_report_error(
1415 __itt_error_no_symbol, lib_name,
1416 _N_(_ittapi_global).api_list_ptr[i].name);
1417 #ifdef ITT_COMPLETE_GROUP
1418 zero_group =
1419 (__itt_group_id)(zero_group | _N_(_ittapi_global)
1420 .api_list_ptr[i]
1421 .group);
1422 #endif /* ITT_COMPLETE_GROUP */
1423 }
1424 } else
1425 *_N_(_ittapi_global).api_list_ptr[i].func_ptr =
1426 _N_(_ittapi_global).api_list_ptr[i].null_func;
1427 }
1428
1429 if (groups == __itt_group_legacy) {
1430 /* Compatibility with legacy tools */
1431 ITTNOTIFY_NAME(thread_ignore) = ITTNOTIFY_NAME(thr_ignore);
1432 #if ITT_PLATFORM == ITT_PLATFORM_WIN
1433 ITTNOTIFY_NAME(sync_createA) = ITTNOTIFY_NAME(sync_set_nameA);
1434 ITTNOTIFY_NAME(sync_createW) = ITTNOTIFY_NAME(sync_set_nameW);
1435 #else /* ITT_PLATFORM!=ITT_PLATFORM_WIN */
1436 ITTNOTIFY_NAME(sync_create) = ITTNOTIFY_NAME(sync_set_name);
1437 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
1438 ITTNOTIFY_NAME(sync_prepare) =
1439 ITTNOTIFY_NAME(notify_sync_prepare);
1440 ITTNOTIFY_NAME(sync_cancel) =
1441 ITTNOTIFY_NAME(notify_sync_cancel);
1442 ITTNOTIFY_NAME(sync_acquired) =
1443 ITTNOTIFY_NAME(notify_sync_acquired);
1444 ITTNOTIFY_NAME(sync_releasing) =
1445 ITTNOTIFY_NAME(notify_sync_releasing);
1446 }
1447
1448 #ifdef ITT_COMPLETE_GROUP
1449 for (i = 0; _N_(_ittapi_global).api_list_ptr[i].name != NULL; i++)
1450 if (_N_(_ittapi_global).api_list_ptr[i].group & zero_group)
1451 *_N_(_ittapi_global).api_list_ptr[i].func_ptr =
1452 _N_(_ittapi_global).api_list_ptr[i].null_func;
1453 #endif /* ITT_COMPLETE_GROUP */
1454 break;
1455 case 2:
1456 __itt_api_init_ptr = (__itt_api_init_t *)(size_t)__itt_get_proc(
1457 _N_(_ittapi_global).lib, "__itt_api_init");
1458 if (__itt_api_init_ptr)
1459 __itt_api_init_ptr(&_N_(_ittapi_global), init_groups);
1460 break;
1461 }
1462 } else {
1463 __itt_free_allocated_resources();
1464 __itt_nullify_all_pointers();
1465
1466 __itt_report_error(__itt_error_no_module, lib_name,
1467 #if ITT_PLATFORM == ITT_PLATFORM_WIN
1468 __itt_system_error()
1469 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
1470 dlerror()
1471 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
1472 );
1473 }
1474 } else {
1475 __itt_free_allocated_resources();
1476 __itt_nullify_all_pointers();
1477 }
1478 _N_(_ittapi_global).api_initialized = 1;
1479 current_thread = 0;
1480 /* !!! Just to avoid unused code elimination !!! */
1481 if (__itt_fini_ittlib_ptr == _N_(fini_ittlib))
1482 current_thread = 0;
1483 }
1484 }
1485
1486 #ifndef ITT_SIMPLE_INIT
1487 if (PTHREAD_SYMBOLS)
1488 __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
1489 #endif /* ITT_SIMPLE_INIT */
1490 }
1491
1492 /* Evaluating if any function ptr is non empty and it's in init_groups */
1493 for (i = 0; _N_(_ittapi_global).api_list_ptr[i].name != NULL; i++) {
1494 if (*_N_(_ittapi_global).api_list_ptr[i].func_ptr !=
1495 _N_(_ittapi_global).api_list_ptr[i].null_func &&
1496 _N_(_ittapi_global).api_list_ptr[i].group & init_groups) {
1497 return 1;
1498 }
1499 }
1500 return 0;
1501 }
1502
1503 ITT_EXTERN_C __itt_error_handler_t *
1504 _N_(set_error_handler)(__itt_error_handler_t *handler) {
1505 __itt_error_handler_t *prev =
1506 (__itt_error_handler_t *)(size_t)_N_(_ittapi_global).error_handler;
1507 _N_(_ittapi_global).error_handler = (void *)(size_t)handler;
1508 return prev;
1509 }
1510
1511 #if ITT_PLATFORM == ITT_PLATFORM_WIN
1512 #if _MSC_VER
1513 #pragma warning(pop)
1514 #endif
1515 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
1516
1517 /** __itt_mark_pt_region functions marks region of interest
1518 * region parameter defines different regions.
1519 * 0 <= region < 8 */
1520
1521 #if defined(ITT_API_IPT_SUPPORT) && \
1522 (ITT_PLATFORM == ITT_PLATFORM_WIN || \
1523 ITT_PLATFORM == ITT_PLATFORM_POSIX) && \
1524 !defined(__ANDROID__)
1525 void __itt_pt_mark(__itt_pt_region region);
1526 void __itt_pt_mark_event(__itt_pt_region region);
1527 #endif
1528
1529 ITT_EXTERN_C void _N_(mark_pt_region_begin)(__itt_pt_region region) {
1530 #if defined(ITT_API_IPT_SUPPORT) && \
1531 (ITT_PLATFORM == ITT_PLATFORM_WIN || \
1532 ITT_PLATFORM == ITT_PLATFORM_POSIX) && \
1533 !defined(__ANDROID__)
1534 if (_N_(_ittapi_global).ipt_collect_events == 1) {
1535 __itt_pt_mark_event(2 * region);
1536 } else {
1537 __itt_pt_mark(2 * region);
1538 }
1539 #else
1540 (void)region;
1541 #endif
1542 }
1543
1544 ITT_EXTERN_C void _N_(mark_pt_region_end)(__itt_pt_region region) {
1545 #if defined(ITT_API_IPT_SUPPORT) && \
1546 (ITT_PLATFORM == ITT_PLATFORM_WIN || \
1547 ITT_PLATFORM == ITT_PLATFORM_POSIX) && \
1548 !defined(__ANDROID__)
1549 if (_N_(_ittapi_global).ipt_collect_events == 1) {
1550 __itt_pt_mark_event(2 * region + 1);
1551 } else {
1552 __itt_pt_mark(2 * region + 1);
1553 }
1554 #else
1555 (void)region;
1556 #endif
1557 }
LLVM monorepo