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#ifndef _ITTNOTIFY_CONFIG_H_ 11#define _ITTNOTIFY_CONFIG_H_ 12 13/** @cond exclude_from_documentation */ 14#ifndef ITT_OS_WIN 15#define ITT_OS_WIN 1 16#endif /* ITT_OS_WIN */ 17 18#ifndef ITT_OS_LINUX 19#define ITT_OS_LINUX 2 20#endif /* ITT_OS_LINUX */ 21 22#ifndef ITT_OS_MAC 23#define ITT_OS_MAC 3 24#endif /* ITT_OS_MAC */ 25 26#ifndef ITT_OS_FREEBSD 27#define ITT_OS_FREEBSD 4 28#endif /* ITT_OS_FREEBSD */ 29 30#ifndef ITT_OS 31#if defined WIN32 || defined _WIN32 32#define ITT_OS ITT_OS_WIN 33#elif defined(__APPLE__) && defined(__MACH__) 34#define ITT_OS ITT_OS_MAC 35#elif defined(__FreeBSD__) 36#define ITT_OS ITT_OS_FREEBSD 37#else 38#define ITT_OS ITT_OS_LINUX 39#endif 40#endif /* ITT_OS */ 41 42#ifndef ITT_PLATFORM_WIN 43#define ITT_PLATFORM_WIN 1 44#endif /* ITT_PLATFORM_WIN */ 45 46#ifndef ITT_PLATFORM_POSIX 47#define ITT_PLATFORM_POSIX 2 48#endif /* ITT_PLATFORM_POSIX */ 49 50#ifndef ITT_PLATFORM_MAC 51#define ITT_PLATFORM_MAC 3 52#endif /* ITT_PLATFORM_MAC */ 53 54#ifndef ITT_PLATFORM_FREEBSD 55#define ITT_PLATFORM_FREEBSD 4 56#endif /* ITT_PLATFORM_FREEBSD */ 57 58#ifndef ITT_PLATFORM 59#if ITT_OS == ITT_OS_WIN 60#define ITT_PLATFORM ITT_PLATFORM_WIN 61#elif ITT_OS == ITT_OS_MAC 62#define ITT_PLATFORM ITT_PLATFORM_MAC 63#elif ITT_OS == ITT_OS_FREEBSD 64#define ITT_PLATFORM ITT_PLATFORM_FREEBSD 65#else 66#define ITT_PLATFORM ITT_PLATFORM_POSIX 67#endif 68#endif /* ITT_PLATFORM */ 69 70#if defined(_UNICODE) && !defined(UNICODE) 71#define UNICODE 72#endif 73 74#include <stddef.h> 75#if ITT_PLATFORM == ITT_PLATFORM_WIN 76#include <tchar.h> 77#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 78#include <stdint.h> 79#if defined(UNICODE) || defined(_UNICODE) 80#include <wchar.h> 81#endif /* UNICODE || _UNICODE */ 82#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 83 84#ifndef ITTAPI_CDECL 85#if ITT_PLATFORM == ITT_PLATFORM_WIN 86#define ITTAPI_CDECL __cdecl 87#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 88#if defined _M_IX86 || defined __i386__ 89#define ITTAPI_CDECL __attribute__((cdecl)) 90#else /* _M_IX86 || __i386__ */ 91#define ITTAPI_CDECL /* actual only on x86 platform */ 92#endif /* _M_IX86 || __i386__ */ 93#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 94#endif /* ITTAPI_CDECL */ 95 96#ifndef STDCALL 97#if ITT_PLATFORM == ITT_PLATFORM_WIN 98#define STDCALL __stdcall 99#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 100#if defined _M_IX86 || defined __i386__ 101#define STDCALL __attribute__((stdcall)) 102#else /* _M_IX86 || __i386__ */ 103#define STDCALL /* supported only on x86 platform */ 104#endif /* _M_IX86 || __i386__ */ 105#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 106#endif /* STDCALL */ 107 108#define ITTAPI ITTAPI_CDECL 109#define LIBITTAPI ITTAPI_CDECL 110 111/* TODO: Temporary for compatibility! */ 112#define ITTAPI_CALL ITTAPI_CDECL 113#define LIBITTAPI_CALL ITTAPI_CDECL 114 115#if ITT_PLATFORM == ITT_PLATFORM_WIN 116/* use __forceinline (VC++ specific) */ 117#if defined(__MINGW32__) && !defined(__cplusplus) 118#define ITT_INLINE \ 119 static __inline__ __attribute__((__always_inline__, __gnu_inline__)) 120#else 121#define ITT_INLINE static __forceinline 122#endif /* __MINGW32__ */ 123 124#define ITT_INLINE_ATTRIBUTE /* nothing */ 125#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 126/* 127 * Generally, functions are not inlined unless optimization is specified. 128 * For functions declared inline, this attribute inlines the function even 129 * if no optimization level was specified. 130 */ 131#ifdef __STRICT_ANSI__ 132#define ITT_INLINE static 133#define ITT_INLINE_ATTRIBUTE __attribute__((unused)) 134#else /* __STRICT_ANSI__ */ 135#define ITT_INLINE static inline 136#define ITT_INLINE_ATTRIBUTE __attribute__((always_inline, unused)) 137#endif /* __STRICT_ANSI__ */ 138#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 139/** @endcond */ 140 141#ifndef ITT_ARCH_IA32 142#define ITT_ARCH_IA32 1 143#endif /* ITT_ARCH_IA32 */ 144 145#ifndef ITT_ARCH_IA32E 146#define ITT_ARCH_IA32E 2 147#endif /* ITT_ARCH_IA32E */ 148 149#ifndef ITT_ARCH_IA64 150#define ITT_ARCH_IA64 3 151#endif /* ITT_ARCH_IA64 */ 152 153#ifndef ITT_ARCH_ARM 154#define ITT_ARCH_ARM 4 155#endif /* ITT_ARCH_ARM */ 156 157#ifndef ITT_ARCH_PPC64 158#define ITT_ARCH_PPC64 5 159#endif /* ITT_ARCH_PPC64 */ 160 161#ifndef ITT_ARCH_ARM64 162#define ITT_ARCH_ARM64 6 163#endif /* ITT_ARCH_ARM64 */ 164 165#ifndef ITT_ARCH_VE 166#define ITT_ARCH_VE 8 167#endif /* ITT_ARCH_VE */ 168 169#ifndef ITT_ARCH_S390X 170#define ITT_ARCH_S390X 8 171#endif /* ITT_ARCH_S390X */ 172 173#ifndef ITT_ARCH 174#if defined _M_IX86 || defined __i386__ 175#define ITT_ARCH ITT_ARCH_IA32 176#elif defined _M_X64 || defined _M_AMD64 || defined __x86_64__ 177#define ITT_ARCH ITT_ARCH_IA32E 178#elif defined _M_IA64 || defined __ia64__ 179#define ITT_ARCH ITT_ARCH_IA64 180#elif defined _M_ARM || defined __arm__ 181#define ITT_ARCH ITT_ARCH_ARM 182#elif defined __aarch64__ 183#define ITT_ARCH ITT_ARCH_ARM64 184#elif defined __powerpc64__ 185#define ITT_ARCH ITT_ARCH_PPC64 186#elif defined __ve__ 187#define ITT_ARCH ITT_ARCH_VE 188#elif defined __s390x__ 189#define ITT_ARCH ITT_ARCH_S390X 190#endif 191#endif 192 193#ifdef __cplusplus 194#define ITT_EXTERN_C extern "C" 195#define ITT_EXTERN_C_BEGIN extern "C" { 196#define ITT_EXTERN_C_END } 197#else 198#define ITT_EXTERN_C /* nothing */ 199#define ITT_EXTERN_C_BEGIN /* nothing */ 200#define ITT_EXTERN_C_END /* nothing */ 201#endif /* __cplusplus */ 202 203#define ITT_TO_STR_AUX(x) #x 204#define ITT_TO_STR(x) ITT_TO_STR_AUX(x) 205 206#define __ITT_BUILD_ASSERT(expr, suffix) \ 207 do { \ 208 static char __itt_build_check_##suffix[(expr) ? 1 : -1]; \ 209 __itt_build_check_##suffix[0] = 0; \ 210 } while (0) 211#define _ITT_BUILD_ASSERT(expr, suffix) __ITT_BUILD_ASSERT((expr), suffix) 212#define ITT_BUILD_ASSERT(expr) _ITT_BUILD_ASSERT((expr), __LINE__) 213 214#define ITT_MAGIC \ 215 { 0xED, 0xAB, 0xAB, 0xEC, 0x0D, 0xEE, 0xDA, 0x30 } 216 217/* Replace with snapshot date YYYYMMDD for promotion build. */ 218#define API_VERSION_BUILD 20180723 219 220#ifndef API_VERSION_NUM 221#define API_VERSION_NUM 3.20.1 222#endif /* API_VERSION_NUM */ 223 224#define API_VERSION \ 225 "ITT-API-Version " ITT_TO_STR(API_VERSION_NUM) " (" ITT_TO_STR( \ 226 API_VERSION_BUILD) ")" 227 228/* OS communication functions */ 229#if ITT_PLATFORM == ITT_PLATFORM_WIN 230#include <windows.h> 231typedef HMODULE lib_t; 232typedef DWORD TIDT; 233typedef CRITICAL_SECTION mutex_t; 234#ifdef __cplusplus 235#define MUTEX_INITIALIZER \ 236 {} 237#else 238#define MUTEX_INITIALIZER \ 239 { 0 } 240#endif 241#define strong_alias(name, aliasname) /* empty for Windows */ 242#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 243#include <dlfcn.h> 244#if defined(UNICODE) || defined(_UNICODE) 245#include <wchar.h> 246#endif /* UNICODE */ 247#ifndef _GNU_SOURCE 248#define _GNU_SOURCE 1 /* need for PTHREAD_MUTEX_RECURSIVE */ 249#endif /* _GNU_SOURCE */ 250#ifndef __USE_UNIX98 251#define __USE_UNIX98 \ 252 1 /* need for PTHREAD_MUTEX_RECURSIVE, on SLES11.1 with gcc 4.3.4 wherein \ 253 pthread.h missing dependency on __USE_XOPEN2K8 */ 254#endif /*__USE_UNIX98*/ 255#include <pthread.h> 256typedef void *lib_t; 257typedef pthread_t TIDT; 258typedef pthread_mutex_t mutex_t; 259#define MUTEX_INITIALIZER PTHREAD_MUTEX_INITIALIZER 260#define _strong_alias(name, aliasname) \ 261 extern __typeof(name) aliasname __attribute__((alias(#name))); 262#define strong_alias(name, aliasname) _strong_alias(name, aliasname) 263#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 264 265#if ITT_PLATFORM == ITT_PLATFORM_WIN 266#define __itt_get_proc(lib, name) GetProcAddress(lib, name) 267#define __itt_mutex_init(mutex) InitializeCriticalSection(mutex) 268#define __itt_mutex_lock(mutex) EnterCriticalSection(mutex) 269#define __itt_mutex_unlock(mutex) LeaveCriticalSection(mutex) 270#define __itt_load_lib(name) LoadLibraryA(name) 271#define __itt_unload_lib(handle) FreeLibrary(handle) 272#define __itt_system_error() (int)GetLastError() 273#define __itt_fstrcmp(s1, s2) lstrcmpA(s1, s2) 274#define __itt_fstrnlen(s, l) strnlen_s(s, l) 275#define __itt_fstrcpyn(s1, b, s2, l) strncpy_s(s1, b, s2, l) 276#define __itt_fstrdup(s) _strdup(s) 277#define __itt_thread_id() GetCurrentThreadId() 278#define __itt_thread_yield() SwitchToThread() 279#ifndef ITT_SIMPLE_INIT 280ITT_INLINE long 281__itt_interlocked_increment(volatile long *ptr) ITT_INLINE_ATTRIBUTE; 282ITT_INLINE long __itt_interlocked_increment(volatile long *ptr) { 283 return InterlockedIncrement(ptr); 284} 285#endif /* ITT_SIMPLE_INIT */ 286 287#define DL_SYMBOLS (1) 288#define PTHREAD_SYMBOLS (1) 289 290#else /* ITT_PLATFORM!=ITT_PLATFORM_WIN */ 291#define __itt_get_proc(lib, name) dlsym(lib, name) 292#define __itt_mutex_init(mutex) \ 293 { \ 294 pthread_mutexattr_t mutex_attr; \ 295 int error_code = pthread_mutexattr_init(&mutex_attr); \ 296 if (error_code) \ 297 __itt_report_error(__itt_error_system, "pthread_mutexattr_init", \ 298 error_code); \ 299 error_code = \ 300 pthread_mutexattr_settype(&mutex_attr, PTHREAD_MUTEX_RECURSIVE); \ 301 if (error_code) \ 302 __itt_report_error(__itt_error_system, "pthread_mutexattr_settype", \ 303 error_code); \ 304 error_code = pthread_mutex_init(mutex, &mutex_attr); \ 305 if (error_code) \ 306 __itt_report_error(__itt_error_system, "pthread_mutex_init", \ 307 error_code); \ 308 error_code = pthread_mutexattr_destroy(&mutex_attr); \ 309 if (error_code) \ 310 __itt_report_error(__itt_error_system, "pthread_mutexattr_destroy", \ 311 error_code); \ 312 } 313#define __itt_mutex_lock(mutex) pthread_mutex_lock(mutex) 314#define __itt_mutex_unlock(mutex) pthread_mutex_unlock(mutex) 315#define __itt_load_lib(name) dlopen(name, RTLD_LAZY) 316#define __itt_unload_lib(handle) dlclose(handle) 317#define __itt_system_error() errno 318#define __itt_fstrcmp(s1, s2) strcmp(s1, s2) 319 320/* makes customer code define safe APIs for SDL_STRNLEN_S and SDL_STRNCPY_S */ 321#ifdef SDL_STRNLEN_S 322#define __itt_fstrnlen(s, l) SDL_STRNLEN_S(s, l) 323#else 324#define __itt_fstrnlen(s, l) strlen(s) 325#endif /* SDL_STRNLEN_S */ 326#ifdef SDL_STRNCPY_S 327#define __itt_fstrcpyn(s1, b, s2, l) SDL_STRNCPY_S(s1, b, s2, l) 328#else 329#define __itt_fstrcpyn(s1, b, s2, l) \ 330 { \ 331 if (b > 0) { \ 332 /* 'volatile' is used to suppress the warning that a destination */ \ 333 /* bound depends on the length of the source. */ \ 334 volatile size_t num_to_copy = \ 335 (size_t)(b - 1) < (size_t)(l) ? (size_t)(b - 1) : (size_t)(l); \ 336 strncpy(s1, s2, num_to_copy); \ 337 s1[num_to_copy] = 0; \ 338 } \ 339 } 340#endif /* SDL_STRNCPY_S */ 341 342#define __itt_fstrdup(s) strdup(s) 343#define __itt_thread_id() pthread_self() 344#define __itt_thread_yield() sched_yield() 345#if ITT_ARCH == ITT_ARCH_IA64 346#ifdef __INTEL_COMPILER 347#define __TBB_machine_fetchadd4(addr, val) __fetchadd4_acq((void *)addr, val) 348#else /* __INTEL_COMPILER */ 349/* TODO: Add Support for not Intel compilers for IA-64 architecture */ 350#endif /* __INTEL_COMPILER */ 351#elif ITT_ARCH == ITT_ARCH_IA32 || \ 352 ITT_ARCH == ITT_ARCH_IA32E /* ITT_ARCH!=ITT_ARCH_IA64 */ 353ITT_INLINE long __TBB_machine_fetchadd4(volatile void *ptr, 354 long addend) ITT_INLINE_ATTRIBUTE; 355ITT_INLINE long __TBB_machine_fetchadd4(volatile void *ptr, long addend) { 356 long result; 357 __asm__ __volatile__("lock\nxadd %0,%1" 358 : "=r"(result), "=m"(*(volatile int *)ptr) 359 : "0"(addend), "m"(*(volatile int *)ptr) 360 : "memory"); 361 return result; 362} 363#else 364#define __TBB_machine_fetchadd4(addr, val) __sync_fetch_and_add(addr, val) 365#endif /* ITT_ARCH==ITT_ARCH_IA64 */ 366#ifndef ITT_SIMPLE_INIT 367ITT_INLINE long 368__itt_interlocked_increment(volatile long *ptr) ITT_INLINE_ATTRIBUTE; 369ITT_INLINE long __itt_interlocked_increment(volatile long *ptr) { 370 return __TBB_machine_fetchadd4(ptr, 1) + 1L; 371} 372#endif /* ITT_SIMPLE_INIT */ 373 374void *dlopen(const char *, int) __attribute__((weak)); 375void *dlsym(void *, const char *) __attribute__((weak)); 376int dlclose(void *) __attribute__((weak)); 377#define DL_SYMBOLS (dlopen && dlsym && dlclose) 378 379int pthread_mutex_init(pthread_mutex_t *, const pthread_mutexattr_t *) 380 __attribute__((weak)); 381int pthread_mutex_lock(pthread_mutex_t *) __attribute__((weak)); 382int pthread_mutex_unlock(pthread_mutex_t *) __attribute__((weak)); 383int pthread_mutex_destroy(pthread_mutex_t *) __attribute__((weak)); 384int pthread_mutexattr_init(pthread_mutexattr_t *) __attribute__((weak)); 385int pthread_mutexattr_settype(pthread_mutexattr_t *, int) __attribute__((weak)); 386int pthread_mutexattr_destroy(pthread_mutexattr_t *) __attribute__((weak)); 387pthread_t pthread_self(void) __attribute__((weak)); 388#define PTHREAD_SYMBOLS \ 389 (pthread_mutex_init && pthread_mutex_lock && pthread_mutex_unlock && \ 390 pthread_mutex_destroy && pthread_mutexattr_init && \ 391 pthread_mutexattr_settype && pthread_mutexattr_destroy && pthread_self) 392 393#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 394 395typedef enum { 396 __itt_collection_normal = 0, 397 __itt_collection_paused = 1 398} __itt_collection_state; 399 400typedef enum { 401 __itt_thread_normal = 0, 402 __itt_thread_ignored = 1 403} __itt_thread_state; 404 405#pragma pack(push, 8) 406 407typedef struct ___itt_thread_info { 408 const char *nameA; /*!< Copy of original name in ASCII. */ 409#if defined(UNICODE) || defined(_UNICODE) 410 const wchar_t *nameW; /*!< Copy of original name in UNICODE. */ 411#else /* UNICODE || _UNICODE */ 412 void *nameW; 413#endif /* UNICODE || _UNICODE */ 414 TIDT tid; 415 __itt_thread_state state; /*!< Thread state (paused or normal) */ 416 int extra1; /*!< Reserved to the runtime */ 417 void *extra2; /*!< Reserved to the runtime */ 418 struct ___itt_thread_info *next; 419} __itt_thread_info; 420 421#include "ittnotify_types.h" /* For __itt_group_id definition */ 422 423typedef struct ___itt_api_info_20101001 { 424 const char *name; 425 void **func_ptr; 426 void *init_func; 427 __itt_group_id group; 428} __itt_api_info_20101001; 429 430typedef struct ___itt_api_info { 431 const char *name; 432 void **func_ptr; 433 void *init_func; 434 void *null_func; 435 __itt_group_id group; 436} __itt_api_info; 437 438typedef struct __itt_counter_info { 439 const char *nameA; /*!< Copy of original name in ASCII. */ 440#if defined(UNICODE) || defined(_UNICODE) 441 const wchar_t *nameW; /*!< Copy of original name in UNICODE. */ 442#else /* UNICODE || _UNICODE */ 443 void *nameW; 444#endif /* UNICODE || _UNICODE */ 445 const char *domainA; /*!< Copy of original name in ASCII. */ 446#if defined(UNICODE) || defined(_UNICODE) 447 const wchar_t *domainW; /*!< Copy of original name in UNICODE. */ 448#else /* UNICODE || _UNICODE */ 449 void *domainW; 450#endif /* UNICODE || _UNICODE */ 451 int type; 452 long index; 453 int extra1; /*!< Reserved to the runtime */ 454 void *extra2; /*!< Reserved to the runtime */ 455 struct __itt_counter_info *next; 456} __itt_counter_info_t; 457 458struct ___itt_domain; 459struct ___itt_string_handle; 460struct ___itt_histogram; 461 462typedef struct ___itt_global { 463 unsigned char magic[8]; 464 unsigned long version_major; 465 unsigned long version_minor; 466 unsigned long version_build; 467 volatile long api_initialized; 468 volatile long mutex_initialized; 469 volatile long atomic_counter; 470 mutex_t mutex; 471 lib_t lib; 472 void *error_handler; 473 const char **dll_path_ptr; 474 __itt_api_info *api_list_ptr; 475 struct ___itt_global *next; 476 /* Joinable structures below */ 477 __itt_thread_info *thread_list; 478 struct ___itt_domain *domain_list; 479 struct ___itt_string_handle *string_list; 480 __itt_collection_state state; 481 __itt_counter_info_t *counter_list; 482 unsigned int ipt_collect_events; 483 struct ___itt_histogram *histogram_list; 484} __itt_global; 485 486#pragma pack(pop) 487 488#define NEW_THREAD_INFO_W(gptr, h, h_tail, t, s, n) \ 489 { \ 490 h = (__itt_thread_info *)malloc(sizeof(__itt_thread_info)); \ 491 if (h != NULL) { \ 492 h->tid = t; \ 493 h->nameA = NULL; \ 494 h->nameW = n ? _wcsdup(n) : NULL; \ 495 h->state = s; \ 496 h->extra1 = 0; /* reserved */ \ 497 h->extra2 = NULL; /* reserved */ \ 498 h->next = NULL; \ 499 if (h_tail == NULL) \ 500 (gptr)->thread_list = h; \ 501 else \ 502 h_tail->next = h; \ 503 } \ 504 } 505 506#define NEW_THREAD_INFO_A(gptr, h, h_tail, t, s, n) \ 507 { \ 508 h = (__itt_thread_info *)malloc(sizeof(__itt_thread_info)); \ 509 if (h != NULL) { \ 510 h->tid = t; \ 511 h->nameA = n ? __itt_fstrdup(n) : NULL; \ 512 h->nameW = NULL; \ 513 h->state = s; \ 514 h->extra1 = 0; /* reserved */ \ 515 h->extra2 = NULL; /* reserved */ \ 516 h->next = NULL; \ 517 if (h_tail == NULL) \ 518 (gptr)->thread_list = h; \ 519 else \ 520 h_tail->next = h; \ 521 } \ 522 } 523 524#define NEW_DOMAIN_W(gptr, h, h_tail, name) \ 525 { \ 526 h = (__itt_domain *)malloc(sizeof(__itt_domain)); \ 527 if (h != NULL) { \ 528 h->flags = 1; /* domain is enabled by default */ \ 529 h->nameA = NULL; \ 530 h->nameW = name ? _wcsdup(name) : NULL; \ 531 h->extra1 = 0; /* reserved */ \ 532 h->extra2 = NULL; /* reserved */ \ 533 h->next = NULL; \ 534 if (h_tail == NULL) \ 535 (gptr)->domain_list = h; \ 536 else \ 537 h_tail->next = h; \ 538 } \ 539 } 540 541#define NEW_DOMAIN_A(gptr, h, h_tail, name) \ 542 { \ 543 h = (__itt_domain *)malloc(sizeof(__itt_domain)); \ 544 if (h != NULL) { \ 545 h->flags = 1; /* domain is enabled by default */ \ 546 h->nameA = name ? __itt_fstrdup(name) : NULL; \ 547 h->nameW = NULL; \ 548 h->extra1 = 0; /* reserved */ \ 549 h->extra2 = NULL; /* reserved */ \ 550 h->next = NULL; \ 551 if (h_tail == NULL) \ 552 (gptr)->domain_list = h; \ 553 else \ 554 h_tail->next = h; \ 555 } \ 556 } 557 558#define NEW_STRING_HANDLE_W(gptr, h, h_tail, name) \ 559 { \ 560 h = (__itt_string_handle *)malloc(sizeof(__itt_string_handle)); \ 561 if (h != NULL) { \ 562 h->strA = NULL; \ 563 h->strW = name ? _wcsdup(name) : NULL; \ 564 h->extra1 = 0; /* reserved */ \ 565 h->extra2 = NULL; /* reserved */ \ 566 h->next = NULL; \ 567 if (h_tail == NULL) \ 568 (gptr)->string_list = h; \ 569 else \ 570 h_tail->next = h; \ 571 } \ 572 } 573 574#define NEW_STRING_HANDLE_A(gptr, h, h_tail, name) \ 575 { \ 576 h = (__itt_string_handle *)malloc(sizeof(__itt_string_handle)); \ 577 if (h != NULL) { \ 578 h->strA = name ? __itt_fstrdup(name) : NULL; \ 579 h->strW = NULL; \ 580 h->extra1 = 0; /* reserved */ \ 581 h->extra2 = NULL; /* reserved */ \ 582 h->next = NULL; \ 583 if (h_tail == NULL) \ 584 (gptr)->string_list = h; \ 585 else \ 586 h_tail->next = h; \ 587 } \ 588 } 589 590#define NEW_COUNTER_W(gptr, h, h_tail, name, domain, type) \ 591 { \ 592 h = (__itt_counter_info_t *)malloc(sizeof(__itt_counter_info_t)); \ 593 if (h != NULL) { \ 594 h->nameA = NULL; \ 595 h->nameW = name ? _wcsdup(name) : NULL; \ 596 h->domainA = NULL; \ 597 h->domainW = name ? _wcsdup(domain) : NULL; \ 598 h->type = type; \ 599 h->index = 0; \ 600 h->next = NULL; \ 601 if (h_tail == NULL) \ 602 (gptr)->counter_list = h; \ 603 else \ 604 h_tail->next = h; \ 605 } \ 606 } 607 608#define NEW_COUNTER_A(gptr, h, h_tail, name, domain, type) \ 609 { \ 610 h = (__itt_counter_info_t *)malloc(sizeof(__itt_counter_info_t)); \ 611 if (h != NULL) { \ 612 h->nameA = name ? __itt_fstrdup(name) : NULL; \ 613 h->nameW = NULL; \ 614 h->domainA = domain ? __itt_fstrdup(domain) : NULL; \ 615 h->domainW = NULL; \ 616 h->type = type; \ 617 h->index = 0; \ 618 h->next = NULL; \ 619 if (h_tail == NULL) \ 620 (gptr)->counter_list = h; \ 621 else \ 622 h_tail->next = h; \ 623 } \ 624 } 625 626#define NEW_HISTOGRAM_W(gptr, h, h_tail, domain, name, x_type, y_type) \ 627 { \ 628 h = (__itt_histogram *)malloc(sizeof(__itt_histogram)); \ 629 if (h != NULL) { \ 630 h->domain = domain; \ 631 h->nameA = NULL; \ 632 h->nameW = name ? _wcsdup(name) : NULL; \ 633 h->x_type = x_type; \ 634 h->y_type = y_type; \ 635 h->extra1 = 0; \ 636 h->extra2 = NULL; \ 637 if (h_tail == NULL) \ 638 (gptr)->histogram_list = h; \ 639 else \ 640 h_tail->next = h; \ 641 } \ 642 } 643 644#define NEW_HISTOGRAM_A(gptr, h, h_tail, domain, name, x_type, y_type) \ 645 { \ 646 h = (__itt_histogram *)malloc(sizeof(__itt_histogram)); \ 647 if (h != NULL) { \ 648 h->domain = domain; \ 649 h->nameA = name ? __itt_fstrdup(name) : NULL; \ 650 h->nameW = NULL; \ 651 h->x_type = x_type; \ 652 h->y_type = y_type; \ 653 h->extra1 = 0; \ 654 h->extra2 = NULL; \ 655 if (h_tail == NULL) \ 656 (gptr)->histogram_list = h; \ 657 else \ 658 h_tail->next = h; \ 659 } \ 660 } 661 662#endif /* _ITTNOTIFY_CONFIG_H_ */ 663