[OpenMP] Update third-party sources of ittnotify client code

[AndreyChurbanov]

Summary

The third-party ittnotify sources updated from https://github.com/intel/ittapi.

Changes applied:

• llvm license aded to all files; initial BSD license saved in LICENSE.txt;
• clang-formatted;
• renamed *.c to *.cpp, similar to what we did with all our sources;
• added #include "kmp_config.h" with definition of INTEL_ITTNOTIFY_PREFIX macro into ittnotify_static.cpp.

[hbae]

LGTM

openmp/runtime/src/thirdparty/ittnotify/LICENSE.txt

+Copyright (c) 2019 Intel Corporation. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

openmp/runtime/src/thirdparty/ittnotify/disable_warnings.h

-// clang-format off
+
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "ittnotify_config.h"
 
 #if ITT_PLATFORM == ITT_PLATFORM_WIN
 
-#pragma warning(disable: 593) /* parameter "XXXX" was set but never used */
-#pragma warning(disable: 344) /* typedef name has already been declared (with
+#pragma warning(disable : 593) /* parameter "XXXX" was set but never used */
+#pragma warning(disable : 344) /* typedef name has already been declared (with \
                                   same type) */
-#pragma warning(disable: 174) /* expression has no effect */
-#pragma warning(disable: 4127) /* conditional expression is constant */
-#pragma warning(disable: 4306) /* conversion from '?' to '?' of greater size */
+#pragma warning(disable : 174) /* expression has no effect */
+#pragma warning(disable : 4127) /* conditional expression is constant */
+#pragma warning(                                                               \
+    disable : 4306) /* conversion from '?' to '?' of greater size */
 
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 
 #if defined __INTEL_COMPILER
 
-#pragma warning(disable: 869) /* parameter "XXXXX" was never referenced */
-#pragma warning(disable: 1418) /* external function definition with no prior
+#pragma warning(disable : 869) /* parameter "XXXXX" was never referenced */
+#pragma warning(disable : 1418) /* external function definition with no prior  \
                                    declaration  */
-#pragma warning(disable: 1419) /* external declaration in primary source file */
+#pragma warning(                                                               \
+    disable : 1419) /* external declaration in primary source file */
 
 #endif /* __INTEL_COMPILER */

openmp/runtime/src/thirdparty/ittnotify/ittnotify.h

 #ifndef _ITTNOTIFY_H_
 #define _ITTNOTIFY_H_
 
 /**
 @file
 @brief Public User API functions and types
 @mainpage
 
-The ITT API is used to annotate a user's program with additional information
+The Instrumentation and Tracing Technology API (ITT API) is used to
+annotate a user's program with additional information
 that can be used by correctness and performance tools. The user inserts
 calls in their program. Those calls generate information that is collected
 at runtime, and used by Intel(R) Threading Tools.
 
 @section API Concepts
 The following general concepts are used throughout the API.
 
 @subsection Unicode Support

 #define LIBITTAPI ITTAPI_CDECL
 
 /* TODO: Temporary for compatibility! */
 #define ITTAPI_CALL ITTAPI_CDECL
 #define LIBITTAPI_CALL ITTAPI_CDECL
 
 #if ITT_PLATFORM == ITT_PLATFORM_WIN
 /* use __forceinline (VC++ specific) */
-#define ITT_INLINE __forceinline
+#if defined(__MINGW32__) && !defined(__cplusplus)
+#define ITT_INLINE                                                             \
+  static __inline__ __attribute__((__always_inline__, __gnu_inline__))
+#else
+#define ITT_INLINE static __forceinline
+#endif /* __MINGW32__ */
+
 #define ITT_INLINE_ATTRIBUTE /* nothing */
 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 /*
  * Generally, functions are not inlined unless optimization is specified.
  * For functions declared inline, this attribute inlines the function even
  * if no optimization level was specified.
  */
 #ifdef __STRICT_ANSI__

 #define __itt_resume_ptr 0
 #define __itt_detach_ptr 0
 #endif /* INTEL_NO_MACRO_BODY */
 /** @endcond */
 /** @} control group */
 /** @endcond */
 
 /**
+ * @defgroup Intel Processor Trace control
+ * API from this group provides control over collection and analysis of Intel
+ * Processor Trace (Intel PT) data Information about Intel Processor Trace
+ * technology can be found here (Volume 3 chapter 35):
+ * https://software.intel.com/sites/default/files/managed/39/c5/325462-sdm-vol-1-2abcd-3abcd.pdf
+ * Use this API to mark particular code regions for loading detailed performance
+ * statistics. This mode makes your analysis faster and more accurate.
+ * @{
+ */
+typedef unsigned char __itt_pt_region;
+
+/**
+ * @brief function saves a region name marked with Intel PT API and returns a
+ * region id. Only 7 names can be registered. Attempts to register more names
+ * will be ignored and a region id with auto names will be returned. For
+ * automatic naming of regions pass NULL as function parameter
+ */
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+__itt_pt_region ITTAPI __itt_pt_region_createA(const char *name);
+__itt_pt_region ITTAPI __itt_pt_region_createW(const wchar_t *name);
+#if defined(UNICODE) || defined(_UNICODE)
+#define __itt_pt_region_create __itt_pt_region_createW
+#else /* UNICODE */
+#define __itt_pt_region_create __itt_pt_region_createA
+#endif /* UNICODE */
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+__itt_pt_region ITTAPI __itt_pt_region_create(const char *name);
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+
+/** @cond exclude_from_documentation */
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+ITT_STUB(ITTAPI, __itt_pt_region, pt_region_createA, (const char *name))
+ITT_STUB(ITTAPI, __itt_pt_region, pt_region_createW, (const wchar_t *name))
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+ITT_STUB(ITTAPI, __itt_pt_region, pt_region_create, (const char *name))
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+#define __itt_pt_region_createA ITTNOTIFY_DATA(pt_region_createA)
+#define __itt_pt_region_createA_ptr ITTNOTIFY_NAME(pt_region_createA)
+#define __itt_pt_region_createW ITTNOTIFY_DATA(pt_region_createW)
+#define __itt_pt_region_createW_ptr ITTNOTIFY_NAME(pt_region_createW)
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#define __itt_pt_region_create ITTNOTIFY_DATA(pt_region_create)
+#define __itt_pt_region_create_ptr ITTNOTIFY_NAME(pt_region_create)
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#else /* INTEL_NO_ITTNOTIFY_API */
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+#define __itt_pt_region_createA(name) (__itt_pt_region)0
+#define __itt_pt_region_createA_ptr 0
+#define __itt_pt_region_createW(name) (__itt_pt_region)0
+#define __itt_pt_region_createW_ptr 0
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#define __itt_pt_region_create(name) (__itt_pt_region)0
+#define __itt_pt_region_create_ptr 0
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_MACRO_BODY */
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+#define __itt_pt_region_createA_ptr 0
+#define __itt_pt_region_createW_ptr 0
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#define __itt_pt_region_create_ptr 0
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+
+/**
+ * @brief function contains a special code pattern identified on the
+ * post-processing stage and marks the beginning of a code region targeted for
+ * Intel PT analysis
+ * @param[in] region - region id, 0 <= region < 8
+ */
+void __itt_mark_pt_region_begin(__itt_pt_region region);
+/**
+ * @brief function contains a special code pattern identified on the
+ * post-processing stage and marks the end of a code region targeted for Intel
+ * PT analysis
+ * @param[in] region - region id, 0 <= region < 8
+ */
+void __itt_mark_pt_region_end(__itt_pt_region region);
+/** @} Intel PT control group*/
+
+/**
  * @defgroup threads Threads
  * @ingroup public
  * Give names to threads
  * @{
  */
 /**
  * @brief Sets thread name of calling thread
  * @param[in] name - name of thread

 /**
  * @defgroup suppress Error suppression
  * @ingroup public
  * General behavior: application continues to run, but errors are suppressed
  *
  * @{
  */
 
-// clang-format off
-/*****************************************************************//**
+/*********************************************************************
  * @name group of functions used for error suppression in correctness tools
  *********************************************************************/
-// clang-format on
 /** @{ */
 /**
  * @hideinitializer
  * @brief possible value for suppression mask
  */
 #define __itt_suppress_all_errors 0x7fffffff
 
 /**

 #define __itt_sync_destroy(addr)
 #define __itt_sync_destroy_ptr 0
 #endif /* INTEL_NO_ITTNOTIFY_API */
 #else /* INTEL_NO_MACRO_BODY */
 #define __itt_sync_destroy_ptr 0
 #endif /* INTEL_NO_MACRO_BODY */
 /** @endcond */
 
-// clang-format off
-/*****************************************************************//**
+/*********************************************************************
  * @name group of functions is used for performance measurement tools
  *********************************************************************/
-// clang-format on
 /** @{ */
 /**
  * @brief Enter spin loop on user-defined sync object
  */
 void ITTAPI __itt_sync_prepare(void *addr);
 
 /** @cond exclude_from_documentation */
 #ifndef INTEL_NO_MACRO_BODY

 #else /* INTEL_NO_MACRO_BODY */
 #define __itt_sync_releasing_ptr 0
 #endif /* INTEL_NO_MACRO_BODY */
 /** @endcond */
 /** @} */
 
 /** @} sync group */
 
-// clang-format off
-/**************************************************************//**
+/******************************************************************
  * @name group of functions is used for correctness checking tools
  ******************************************************************/
-// clang-format on
 /** @{ */
 /**
  * @ingroup legacy
  * @deprecated Legacy API
  * @brief Fast synchronization which does no require spinning.
  * - This special function is to be used by TBB and OpenMP libraries only when
  * they know there is no spin but they need to suppress TC warnings about shared
  * variable modifications.

  * The metadata API is used to attach extra information to named
  * entities. Metadata can be attached to an identified named entity by ID,
  * or to the current entity (which is always a task).
  *
  * Conceptually metadata has a type (what kind of metadata), a key (the
  * name of the metadata), and a value (the actual data). The encoding of
  * the value depends on the type of the metadata.
  *
- * The type of metadata is specified by an enumerated type __itt_metadata_type.
+ * The type of metadata is specified by an enumerated type __itt_metdata_type.
  * @{
  */
 
 /**
  * @ingroup parameters
  * @brief describes the type of metadata
  */
 typedef enum {

 #define __itt_relation_add_to_current_ex(d, x, y, z, a)                        \
   ITTNOTIFY_VOID_D4(relation_add_to_current_ex, d, x, y, z, a)
 #define __itt_relation_add_to_current_ex_ptr                                   \
   ITTNOTIFY_NAME(relation_add_to_current_ex)
 #define __itt_relation_add_ex(d, x, y, z, a, b)                                \
   ITTNOTIFY_VOID_D5(relation_add_ex, d, x, y, z, a, b)
 #define __itt_relation_add_ex_ptr ITTNOTIFY_NAME(relation_add_ex)
 #else /* INTEL_NO_ITTNOTIFY_API */
-#define __itt_relation_add_to_current_ex(domain, clock_domain, timestamp,      \
+#define __itt_relation_add_to_current_ex(domain, clock_domain, timestame,      \
                                          relation, tail)
 #define __itt_relation_add_to_current_ex_ptr 0
 #define __itt_relation_add_ex(domain, clock_domain, timestamp, head, relation, \
                               tail)
 #define __itt_relation_add_ex_ptr 0
 #endif /* INTEL_NO_ITTNOTIFY_API */
 #else /* INTEL_NO_MACRO_BODY */
 #define __itt_relation_add_to_current_ex_ptr 0

 
 /** @cond exclude_from_gpa_documentation */
 
 /** @} arrays group */
 
 /** @endcond */
 
 /**
- * @brief Module load info
- * This API is used to report necessary information in case of module relocation
- * @param[in] start_addr - relocated module start address
- * @param[in] end_addr - relocated module end address
- * @param[in] path - file system path to the module
+ * @brief Module load notification
+ * This API is used to report necessary information in case of bypassing default
+ * system loader. Notification should be done immidiatelly after this module is
+ * loaded to process memory.
+ * @param[in] start_addr - module start address
+ * @param[in] end_addr - module end address
+ * @param[in] path - file system full path to the module
  */
 #if ITT_PLATFORM == ITT_PLATFORM_WIN
 void ITTAPI __itt_module_loadA(void *start_addr, void *end_addr,
                                const char *path);
 void ITTAPI __itt_module_loadW(void *start_addr, void *end_addr,
                                const wchar_t *path);
 #if defined(UNICODE) || defined(_UNICODE)
 #define __itt_module_load __itt_module_loadW

 #define __itt_module_loadA_ptr 0
 #define __itt_module_loadW_ptr 0
 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 #define __itt_module_load_ptr 0
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 #endif /* INTEL_NO_MACRO_BODY */
 /** @endcond */
 
+/**
+ * @brief Report module unload
+ * This API is used to report necessary information in case of bypassing default
+ * system loader. Notification should be done just before the module is unloaded
+ * from process memory.
+ * @param[in] addr - base address of loaded module
+ */
+void ITTAPI __itt_module_unload(void *addr);
+
+/** @cond exclude_from_documentation */
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+ITT_STUBV(ITTAPI, void, module_unload, (void *addr))
+#define __itt_module_unload ITTNOTIFY_VOID(module_unload)
+#define __itt_module_unload_ptr ITTNOTIFY_NAME(module_unload)
+#else /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_module_unload(addr)
+#define __itt_module_unload_ptr 0
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_MACRO_BODY */
+#define __itt_module_unload_ptr 0
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+
+/** @cond exclude_from_documentation */
+typedef enum {
+  __itt_module_type_unknown = 0,
+  __itt_module_type_elf,
+  __itt_module_type_coff
+} __itt_module_type;
+/** @endcond */
+
+/** @cond exclude_from_documentation */
+typedef enum {
+  itt_section_type_unknown,
+  itt_section_type_bss, /* notifies that the section contains uninitialized
+                         * data. These are the relevant section types and the
+                         * modules that contain them: ELF module:  SHT_NOBITS
+                         * section type COFF module:
+                         * IMAGE_SCN_CNT_UNINITIALIZED_DATA section type
+                         */
+  itt_section_type_data, /* notifies that section contains initialized data.
+                          * These are the relevant section types and the modules
+                          * that contain them: ELF module:  SHT_PROGBITS section
+                          * type COFF module: IMAGE_SCN_CNT_INITIALIZED_DATA
+                          * section type
+                          */
+  itt_section_type_text /* notifies that the section contains executable code.
+                         * These are the relevant section types and the modules
+                         * that contain them: ELF module:  SHT_PROGBITS section
+                         * type COFF module: IMAGE_SCN_CNT_CODE section type
+                         */
+} __itt_section_type;
+/** @endcond */
+
+/**
+ * @hideinitializer
+ * @brief bit-mask, detects a section attribute that indicates whether a section
+ * can be executed as code: These are the relevant section attributes and the
+ * modules that contain them: ELF module:  PF_X section attribute COFF module:
+ * IMAGE_SCN_MEM_EXECUTE attribute
+ */
+#define __itt_section_exec 0x20000000
+
+/**
+ * @hideinitializer
+ * @brief bit-mask, detects a section attribute that indicates whether a section
+ * can be read. These are the relevant section attributes and the modules that
+ * contain them: ELF module:  PF_R attribute COFF module: IMAGE_SCN_MEM_READ
+ * attribute
+ */
+#define __itt_section_read 0x40000000
+
+/**
+ * @hideinitializer
+ * @brief bit-mask, detects a section attribute that indicates whether a section
+ * can be written to. These are the relevant section attributes and the modules
+ * that contain them: ELF module:  PF_W attribute COFF module:
+ * IMAGE_SCN_MEM_WRITE attribute
+ */
+#define __itt_section_write 0x80000000
+
+/** @cond exclude_from_documentation */
+#pragma pack(push, 8)
+
+typedef struct ___itt_section_info {
+  const char *name; /*!< Section name in UTF8 */
+  __itt_section_type type; /*!< Section content and semantics description */
+  size_t flags; /*!< Section bit flags that describe attributes using bit mask
+                 * Zero if disabled, non-zero if enabled
+                 */
+  void *start_addr; /*!< Section load(relocated) start address */
+  size_t size; /*!< Section file offset */
+  size_t file_offset; /*!< Section size */
+} __itt_section_info;
+
+#pragma pack(pop)
+/** @endcond */
+
+/** @cond exclude_from_documentation */
+#pragma pack(push, 8)
+
+typedef struct ___itt_module_object {
+  unsigned int version; /*!< API version*/
+  __itt_id module_id; /*!< Unique identifier. This is unchanged for sections
+                         that belong to the same module */
+  __itt_module_type module_type; /*!< Binary module format */
+  const char *module_name; /*!< Unique module name or path to module in UTF8
+                            * Contains module name when module_bufer and
+                            * module_size exist Contains module path when
+                            * module_bufer and module_size absent module_name
+                            * remains the same for the certain module_id
+                            */
+  void *module_buffer; /*!< Module buffer content */
+  size_t module_size; /*!< Module buffer size */
+  /*!< If module_buffer and module_size exist, the binary module is dumped onto
+   * the system. If module_buffer and module_size do not exist, the binary
+   * module exists on the system already. The module_name parameter contains the
+   * path to the module.
+   */
+  __itt_section_info *section_array; /*!< Reference to section information */
+  size_t section_number;
+} __itt_module_object;
+
+#pragma pack(pop)
+/** @endcond */
+
+/**
+ * @brief Load module content and its loaded(relocated) sections.
+ * This API is useful to save a module, or specify its location on the system
+ * and report information about loaded sections. The target module is saved on
+ * the system if module buffer content and size are available. If module buffer
+ * content and size are unavailable, the module name contains the path to the
+ * existing binary module.
+ * @param[in] module_obj - provides module and section information, along with
+ * unique module identifiers (name,module ID) which bind the binary module to
+ * particular sections.
+ */
+void ITTAPI __itt_module_load_with_sections(__itt_module_object *module_obj);
+
+/** @cond exclude_from_documentation */
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+ITT_STUBV(ITTAPI, void, module_load_with_sections,
+          (__itt_module_object * module_obj))
+#define __itt_module_load_with_sections                                        \
+  ITTNOTIFY_VOID(module_load_with_sections)
+#define __itt_module_load_with_sections_ptr                                    \
+  ITTNOTIFY_NAME(module_load_with_sections)
+#else /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_module_load_with_sections(module_obj)
+#define __itt_module_load_with_sections_ptr 0
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_MACRO_BODY */
+#define __itt_module_load_with_sections_ptr 0
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+
+/**
+ * @brief Unload a module and its loaded(relocated) sections.
+ * This API notifies that the module and its sections were unloaded.
+ * @param[in] module_obj - provides module and sections information, along with
+ * unique module identifiers (name,module ID) which bind the binary module to
+ * particular sections.
+ */
+void ITTAPI __itt_module_unload_with_sections(__itt_module_object *module_obj);
+
+/** @cond exclude_from_documentation */
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+ITT_STUBV(ITTAPI, void, module_unload_with_sections,
+          (__itt_module_object * module_obj))
+#define __itt_module_unload_with_sections                                      \
+  ITTNOTIFY_VOID(module_unload_with_sections)
+#define __itt_module_unload_with_sections_ptr                                  \
+  ITTNOTIFY_NAME(module_unload_with_sections)
+#else /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_module_unload_with_sections(module_obj)
+#define __itt_module_unload_with_sections_ptr 0
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_MACRO_BODY */
+#define __itt_module_unload_with_sections_ptr 0
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+
+/** @cond exclude_from_documentation */
+#pragma pack(push, 8)
+
+typedef struct ___itt_histogram {
+  const __itt_domain *domain; /*!< Domain of the histogram*/
+  const char *nameA; /*!< Name of the histogram */
+#if defined(UNICODE) || defined(_UNICODE)
+  const wchar_t *nameW;
+#else /* UNICODE || _UNICODE */
+  void *nameW;
+#endif /* UNICODE || _UNICODE */
+  __itt_metadata_type x_type; /*!< Type of the histogram X axis */
+  __itt_metadata_type y_type; /*!< Type of the histogram Y axis */
+  int extra1; /*!< Reserved to the runtime */
+  void *extra2; /*!< Reserved to the runtime */
+  struct ___itt_histogram *next;
+} __itt_histogram;
+
+#pragma pack(pop)
+/** @endcond */
+
+/**
+ * @brief Create a typed histogram instance with given name/domain.
+ * @param[in] domain The domain controlling the call.
+ * @param[in] name   The name of the histogram.
+ * @param[in] x_type The type of the X axis in histogram (may be 0 to calculate
+ * batch statistics).
+ * @param[in] y_type The type of the Y axis in histogram.
+ */
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+__itt_histogram *ITTAPI __itt_histogram_createA(const __itt_domain *domain,
+                                                const char *name,
+                                                __itt_metadata_type x_type,
+                                                __itt_metadata_type y_type);
+__itt_histogram *ITTAPI __itt_histogram_createW(const __itt_domain *domain,
+                                                const wchar_t *name,
+                                                __itt_metadata_type x_type,
+                                                __itt_metadata_type y_type);
+#if defined(UNICODE) || defined(_UNICODE)
+#define __itt_histogram_create __itt_histogram_createW
+#define __itt_histogram_create_ptr __itt_histogram_createW_ptr
+#else /* UNICODE */
+#define __itt_histogram_create __itt_histogram_createA
+#define __itt_histogram_create_ptr __itt_histogram_createA_ptr
+#endif /* UNICODE */
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+__itt_histogram *ITTAPI __itt_histogram_create(const __itt_domain *domain,
+                                               const char *name,
+                                               __itt_metadata_type x_type,
+                                               __itt_metadata_type y_type);
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+
+/** @cond exclude_from_documentation */
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+ITT_STUB(ITTAPI, __itt_histogram *, histogram_createA,
+         (const __itt_domain *domain, const char *name,
+          __itt_metadata_type x_type, __itt_metadata_type y_type))
+ITT_STUB(ITTAPI, __itt_histogram *, histogram_createW,
+         (const __itt_domain *domain, const wchar_t *name,
+          __itt_metadata_type x_type, __itt_metadata_type y_type))
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+ITT_STUB(ITTAPI, __itt_histogram *, histogram_create,
+         (const __itt_domain *domain, const char *name,
+          __itt_metadata_type x_type, __itt_metadata_type y_type))
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+#define __itt_histogram_createA ITTNOTIFY_DATA(histogram_createA)
+#define __itt_histogram_createA_ptr ITTNOTIFY_NAME(histogram_createA)
+#define __itt_histogram_createW ITTNOTIFY_DATA(histogram_createW)
+#define __itt_histogram_createW_ptr ITTNOTIFY_NAME(histogram_createW)
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#define __itt_histogram_create ITTNOTIFY_DATA(histogram_create)
+#define __itt_histogram_create_ptr ITTNOTIFY_NAME(histogram_create)
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#else /* INTEL_NO_ITTNOTIFY_API */
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+#define __itt_histogram_createA(domain, name, x_type, y_type)                  \
+  (__itt_histogram *)0
+#define __itt_histogram_createA_ptr 0
+#define __itt_histogram_createW(domain, name, x_type, y_type)                  \
+  (__itt_histogram *)0
+#define __itt_histogram_createW_ptr 0
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#define __itt_histogram_create(domain, name, x_type, y_type)                   \
+  (__itt_histogram *)0
+#define __itt_histogram_create_ptr 0
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_MACRO_BODY */
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+#define __itt_histogram_createA_ptr 0
+#define __itt_histogram_createW_ptr 0
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#define __itt_histogram_create_ptr 0
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+
+/**
+ * @brief Submit statistics for a histogram instance.
+ * @param[in] hist    Pointer to the histogram instance to which the histogram
+ * statistic is to be dumped.
+ * @param[in] length  The number of elements in dumped axis data array.
+ * @param[in] x_data  The X axis dumped data itself (may be NULL to calculate
+ * batch statistics).
+ * @param[in] y_data  The Y axis dumped data itself.
+ */
+void ITTAPI __itt_histogram_submit(__itt_histogram *hist, size_t length,
+                                   void *x_data, void *y_data);
+
+/** @cond exclude_from_documentation */
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+ITT_STUBV(ITTAPI, void, histogram_submit,
+          (__itt_histogram * hist, size_t length, void *x_data, void *y_data))
+#define __itt_histogram_submit ITTNOTIFY_VOID(histogram_submit)
+#define __itt_histogram_submit_ptr ITTNOTIFY_NAME(histogram_submit)
+#else /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_histogram_submit(hist, length, x_data, y_data)
+#define __itt_histogram_submit_ptr 0
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_MACRO_BODY */
+#define __itt_histogram_submit_ptr 0
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+
 #ifdef __cplusplus
 }
 #endif /* __cplusplus */
 
 #endif /* _ITTNOTIFY_H_ */
 
 #ifdef INTEL_ITTNOTIFY_API_PRIVATE
 

openmp/runtime/src/thirdparty/ittnotify/ittnotify_config.h

 #define LIBITTAPI ITTAPI_CDECL
 
 /* TODO: Temporary for compatibility! */
 #define ITTAPI_CALL ITTAPI_CDECL
 #define LIBITTAPI_CALL ITTAPI_CDECL
 
 #if ITT_PLATFORM == ITT_PLATFORM_WIN
 /* use __forceinline (VC++ specific) */
-#define ITT_INLINE __forceinline
+#if defined(__MINGW32__) && !defined(__cplusplus)
+#define ITT_INLINE                                                             \
+  static __inline__ __attribute__((__always_inline__, __gnu_inline__))
+#else
+#define ITT_INLINE static __forceinline
+#endif /* __MINGW32__ */
+
 #define ITT_INLINE_ATTRIBUTE /* nothing */
 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 /*
  * Generally, functions are not inlined unless optimization is specified.
  * For functions declared inline, this attribute inlines the function even
  * if no optimization level was specified.
  */
 #ifdef __STRICT_ANSI__

 #ifndef ITT_ARCH_IA32
 #define ITT_ARCH_IA32 1
 #endif /* ITT_ARCH_IA32 */
 
 #ifndef ITT_ARCH_IA32E
 #define ITT_ARCH_IA32E 2
 #endif /* ITT_ARCH_IA32E */
 
-/* Was there a magical reason we didn't have 3 here before? */
-#ifndef ITT_ARCH_AARCH64
-#define ITT_ARCH_AARCH64 3
-#endif /* ITT_ARCH_AARCH64 */
+#ifndef ITT_ARCH_IA64
+#define ITT_ARCH_IA64 3
+#endif /* ITT_ARCH_IA64 */
 
 #ifndef ITT_ARCH_ARM
 #define ITT_ARCH_ARM 4
 #endif /* ITT_ARCH_ARM */
 
 #ifndef ITT_ARCH_PPC64
 #define ITT_ARCH_PPC64 5
 #endif /* ITT_ARCH_PPC64 */
 
-#ifndef ITT_ARCH_MIPS
-#define ITT_ARCH_MIPS 6
-#endif /* ITT_ARCH_MIPS */
-
-#ifndef ITT_ARCH_MIPS64
-#define ITT_ARCH_MIPS64 6
-#endif /* ITT_ARCH_MIPS64 */
-
-#ifndef ITT_ARCH_RISCV64
-#define ITT_ARCH_RISCV64 7
-#endif /* ITT_ARCH_RISCV64 */
+#ifndef ITT_ARCH_ARM64
+#define ITT_ARCH_ARM64 6
+#endif /* ITT_ARCH_ARM64 */
 
 #ifndef ITT_ARCH
 #if defined _M_IX86 || defined __i386__
 #define ITT_ARCH ITT_ARCH_IA32
 #elif defined _M_X64 || defined _M_AMD64 || defined __x86_64__
 #define ITT_ARCH ITT_ARCH_IA32E
 #elif defined _M_IA64 || defined __ia64__
 #define ITT_ARCH ITT_ARCH_IA64
 #elif defined _M_ARM || defined __arm__
 #define ITT_ARCH ITT_ARCH_ARM
+#elif defined __aarch64__
+#define ITT_ARCH ITT_ARCH_ARM64
 #elif defined __powerpc64__
 #define ITT_ARCH ITT_ARCH_PPC64
-#elif defined __aarch64__
-#define ITT_ARCH ITT_ARCH_AARCH64
-#elif defined __mips__ && !defined __mips64
-#define ITT_ARCH ITT_ARCH_MIPS
-#elif defined __mips__ && defined __mips64
-#define ITT_ARCH ITT_ARCH_MIPS64
-#elif defined __riscv && __riscv_xlen == 64
-#define ITT_ARCH ITT_ARCH_RISCV64
 #endif
 #endif
 
 #ifdef __cplusplus
 #define ITT_EXTERN_C extern "C"
 #define ITT_EXTERN_C_BEGIN extern "C" {
 #define ITT_EXTERN_C_END }
 #else
#define __ITT_BUILD_ASSERT(expr, suffix)                                       \
   } while (0)
 #define _ITT_BUILD_ASSERT(expr, suffix) __ITT_BUILD_ASSERT((expr), suffix)
 #define ITT_BUILD_ASSERT(expr) _ITT_BUILD_ASSERT((expr), __LINE__)
 
 #define ITT_MAGIC                                                              \
   { 0xED, 0xAB, 0xAB, 0xEC, 0x0D, 0xEE, 0xDA, 0x30 }
 
 /* Replace with snapshot date YYYYMMDD for promotion build. */
-#define API_VERSION_BUILD 20151119
+#define API_VERSION_BUILD 20180723
 
 #ifndef API_VERSION_NUM
-#define API_VERSION_NUM 0.0.0
+#define API_VERSION_NUM 3.20.1
 #endif /* API_VERSION_NUM */
 
 #define API_VERSION                                                            \
   "ITT-API-Version " ITT_TO_STR(API_VERSION_NUM) " (" ITT_TO_STR(              \
       API_VERSION_BUILD) ")"
 
 /* OS communication functions */
 #if ITT_PLATFORM == ITT_PLATFORM_WIN
 #include <windows.h>
 typedef HMODULE lib_t;
 typedef DWORD TIDT;
 typedef CRITICAL_SECTION mutex_t;
+#ifdef __cplusplus
+#define MUTEX_INITIALIZER                                                      \
+  {}
+#else
 #define MUTEX_INITIALIZER                                                      \
   { 0 }
+#endif
 #define strong_alias(name, aliasname) /* empty for Windows */
 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 #include <dlfcn.h>
 #if defined(UNICODE) || defined(_UNICODE)
 #include <wchar.h>
 #endif /* UNICODE */
 #ifndef _GNU_SOURCE
 #define _GNU_SOURCE 1 /* need for PTHREAD_MUTEX_RECURSIVE */

 #ifdef SDL_STRNLEN_S
 #define __itt_fstrnlen(s, l) SDL_STRNLEN_S(s, l)
 #else
 #define __itt_fstrnlen(s, l) strlen(s)
 #endif /* SDL_STRNLEN_S */
 #ifdef SDL_STRNCPY_S
 #define __itt_fstrcpyn(s1, b, s2, l) SDL_STRNCPY_S(s1, b, s2, l)
 #else
-#define __itt_fstrcpyn(s1, b, s2, l) strncpy(s1, s2, l)
+#define __itt_fstrcpyn(s1, b, s2, l)                                           \
+  {                                                                            \
+    if (b > 0) {                                                               \
+      /* 'volatile' is used to suppress the warning that a destination */      \
+      /*  bound depends on the length of the source.                   */      \
+      volatile size_t num_to_copy =                                            \
+          (size_t)(b - 1) < (size_t)(l) ? (size_t)(b - 1) : (size_t)(l);       \
+      strncpy(s1, s2, num_to_copy);                                            \
+      s1[num_to_copy] = 0;                                                     \
+    }                                                                          \
+  }
 #endif /* SDL_STRNCPY_S */
 
 #define __itt_fstrdup(s) strdup(s)
 #define __itt_thread_id() pthread_self()
 #define __itt_thread_yield() sched_yield()
 #if ITT_ARCH == ITT_ARCH_IA64
 #ifdef __INTEL_COMPILER
 #define __TBB_machine_fetchadd4(addr, val) __fetchadd4_acq((void *)addr, val)
 #else /* __INTEL_COMPILER */
 /* TODO: Add Support for not Intel compilers for IA-64 architecture */
 #endif /* __INTEL_COMPILER */
 #elif ITT_ARCH == ITT_ARCH_IA32 ||                                             \
     ITT_ARCH == ITT_ARCH_IA32E /* ITT_ARCH!=ITT_ARCH_IA64 */
 ITT_INLINE long __TBB_machine_fetchadd4(volatile void *ptr,
                                         long addend) ITT_INLINE_ATTRIBUTE;
 ITT_INLINE long __TBB_machine_fetchadd4(volatile void *ptr, long addend) {
   long result;
   __asm__ __volatile__("lock\nxadd %0,%1"
                        : "=r"(result), "=m"(*(volatile int *)ptr)
                        : "0"(addend), "m"(*(volatile int *)ptr)
                        : "memory");
   return result;
 }
-#elif ITT_ARCH == ITT_ARCH_ARM || ITT_ARCH == ITT_ARCH_PPC64 ||                \
-    ITT_ARCH == ITT_ARCH_AARCH64 || ITT_ARCH == ITT_ARCH_MIPS ||               \
-    ITT_ARCH == ITT_ARCH_MIPS64 || ITT_ARCH == ITT_ARCH_RISCV64
+#else
 #define __TBB_machine_fetchadd4(addr, val) __sync_fetch_and_add(addr, val)
 #endif /* ITT_ARCH==ITT_ARCH_IA64 */
 #ifndef ITT_SIMPLE_INIT
 ITT_INLINE long
 __itt_interlocked_increment(volatile long *ptr) ITT_INLINE_ATTRIBUTE;
 ITT_INLINE long __itt_interlocked_increment(volatile long *ptr) {
   return __TBB_machine_fetchadd4(ptr, 1) + 1L;
 }
#endif /* UNICODE || _UNICODE */
   long index;
   int extra1; /*!< Reserved to the runtime */
   void *extra2; /*!< Reserved to the runtime */
   struct __itt_counter_info *next;
 } __itt_counter_info_t;
 
 struct ___itt_domain;
 struct ___itt_string_handle;
+struct ___itt_histogram;
 
 typedef struct ___itt_global {
   unsigned char magic[8];
   unsigned long version_major;
   unsigned long version_minor;
   unsigned long version_build;
   volatile long api_initialized;
   volatile long mutex_initialized;
   volatile long atomic_counter;
   mutex_t mutex;
   lib_t lib;
   void *error_handler;
   const char **dll_path_ptr;
   __itt_api_info *api_list_ptr;
   struct ___itt_global *next;
   /* Joinable structures below */
   __itt_thread_info *thread_list;
   struct ___itt_domain *domain_list;
   struct ___itt_string_handle *string_list;
   __itt_collection_state state;
   __itt_counter_info_t *counter_list;
+  unsigned int ipt_collect_events;
+  struct ___itt_histogram *histogram_list;
 } __itt_global;
 
 #pragma pack(pop)
 
 #define NEW_THREAD_INFO_W(gptr, h, h_tail, t, s, n)                            \
   {                                                                            \
     h = (__itt_thread_info *)malloc(sizeof(__itt_thread_info));                \
     if (h != NULL) {                                                           \
if (h != NULL) {                                                           \
       h->next = NULL;                                                          \
       if (h_tail == NULL)                                                      \
         (gptr)->counter_list = h;                                              \
       else                                                                     \
         h_tail->next = h;                                                      \
     }                                                                          \
   }
 
+#define NEW_HISTOGRAM_W(gptr, h, h_tail, domain, name, x_type, y_type)         \
+  {                                                                            \
+    h = (__itt_histogram *)malloc(sizeof(__itt_histogram));                    \
+    if (h != NULL) {                                                           \
+      h->domain = domain;                                                      \
+      h->nameA = NULL;                                                         \
+      h->nameW = name ? _wcsdup(name) : NULL;                                  \
+      h->x_type = x_type;                                                      \
+      h->y_type = y_type;                                                      \
+      h->extra1 = 0;                                                           \
+      h->extra2 = NULL;                                                        \
+      if (h_tail == NULL)                                                      \
+        (gptr)->histogram_list = h;                                            \
+      else                                                                     \
+        h_tail->next = h;                                                      \
+    }                                                                          \
+  }
+
+#define NEW_HISTOGRAM_A(gptr, h, h_tail, domain, name, x_type, y_type)         \
+  {                                                                            \
+    h = (__itt_histogram *)malloc(sizeof(__itt_histogram));                    \
+    if (h != NULL) {                                                           \
+      h->domain = domain;                                                      \
+      h->nameA = name ? __itt_fstrdup(name) : NULL;                            \
+      h->nameW = NULL;                                                         \
+      h->x_type = x_type;                                                      \
+      h->y_type = y_type;                                                      \
+      h->extra1 = 0;                                                           \
+      h->extra2 = NULL;                                                        \
+      if (h_tail == NULL)                                                      \
+        (gptr)->histogram_list = h;                                            \
+      else                                                                     \
+        h_tail->next = h;                                                      \
+    }                                                                          \
+  }
+
 #endif /* _ITTNOTIFY_CONFIG_H_ */

openmp/runtime/src/thirdparty/ittnotify/ittnotify_static.h

ITT_STUB(ITTAPI, __itt_domain *, domain_createA, (const char *name),
          (ITT_FORMAT name), domain_createA, __itt_group_structure, "\"%s\"")
 ITT_STUB(ITTAPI, __itt_domain *, domain_createW, (const wchar_t *name),
          (ITT_FORMAT name), domain_createW, __itt_group_structure, "\"%S\"")
 #else /* ITT_PLATFORM!=ITT_PLATFORM_WIN */
 ITT_STUB(ITTAPI, __itt_domain *, domain_create, (const char *name),
          (ITT_FORMAT name), domain_create, __itt_group_structure, "\"%s\"")
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 
+ITT_STUBV(ITTAPI, void, module_load_with_sections,
+          (__itt_module_object * module_obj), (ITT_FORMAT module_obj),
+          module_load_with_sections, __itt_group_module, "%p")
+ITT_STUBV(ITTAPI, void, module_unload_with_sections,
+          (__itt_module_object * module_obj), (ITT_FORMAT module_obj),
+          module_unload_with_sections, __itt_group_module, "%p")
+
 #if ITT_PLATFORM == ITT_PLATFORM_WIN
 ITT_STUB(ITTAPI, __itt_string_handle *, string_handle_createA,
          (const char *name), (ITT_FORMAT name), string_handle_createA,
          __itt_group_structure, "\"%s\"")
 ITT_STUB(ITTAPI, __itt_string_handle *, string_handle_createW,
          (const wchar_t *name), (ITT_FORMAT name), string_handle_createW,
          __itt_group_structure, "\"%S\"")
 #else /* ITT_PLATFORM!=ITT_PLATFORM_WIN */
ITT_STUB(LIBITTAPI, int, thr_name_setW, (const wchar_t *name, int namelen),
          __itt_group_thread | __itt_group_legacy, "\"%S\", %d")
 #else /* ITT_PLATFORM!=ITT_PLATFORM_WIN */
 ITT_STUB(LIBITTAPI, int, thr_name_set, (const char *name, int namelen),
          (ITT_FORMAT name, namelen), thr_name_set,
          __itt_group_thread | __itt_group_legacy, "\"%s\", %d")
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 ITT_STUBV(LIBITTAPI, void, thr_ignore, (void), (ITT_NO_PARAMS), thr_ignore,
           __itt_group_thread | __itt_group_legacy, "no args")
+
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+ITT_STUB(ITTAPI, __itt_histogram *, histogram_createA,
+         (const __itt_domain *domain, const char *name,
+          __itt_metadata_type x_type, __itt_metadata_type y_type),
+         (ITT_FORMAT domain, name, x_type, y_type), histogram_createA,
+         __itt_group_structure, "%p, \"%s\", %d, %d")
+ITT_STUB(ITTAPI, __itt_histogram *, histogram_createW,
+         (const __itt_domain *domain, const wchar_t *name,
+          __itt_metadata_type x_type, __itt_metadata_type y_type),
+         (ITT_FORMAT domain, name, x_type, y_type), histogram_createW,
+         __itt_group_structure, "%p, \"%s\", %d, %d")
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+ITT_STUB(ITTAPI, __itt_histogram *, histogram_create,
+         (const __itt_domain *domain, const char *name,
+          __itt_metadata_type x_type, __itt_metadata_type y_type),
+         (ITT_FORMAT domain, name, x_type, y_type), histogram_create,
+         __itt_group_structure, "%p, \"%s\", %d, %d")
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+
 #endif /* __ITT_INTERNAL_BODY */
 
 ITT_STUBV(ITTAPI, void, enable_attach, (void), (ITT_NO_PARAMS), enable_attach,
           __itt_group_all, "no args")
 
 #else /* __ITT_INTERNAL_INIT */
 
 ITT_STUBV(ITTAPI, void, detach, (void), (ITT_NO_PARAMS), detach,

 ITT_STUB(ITTAPI, __itt_frame, frame_createA, (const char *domain),
          (ITT_FORMAT domain), frame_createA, __itt_group_frame, "\"%s\"")
 ITT_STUB(ITTAPI, __itt_frame, frame_createW, (const wchar_t *domain),
          (ITT_FORMAT domain), frame_createW, __itt_group_frame, "\"%s\"")
 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 ITT_STUB(ITTAPI, __itt_frame, frame_create, (const char *domain),
          (ITT_FORMAT domain), frame_create, __itt_group_frame, "\"%s\"")
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+ITT_STUB(ITTAPI, __itt_pt_region, pt_region_createA, (const char *name),
+         (ITT_FORMAT name), pt_region_createA, __itt_group_structure, "\"%s\"")
+ITT_STUB(ITTAPI, __itt_pt_region, pt_region_createW, (const wchar_t *name),
+         (ITT_FORMAT name), pt_region_createW, __itt_group_structure, "\"%S\"")
+#else /* ITT_PLATFORM!=ITT_PLATFORM_WIN */
+ITT_STUB(ITTAPI, __itt_pt_region, pt_region_create, (const char *name),
+         (ITT_FORMAT name), pt_region_create, __itt_group_structure, "\"%s\"")
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 #endif /* __ITT_INTERNAL_BODY */
 ITT_STUBV(ITTAPI, void, frame_begin, (__itt_frame frame), (ITT_FORMAT frame),
           frame_begin, __itt_group_frame, "%p")
 ITT_STUBV(ITTAPI, void, frame_end, (__itt_frame frame), (ITT_FORMAT frame),
           frame_end, __itt_group_frame, "%p")
 
 ITT_STUBV(ITTAPI, void, counter_destroy, (__itt_counter id), (ITT_FORMAT id),
           counter_destroy, __itt_group_counter, "%p")

 ITT_STUB(ITTAPI, int, av_save,
          (void *data, int rank, const int *dimensions, int type,
           const char *filePath, int columnOrder),
          (ITT_FORMAT data, rank, dimensions, type, filePath, columnOrder),
          av_save, __itt_group_arrays, "%p, %d, %p, %d, \"%s\", %d")
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 #endif /* __ITT_INTERNAL_BODY */
 
-#ifndef __ITT_INTERNAL_BODY
 #if ITT_PLATFORM == ITT_PLATFORM_WIN
 ITT_STUBV(ITTAPI, void, module_loadA,
           (void *start_addr, void *end_addr, const char *path),
           (ITT_FORMAT start_addr, end_addr, path), module_loadA,
-          __itt_group_none, "%p, %p, %p")
+          __itt_group_module, "%p, %p, %p")
 ITT_STUBV(ITTAPI, void, module_loadW,
           (void *start_addr, void *end_addr, const wchar_t *path),
           (ITT_FORMAT start_addr, end_addr, path), module_loadW,
-          __itt_group_none, "%p, %p, %p")
+          __itt_group_module, "%p, %p, %p")
 #else /* ITT_PLATFORM!=ITT_PLATFORM_WIN */
 ITT_STUBV(ITTAPI, void, module_load,
           (void *start_addr, void *end_addr, const char *path),
           (ITT_FORMAT start_addr, end_addr, path), module_load,
-          __itt_group_none, "%p, %p, %p")
+          __itt_group_module, "%p, %p, %p")
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-#endif /* __ITT_INTERNAL_BODY */
+ITT_STUBV(ITTAPI, void, module_unload, (void *start_addr),
+          (ITT_FORMAT start_addr), module_unload, __itt_group_module, "%p")
+
+ITT_STUBV(ITTAPI, void, histogram_submit,
+          (__itt_histogram * hist, size_t length, void *x_data, void *y_data),
+          (ITT_FORMAT hist, length, x_data, y_data), histogram_submit,
+          __itt_group_structure, "%p, %lu, %p, %p")
 
 #endif /* __ITT_INTERNAL_INIT */

openmp/runtime/src/thirdparty/ittnotify/ittnotify_static.cpp

 
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-#include "kmp_config.h"
-#include "kmp_os.h"
+#include "kmp_config.h" // INTEL_ITTNOTIFY_PREFIX definition
 #include "ittnotify_config.h"
 
 #if ITT_PLATFORM == ITT_PLATFORM_WIN
-#if defined(__MINGW32__)
-#include <limits.h>
-#else
+#if !defined(PATH_MAX)
 #define PATH_MAX 512
 #endif
 #else /* ITT_PLATFORM!=ITT_PLATFORM_WIN */
 #include <limits.h>
 #include <dlfcn.h>
 #include <errno.h>
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 #include <stdio.h>
 #include <stdlib.h>
 #include <stdarg.h>
 #include <string.h>
 
 #define INTEL_NO_MACRO_BODY
 #define INTEL_ITTNOTIFY_API_PRIVATE
 #include "ittnotify.h"
 #include "legacy/ittnotify.h"
 
-#if KMP_MSVC_COMPAT
 #include "disable_warnings.h"
-#endif
 
-static const char api_version[] = API_VERSION "\0\n@(#) $Revision: 481659 $\n";
+static const char api_version[] = API_VERSION "\0\n@(#) $Revision$\n";
 
 #define _N_(n) ITT_JOIN(INTEL_ITTNOTIFY_PREFIX, n)
 
+#ifndef HAS_CPP_ATTR
+#if defined(__cplusplus) && defined(__has_cpp_attribute)
+#define HAS_CPP_ATTR(X) __has_cpp_attribute(X)
+#else
+#define HAS_CPP_ATTR(X) 0
+#endif
+#endif
+
+#ifndef HAS_C_ATTR
+#if defined(__STDC__) && defined(__has_c_attribute)
+#define HAS_C_ATTR(X) __has_c_attribute(X)
+#else
+#define HAS_C_ATTR(X) 0
+#endif
+#endif
+
+#ifndef HAS_GNU_ATTR
+#if defined(__has_attribute)
+#define HAS_GNU_ATTR(X) __has_attribute(X)
+#else
+#define HAS_GNU_ATTR(X) 0
+#endif
+#endif
+
+#ifndef ITT_ATTRIBUTE_FALLTHROUGH
+#if (HAS_CPP_ATTR(fallthrough) || HAS_C_ATTR(fallthrough)) &&                  \
+    (__cplusplus >= 201703L || _MSVC_LANG >= 201703L)
+#define ITT_ATTRIBUTE_FALLTHROUGH [[fallthrough]]
+#elif HAS_CPP_ATTR(gnu::fallthrough)
+#define ITT_ATTRIBUTE_FALLTHROUGH [[gnu::fallthrough]]
+#elif HAS_CPP_ATTR(clang::fallthrough)
+#define ITT_ATTRIBUTE_FALLTHROUGH [[clang::fallthrough]]
+#elif HAS_GNU_ATTR(fallthrough) && !__INTEL_COMPILER
+#define ITT_ATTRIBUTE_FALLTHROUGH __attribute__((fallthrough))
+#else
+#define ITT_ATTRIBUTE_FALLTHROUGH
+#endif
+#endif
+
 #if ITT_OS == ITT_OS_WIN
 static const char *ittnotify_lib_name = "libittnotify.dll";
 #elif ITT_OS == ITT_OS_LINUX || ITT_OS == ITT_OS_FREEBSD
 static const char *ittnotify_lib_name = "libittnotify.so";
 #elif ITT_OS == ITT_OS_MAC
 static const char *ittnotify_lib_name = "libittnotify.dylib";
 #else
 #error Unsupported or unknown OS.

 #if ITT_ARCH == ITT_ARCH_IA32 || ITT_ARCH == ITT_ARCH_ARM
 #define ANDROID_ITTNOTIFY_DEFAULT_PATH ANDROID_ITTNOTIFY_DEFAULT_PATH_MASK(32)
 #else
 #define ANDROID_ITTNOTIFY_DEFAULT_PATH ANDROID_ITTNOTIFY_DEFAULT_PATH_MASK(64)
 #endif
 
 #endif
 
-#ifndef PATH_MAX
-#define PATH_MAX 4096
-#endif
-
 #ifndef LIB_VAR_NAME
-#if ITT_ARCH == ITT_ARCH_IA32 || ITT_ARCH == ITT_ARCH_ARM ||                   \
-    ITT_ARCH == ITT_ARCH_MIPS
+#if ITT_ARCH == ITT_ARCH_IA32 || ITT_ARCH == ITT_ARCH_ARM
 #define LIB_VAR_NAME INTEL_LIBITTNOTIFY32
 #else
 #define LIB_VAR_NAME INTEL_LIBITTNOTIFY64
 #endif
 #endif /* LIB_VAR_NAME */
 
 #define ITT_MUTEX_INIT_AND_LOCK(p)                                             \
   {                                                                            \
     if (PTHREAD_SYMBOLS) {                                                     \
       if (!p.mutex_initialized) {                                              \
         if (__itt_interlocked_increment(&p.atomic_counter) == 1) {             \
           __itt_mutex_init(&p.mutex);                                          \
           p.mutex_initialized = 1;                                             \
         } else                                                                 \
           while (!p.mutex_initialized)                                         \
             __itt_thread_yield();                                              \
       }                                                                        \
       __itt_mutex_lock(&p.mutex);                                              \
     }                                                                          \
   }
 
+#define ITT_MODULE_OBJECT_VERSION 1
+
 typedef int(__itt_init_ittlib_t)(const char *, __itt_group_id);
 
 /* this define used to control initialization function name. */
 #ifndef __itt_init_ittlib_name
 ITT_EXTERN_C int _N_(init_ittlib)(const char *, __itt_group_id);
 static __itt_init_ittlib_t *__itt_init_ittlib_ptr = _N_(init_ittlib);
 #define __itt_init_ittlib_name __itt_init_ittlib_ptr
 #endif /* __itt_init_ittlib_name */
 
 typedef void(__itt_fini_ittlib_t)(void);
 
 /* this define used to control finalization function name. */
 #ifndef __itt_fini_ittlib_name
 ITT_EXTERN_C void _N_(fini_ittlib)(void);
 static __itt_fini_ittlib_t *__itt_fini_ittlib_ptr = _N_(fini_ittlib);
 #define __itt_fini_ittlib_name __itt_fini_ittlib_ptr
 #endif /* __itt_fini_ittlib_name */
 
+extern __itt_global _N_(_ittapi_global);
+
 /* building pointers to imported funcs */
 #undef ITT_STUBV
 #undef ITT_STUB
 #define ITT_STUB(api, type, name, args, params, ptr, group, format)            \
   static type api ITT_VERSIONIZE(ITT_JOIN(_N_(name), _init)) args;             \
   typedef type api ITT_JOIN(_N_(name), _t) args;                               \
   ITT_EXTERN_C_BEGIN ITT_JOIN(_N_(name), _t) * ITTNOTIFY_NAME(name) =          \
       ITT_VERSIONIZE(ITT_JOIN(_N_(name), _init));                              \
   ITT_EXTERN_C_END                                                             \
   static type api ITT_VERSIONIZE(ITT_JOIN(_N_(name), _init)) args {            \
-    __itt_init_ittlib_name(NULL, __itt_group_all);                             \
+    if (!_N_(_ittapi_global).api_initialized &&                                \
+        _N_(_ittapi_global).thread_list == NULL)                               \
+      __itt_init_ittlib_name(NULL, __itt_group_all);                           \
     if (ITTNOTIFY_NAME(name) &&                                                \
         ITTNOTIFY_NAME(name) != ITT_VERSIONIZE(ITT_JOIN(_N_(name), _init)))    \
       return ITTNOTIFY_NAME(name) params;                                      \
     else                                                                       \
       return (type)0;                                                          \
   }
 
 #define ITT_STUBV(api, type, name, args, params, ptr, group, format)           \
   static type api ITT_VERSIONIZE(ITT_JOIN(_N_(name), _init)) args;             \
   typedef type api ITT_JOIN(_N_(name), _t) args;                               \
   ITT_EXTERN_C_BEGIN ITT_JOIN(_N_(name), _t) * ITTNOTIFY_NAME(name) =          \
       ITT_VERSIONIZE(ITT_JOIN(_N_(name), _init));                              \
   ITT_EXTERN_C_END                                                             \
   static type api ITT_VERSIONIZE(ITT_JOIN(_N_(name), _init)) args {            \
-    __itt_init_ittlib_name(NULL, __itt_group_all);                             \
+    if (!_N_(_ittapi_global).api_initialized &&                                \
+        _N_(_ittapi_global).thread_list == NULL)                               \
+      __itt_init_ittlib_name(NULL, __itt_group_all);                           \
     if (ITTNOTIFY_NAME(name) &&                                                \
         ITTNOTIFY_NAME(name) != ITT_VERSIONIZE(ITT_JOIN(_N_(name), _init)))    \
       ITTNOTIFY_NAME(name) params;                                             \
     else                                                                       \
       return;                                                                  \
   }
 
 #undef __ITT_INTERNAL_INIT
(__itt_group_id)(__itt_group_control | __itt_group_thread |
                       __itt_group_suppress)},
     {NULL, (__itt_group_none)},
     {api_version,
      (__itt_group_none)} /* !!! Just to avoid unused code elimination !!! */
 };
 
 #pragma pack(pop)
 
-// clang-format off
-#if ITT_PLATFORM == ITT_PLATFORM_WIN && KMP_MSVC_COMPAT
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+#if _MSC_VER
 #pragma warning(push)
-#pragma warning(disable: 4054) /* warning C4054: 'type cast' : from function
+#pragma warning(disable : 4054) /* warning C4054: 'type cast' : from function  \
                                    pointer 'XXX' to data pointer 'void *' */
+#endif
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-// clang-format onå
 
 static __itt_api_info api_list[] = {
 /* Define functions with static implementation */
 #undef ITT_STUB
 #undef ITT_STUBV
 #define ITT_STUB(api, type, name, args, params, nameindll, group, format)      \
   {ITT_TO_STR(ITT_JOIN(__itt_, nameindll)),                                    \
    (void **)(void *)&ITTNOTIFY_NAME(name),                                     \
#define ITT_STUB(api, type, name, args, params, nameindll, group, format)      \
   {ITT_TO_STR(ITT_JOIN(__itt_, nameindll)),                                    \
    (void **)(void *)&ITTNOTIFY_NAME(name),                                     \
    (void *)(size_t)&ITT_VERSIONIZE(ITT_JOIN(_N_(name), _init)), NULL,          \
    (__itt_group_id)(group)},
 #define ITT_STUBV ITT_STUB
 #include "ittnotify_static.h"
     {NULL, NULL, NULL, NULL, __itt_group_none}};
 
-#if ITT_PLATFORM == ITT_PLATFORM_WIN && KMP_MSVC_COMPAT
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+#if _MSC_VER
 #pragma warning(pop)
+#endif
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 
 /* static part descriptor which handles. all notification api attributes. */
 __itt_global _N_(_ittapi_global) = {
     ITT_MAGIC, /* identification info */
     ITT_MAJOR,
     ITT_MINOR,
     API_VERSION_BUILD, /* version info */
     0, /* api_initialized */
     0, /* mutex_initialized */
     0, /* atomic_counter */
     MUTEX_INITIALIZER, /* mutex */
     NULL, /* dynamic library handle */
     NULL, /* error_handler */
     NULL, /* dll_path_ptr */
     (__itt_api_info *)&api_list, /* api_list_ptr */
     NULL, /* next __itt_global */
     NULL, /* thread_list */
     NULL, /* domain_list */
     NULL, /* string_list */
     __itt_collection_normal, /* collection state */
-    NULL /* counter_list */
+    NULL, /* counter_list */
+    0, /* ipt_collect_events */
+    NULL /* histogram_list */
 };
 
 typedef void(__itt_api_init_t)(__itt_global *, __itt_group_id);
 typedef void(__itt_api_fini_t)(__itt_global *);
 
+static __itt_domain dummy_domain;
 /* ========================================================================= */
 
 #ifdef ITT_NOTIFY_EXT_REPORT
 ITT_EXTERN_C void _N_(error_handler)(__itt_error_code, va_list args);
 #endif /* ITT_NOTIFY_EXT_REPORT */
 
-// clang-format off
-#if ITT_PLATFORM == ITT_PLATFORM_WIN && KMP_MSVC_COMPAT
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+#if _MSC_VER
 #pragma warning(push)
-#pragma warning(disable: 4055) /* warning C4055: 'type cast' : from data pointer
-                                  'void *' to function pointer 'XXX' */
+#pragma warning(                                                               \
+    disable : 4055) /* warning C4055: 'type cast' : from data pointer 'void *' \
+                       to function pointer 'XXX' */
+#endif
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-// clang-format on
 
-static void __itt_report_error(unsigned code_arg, ...) {
+static void __itt_report_error(int code, ...) {
   va_list args;
-  va_start(args, code_arg);
-
-  // We use unsigned for the code argument and explicitly cast it here to the
-  // right enumerator because variadic functions are not compatible with
-  // default promotions.
-  __itt_error_code code = (__itt_error_code)code_arg;
-
+  va_start(args, code);
   if (_N_(_ittapi_global).error_handler != NULL) {
     __itt_error_handler_t *handler =
         (__itt_error_handler_t *)(size_t)_N_(_ittapi_global).error_handler;
-    handler(code, args);
+    handler((__itt_error_code)code, args);
   }
 #ifdef ITT_NOTIFY_EXT_REPORT
-  _N_(error_handler)(code, args);
+  _N_(error_handler)((__itt_error_code)code, args);
 #endif /* ITT_NOTIFY_EXT_REPORT */
   va_end(args);
 }
 
-#if ITT_PLATFORM == ITT_PLATFORM_WIN && KMP_MSVC_COMPAT
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+#if _MSC_VER
 #pragma warning(pop)
+#endif
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 
 #if ITT_PLATFORM == ITT_PLATFORM_WIN
 static __itt_domain *ITTAPI
 ITT_VERSIONIZE(ITT_JOIN(_N_(domain_createW), _init))(const wchar_t *name) {
   __itt_domain *h_tail = NULL, *h = NULL;
 
   if (name == NULL) {
     return NULL;
   }
 
   ITT_MUTEX_INIT_AND_LOCK(_N_(_ittapi_global));
   if (_N_(_ittapi_global).api_initialized) {
     if (ITTNOTIFY_NAME(domain_createW) &&
         ITTNOTIFY_NAME(domain_createW) !=
             ITT_VERSIONIZE(ITT_JOIN(_N_(domain_createW), _init))) {
       __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
       return ITTNOTIFY_NAME(domain_createW)(name);
+    } else {
+      __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
+      return &dummy_domain;
     }
   }
   for (h_tail = NULL, h = _N_(_ittapi_global).domain_list; h != NULL;
        h_tail = h, h = h->next) {
     if (h->nameW != NULL && !wcscmp(h->nameW, name))
       break;
   }
   if (h == NULL) {
#else
     if (ITTNOTIFY_NAME(domain_create) &&
         ITTNOTIFY_NAME(domain_create) !=
             ITT_VERSIONIZE(ITT_JOIN(_N_(domain_create), _init))) {
       if (PTHREAD_SYMBOLS)
         __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
       return ITTNOTIFY_NAME(domain_create)(name);
     }
 #endif
+    else {
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+      __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
+#else
+      if (PTHREAD_SYMBOLS)
+        __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
+#endif
+      return &dummy_domain;
+    }
   }
   for (h_tail = NULL, h = _N_(_ittapi_global).domain_list; h != NULL;
        h_tail = h, h = h->next) {
     if (h->nameA != NULL && !__itt_fstrcmp(h->nameA, name))
       break;
   }
   if (h == NULL) {
     NEW_DOMAIN_A(&_N_(_ittapi_global), h, h_tail, name);
   }
   if (PTHREAD_SYMBOLS)
     __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
   return h;
 }
 
+static void ITTAPI ITT_VERSIONIZE(ITT_JOIN(
+    _N_(module_load_with_sections), _init))(__itt_module_object *module_obj) {
+  if (!_N_(_ittapi_global).api_initialized &&
+      _N_(_ittapi_global).thread_list == NULL) {
+    __itt_init_ittlib_name(NULL, __itt_group_all);
+  }
+  if (ITTNOTIFY_NAME(module_load_with_sections) &&
+      ITTNOTIFY_NAME(module_load_with_sections) !=
+          ITT_VERSIONIZE(ITT_JOIN(_N_(module_load_with_sections), _init))) {
+    if (module_obj != NULL) {
+      module_obj->version = ITT_MODULE_OBJECT_VERSION;
+      ITTNOTIFY_NAME(module_load_with_sections)(module_obj);
+    }
+  }
+}
+
+static void ITTAPI ITT_VERSIONIZE(ITT_JOIN(
+    _N_(module_unload_with_sections), _init))(__itt_module_object *module_obj) {
+  if (!_N_(_ittapi_global).api_initialized &&
+      _N_(_ittapi_global).thread_list == NULL) {
+    __itt_init_ittlib_name(NULL, __itt_group_all);
+  }
+  if (ITTNOTIFY_NAME(module_unload_with_sections) &&
+      ITTNOTIFY_NAME(module_unload_with_sections) !=
+          ITT_VERSIONIZE(ITT_JOIN(_N_(module_unload_with_sections), _init))) {
+    if (module_obj != NULL) {
+      module_obj->version = ITT_MODULE_OBJECT_VERSION;
+      ITTNOTIFY_NAME(module_unload_with_sections)(module_obj);
+    }
+  }
+}
+
 #if ITT_PLATFORM == ITT_PLATFORM_WIN
 static __itt_string_handle *ITTAPI ITT_VERSIONIZE(
     ITT_JOIN(_N_(string_handle_createW), _init))(const wchar_t *name) {
   __itt_string_handle *h_tail = NULL, *h = NULL;
 
   if (name == NULL) {
     return NULL;
   }
 
   ITT_MUTEX_INIT_AND_LOCK(_N_(_ittapi_global));
   if (_N_(_ittapi_global).api_initialized) {
     if (ITTNOTIFY_NAME(string_handle_createW) &&
         ITTNOTIFY_NAME(string_handle_createW) !=
             ITT_VERSIONIZE(ITT_JOIN(_N_(string_handle_createW), _init))) {
       __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
       return ITTNOTIFY_NAME(string_handle_createW)(name);
+    } else {
+      __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
+      return NULL;
     }
   }
   for (h_tail = NULL, h = _N_(_ittapi_global).string_list; h != NULL;
        h_tail = h, h = h->next) {
     if (h->strW != NULL && !wcscmp(h->strW, name))
       break;
   }
   if (h == NULL) {
#else
     if (ITTNOTIFY_NAME(string_handle_create) &&
         ITTNOTIFY_NAME(string_handle_create) !=
             ITT_VERSIONIZE(ITT_JOIN(_N_(string_handle_create), _init))) {
       if (PTHREAD_SYMBOLS)
         __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
       return ITTNOTIFY_NAME(string_handle_create)(name);
     }
 #endif
+    else {
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+      __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
+#else
+      if (PTHREAD_SYMBOLS)
+        __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
+#endif
+      return NULL;
+    }
   }
   for (h_tail = NULL, h = _N_(_ittapi_global).string_list; h != NULL;
        h_tail = h, h = h->next) {
     if (h->strA != NULL && !__itt_fstrcmp(h->strA, name))
       break;
   }
   if (h == NULL) {
     NEW_STRING_HANDLE_A(&_N_(_ittapi_global), h, h_tail, name);
static __itt_counter ITTAPI ITT_VERSIONIZE(ITT_JOIN(
 
   ITT_MUTEX_INIT_AND_LOCK(_N_(_ittapi_global));
   if (_N_(_ittapi_global).api_initialized) {
     if (ITTNOTIFY_NAME(counter_createW) &&
         ITTNOTIFY_NAME(counter_createW) !=
             ITT_VERSIONIZE(ITT_JOIN(_N_(counter_createW), _init))) {
       __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
       return ITTNOTIFY_NAME(counter_createW)(name, domain);
+    } else {
+      __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
+      return NULL;
     }
   }
   for (h_tail = NULL, h = _N_(_ittapi_global).counter_list; h != NULL;
        h_tail = h, h = h->next) {
-    if (h->nameW != NULL && h->type == type && !wcscmp(h->nameW, name) &&
+    if (h->nameW != NULL && h->type == (int)type && !wcscmp(h->nameW, name) &&
         ((h->domainW == NULL && domain == NULL) ||
          (h->domainW != NULL && domain != NULL && !wcscmp(h->domainW, domain))))
       break;
   }
   if (h == NULL) {
     NEW_COUNTER_W(&_N_(_ittapi_global), h, h_tail, name, domain, type);
   }
   __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
#else
     if (ITTNOTIFY_NAME(counter_create) &&
         ITTNOTIFY_NAME(counter_create) !=
             ITT_VERSIONIZE(ITT_JOIN(_N_(counter_create), _init))) {
       if (PTHREAD_SYMBOLS)
         __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
       return ITTNOTIFY_NAME(counter_create)(name, domain);
     }
 #endif
+    else {
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+      __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
+#else
+      if (PTHREAD_SYMBOLS)
+        __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
+#endif
+      return NULL;
+    }
   }
   for (h_tail = NULL, h = _N_(_ittapi_global).counter_list; h != NULL;
        h_tail = h, h = h->next) {
-    if (h->nameA != NULL && h->type == type && !__itt_fstrcmp(h->nameA, name) &&
+    if (h->nameA != NULL && h->type == (int)type &&
+        !__itt_fstrcmp(h->nameA, name) &&
         ((h->domainA == NULL && domain == NULL) ||
          (h->domainA != NULL && domain != NULL &&
           !__itt_fstrcmp(h->domainA, domain))))
       break;
   }
   if (h == NULL) {
     NEW_COUNTER_A(&_N_(_ittapi_global), h, h_tail, name, domain, type);
   }
static __itt_counter ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(counter_create_typedW),
 
   ITT_MUTEX_INIT_AND_LOCK(_N_(_ittapi_global));
   if (_N_(_ittapi_global).api_initialized) {
     if (ITTNOTIFY_NAME(counter_create_typedW) &&
         ITTNOTIFY_NAME(counter_create_typedW) !=
             ITT_VERSIONIZE(ITT_JOIN(_N_(counter_create_typedW), _init))) {
       __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
       return ITTNOTIFY_NAME(counter_create_typedW)(name, domain, type);
+    } else {
+      __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
+      return NULL;
     }
   }
   for (h_tail = NULL, h = _N_(_ittapi_global).counter_list; h != NULL;
        h_tail = h, h = h->next) {
-    if (h->nameW != NULL && h->type == type && !wcscmp(h->nameW, name) &&
+    if (h->nameW != NULL && h->type == (int)type && !wcscmp(h->nameW, name) &&
         ((h->domainW == NULL && domain == NULL) ||
          (h->domainW != NULL && domain != NULL && !wcscmp(h->domainW, domain))))
       break;
   }
   if (h == NULL) {
     NEW_COUNTER_W(&_N_(_ittapi_global), h, h_tail, name, domain, type);
   }
   __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
#else
     if (ITTNOTIFY_NAME(counter_create_typed) &&
         ITTNOTIFY_NAME(counter_create_typed) !=
             ITT_VERSIONIZE(ITT_JOIN(_N_(counter_create_typed), _init))) {
       if (PTHREAD_SYMBOLS)
         __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
       return ITTNOTIFY_NAME(counter_create_typed)(name, domain, type);
     }
 #endif
+    else {
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+      __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
+#else
+      if (PTHREAD_SYMBOLS)
+        __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
+#endif
+      return NULL;
+    }
   }
   for (h_tail = NULL, h = _N_(_ittapi_global).counter_list; h != NULL;
        h_tail = h, h = h->next) {
-    if (h->nameA != NULL && h->type == type && !__itt_fstrcmp(h->nameA, name) &&
+    if (h->nameA != NULL && h->type == (int)type &&
+        !__itt_fstrcmp(h->nameA, name) &&
         ((h->domainA == NULL && domain == NULL) ||
          (h->domainA != NULL && domain != NULL &&
           !__itt_fstrcmp(h->domainA, domain))))
       break;
   }
   if (h == NULL) {
     NEW_COUNTER_A(&_N_(_ittapi_global), h, h_tail, name, domain, type);
   }
   if (PTHREAD_SYMBOLS)
     __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
   return (__itt_counter)h;
 }
 
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+static __itt_histogram *ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(histogram_createW),
+                                                       _init))(
+    const __itt_domain *domain, const wchar_t *name, __itt_metadata_type x_type,
+    __itt_metadata_type y_type) {
+  __itt_histogram *h_tail = NULL, *h = NULL;
+
+  if (domain == NULL || name == NULL) {
+    return NULL;
+  }
+
+  ITT_MUTEX_INIT_AND_LOCK(_N_(_ittapi_global));
+  if (_N_(_ittapi_global).api_initialized) {
+    if (ITTNOTIFY_NAME(histogram_createW) &&
+        ITTNOTIFY_NAME(histogram_createW) !=
+            ITT_VERSIONIZE(ITT_JOIN(_N_(histogram_createW), _init))) {
+      __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
+      return ITTNOTIFY_NAME(histogram_createW)(domain, name, x_type, y_type);
+    } else {
+      __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
+      return NULL;
+    }
+  }
+  for (h_tail = NULL, h = _N_(_ittapi_global).histogram_list; h != NULL;
+       h_tail = h, h = h->next) {
+    if (h->domain == NULL)
+      continue;
+    else if (h->domain != domain && h->nameW != NULL && !wcscmp(h->nameW, name))
+      break;
+  }
+  if (h == NULL) {
+    NEW_HISTOGRAM_W(&_N_(_ittapi_global), h, h_tail, domain, name, x_type,
+                    y_type);
+  }
+  __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
+  return (__itt_histogram *)h;
+}
+
+static __itt_histogram *ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(histogram_createA),
+                                                       _init))(
+    const __itt_domain *domain, const char *name, __itt_metadata_type x_type,
+    __itt_metadata_type y_type)
+#else /* ITT_PLATFORM!=ITT_PLATFORM_WIN */
+static __itt_histogram *ITTAPI ITT_VERSIONIZE(ITT_JOIN(
+    _N_(histogram_create), _init))(const __itt_domain *domain, const char *name,
+                                   __itt_metadata_type x_type,
+                                   __itt_metadata_type y_type)
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+{
+  __itt_histogram *h_tail = NULL, *h = NULL;
+
+  if (domain == NULL || name == NULL) {
+    return NULL;
+  }
+
+  ITT_MUTEX_INIT_AND_LOCK(_N_(_ittapi_global));
+  if (_N_(_ittapi_global).api_initialized) {
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+    if (ITTNOTIFY_NAME(histogram_createA) &&
+        ITTNOTIFY_NAME(histogram_createA) !=
+            ITT_VERSIONIZE(ITT_JOIN(_N_(histogram_createA), _init))) {
+      __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
+      return ITTNOTIFY_NAME(histogram_createA)(domain, name, x_type, y_type);
+    }
+#else
+    if (ITTNOTIFY_NAME(histogram_create) &&
+        ITTNOTIFY_NAME(histogram_create) !=
+            ITT_VERSIONIZE(ITT_JOIN(_N_(histogram_create), _init))) {
+      if (PTHREAD_SYMBOLS)
+        __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
+      return ITTNOTIFY_NAME(histogram_create)(domain, name, x_type, y_type);
+    }
+#endif
+    else {
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+      __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
+#else
+      if (PTHREAD_SYMBOLS)
+        __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
+#endif
+      return NULL;
+    }
+  }
+  for (h_tail = NULL, h = _N_(_ittapi_global).histogram_list; h != NULL;
+       h_tail = h, h = h->next) {
+    if (h->domain == NULL)
+      continue;
+    else if (h->domain != domain && h->nameA != NULL &&
+             !__itt_fstrcmp(h->nameA, name))
+      break;
+  }
+  if (h == NULL) {
+    NEW_HISTOGRAM_A(&_N_(_ittapi_global), h, h_tail, domain, name, x_type,
+                    y_type);
+  }
+  if (PTHREAD_SYMBOLS)
+    __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
+  return (__itt_histogram *)h;
+}
+
 /* -------------------------------------------------------------------------- */
 
 static void ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(pause), _init))(void) {
   if (!_N_(_ittapi_global).api_initialized &&
       _N_(_ittapi_global).thread_list == NULL) {
     __itt_init_ittlib_name(NULL, __itt_group_all);
   }
   if (ITTNOTIFY_NAME(pause) &&
if (itt_marker_file_fd == -1) {
       ITT_ANDROID_LOGI("ITT Lib path from env: %s", lib_name);
     }
   }
 #endif
 
   return lib_name;
 }
 
-/* Avoid clashes with std::min, reported by tbb team */
-#define __itt_min(a, b) (a) < (b) ? (a) : (b)
+/* Avoid clashes with std::min */
+#define __itt_min(a, b) ((a) < (b) ? (a) : (b))
 
 static __itt_group_id __itt_get_groups(void) {
   int i;
   __itt_group_id res = __itt_group_none;
   const char *var_name = "INTEL_ITTNOTIFY_GROUPS";
   const char *group_str = __itt_get_env_var(var_name);
 
   if (group_str != NULL) {
static int __itt_lib_version(lib_t lib) {
   if (__itt_get_proc(lib, "__itt_api_version"))
     return 1;
   return 0;
 }
 
 /* It's not used right now! Comment it out to avoid warnings.
 static void __itt_reinit_all_pointers(void)
 {
-    int i;
+    register int i;
     // Fill all pointers with initial stubs
     for (i = 0; _N_(_ittapi_global).api_list_ptr[i].name != NULL; i++)
         *_N_(_ittapi_global).api_list_ptr[i].func_ptr =
 _N_(_ittapi_global).api_list_ptr[i].init_func;
 }
 */
 
 static void __itt_nullify_all_pointers(void) {
   int i;
-  /* Nullify all pointers except domain_create, string_handle_create  and
+  /* Nulify all pointers except domain_create, string_handle_create  and
    * counter_create */
   for (i = 0; _N_(_ittapi_global).api_list_ptr[i].name != NULL; i++)
     *_N_(_ittapi_global).api_list_ptr[i].func_ptr =
         _N_(_ittapi_global).api_list_ptr[i].null_func;
 }
 
-// clang-format off
-#if ITT_PLATFORM == ITT_PLATFORM_WIN && KMP_MSVC_COMPAT
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+#if _MSC_VER
 #pragma warning(push)
-#pragma warning(disable: 4054) /* warning C4054: 'type cast' : from function
+#pragma warning(disable : 4054) /* warning C4054: 'type cast' : from function  \
                                    pointer 'XXX' to data pointer 'void *' */
-#pragma warning(disable: 4055) /* warning C4055: 'type cast' : from data pointer
-                                  'void *' to function pointer 'XXX' */
+#pragma warning(                                                               \
+    disable : 4055) /* warning C4055: 'type cast' : from data pointer 'void *' \
+                       to function pointer 'XXX' */
+#endif
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-// clang-format on
 
 ITT_EXTERN_C void _N_(fini_ittlib)(void) {
   __itt_api_fini_t *__itt_api_fini_ptr = NULL;
   static volatile TIDT current_thread = 0;
 
   if (_N_(_ittapi_global).api_initialized) {
     ITT_MUTEX_INIT_AND_LOCK(_N_(_ittapi_global));
     if (_N_(_ittapi_global).api_initialized) {
if (_N_(_ittapi_global).api_initialized) {
         current_thread = 0;
       }
     }
     if (PTHREAD_SYMBOLS)
       __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
   }
 }
 
+/* !!! this function should be called under mutex lock !!! */
+static void __itt_free_allocated_resources(void) {
+  __itt_string_handle *current_string = _N_(_ittapi_global).string_list;
+  while (current_string != NULL) {
+    __itt_string_handle *tmp = current_string->next;
+    free((char *)current_string->strA);
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+    free((wchar_t *)current_string->strW);
+#endif
+    free(current_string);
+    current_string = tmp;
+  }
+  _N_(_ittapi_global).string_list = NULL;
+
+  __itt_domain *current_domain = _N_(_ittapi_global).domain_list;
+  while (current_domain != NULL) {
+    __itt_domain *tmp = current_domain->next;
+    free((char *)current_domain->nameA);
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+    free((wchar_t *)current_domain->nameW);
+#endif
+    free(current_domain);
+    current_domain = tmp;
+  }
+  _N_(_ittapi_global).domain_list = NULL;
+
+  __itt_counter_info_t *current_couter = _N_(_ittapi_global).counter_list;
+  while (current_couter != NULL) {
+    __itt_counter_info_t *tmp = current_couter->next;
+    free((char *)current_couter->nameA);
+    free((char *)current_couter->domainA);
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+    free((wchar_t *)current_couter->nameW);
+    free((wchar_t *)current_couter->domainW);
+#endif
+    free(current_couter);
+    current_couter = tmp;
+  }
+  _N_(_ittapi_global).counter_list = NULL;
+
+  __itt_histogram *current_histogram = _N_(_ittapi_global).histogram_list;
+  while (current_histogram != NULL) {
+    __itt_histogram *tmp = current_histogram->next;
+    free((char *)current_histogram->nameA);
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+    free((wchar_t *)current_histogram->nameW);
+#endif
+    free(current_histogram);
+    current_histogram = tmp;
+  }
+  _N_(_ittapi_global).histogram_list = NULL;
+}
+
 ITT_EXTERN_C int _N_(init_ittlib)(const char *lib_name,
                                   __itt_group_id init_groups) {
   int i;
   __itt_group_id groups;
 #ifdef ITT_COMPLETE_GROUP
   __itt_group_id zero_group = __itt_group_none;
 #endif /* ITT_COMPLETE_GROUP */
   static volatile TIDT current_thread = 0;
if (!_N_(_ittapi_global).api_initialized) {
 
           if (_N_(_ittapi_global).lib != NULL) {
             __itt_api_init_t *__itt_api_init_ptr;
             int lib_version = __itt_lib_version(_N_(_ittapi_global).lib);
 
             switch (lib_version) {
             case 0:
               groups = __itt_group_legacy;
-              KMP_FALLTHROUGH();
+              ITT_ATTRIBUTE_FALLTHROUGH;
             case 1:
               /* Fill all pointers from dynamic library */
               for (i = 0; _N_(_ittapi_global).api_list_ptr[i].name != NULL;
                    i++) {
                 if (_N_(_ittapi_global).api_list_ptr[i].group & groups &
                     init_groups) {
                   *_N_(_ittapi_global).api_list_ptr[i].func_ptr =
                       (void *)__itt_get_proc(
                           _N_(_ittapi_global).lib,
                           _N_(_ittapi_global).api_list_ptr[i].name);
                   if (*_N_(_ittapi_global).api_list_ptr[i].func_ptr == NULL) {
                     /* Restore pointers for function with static implementation
                      */
                     *_N_(_ittapi_global).api_list_ptr[i].func_ptr =
                         _N_(_ittapi_global).api_list_ptr[i].null_func;
                     __itt_report_error(
                         __itt_error_no_symbol, lib_name,
                         _N_(_ittapi_global).api_list_ptr[i].name);
 #ifdef ITT_COMPLETE_GROUP
-                    zero_group = (__itt_group_id)(
-                        zero_group | _N_(_ittapi_global).api_list_ptr[i].group);
+                    zero_group =
+                        (__itt_group_id)(zero_group | _N_(_ittapi_global)
+                                                          .api_list_ptr[i]
+                                                          .group);
 #endif /* ITT_COMPLETE_GROUP */
                   }
                 } else
                   *_N_(_ittapi_global).api_list_ptr[i].func_ptr =
                       _N_(_ittapi_global).api_list_ptr[i].null_func;
               }
 
               if (groups == __itt_group_legacy) {
#endif /* ITT_COMPLETE_GROUP */
             case 2:
               __itt_api_init_ptr = (__itt_api_init_t *)(size_t)__itt_get_proc(
                   _N_(_ittapi_global).lib, "__itt_api_init");
               if (__itt_api_init_ptr)
                 __itt_api_init_ptr(&_N_(_ittapi_global), init_groups);
               break;
             }
           } else {
+            __itt_free_allocated_resources();
             __itt_nullify_all_pointers();
 
             __itt_report_error(__itt_error_no_module, lib_name,
 #if ITT_PLATFORM == ITT_PLATFORM_WIN
                                __itt_system_error()
 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
                                dlerror()
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
             );
           }
         } else {
+          __itt_free_allocated_resources();
           __itt_nullify_all_pointers();
         }
         _N_(_ittapi_global).api_initialized = 1;
         current_thread = 0;
         /* !!! Just to avoid unused code elimination !!! */
         if (__itt_fini_ittlib_ptr == _N_(fini_ittlib))
           current_thread = 0;
       }

 ITT_EXTERN_C __itt_error_handler_t *
 _N_(set_error_handler)(__itt_error_handler_t *handler) {
   __itt_error_handler_t *prev =
       (__itt_error_handler_t *)(size_t)_N_(_ittapi_global).error_handler;
   _N_(_ittapi_global).error_handler = (void *)(size_t)handler;
   return prev;
 }
 
-#if ITT_PLATFORM == ITT_PLATFORM_WIN && KMP_MSVC_COMPAT
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+#if _MSC_VER
 #pragma warning(pop)
+#endif
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+
+/** __itt_mark_pt_region functions marks region of interest
+ * region parameter defines different regions.
+ * 0 <= region < 8 */
+
+#if defined(ITT_API_IPT_SUPPORT) &&                                            \
+    (ITT_PLATFORM == ITT_PLATFORM_WIN ||                                       \
+     ITT_PLATFORM == ITT_PLATFORM_POSIX) &&                                    \
+    !defined(__ANDROID__)
+void __itt_pt_mark(__itt_pt_region region);
+void __itt_pt_mark_event(__itt_pt_region region);
+#endif
+
+ITT_EXTERN_C void _N_(mark_pt_region_begin)(__itt_pt_region region) {
+#if defined(ITT_API_IPT_SUPPORT) &&                                            \
+    (ITT_PLATFORM == ITT_PLATFORM_WIN ||                                       \
+     ITT_PLATFORM == ITT_PLATFORM_POSIX) &&                                    \
+    !defined(__ANDROID__)
+  if (_N_(_ittapi_global).ipt_collect_events == 1) {
+    __itt_pt_mark_event(2 * region);
+  } else {
+    __itt_pt_mark(2 * region);
+  }
+#else
+  (void)region;
+#endif
+}
+
+ITT_EXTERN_C void _N_(mark_pt_region_end)(__itt_pt_region region) {
+#if defined(ITT_API_IPT_SUPPORT) &&                                            \
+    (ITT_PLATFORM == ITT_PLATFORM_WIN ||                                       \
+     ITT_PLATFORM == ITT_PLATFORM_POSIX) &&                                    \
+    !defined(__ANDROID__)
+  if (_N_(_ittapi_global).ipt_collect_events == 1) {
+    __itt_pt_mark_event(2 * region + 1);
+  } else {
+    __itt_pt_mark(2 * region + 1);
+  }
+#else
+  (void)region;
+#endif
+}

openmp/runtime/src/thirdparty/ittnotify/ittnotify_types.h

typedef enum ___itt_group_id {
   __itt_group_counter = 1 << 8,
   __itt_group_frame = 1 << 9,
   __itt_group_stitch = 1 << 10,
   __itt_group_heap = 1 << 11,
   __itt_group_splitter_max = 1 << 12,
   __itt_group_structure = 1 << 12,
   __itt_group_suppress = 1 << 13,
   __itt_group_arrays = 1 << 14,
+  __itt_group_module = 1 << 15,
   __itt_group_all = -1
 } __itt_group_id;
 
 #pragma pack(push, 8)
 
 typedef struct ___itt_group_list {
   __itt_group_id id;
   const char *name;
static __itt_group_list varname[] = {{__itt_group_all, "all"},               \
                                        {__itt_group_model, "model"},           \
                                        {__itt_group_counter, "counter"},       \
                                        {__itt_group_frame, "frame"},           \
                                        {__itt_group_stitch, "stitch"},         \
                                        {__itt_group_heap, "heap"},             \
                                        {__itt_group_structure, "structure"},   \
                                        {__itt_group_suppress, "suppress"},     \
                                        {__itt_group_arrays, "arrays"},         \
+                                       {__itt_group_module, "module"},         \
                                        {__itt_group_none, NULL}}
 
 #endif /* _ITTNOTIFY_TYPES_H_ */

openmp/runtime/src/thirdparty/ittnotify/legacy/ittnotify.h

 #define LIBITTAPI ITTAPI_CDECL
 
 /* TODO: Temporary for compatibility! */
 #define ITTAPI_CALL ITTAPI_CDECL
 #define LIBITTAPI_CALL ITTAPI_CDECL
 
 #if ITT_PLATFORM == ITT_PLATFORM_WIN
 /* use __forceinline (VC++ specific) */
-#define ITT_INLINE __forceinline
+#if defined(__MINGW32__) && !defined(__cplusplus)
+#define ITT_INLINE                                                             \
+  static __inline__ __attribute__((__always_inline__, __gnu_inline__))
+#else
+#define ITT_INLINE static __forceinline
+#endif /* __MINGW32__ */
+
 #define ITT_INLINE_ATTRIBUTE /* nothing */
 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 /*
  * Generally, functions are not inlined unless optimization is specified.
  * For functions declared inline, this attribute inlines the function even
  * if no optimization level was specified.
  */
 #ifdef __STRICT_ANSI__