1berry/nodejs
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

build,deps,src: fix Intel VTune profiling support

Browse Source 
PR-URL: https://github.com/nodejs/node/pull/45248
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
Reviewed-By: Michaël Zasso <targos@protonmail.com>
This commit is contained in:
Shi Lei 2022-11-22 16:28:19 +08:00 committed by GitHub
parent be049df055
commit d783a1c128
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
48 changed files with 16636 additions and 2 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
LICENSE
View File

@ -107,6 +107,18 @@ The externally maintained libraries used by Node.js are:
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
"""
- ittapi, located at deps/v8/third_party/ittapi, is licensed as follows:
"""
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.
"""
- ICU, located at deps/icu-small, is licensed as follows:
"""
UNICODE, INC. LICENSE AGREEMENT - DATA FILES AND SOFTWARE

16
configure.py
View File

@ -160,6 +160,13 @@ parser.add_argument("--partly-static",
help="Generate an executable with libgcc and libstdc++ libraries. This "
"will not work on OSX when using the default compilation environment")
parser.add_argument("--enable-vtune-profiling",
action="store_true",
dest="enable_vtune_profiling",
help="Enable profiling support for Intel VTune profiler to profile "
"JavaScript code executed in Node.js. This feature is only available "
"for x32, x86, and x64 architectures.")
parser.add_argument("--enable-pgo-generate",
action="store_true",
dest="enable_pgo_generate",
@ -1280,6 +1287,15 @@ def configure_node(o):
if flavor == 'aix':
o['variables']['node_target_type'] = 'static_library'
if target_arch in ('x86', 'x64', 'ia32', 'x32'):
o['variables']['node_enable_v8_vtunejit'] = b(options.enable_vtune_profiling)
elif options.enable_vtune_profiling:
raise Exception(
'The VTune profiler for JavaScript is only supported on x32, x86, and x64 '
'architectures.')
else:
o['variables']['node_enable_v8_vtunejit'] = 'false'
if flavor != 'linux' and (options.enable_pgo_generate or options.enable_pgo_use):
raise Exception(
'The pgo option is supported only on linux.')

1
deps/v8/.gitignore vendored
View File

@ -122,3 +122,4 @@ bazel-v8
/third_party/zlib/contrib/bench
/third_party/zlib/contrib/tests
/third_party/zlib/google/test
!/third_party/ittapi

93
deps/v8/third_party/ittapi/CMakeLists.txt vendored Normal file
View File

@ -0,0 +1,93 @@
#
# Copyright (C) 2005-2019 Intel Corporation
#
# SPDX-License-Identifier: GPL-2.0-only OR BSD-3-Clause
#
cmake_minimum_required(VERSION 2.8.12)
project(ittapi)
OPTION(FORCE_32 "Force a 32bit compile on 64bit" OFF)
OPTION(ITT_API_IPT_SUPPORT "ptmarks support")
IF(FORCE_32 AND UNIX)
SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -m32")
SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -m32")
ENDIF()
if(CMAKE_SIZEOF_VOID_P MATCHES "8" AND NOT(FORCE_32))
set(ARCH_64 1)
endif()
if(CMAKE_BUILD_TYPE STREQUAL "Debug")
add_definitions(-D_DEBUG)
if (NOT WIN32)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -g")
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -g")
endif()
else()
if (NOT WIN32)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -O2")
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -O2")
endif()
add_definitions(-DNDEBUG)
endif()
set(LIBRARY_OUTPUT_PATH ${CMAKE_BINARY_DIR}/bin)
foreach( OUTPUTCONFIG ${CMAKE_CONFIGURATION_TYPES} )
string( TOUPPER ${OUTPUTCONFIG} OUTPUTCONFIG )
set( CMAKE_LIBRARY_OUTPUT_DIRECTORY_${OUTPUTCONFIG} ${LIBRARY_OUTPUT_PATH} )
endforeach( OUTPUTCONFIG CMAKE_CONFIGURATION_TYPES )
set(ITT_PUBLIC_HDRS
include/ittnotify.h
include/jitprofiling.h
include/libittnotify.h
)
if (ITT_API_IPT_SUPPORT)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DITT_API_IPT_SUPPORT")
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DITT_API_IPT_SUPPORT")
if (NOT WIN32)
enable_language(ASM)
if (ARCH_64)
set(ITT_PT src/ittnotify/ittptmark64.S)
else()
set(ASM_OPTIONS "-m32")
set(ITT_PT src/ittnotify/ittptmark32.S)
endif()
set(CMAKE_ASM_FLAGS "${CFLAGS} ${ASM_OPTIONS}" )
else()
enable_language(ASM_MASM)
if (ARCH_64)
set(ITT_PT src/ittnotify/ittptmark64.asm)
else()
set(ITT_PT src/ittnotify/ittptmark32.asm)
endif()
endif()
endif()
file(GLOB ITT_SRCS "src/ittnotify/*.c" "src/ittnotify/*.h")
add_library(ittnotify STATIC ${ITT_SRCS} ${ITT_PUBLIC_HDRS} ${ITT_PT})
if(WIN32)
SET_TARGET_PROPERTIES(ittnotify PROPERTIES OUTPUT_NAME libittnotify)
else()
SET_TARGET_PROPERTIES(ittnotify PROPERTIES OUTPUT_NAME ittnotify)
endif()
if (NOT WIN32)
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fPIC")
TARGET_LINK_LIBRARIES(ittnotify dl)
endif()
SET_TARGET_PROPERTIES(ittnotify PROPERTIES LINKER_LANGUAGE C)
target_include_directories(ittnotify
PUBLIC include src/ittnotify
)
set(CMAKE_SUPPRESS_REGENERATION true)

8
deps/v8/third_party/ittapi/LICENSES/BSD-3-Clause.txt vendored Normal file
View File

@ -0,0 +1,8 @@
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.

103
deps/v8/third_party/ittapi/LICENSES/GPL-2.0-only.txt vendored Normal file
View File

@ -0,0 +1,103 @@
GNU GENERAL PUBLIC LICENSE
Version 2, June 1991
Copyright (C) 1989, 1991 Free Software Foundation, Inc.
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed.
Preamble
The licenses for most software are designed to take away your freedom to share and change it. By contrast, the GNU General Public License is intended to guarantee your freedom to share and change free software--to make sure the software is free for all its users. This General Public License applies to most of the Free Software Foundation's software and to any other program whose authors commit to using it. (Some other Free Software Foundation software is covered by the GNU Lesser General Public License instead.) You can apply it to your programs, too.
When we speak of free software, we are referring to freedom, not price. Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for this service if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs; and that you know you can do these things.
To protect your rights, we need to make restrictions that forbid anyone to deny you these rights or to ask you to surrender the rights. These restrictions translate to certain responsibilities for you if you distribute copies of the software, or if you modify it.
For example, if you distribute copies of such a program, whether gratis or for a fee, you must give the recipients all the rights that you have. You must make sure that they, too, receive or can get the source code. And you must show them these terms so they know their rights.
We protect your rights with two steps: (1) copyright the software, and (2) offer you this license which gives you legal permission to copy, distribute and/or modify the software.
Also, for each author's protection and ours, we want to make certain that everyone understands that there is no warranty for this free software. If the software is modified by someone else and passed on, we want its recipients to know that what they have is not the original, so that any problems introduced by others will not reflect on the original authors' reputations.
Finally, any free program is threatened constantly by software patents. We wish to avoid the danger that redistributors of a free program will individually obtain patent licenses, in effect making the program proprietary. To prevent this, we have made it clear that any patent must be licensed for everyone's free use or not licensed at all.
The precise terms and conditions for copying, distribution and modification follow.
TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
0. This License applies to any program or other work which contains a notice placed by the copyright holder saying it may be distributed under the terms of this General Public License. The "Program", below, refers to any such program or work, and a "work based on the Program" means either the Program or any derivative work under copyright law: that is to say, a work containing the Program or a portion of it, either verbatim or with modifications and/or translated into another language. (Hereinafter, translation is included without limitation in the term "modification".) Each licensee is addressed as "you".
Activities other than copying, distribution and modification are not covered by this License; they are outside its scope. The act of running the Program is not restricted, and the output from the Program is covered only if its contents constitute a work based on the Program (independent of having been made by running the Program). Whether that is true depends on what the Program does.
1. You may copy and distribute verbatim copies of the Program's source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice and disclaimer of warranty; keep intact all the notices that refer to this License and to the absence of any warranty; and give any other recipients of the Program a copy of this License along with the Program.
You may charge a fee for the physical act of transferring a copy, and you may at your option offer warranty protection in exchange for a fee.
2. You may modify your copy or copies of the Program or any portion of it, thus forming a work based on the Program, and copy and distribute such modifications or work under the terms of Section 1 above, provided that you also meet all of these conditions:
a) You must cause the modified files to carry prominent notices stating that you changed the files and the date of any change.
b) You must cause any work that you distribute or publish, that in whole or in part contains or is derived from the Program or any part thereof, to be licensed as a whole at no charge to all third parties under the terms of this License.
c) If the modified program normally reads commands interactively when run, you must cause it, when started running for such interactive use in the most ordinary way, to print or display an announcement including an appropriate copyright notice and a notice that there is no warranty (or else, saying that you provide a warranty) and that users may redistribute the program under these conditions, and telling the user how to view a copy of this License. (Exception: if the Program itself is interactive but does not normally print such an announcement, your work based on the Program is not required to print an announcement.)
These requirements apply to the modified work as a whole. If identifiable sections of that work are not derived from the Program, and can be reasonably considered independent and separate works in themselves, then this License, and its terms, do not apply to those sections when you distribute them as separate works. But when you distribute the same sections as part of a whole which is a work based on the Program, the distribution of the whole must be on the terms of this License, whose permissions for other licensees extend to the entire whole, and thus to each and every part regardless of who wrote it.
Thus, it is not the intent of this section to claim rights or contest your rights to work written entirely by you; rather, the intent is to exercise the right to control the distribution of derivative or collective works based on the Program.
In addition, mere aggregation of another work not based on the Program with the Program (or with a work based on the Program) on a volume of a storage or distribution medium does not bring the other work under the scope of this License.
3. You may copy and distribute the Program (or a work based on it, under Section 2) in object code or executable form under the terms of Sections 1 and 2 above provided that you also do one of the following:
a) Accompany it with the complete corresponding machine-readable source code, which must be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or,
b) Accompany it with a written offer, valid for at least three years, to give any third party, for a charge no more than your cost of physically performing source distribution, a complete machine-readable copy of the corresponding source code, to be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or,
c) Accompany it with the information you received as to the offer to distribute corresponding source code. (This alternative is allowed only for noncommercial distribution and only if you received the program in object code or executable form with such an offer, in accord with Subsection b above.)
The source code for a work means the preferred form of the work for making modifications to it. For an executable work, complete source code means all the source code for all modules it contains, plus any associated interface definition files, plus the scripts used to control compilation and installation of the executable. However, as a special exception, the source code distributed need not include anything that is normally distributed (in either source or binary form) with the major components (compiler, kernel, and so on) of the operating system on which the executable runs, unless that component itself accompanies the executable.
If distribution of executable or object code is made by offering access to copy from a designated place, then offering equivalent access to copy the source code from the same place counts as distribution of the source code, even though third parties are not compelled to copy the source along with the object code.
4. You may not copy, modify, sublicense, or distribute the Program except as expressly provided under this License. Any attempt otherwise to copy, modify, sublicense or distribute the Program is void, and will automatically terminate your rights under this License. However, parties who have received copies, or rights, from you under this License will not have their licenses terminated so long as such parties remain in full compliance.
5. You are not required to accept this License, since you have not signed it. However, nothing else grants you permission to modify or distribute the Program or its derivative works. These actions are prohibited by law if you do not accept this License. Therefore, by modifying or distributing the Program (or any work based on the Program), you indicate your acceptance of this License to do so, and all its terms and conditions for copying, distributing or modifying the Program or works based on it.
6. Each time you redistribute the Program (or any work based on the Program), the recipient automatically receives a license from the original licensor to copy, distribute or modify the Program subject to these terms and conditions. You may not impose any further restrictions on the recipients' exercise of the rights granted herein. You are not responsible for enforcing compliance by third parties to this License.
7. If, as a consequence of a court judgment or allegation of patent infringement or for any other reason (not limited to patent issues), conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License. If you cannot distribute so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not distribute the Program at all. For example, if a patent license would not permit royalty-free redistribution of the Program by all those who receive copies directly or indirectly through you, then the only way you could satisfy both it and this License would be to refrain entirely from distribution of the Program.
If any portion of this section is held invalid or unenforceable under any particular circumstance, the balance of the section is intended to apply and the section as a whole is intended to apply in other circumstances.
It is not the purpose of this section to induce you to infringe any patents or other property right claims or to contest validity of any such claims; this section has the sole purpose of protecting the integrity of the free software distribution system, which is implemented by public license practices. Many people have made generous contributions to the wide range of software distributed through that system in reliance on consistent application of that system; it is up to the author/donor to decide if he or she is willing to distribute software through any other system and a licensee cannot impose that choice.
This section is intended to make thoroughly clear what is believed to be a consequence of the rest of this License.
8. If the distribution and/or use of the Program is restricted in certain countries either by patents or by copyrighted interfaces, the original copyright holder who places the Program under this License may add an explicit geographical distribution limitation excluding those countries, so that distribution is permitted only in or among countries not thus excluded. In such case, this License incorporates the limitation as if written in the body of this License.
9. The Free Software Foundation may publish revised and/or new versions of the General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns.
Each version is given a distinguishing version number. If the Program specifies a version number of this License which applies to it and "any later version", you have the option of following the terms and conditions either of that version or of any later version published by the Free Software Foundation. If the Program does not specify a version number of this License, you may choose any version ever published by the Free Software Foundation.
10. If you wish to incorporate parts of the Program into other free programs whose distribution conditions are different, write to the author to ask for permission. For software which is copyrighted by the Free Software Foundation, write to the Free Software Foundation; we sometimes make exceptions for this. Our decision will be guided by the two goals of preserving the free status of all derivatives of our free software and of promoting the sharing and reuse of software generally.
NO WARRANTY
11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
END OF TERMS AND CONDITIONS
How to Apply These Terms to Your New Programs
If you develop a new program, and you want it to be of the greatest possible use to the public, the best way to achieve this is to make it free software which everyone can redistribute and change under these terms.
To do so, attach the following notices to the program. It is safest to attach them to the start of each source file to most effectively convey the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found.
<one line to give the program's name and an idea of what it does.>
Copyright (C) < yyyy> <name of author>
This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
Also add information on how to contact you by electronic and paper mail.
If the program is interactive, make it output a short notice like this when it starts in an interactive mode:
Gnomovision version 69, Copyright (C) year name of author Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. This is free software, and you are welcome to redistribute it under certain conditions; type `show c' for details.
The hypothetical commands `show w' and `show c' should show the appropriate parts of the General Public License. Of course, the commands you use may be called something other than `show w' and `show c'; they could even be mouse-clicks or menu items--whatever suits your program.
You should also get your employer (if you work as a programmer) or your school, if any, to sign a "copyright disclaimer" for the program, if necessary. Here is a sample; alter the names:
Yoyodyne, Inc., hereby disclaims all copyright interest in the program `Gnomovision' (which makes passes at compilers) written by James Hacker.
<signature of Ty Coon>, 1 April 1989 Ty Coon, President of Vice
This General Public License does not permit incorporating your program into proprietary programs. If your program is a subroutine library, you may consider it more useful to permit linking proprietary applications with the library. If this is what you want to do, use the GNU Lesser General Public License instead of this License.

38
deps/v8/third_party/ittapi/README.md vendored Normal file
View File

@ -0,0 +1,38 @@
Intel® Instrumentation and Tracing Technology (ITT) and Just-In-Time (JIT) API
==================================================================================
This ITT/JIT open source profiling API includes:
- Instrumentation and Tracing Technology (ITT) API
- Just-In-Time (JIT) Profiling API
The Instrumentation and Tracing Technology (ITT) API enables your application
to generate and control the collection of trace data during its execution
across different Intel tools.
ITT API consists of two parts: a _static part_ and a _dynamic part_. The
_dynamic part_ is specific for a tool and distributed only with a particular
tool. The _static part_ is a common part shared between tools. Currently, the
static part of ITT API is distributed as a static library and released under
a BSD/GPLv2 dual license with every tool supporting ITT API.
### Build
To build the library:
- On Windows, Linux and OSX: requires [cmake](https://cmake.org) to be set in `PATH`
- Windows: requires Visual Studio installed or requires [Ninja](https://github.com/ninja-build/ninja/releases) to be set in `PATH`
- To list available build options execute: `python buildall.py -h`
```
usage: buildall.py [-h] [-d] [-c] [-v] [-pt] [--force_bits]
optional arguments:
-h, --help show this help message and exit
-d, --debug specify debug build configuration (release by default)
-c, --clean delete any intermediate and output files
-v, --verbose enable verbose output from build process
-pt, --ptmark enable anomaly detection support
--force_bits specify bit version for the target
```
### License
All code in the repo is dual licensed under GPLv2 and 3-Clause BSD licenses

169
deps/v8/third_party/ittapi/buildall.py vendored Executable file
View File

@ -0,0 +1,169 @@
#!/usr/bin/env python
#
# Copyright (C) 2005-2019 Intel Corporation
#
# SPDX-License-Identifier: GPL-2.0-only OR BSD-3-Clause
#
from __future__ import print_function
import os
import sys
import shutil
import fnmatch
import subprocess
def run_shell(cmd):
print("\n>>", cmd)
os.system(cmd)
if sys.platform == 'win32':
def read_registry(path, depth=0xFFFFFFFF, statics={}):
try:
import _winreg
except ImportError:
import winreg as _winreg
parts = path.split('\\')
hub = parts[0]
path = '\\'.join(parts[1:])
if not statics:
statics['hubs'] = {'HKLM': _winreg.HKEY_LOCAL_MACHINE, 'HKCL': _winreg.HKEY_CLASSES_ROOT}
def enum_nodes(curpath, level):
if level < 1:
return {}
res = {}
try:
aKey = _winreg.OpenKey(statics['hubs'][hub], curpath, 0, _winreg.KEY_READ | _winreg.KEY_WOW64_64KEY)
except WindowsError:
return res
try:
i = 0
while True:
name, value, _ = _winreg.EnumValue(aKey, i)
i += 1
res[name] = value
except WindowsError:
pass
keys = []
try:
i = 0
while True:
key = _winreg.EnumKey(aKey, i)
i += 1
keys.append(key)
except WindowsError:
pass
_winreg.CloseKey(aKey)
for key in keys:
res[key] = enum_nodes(curpath + '\\' + key, level - 1)
return res
return enum_nodes(path, depth)
def get_vs_versions(): # https://www.mztools.com/articles/2008/MZ2008003.aspx
if sys.platform != 'win32':
return []
versions = []
hkcl = read_registry(r'HKCL', 1)
for key in hkcl:
if 'VisualStudio.DTE.' in key:
version = key.split('.')[2]
if int(version) >= 12:
versions.append(version)
if not versions:
print("No Visual Studio version found")
return sorted(versions)
def detect_cmake():
if sys.platform == 'darwin':
path, err = subprocess.Popen("which cmake", shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE).communicate()
if not path.strip():
path, err = subprocess.Popen("which xcrun", shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE).communicate()
if not path.strip():
print("No cmake and no XCode found...")
return None
return 'xcrun cmake'
return 'cmake'
def main():
import argparse
parser = argparse.ArgumentParser()
vs_versions = get_vs_versions()
parser.add_argument("-d", "--debug", help="specify debug build configuration (release by default)", action="store_true")
parser.add_argument("-c", "--clean", help="delete any intermediate and output files", action="store_true")
parser.add_argument("-v", "--verbose", help="enable verbose output from build process", action="store_true")
parser.add_argument("-pt", "--ptmark", help="enable anomaly detection support", action="store_true")
parser.add_argument("--force_bits", choices=["32", "64"], help="specify bit version for the target")
if sys.platform == 'win32' and vs_versions:
parser.add_argument("--vs", help="specify visual studio version {default}", choices=vs_versions, default=vs_versions[0])
args = parser.parse_args()
if args.force_bits:
target_bits = [args.force_bits]
else:
target_bits = ['64']
if (sys.platform != 'darwin'): # on MAC OSX we produce FAT library including both 32 and 64 bits
target_bits.append('32')
print("target_bits", target_bits)
work_dir = os.getcwd()
if args.clean:
bin_dir = os.path.join(work_dir, 'bin')
if os.path.exists(bin_dir):
shutil.rmtree(bin_dir)
for bits in target_bits:
work_folder = os.path.join(work_dir, "build_" + (sys.platform.replace('32', "")), bits)
already_there = os.path.exists(work_folder)
if already_there and args.clean:
shutil.rmtree(work_folder)
already_there = False
if not already_there:
os.makedirs(work_folder)
print("work_folder: ", work_folder)
os.chdir(work_folder)
if args.clean:
continue
cmake = detect_cmake()
if not cmake:
print("Error: cmake is not found")
return
if sys.platform == 'win32':
if vs_versions:
generator = ('Visual Studio %s' % args.vs) + (' Win64' if bits == '64' else '')
else:
generator = 'Ninja'
else:
generator = 'Unix Makefiles'
run_shell('%s "%s" -G"%s" %s' % (cmake, work_dir, generator, " ".join([
("-DFORCE_32=ON" if bits == '32' else ""),
("-DCMAKE_BUILD_TYPE=Debug" if args.debug else ""),
('-DCMAKE_VERBOSE_MAKEFILE:BOOL=ON' if args.verbose else ''),
("-DITT_API_IPT_SUPPORT=1" if args.ptmark else "")
])))
if sys.platform == 'win32':
target_project = 'ALL_BUILD'
run_shell('%s --build . --config %s --target %s' % (cmake, ('Debug' if args.debug else 'Release'), target_project))
else:
import glob
run_shell('%s --build . --config %s' % (cmake, ('Debug' if args.debug else 'Release')))
if ('linux' in sys.platform and bits == '64'):
continue
run_shell('%s --build . --config %s --target' % (cmake, ('Debug' if args.debug else 'Release')))
if __name__== "__main__":
main()

473
deps/v8/third_party/ittapi/include/fortran/posix/ittnotify.f90 vendored Normal file
View File

@ -0,0 +1,473 @@
! ========================================================================
! <copyright>
! This file is provided under a dual BSD/GPLv2 license. When using or
! redistributing this file, you may do so under either license.
!
! GPL LICENSE SUMMARY
!
! Copyright (c) 2005-2017 Intel Corporation. All rights reserved.
!
! This program is free software; you can redistribute it and/or modify
! it under the terms of version 2 of the GNU General Public License as
! published by the Free Software Foundation.
!
! This program is distributed in the hope that it will be useful, but
! WITHOUT ANY WARRANTY; without even the implied warranty of
! MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
! General Public License for more details.
!
! You should have received a copy of the GNU General Public License
! along with this program; if not, write to the Free Software
! Foundation, Inc., 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
! The full GNU General Public License is included in this distribution
! in the file called LICENSE.GPL.
!
! Contact Information:
! http://software.intel.com/en-us/articles/intel-vtune-amplifier-xe/
!
! BSD LICENSE
!
! Copyright (c) 2005-2017 Intel Corporation. All rights reserved.
! All rights reserved.
!
! Redistribution and use in source and binary forms, with or without
! modification, are permitted provided that the following conditions
! are met:
!
! * Redistributions of source code must retain the above copyright
! notice, this list of conditions and the following disclaimer.
! * 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.
! * Neither the name of Intel Corporation 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
! OWNER 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.
! </copyright>
! ========================================================================
!
!--------
!
! This file defines functions used by Intel(R) Parallel Inspector and
! Amplifier.
!
! Version of ittnotify that was used to generate this file.
! This is not Fortran code that can be used to check but rather a comment
! that only serves to identify the interface.
! INTEL_ITT_FORTRAN_API_VERSION 3.0
!--------
module ittnotify
use, intrinsic :: iso_c_binding, only: C_PTR, C_FUNPTR, C_INT, C_CHAR, C_NULL_CHAR, C_F_PROCPOINTER, C_LOC, C_ASSOCIATED
implicit none
!--------
!
! Public interface
!
!--------
integer, parameter :: itt_ptr = int_ptr_kind()
public :: itt_pause
public :: itt_resume
public :: itt_thread_ignore
public :: itt_suppress_push
public :: itt_suppress_pop
public :: itt_suppress_mark_range
public :: itt_suppress_clear_range
public :: itt_sync_prepare
public :: itt_sync_cancel
public :: itt_sync_acquired
public :: itt_sync_releasing
public :: itt_fsync_prepare
public :: itt_fsync_cancel
public :: itt_fsync_acquired
public :: itt_fsync_releasing
public :: itt_sync_destroy
public :: itt_sync_create
public :: itt_sync_rename
public :: itt_thread_set_name
public :: itt_heap_record_memory_growth_begin
public :: itt_heap_record_memory_growth_end
public :: itt_heap_reset_detection
public :: itt_heap_record
integer, parameter, public :: itt_attr_barrier = 1
integer, parameter, public :: itt_attr_mutex = 2
integer, parameter, public :: itt_suppress_threading_errors = 255
integer, parameter, public :: itt_suppress_memory_errors = 65280
integer, parameter, public :: itt_suppress_all_errors = 2147483647
integer, parameter, public :: itt_unsuppress_range = 0
integer, parameter, public :: itt_suppress_range = 1
integer, parameter, public :: itt_heap_leaks = 1
integer, parameter, public :: itt_heap_growth = 2
private
abstract interface
subroutine itt_proc_none() bind(C)
import
end subroutine itt_proc_none
subroutine itt_proc_sup_push(mask) bind(C)
import
integer, intent(in), value :: mask
end subroutine itt_proc_sup_push
subroutine itt_proc_sup_range(action, mask, addr, size) bind(C)
import
integer, intent(in), value :: action
integer, intent(in), value :: mask
integer(kind=itt_ptr), intent(in), value :: addr
integer(kind=itt_ptr), intent(in), value :: size
end subroutine itt_proc_sup_range
subroutine itt_proc_address(addr) bind(C)
import
integer(kind=itt_ptr), intent(in), value :: addr
end subroutine itt_proc_address
subroutine itt_proc_create(addr, objname, attribute) bind(C)
import
integer(kind=itt_ptr), intent(in), value :: addr
character(kind=C_CHAR), dimension(*), intent(in) :: objname
integer, intent(in), value :: attribute
end subroutine itt_proc_create
subroutine itt_proc_name(name) bind(C)
import
character(kind=C_CHAR), dimension(*), intent(in) :: name
end subroutine itt_proc_name
subroutine itt_proc_rename(addr, objname) bind(C)
import
integer(kind=itt_ptr), intent(in), value :: addr
character(kind=C_CHAR), dimension(*), intent(in) :: objname
end subroutine itt_proc_rename
subroutine itt_proc_heapmask(heapmask) bind(C)
import
integer, intent(in), value :: heapmask
end subroutine itt_proc_heapmask
end interface
type(C_FUNPTR) :: itt_pause_fort_ptr
!DEC$ ATTRIBUTES C, EXTERN, ALIAS:'__itt_pause_ptr__3_0' :: itt_pause_fort_ptr
type(C_FUNPTR) :: itt_resume_fort_ptr
!DEC$ ATTRIBUTES C, EXTERN, ALIAS:'__itt_resume_ptr__3_0' :: itt_resume_fort_ptr
type(C_FUNPTR) :: itt_thread_ignore_fort_ptr
!DEC$ ATTRIBUTES C, EXTERN, ALIAS:'__itt_thread_ignore_ptr__3_0' :: itt_thread_ignore_fort_ptr
type(C_FUNPTR) :: itt_suppress_push_fort_ptr
!DEC$ ATTRIBUTES C, EXTERN, ALIAS:'__itt_suppress_push_ptr__3_0' :: itt_suppress_push_fort_ptr
type(C_FUNPTR) :: itt_suppress_pop_fort_ptr
!DEC$ ATTRIBUTES C, EXTERN, ALIAS:'__itt_suppress_pop_ptr__3_0' :: itt_suppress_pop_fort_ptr
type(C_FUNPTR) :: itt_suppress_mark_range_fort_ptr
!DEC$ ATTRIBUTES C, EXTERN, ALIAS:'__itt_suppress_mark_range_ptr__3_0' :: itt_suppress_mark_range_fort_ptr
type(C_FUNPTR) :: itt_suppress_clear_range_fort_ptr
!DEC$ ATTRIBUTES C, EXTERN, ALIAS:'__itt_suppress_clear_range_ptr__3_0' :: itt_suppress_clear_range_fort_ptr
type(C_FUNPTR) :: itt_sync_prepare_fort_ptr
!DEC$ ATTRIBUTES C, EXTERN, ALIAS:'__itt_sync_prepare_ptr__3_0' :: itt_sync_prepare_fort_ptr
type(C_FUNPTR) :: itt_sync_cancel_fort_ptr
!DEC$ ATTRIBUTES C, EXTERN, ALIAS:'__itt_sync_cancel_ptr__3_0' :: itt_sync_cancel_fort_ptr
type(C_FUNPTR) :: itt_sync_acquired_fort_ptr
!DEC$ ATTRIBUTES C, EXTERN, ALIAS:'__itt_sync_acquired_ptr__3_0' :: itt_sync_acquired_fort_ptr
type(C_FUNPTR) :: itt_sync_releasing_fort_ptr
!DEC$ ATTRIBUTES C, EXTERN, ALIAS:'__itt_sync_releasing_ptr__3_0' :: itt_sync_releasing_fort_ptr
type(C_FUNPTR) :: itt_fsync_prepare_fort_ptr
!DEC$ ATTRIBUTES C, EXTERN, ALIAS:'__itt_fsync_prepare_ptr__3_0' :: itt_fsync_prepare_fort_ptr
type(C_FUNPTR) :: itt_fsync_cancel_fort_ptr
!DEC$ ATTRIBUTES C, EXTERN, ALIAS:'__itt_fsync_cancel_ptr__3_0' :: itt_fsync_cancel_fort_ptr
type(C_FUNPTR) :: itt_fsync_acquired_fort_ptr
!DEC$ ATTRIBUTES C, EXTERN, ALIAS:'__itt_fsync_acquired_ptr__3_0' :: itt_fsync_acquired_fort_ptr
type(C_FUNPTR) :: itt_fsync_releasing_fort_ptr
!DEC$ ATTRIBUTES C, EXTERN, ALIAS:'__itt_fsync_releasing_ptr__3_0' :: itt_fsync_releasing_fort_ptr
type(C_FUNPTR) :: itt_sync_destroy_fort_ptr
!DEC$ ATTRIBUTES C, EXTERN, ALIAS:'__itt_sync_destroy_ptr__3_0' :: itt_sync_destroy_fort_ptr
type(C_FUNPTR) :: itt_sync_create_fort_ptr
!DEC$ ATTRIBUTES C, EXTERN, ALIAS:'__itt_sync_create_ptr__3_0' :: itt_sync_create_fort_ptr
type(C_FUNPTR) :: itt_sync_rename_fort_ptr
!DEC$ ATTRIBUTES C, EXTERN, ALIAS:'__itt_sync_rename_ptr__3_0' :: itt_sync_rename_fort_ptr
type(C_FUNPTR) :: itt_thread_set_name_fort_ptr
!DEC$ ATTRIBUTES C, EXTERN, ALIAS:'__itt_thread_set_name_ptr__3_0' :: itt_thread_set_name_fort_ptr
type(C_FUNPTR) :: itt_heap_record_memory_growth_begin_fort_ptr
!DEC$ ATTRIBUTES C, EXTERN, ALIAS:'__itt_heap_record_memory_growth_begin_ptr__3_0' :: itt_heap_record_memory_growth_begin_fort_ptr
type(C_FUNPTR) :: itt_heap_record_memory_growth_end_fort_ptr
!DEC$ ATTRIBUTES C, EXTERN, ALIAS:'__itt_heap_record_memory_growth_end_ptr__3_0' :: itt_heap_record_memory_growth_end_fort_ptr
type(C_FUNPTR) :: itt_heap_reset_detection_fort_ptr
!DEC$ ATTRIBUTES C, EXTERN, ALIAS:'__itt_heap_reset_detection_ptr__3_0' :: itt_heap_reset_detection_fort_ptr
type(C_FUNPTR) :: itt_heap_record_fort_ptr
!DEC$ ATTRIBUTES C, EXTERN, ALIAS:'__itt_heap_record_ptr__3_0' :: itt_heap_record_fort_ptr
contains
subroutine itt_pause()
procedure(itt_proc_none), pointer :: pause_ptr
!DEC$ ATTRIBUTES DEFAULT :: itt_pause
if (C_ASSOCIATED(itt_pause_fort_ptr)) then
call C_F_PROCPOINTER(itt_pause_fort_ptr, pause_ptr)
call pause_ptr()
end if
end subroutine itt_pause
subroutine itt_resume()
procedure(itt_proc_none), pointer :: resume_ptr
!DEC$ ATTRIBUTES DEFAULT :: itt_resume
if (C_ASSOCIATED(itt_resume_fort_ptr)) then
call C_F_PROCPOINTER(itt_resume_fort_ptr, resume_ptr)
call resume_ptr()
end if
end subroutine itt_resume
subroutine itt_thread_ignore()
procedure(itt_proc_none), pointer :: thread_ignore_ptr
!DEC$ ATTRIBUTES DEFAULT :: itt_thread_ignore
if (C_ASSOCIATED(itt_thread_ignore_fort_ptr)) then
call C_F_PROCPOINTER(itt_thread_ignore_fort_ptr, thread_ignore_ptr)
call thread_ignore_ptr()
end if
end subroutine itt_thread_ignore
subroutine itt_suppress_push(mask)
procedure(itt_proc_sup_push), pointer :: suppress_push_ptr
!DEC$ ATTRIBUTES DEFAULT :: itt_suppress_push
integer, intent(in), value :: mask
if (C_ASSOCIATED(itt_suppress_push_fort_ptr)) then
call C_F_PROCPOINTER(itt_suppress_push_fort_ptr, suppress_push_ptr)
call suppress_push_ptr(mask)
end if
end subroutine itt_suppress_push
subroutine itt_suppress_pop()
procedure(itt_proc_none), pointer :: suppress_pop_ptr
!DEC$ ATTRIBUTES DEFAULT :: itt_suppress_pop
if (C_ASSOCIATED(itt_suppress_pop_fort_ptr)) then
call C_F_PROCPOINTER(itt_suppress_pop_fort_ptr, suppress_pop_ptr)
call suppress_pop_ptr()
end if
end subroutine itt_suppress_pop
subroutine itt_suppress_mark_range(action, mask, addr, size)
procedure(itt_proc_sup_range), pointer :: suppress_mark_range_ptr
!DEC$ ATTRIBUTES DEFAULT :: itt_suppress_mark_range
integer, intent(in), value :: action
integer, intent(in), value :: mask
integer(kind=itt_ptr), intent(in), value :: addr
integer(kind=itt_ptr), intent(in), value :: size
if (C_ASSOCIATED(itt_suppress_mark_range_fort_ptr)) then
call C_F_PROCPOINTER(itt_suppress_mark_range_fort_ptr, suppress_mark_range_ptr)
call suppress_mark_range_ptr(action, mask, addr, size)
end if
end subroutine itt_suppress_mark_range
subroutine itt_suppress_clear_range(action, mask, addr, size)
procedure(itt_proc_sup_range), pointer :: suppress_clear_range_ptr
!DEC$ ATTRIBUTES DEFAULT :: itt_suppress_clear_range
integer, intent(in), value :: action
integer, intent(in), value :: mask
integer(kind=itt_ptr), intent(in), value :: addr
integer(kind=itt_ptr), intent(in), value :: size
if (C_ASSOCIATED(itt_suppress_clear_range_fort_ptr)) then
call C_F_PROCPOINTER(itt_suppress_clear_range_fort_ptr, suppress_clear_range_ptr)
call suppress_clear_range_ptr(action, mask, addr, size)
end if
end subroutine itt_suppress_clear_range
subroutine itt_sync_prepare(addr)
procedure(itt_proc_address), pointer :: sync_prepare_ptr
!DEC$ ATTRIBUTES DEFAULT :: itt_sync_prepare
integer(kind=itt_ptr), intent(in), value :: addr
if (C_ASSOCIATED(itt_sync_prepare_fort_ptr)) then
call C_F_PROCPOINTER(itt_sync_prepare_fort_ptr, sync_prepare_ptr)
call sync_prepare_ptr(addr)
end if
end subroutine itt_sync_prepare
subroutine itt_sync_cancel(addr)
procedure(itt_proc_address), pointer :: sync_cancel_ptr
!DEC$ ATTRIBUTES DEFAULT :: itt_sync_cancel
integer(kind=itt_ptr), intent(in), value :: addr
if (C_ASSOCIATED(itt_sync_cancel_fort_ptr)) then
call C_F_PROCPOINTER(itt_sync_cancel_fort_ptr, sync_cancel_ptr)
call sync_cancel_ptr(addr)
end if
end subroutine itt_sync_cancel
subroutine itt_sync_acquired(addr)
procedure(itt_proc_address), pointer :: sync_acquired_ptr
!DEC$ ATTRIBUTES DEFAULT :: itt_sync_acquired
integer(kind=itt_ptr), intent(in), value :: addr
if (C_ASSOCIATED(itt_sync_acquired_fort_ptr)) then
call C_F_PROCPOINTER(itt_sync_acquired_fort_ptr, sync_acquired_ptr)
call sync_acquired_ptr(addr)
end if
end subroutine itt_sync_acquired
subroutine itt_sync_releasing(addr)
procedure(itt_proc_address), pointer :: sync_releasing_ptr
!DEC$ ATTRIBUTES DEFAULT :: itt_sync_releasing
integer(kind=itt_ptr), intent(in), value :: addr
if (C_ASSOCIATED(itt_sync_releasing_fort_ptr)) then
call C_F_PROCPOINTER(itt_sync_releasing_fort_ptr, sync_releasing_ptr)
call sync_releasing_ptr(addr)
end if
end subroutine itt_sync_releasing
subroutine itt_fsync_prepare(addr)
procedure(itt_proc_address), pointer :: fsync_prepare_ptr
!DEC$ ATTRIBUTES DEFAULT :: itt_fsync_prepare
integer(kind=itt_ptr), intent(in), value :: addr
if (C_ASSOCIATED(itt_fsync_prepare_fort_ptr)) then
call C_F_PROCPOINTER(itt_fsync_prepare_fort_ptr, fsync_prepare_ptr)
call fsync_prepare_ptr(addr)
end if
end subroutine itt_fsync_prepare
subroutine itt_fsync_cancel(addr)
procedure(itt_proc_address), pointer :: fsync_cancel_ptr
!DEC$ ATTRIBUTES DEFAULT :: itt_fsync_cancel
integer(kind=itt_ptr), intent(in), value :: addr
if (C_ASSOCIATED(itt_fsync_cancel_fort_ptr)) then
call C_F_PROCPOINTER(itt_fsync_cancel_fort_ptr, fsync_cancel_ptr)
call fsync_cancel_ptr(addr)
end if
end subroutine itt_fsync_cancel
subroutine itt_fsync_acquired(addr)
procedure(itt_proc_address), pointer :: fsync_acquired_ptr
!DEC$ ATTRIBUTES DEFAULT :: itt_fsync_acquired
integer(kind=itt_ptr), intent(in), value :: addr
if (C_ASSOCIATED(itt_fsync_acquired_fort_ptr)) then
call C_F_PROCPOINTER(itt_fsync_acquired_fort_ptr, fsync_acquired_ptr)
call fsync_acquired_ptr(addr)
end if
end subroutine itt_fsync_acquired
subroutine itt_fsync_releasing(addr)
procedure(itt_proc_address), pointer :: fsync_releasing_ptr
!DEC$ ATTRIBUTES DEFAULT :: itt_fsync_releasing
integer(kind=itt_ptr), intent(in), value :: addr
if (C_ASSOCIATED(itt_fsync_releasing_fort_ptr)) then
call C_F_PROCPOINTER(itt_fsync_releasing_fort_ptr, fsync_releasing_ptr)
call fsync_releasing_ptr(addr)
end if
end subroutine itt_fsync_releasing
subroutine itt_sync_destroy(addr)
procedure(itt_proc_address), pointer :: sync_destroy_ptr
!DEC$ ATTRIBUTES DEFAULT :: itt_sync_destroy
integer(kind=itt_ptr), intent(in), value :: addr
if (C_ASSOCIATED(itt_sync_destroy_fort_ptr)) then
call C_F_PROCPOINTER(itt_sync_destroy_fort_ptr, sync_destroy_ptr)
call sync_destroy_ptr(addr)
end if
end subroutine itt_sync_destroy
subroutine itt_sync_create(addr, objname, attribute)
procedure(itt_proc_create), pointer :: sync_create_ptr
!DEC$ ATTRIBUTES DEFAULT :: itt_sync_create
integer(kind=itt_ptr), intent(in), value :: addr
character(len=*), intent(in) :: objname
integer, intent(in), value :: attribute
CHARACTER(LEN=1,KIND=C_CHAR) :: objnametmp(LEN_TRIM(objname)+1)
INTEGER :: iobjname, nobjname
if (C_ASSOCIATED(itt_sync_create_fort_ptr)) then
nobjname = LEN_TRIM(objname)
DO iobjname = 1, nobjname
objnametmp(iobjname) = objname(iobjname:iobjname)
END DO
objnametmp(nobjname + 1) = C_NULL_CHAR
call C_F_PROCPOINTER(itt_sync_create_fort_ptr, sync_create_ptr)
call sync_create_ptr(addr, objnametmp, attribute)
end if
end subroutine itt_sync_create
subroutine itt_sync_rename(addr, objname)
procedure(itt_proc_rename), pointer :: sync_rename_ptr
!DEC$ ATTRIBUTES DEFAULT :: itt_sync_rename
integer(kind=itt_ptr), intent(in), value :: addr
character(len=*), intent(in) :: objname
CHARACTER(LEN=1,KIND=C_CHAR) :: objnametmp(LEN_TRIM(objname)+1)
INTEGER :: iobjname, nobjname
if (C_ASSOCIATED(itt_sync_rename_fort_ptr)) then
nobjname = LEN_TRIM(objname)
DO iobjname = 1, nobjname
objnametmp(iobjname) = objname(iobjname:iobjname)
END DO
objnametmp(nobjname + 1) = C_NULL_CHAR
call C_F_PROCPOINTER(itt_sync_rename_fort_ptr, sync_rename_ptr)
call sync_rename_ptr(addr, objnametmp)
end if
end subroutine itt_sync_rename
subroutine itt_thread_set_name(name)
procedure(itt_proc_name), pointer :: thread_set_name_ptr
!DEC$ ATTRIBUTES DEFAULT :: itt_thread_set_name
character(len=*), intent(in) :: name
CHARACTER(LEN=1,KIND=C_CHAR) :: nametmp(LEN_TRIM(name)+1)
INTEGER :: iname, nname
if (C_ASSOCIATED(itt_thread_set_name_fort_ptr)) then
nname = LEN_TRIM(name)
DO iname = 1, nname
nametmp(iname) = name(iname:iname)
END DO
nametmp(nname + 1) = C_NULL_CHAR
call C_F_PROCPOINTER(itt_thread_set_name_fort_ptr, thread_set_name_ptr)
call thread_set_name_ptr(nametmp)
end if
end subroutine itt_thread_set_name
subroutine itt_heap_record_memory_growth_begin()
procedure(itt_proc_none), pointer :: heap_record_memory_growth_begin_ptr
!DEC$ ATTRIBUTES DEFAULT :: itt_heap_record_memory_growth_begin
if (C_ASSOCIATED(itt_heap_record_memory_growth_begin_fort_ptr)) then
call C_F_PROCPOINTER(itt_heap_record_memory_growth_begin_fort_ptr, heap_record_memory_growth_begin_ptr)
call heap_record_memory_growth_begin_ptr()
end if
end subroutine itt_heap_record_memory_growth_begin
subroutine itt_heap_record_memory_growth_end()
procedure(itt_proc_none), pointer :: heap_record_memory_growth_end_ptr
!DEC$ ATTRIBUTES DEFAULT :: itt_heap_record_memory_growth_end
if (C_ASSOCIATED(itt_heap_record_memory_growth_end_fort_ptr)) then
call C_F_PROCPOINTER(itt_heap_record_memory_growth_end_fort_ptr, heap_record_memory_growth_end_ptr)
call heap_record_memory_growth_end_ptr()
end if
end subroutine itt_heap_record_memory_growth_end
subroutine itt_heap_reset_detection(heapmask)
procedure(itt_proc_heapmask), pointer :: heap_reset_detection_ptr
!DEC$ ATTRIBUTES DEFAULT :: itt_heap_reset_detection
integer, intent(in), value :: heapmask
if (C_ASSOCIATED(itt_heap_reset_detection_fort_ptr)) then
call C_F_PROCPOINTER(itt_heap_reset_detection_fort_ptr, heap_reset_detection_ptr)
call heap_reset_detection_ptr(heapmask)
end if
end subroutine itt_heap_reset_detection
subroutine itt_heap_record(heapmask)
procedure(itt_proc_heapmask), pointer :: heap_record_ptr
!DEC$ ATTRIBUTES DEFAULT :: itt_heap_record
integer, intent(in), value :: heapmask
if (C_ASSOCIATED(itt_heap_record_fort_ptr)) then
call C_F_PROCPOINTER(itt_heap_record_fort_ptr, heap_record_ptr)
call heap_record_ptr(heapmask)
end if
end subroutine itt_heap_record
end module ittnotify

522
deps/v8/third_party/ittapi/include/fortran/win32/ittnotify.f90 vendored Normal file
View File

@ -0,0 +1,522 @@
! ========================================================================
! <copyright>
! This file is provided under a dual BSD/GPLv2 license. When using or
! redistributing this file, you may do so under either license.
!
! GPL LICENSE SUMMARY
!
! Copyright (c) 2005-2017 Intel Corporation. All rights reserved.
!
! This program is free software; you can redistribute it and/or modify
! it under the terms of version 2 of the GNU General Public License as
! published by the Free Software Foundation.
!
! This program is distributed in the hope that it will be useful, but
! WITHOUT ANY WARRANTY; without even the implied warranty of
! MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
! General Public License for more details.
!
! You should have received a copy of the GNU General Public License
! along with this program; if not, write to the Free Software
! Foundation, Inc., 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
! The full GNU General Public License is included in this distribution
! in the file called LICENSE.GPL.
!
! Contact Information:
! http://software.intel.com/en-us/articles/intel-vtune-amplifier-xe/
!
! BSD LICENSE
!
! Copyright (c) 2005-2017 Intel Corporation. All rights reserved.
! All rights reserved.
!
! Redistribution and use in source and binary forms, with or without
! modification, are permitted provided that the following conditions
! are met:
!
! * Redistributions of source code must retain the above copyright
! notice, this list of conditions and the following disclaimer.
! * 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.
! * Neither the name of Intel Corporation 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
! OWNER 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.
! </copyright>
! ========================================================================
!
!--------
!
! This file defines functions used by Intel(R) Parallel Inspector and
! Amplifier.
!
! Version of ittnotify that was used to generate this file.
! This is not Fortran code that can be used to check but rather a comment
! that only serves to identify the interface.
! INTEL_ITT_FORTRAN_API_VERSION 3.0
!--------
module ittnotify
use, intrinsic :: iso_c_binding, only: C_PTR, C_FUNPTR, C_INT, C_CHAR, C_NULL_CHAR, C_F_PROCPOINTER, C_LOC, C_ASSOCIATED
implicit none
!--------
!
! Public interface
!
!--------
integer, parameter :: itt_ptr = int_ptr_kind()
public :: itt_pause
public :: itt_resume
public :: itt_thread_ignore
public :: itt_suppress_push
public :: itt_suppress_pop
public :: itt_suppress_mark_range
public :: itt_suppress_clear_range
public :: itt_sync_prepare
public :: itt_sync_cancel
public :: itt_sync_acquired
public :: itt_sync_releasing
public :: itt_fsync_prepare
public :: itt_fsync_cancel
public :: itt_fsync_acquired
public :: itt_fsync_releasing
public :: itt_sync_destroy
public :: itt_sync_create
public :: itt_sync_rename
public :: itt_thread_set_name
public :: itt_heap_record_memory_growth_begin
public :: itt_heap_record_memory_growth_end
public :: itt_heap_reset_detection
public :: itt_heap_record
integer, parameter, public :: itt_attr_barrier = 1
integer, parameter, public :: itt_attr_mutex = 2
integer, parameter, public :: itt_suppress_threading_errors = 255
integer, parameter, public :: itt_suppress_memory_errors = 65280
integer, parameter, public :: itt_suppress_all_errors = 2147483647
integer, parameter, public :: itt_unsuppress_range = 0
integer, parameter, public :: itt_suppress_range = 1
integer, parameter, public :: itt_heap_leaks = 1
integer, parameter, public :: itt_heap_growth = 2
private
abstract interface
subroutine itt_proc_none() bind(C)
import
end subroutine itt_proc_none
subroutine itt_proc_sup_push(mask) bind(C)
import
integer, intent(in), value :: mask
end subroutine itt_proc_sup_push
subroutine itt_proc_sup_range(action, mask, addr, size) bind(C)
import
integer, intent(in), value :: action
integer, intent(in), value :: mask
integer(kind=itt_ptr), intent(in), value :: addr
integer(kind=itt_ptr), intent(in), value :: size
end subroutine itt_proc_sup_range
subroutine itt_proc_address(addr) bind(C)
import
integer(kind=itt_ptr), intent(in), value :: addr
end subroutine itt_proc_address
subroutine itt_proc_create(addr, objname, attribute) bind(C)
import
integer(kind=itt_ptr), intent(in), value :: addr
character(kind=C_CHAR), dimension(*), intent(in) :: objname
integer, intent(in), value :: attribute
end subroutine itt_proc_create
subroutine itt_proc_name(name) bind(C)
import
character(kind=C_CHAR), dimension(*), intent(in) :: name
end subroutine itt_proc_name
subroutine itt_proc_rename(addr, objname) bind(C)
import
integer(kind=itt_ptr), intent(in), value :: addr
character(kind=C_CHAR), dimension(*), intent(in) :: objname
end subroutine itt_proc_rename
subroutine itt_proc_heapmask(heapmask) bind(C)
import
integer, intent(in), value :: heapmask
end subroutine itt_proc_heapmask
end interface
!DEC$IF DEFINED(intel64)
type(C_FUNPTR) :: itt_pause_fort_ptr
!DEC$ ATTRIBUTES C, EXTERN, ALIAS:'__itt_pause_ptr__3_0' :: itt_pause_fort_ptr
type(C_FUNPTR) :: itt_resume_fort_ptr
!DEC$ ATTRIBUTES C, EXTERN, ALIAS:'__itt_resume_ptr__3_0' :: itt_resume_fort_ptr
type(C_FUNPTR) :: itt_thread_ignore_fort_ptr
!DEC$ ATTRIBUTES C, EXTERN, ALIAS:'__itt_thread_ignore_ptr__3_0' :: itt_thread_ignore_fort_ptr
type(C_FUNPTR) :: itt_suppress_push_fort_ptr
!DEC$ ATTRIBUTES C, EXTERN, ALIAS:'__itt_suppress_push_ptr__3_0' :: itt_suppress_push_fort_ptr
type(C_FUNPTR) :: itt_suppress_pop_fort_ptr
!DEC$ ATTRIBUTES C, EXTERN, ALIAS:'__itt_suppress_pop_ptr__3_0' :: itt_suppress_pop_fort_ptr
type(C_FUNPTR) :: itt_suppress_mark_range_fort_ptr
!DEC$ ATTRIBUTES C, EXTERN, ALIAS:'__itt_suppress_mark_range_ptr__3_0' :: itt_suppress_mark_range_fort_ptr
type(C_FUNPTR) :: itt_suppress_clear_range_fort_ptr
!DEC$ ATTRIBUTES C, EXTERN, ALIAS:'__itt_suppress_clear_range_ptr__3_0' :: itt_suppress_clear_range_fort_ptr
type(C_FUNPTR) :: itt_sync_prepare_fort_ptr
!DEC$ ATTRIBUTES C, EXTERN, ALIAS:'__itt_sync_prepare_ptr__3_0' :: itt_sync_prepare_fort_ptr
type(C_FUNPTR) :: itt_sync_cancel_fort_ptr
!DEC$ ATTRIBUTES C, EXTERN, ALIAS:'__itt_sync_cancel_ptr__3_0' :: itt_sync_cancel_fort_ptr
type(C_FUNPTR) :: itt_sync_acquired_fort_ptr
!DEC$ ATTRIBUTES C, EXTERN, ALIAS:'__itt_sync_acquired_ptr__3_0' :: itt_sync_acquired_fort_ptr
type(C_FUNPTR) :: itt_sync_releasing_fort_ptr
!DEC$ ATTRIBUTES C, EXTERN, ALIAS:'__itt_sync_releasing_ptr__3_0' :: itt_sync_releasing_fort_ptr
type(C_FUNPTR) :: itt_fsync_prepare_fort_ptr
!DEC$ ATTRIBUTES C, EXTERN, ALIAS:'__itt_fsync_prepare_ptr__3_0' :: itt_fsync_prepare_fort_ptr
type(C_FUNPTR) :: itt_fsync_cancel_fort_ptr
!DEC$ ATTRIBUTES C, EXTERN, ALIAS:'__itt_fsync_cancel_ptr__3_0' :: itt_fsync_cancel_fort_ptr
type(C_FUNPTR) :: itt_fsync_acquired_fort_ptr
!DEC$ ATTRIBUTES C, EXTERN, ALIAS:'__itt_fsync_acquired_ptr__3_0' :: itt_fsync_acquired_fort_ptr
type(C_FUNPTR) :: itt_fsync_releasing_fort_ptr
!DEC$ ATTRIBUTES C, EXTERN, ALIAS:'__itt_fsync_releasing_ptr__3_0' :: itt_fsync_releasing_fort_ptr
type(C_FUNPTR) :: itt_sync_destroy_fort_ptr
!DEC$ ATTRIBUTES C, EXTERN, ALIAS:'__itt_sync_destroy_ptr__3_0' :: itt_sync_destroy_fort_ptr
type(C_FUNPTR) :: itt_sync_create_fort_ptr
!DEC$ ATTRIBUTES C, EXTERN, ALIAS:'__itt_sync_createA_ptr__3_0' :: itt_sync_create_fort_ptr
type(C_FUNPTR) :: itt_sync_rename_fort_ptr
!DEC$ ATTRIBUTES C, EXTERN, ALIAS:'__itt_sync_renameA_ptr__3_0' :: itt_sync_rename_fort_ptr
type(C_FUNPTR) :: itt_thread_set_name_fort_ptr
!DEC$ ATTRIBUTES C, EXTERN, ALIAS:'__itt_thread_set_nameA_ptr__3_0' :: itt_thread_set_name_fort_ptr
type(C_FUNPTR) :: itt_heap_record_memory_growth_begin_fort_ptr
!DEC$ ATTRIBUTES C, EXTERN, ALIAS:'__itt_heap_record_memory_growth_begin_ptr__3_0' :: itt_heap_record_memory_growth_begin_fort_ptr
type(C_FUNPTR) :: itt_heap_record_memory_growth_end_fort_ptr
!DEC$ ATTRIBUTES C, EXTERN, ALIAS:'__itt_heap_record_memory_growth_end_ptr__3_0' :: itt_heap_record_memory_growth_end_fort_ptr
type(C_FUNPTR) :: itt_heap_reset_detection_fort_ptr
!DEC$ ATTRIBUTES C, EXTERN, ALIAS:'__itt_heap_reset_detection_ptr__3_0' :: itt_heap_reset_detection_fort_ptr
type(C_FUNPTR) :: itt_heap_record_fort_ptr
!DEC$ ATTRIBUTES C, EXTERN, ALIAS:'__itt_heap_record_ptr__3_0' :: itt_heap_record_fort_ptr
!DEC$ELSE
type(C_FUNPTR) :: itt_pause_fort_ptr
!DEC$ ATTRIBUTES C, EXTERN, ALIAS:'___itt_pause_ptr__3_0' :: itt_pause_fort_ptr
type(C_FUNPTR) :: itt_resume_fort_ptr
!DEC$ ATTRIBUTES C, EXTERN, ALIAS:'___itt_resume_ptr__3_0' :: itt_resume_fort_ptr
type(C_FUNPTR) :: itt_thread_ignore_fort_ptr
!DEC$ ATTRIBUTES C, EXTERN, ALIAS:'___itt_thread_ignore_ptr__3_0' :: itt_thread_ignore_fort_ptr
type(C_FUNPTR) :: itt_suppress_push_fort_ptr
!DEC$ ATTRIBUTES C, EXTERN, ALIAS:'___itt_suppress_push_ptr__3_0' :: itt_suppress_push_fort_ptr
type(C_FUNPTR) :: itt_suppress_pop_fort_ptr
!DEC$ ATTRIBUTES C, EXTERN, ALIAS:'___itt_suppress_pop_ptr__3_0' :: itt_suppress_pop_fort_ptr
type(C_FUNPTR) :: itt_suppress_mark_range_fort_ptr
!DEC$ ATTRIBUTES C, EXTERN, ALIAS:'___itt_suppress_mark_range_ptr__3_0' :: itt_suppress_mark_range_fort_ptr
type(C_FUNPTR) :: itt_suppress_clear_range_fort_ptr
!DEC$ ATTRIBUTES C, EXTERN, ALIAS:'___itt_suppress_clear_range_ptr__3_0' :: itt_suppress_clear_range_fort_ptr
type(C_FUNPTR) :: itt_sync_prepare_fort_ptr
!DEC$ ATTRIBUTES C, EXTERN, ALIAS:'___itt_sync_prepare_ptr__3_0' :: itt_sync_prepare_fort_ptr
type(C_FUNPTR) :: itt_sync_cancel_fort_ptr
!DEC$ ATTRIBUTES C, EXTERN, ALIAS:'___itt_sync_cancel_ptr__3_0' :: itt_sync_cancel_fort_ptr
type(C_FUNPTR) :: itt_sync_acquired_fort_ptr
!DEC$ ATTRIBUTES C, EXTERN, ALIAS:'___itt_sync_acquired_ptr__3_0' :: itt_sync_acquired_fort_ptr
type(C_FUNPTR) :: itt_sync_releasing_fort_ptr
!DEC$ ATTRIBUTES C, EXTERN, ALIAS:'___itt_sync_releasing_ptr__3_0' :: itt_sync_releasing_fort_ptr
type(C_FUNPTR) :: itt_fsync_prepare_fort_ptr
!DEC$ ATTRIBUTES C, EXTERN, ALIAS:'___itt_fsync_prepare_ptr__3_0' :: itt_fsync_prepare_fort_ptr
type(C_FUNPTR) :: itt_fsync_cancel_fort_ptr
!DEC$ ATTRIBUTES C, EXTERN, ALIAS:'___itt_fsync_cancel_ptr__3_0' :: itt_fsync_cancel_fort_ptr
type(C_FUNPTR) :: itt_fsync_acquired_fort_ptr
!DEC$ ATTRIBUTES C, EXTERN, ALIAS:'___itt_fsync_acquired_ptr__3_0' :: itt_fsync_acquired_fort_ptr
type(C_FUNPTR) :: itt_fsync_releasing_fort_ptr
!DEC$ ATTRIBUTES C, EXTERN, ALIAS:'___itt_fsync_releasing_ptr__3_0' :: itt_fsync_releasing_fort_ptr
type(C_FUNPTR) :: itt_sync_destroy_fort_ptr
!DEC$ ATTRIBUTES C, EXTERN, ALIAS:'___itt_sync_destroy_ptr__3_0' :: itt_sync_destroy_fort_ptr
type(C_FUNPTR) :: itt_sync_create_fort_ptr
!DEC$ ATTRIBUTES C, EXTERN, ALIAS:'___itt_sync_createA_ptr__3_0' :: itt_sync_create_fort_ptr
type(C_FUNPTR) :: itt_sync_rename_fort_ptr
!DEC$ ATTRIBUTES C, EXTERN, ALIAS:'___itt_sync_renameA_ptr__3_0' :: itt_sync_rename_fort_ptr
type(C_FUNPTR) :: itt_thread_set_name_fort_ptr
!DEC$ ATTRIBUTES C, EXTERN, ALIAS:'___itt_thread_set_nameA_ptr__3_0' :: itt_thread_set_name_fort_ptr
type(C_FUNPTR) :: itt_heap_record_memory_growth_begin_fort_ptr
!DEC$ ATTRIBUTES C, EXTERN, ALIAS:'___itt_heap_record_memory_growth_begin_ptr__3_0' :: itt_heap_record_memory_growth_begin_fort_ptr
type(C_FUNPTR) :: itt_heap_record_memory_growth_end_fort_ptr
!DEC$ ATTRIBUTES C, EXTERN, ALIAS:'___itt_heap_record_memory_growth_end_ptr__3_0' :: itt_heap_record_memory_growth_end_fort_ptr
type(C_FUNPTR) :: itt_heap_reset_detection_fort_ptr
!DEC$ ATTRIBUTES C, EXTERN, ALIAS:'___itt_heap_reset_detection_ptr__3_0' :: itt_heap_reset_detection_fort_ptr
type(C_FUNPTR) :: itt_heap_record_fort_ptr
!DEC$ ATTRIBUTES C, EXTERN, ALIAS:'___itt_heap_record_ptr__3_0' :: itt_heap_record_fort_ptr
!DEC$ENDIF
contains
subroutine itt_pause()
procedure(itt_proc_none), pointer :: pause_ptr
!DEC$ ATTRIBUTES DEFAULT :: itt_pause
if (C_ASSOCIATED(itt_pause_fort_ptr)) then
call C_F_PROCPOINTER(itt_pause_fort_ptr, pause_ptr)
call pause_ptr()
end if
end subroutine itt_pause
subroutine itt_resume()
procedure(itt_proc_none), pointer :: resume_ptr
!DEC$ ATTRIBUTES DEFAULT :: itt_resume
if (C_ASSOCIATED(itt_resume_fort_ptr)) then
call C_F_PROCPOINTER(itt_resume_fort_ptr, resume_ptr)
call resume_ptr()
end if
end subroutine itt_resume
subroutine itt_thread_ignore()
procedure(itt_proc_none), pointer :: thread_ignore_ptr
!DEC$ ATTRIBUTES DEFAULT :: itt_thread_ignore
if (C_ASSOCIATED(itt_thread_ignore_fort_ptr)) then
call C_F_PROCPOINTER(itt_thread_ignore_fort_ptr, thread_ignore_ptr)
call thread_ignore_ptr()
end if
end subroutine itt_thread_ignore
subroutine itt_suppress_push(mask)
procedure(itt_proc_sup_push), pointer :: suppress_push_ptr
!DEC$ ATTRIBUTES DEFAULT :: itt_suppress_push
integer, intent(in), value :: mask
if (C_ASSOCIATED(itt_suppress_push_fort_ptr)) then
call C_F_PROCPOINTER(itt_suppress_push_fort_ptr, suppress_push_ptr)
call suppress_push_ptr(mask)
end if
end subroutine itt_suppress_push
subroutine itt_suppress_pop()
procedure(itt_proc_none), pointer :: suppress_pop_ptr
!DEC$ ATTRIBUTES DEFAULT :: itt_suppress_pop
if (C_ASSOCIATED(itt_suppress_pop_fort_ptr)) then
call C_F_PROCPOINTER(itt_suppress_pop_fort_ptr, suppress_pop_ptr)
call suppress_pop_ptr()
end if
end subroutine itt_suppress_pop
subroutine itt_suppress_mark_range(action, mask, addr, size)
procedure(itt_proc_sup_range), pointer :: suppress_mark_range_ptr
!DEC$ ATTRIBUTES DEFAULT :: itt_suppress_mark_range
integer, intent(in), value :: action
integer, intent(in), value :: mask
integer(kind=itt_ptr), intent(in), value :: addr
integer(kind=itt_ptr), intent(in), value :: size
if (C_ASSOCIATED(itt_suppress_mark_range_fort_ptr)) then
call C_F_PROCPOINTER(itt_suppress_mark_range_fort_ptr, suppress_mark_range_ptr)
call suppress_mark_range_ptr(action, mask, addr, size)
end if
end subroutine itt_suppress_mark_range
subroutine itt_suppress_clear_range(action, mask, addr, size)
procedure(itt_proc_sup_range), pointer :: suppress_clear_range_ptr
!DEC$ ATTRIBUTES DEFAULT :: itt_suppress_clear_range
integer, intent(in), value :: action
integer, intent(in), value :: mask
integer(kind=itt_ptr), intent(in), value :: addr
integer(kind=itt_ptr), intent(in), value :: size
if (C_ASSOCIATED(itt_suppress_clear_range_fort_ptr)) then
call C_F_PROCPOINTER(itt_suppress_clear_range_fort_ptr, suppress_clear_range_ptr)
call suppress_clear_range_ptr(action, mask, addr, size)
end if
end subroutine itt_suppress_clear_range
subroutine itt_sync_prepare(addr)
procedure(itt_proc_address), pointer :: sync_prepare_ptr
!DEC$ ATTRIBUTES DEFAULT :: itt_sync_prepare
integer(kind=itt_ptr), intent(in), value :: addr
if (C_ASSOCIATED(itt_sync_prepare_fort_ptr)) then
call C_F_PROCPOINTER(itt_sync_prepare_fort_ptr, sync_prepare_ptr)
call sync_prepare_ptr(addr)
end if
end subroutine itt_sync_prepare
subroutine itt_sync_cancel(addr)
procedure(itt_proc_address), pointer :: sync_cancel_ptr
!DEC$ ATTRIBUTES DEFAULT :: itt_sync_cancel
integer(kind=itt_ptr), intent(in), value :: addr
if (C_ASSOCIATED(itt_sync_cancel_fort_ptr)) then
call C_F_PROCPOINTER(itt_sync_cancel_fort_ptr, sync_cancel_ptr)
call sync_cancel_ptr(addr)
end if
end subroutine itt_sync_cancel
subroutine itt_sync_acquired(addr)
procedure(itt_proc_address), pointer :: sync_acquired_ptr
!DEC$ ATTRIBUTES DEFAULT :: itt_sync_acquired
integer(kind=itt_ptr), intent(in), value :: addr
if (C_ASSOCIATED(itt_sync_acquired_fort_ptr)) then
call C_F_PROCPOINTER(itt_sync_acquired_fort_ptr, sync_acquired_ptr)
call sync_acquired_ptr(addr)
end if
end subroutine itt_sync_acquired
subroutine itt_sync_releasing(addr)
procedure(itt_proc_address), pointer :: sync_releasing_ptr
!DEC$ ATTRIBUTES DEFAULT :: itt_sync_releasing
integer(kind=itt_ptr), intent(in), value :: addr
if (C_ASSOCIATED(itt_sync_releasing_fort_ptr)) then
call C_F_PROCPOINTER(itt_sync_releasing_fort_ptr, sync_releasing_ptr)
call sync_releasing_ptr(addr)
end if
end subroutine itt_sync_releasing
subroutine itt_fsync_prepare(addr)
procedure(itt_proc_address), pointer :: fsync_prepare_ptr
!DEC$ ATTRIBUTES DEFAULT :: itt_fsync_prepare
integer(kind=itt_ptr), intent(in), value :: addr
if (C_ASSOCIATED(itt_fsync_prepare_fort_ptr)) then
call C_F_PROCPOINTER(itt_fsync_prepare_fort_ptr, fsync_prepare_ptr)
call fsync_prepare_ptr(addr)
end if
end subroutine itt_fsync_prepare
subroutine itt_fsync_cancel(addr)
procedure(itt_proc_address), pointer :: fsync_cancel_ptr
!DEC$ ATTRIBUTES DEFAULT :: itt_fsync_cancel
integer(kind=itt_ptr), intent(in), value :: addr
if (C_ASSOCIATED(itt_fsync_cancel_fort_ptr)) then
call C_F_PROCPOINTER(itt_fsync_cancel_fort_ptr, fsync_cancel_ptr)
call fsync_cancel_ptr(addr)
end if
end subroutine itt_fsync_cancel
subroutine itt_fsync_acquired(addr)
procedure(itt_proc_address), pointer :: fsync_acquired_ptr
!DEC$ ATTRIBUTES DEFAULT :: itt_fsync_acquired
integer(kind=itt_ptr), intent(in), value :: addr
if (C_ASSOCIATED(itt_fsync_acquired_fort_ptr)) then
call C_F_PROCPOINTER(itt_fsync_acquired_fort_ptr, fsync_acquired_ptr)
call fsync_acquired_ptr(addr)
end if
end subroutine itt_fsync_acquired
subroutine itt_fsync_releasing(addr)
procedure(itt_proc_address), pointer :: fsync_releasing_ptr
!DEC$ ATTRIBUTES DEFAULT :: itt_fsync_releasing
integer(kind=itt_ptr), intent(in), value :: addr
if (C_ASSOCIATED(itt_fsync_releasing_fort_ptr)) then
call C_F_PROCPOINTER(itt_fsync_releasing_fort_ptr, fsync_releasing_ptr)
call fsync_releasing_ptr(addr)
end if
end subroutine itt_fsync_releasing
subroutine itt_sync_destroy(addr)
procedure(itt_proc_address), pointer :: sync_destroy_ptr
!DEC$ ATTRIBUTES DEFAULT :: itt_sync_destroy
integer(kind=itt_ptr), intent(in), value :: addr
if (C_ASSOCIATED(itt_sync_destroy_fort_ptr)) then
call C_F_PROCPOINTER(itt_sync_destroy_fort_ptr, sync_destroy_ptr)
call sync_destroy_ptr(addr)
end if
end subroutine itt_sync_destroy
subroutine itt_sync_create(addr, objname, attribute)
procedure(itt_proc_create), pointer :: sync_create_ptr
!DEC$ ATTRIBUTES DEFAULT :: itt_sync_create
integer(kind=itt_ptr), intent(in), value :: addr
character(len=*), intent(in) :: objname
integer, intent(in), value :: attribute
CHARACTER(LEN=1,KIND=C_CHAR) :: objnametmp(LEN_TRIM(objname)+1)
INTEGER :: iobjname, nobjname
if (C_ASSOCIATED(itt_sync_create_fort_ptr)) then
nobjname = LEN_TRIM(objname)
DO iobjname = 1, nobjname
objnametmp(iobjname) = objname(iobjname:iobjname)
END DO
objnametmp(nobjname + 1) = C_NULL_CHAR
call C_F_PROCPOINTER(itt_sync_create_fort_ptr, sync_create_ptr)
call sync_create_ptr(addr, objnametmp, attribute)
end if
end subroutine itt_sync_create
subroutine itt_sync_rename(addr, objname)
procedure(itt_proc_rename), pointer :: sync_rename_ptr
!DEC$ ATTRIBUTES DEFAULT :: itt_sync_rename
integer(kind=itt_ptr), intent(in), value :: addr
character(len=*), intent(in) :: objname
CHARACTER(LEN=1,KIND=C_CHAR) :: objnametmp(LEN_TRIM(objname)+1)
INTEGER :: iobjname, nobjname
if (C_ASSOCIATED(itt_sync_rename_fort_ptr)) then
nobjname = LEN_TRIM(objname)
DO iobjname = 1, nobjname
objnametmp(iobjname) = objname(iobjname:iobjname)
END DO
objnametmp(nobjname + 1) = C_NULL_CHAR
call C_F_PROCPOINTER(itt_sync_rename_fort_ptr, sync_rename_ptr)
call sync_rename_ptr(addr, objnametmp)
end if
end subroutine itt_sync_rename
subroutine itt_thread_set_name(name)
procedure(itt_proc_name), pointer :: thread_set_name_ptr
!DEC$ ATTRIBUTES DEFAULT :: itt_thread_set_name
character(len=*), intent(in) :: name
CHARACTER(LEN=1,KIND=C_CHAR) :: nametmp(LEN_TRIM(name)+1)
INTEGER :: iname, nname
if (C_ASSOCIATED(itt_thread_set_name_fort_ptr)) then
nname = LEN_TRIM(name)
DO iname = 1, nname
nametmp(iname) = name(iname:iname)
END DO
nametmp(nname + 1) = C_NULL_CHAR
call C_F_PROCPOINTER(itt_thread_set_name_fort_ptr, thread_set_name_ptr)
call thread_set_name_ptr(nametmp)
end if
end subroutine itt_thread_set_name
subroutine itt_heap_record_memory_growth_begin()
procedure(itt_proc_none), pointer :: heap_record_memory_growth_begin_ptr
!DEC$ ATTRIBUTES DEFAULT :: itt_heap_record_memory_growth_begin
if (C_ASSOCIATED(itt_heap_record_memory_growth_begin_fort_ptr)) then
call C_F_PROCPOINTER(itt_heap_record_memory_growth_begin_fort_ptr, heap_record_memory_growth_begin_ptr)
call heap_record_memory_growth_begin_ptr()
end if
end subroutine itt_heap_record_memory_growth_begin
subroutine itt_heap_record_memory_growth_end()
procedure(itt_proc_none), pointer :: heap_record_memory_growth_end_ptr
!DEC$ ATTRIBUTES DEFAULT :: itt_heap_record_memory_growth_end
if (C_ASSOCIATED(itt_heap_record_memory_growth_end_fort_ptr)) then
call C_F_PROCPOINTER(itt_heap_record_memory_growth_end_fort_ptr, heap_record_memory_growth_end_ptr)
call heap_record_memory_growth_end_ptr()
end if
end subroutine itt_heap_record_memory_growth_end
subroutine itt_heap_reset_detection(heapmask)
procedure(itt_proc_heapmask), pointer :: heap_reset_detection_ptr
!DEC$ ATTRIBUTES DEFAULT :: itt_heap_reset_detection
integer, intent(in), value :: heapmask
if (C_ASSOCIATED(itt_heap_reset_detection_fort_ptr)) then
call C_F_PROCPOINTER(itt_heap_reset_detection_fort_ptr, heap_reset_detection_ptr)
call heap_reset_detection_ptr(heapmask)
end if
end subroutine itt_heap_reset_detection
subroutine itt_heap_record(heapmask)
procedure(itt_proc_heapmask), pointer :: heap_record_ptr
!DEC$ ATTRIBUTES DEFAULT :: itt_heap_record
integer, intent(in), value :: heapmask
if (C_ASSOCIATED(itt_heap_record_fort_ptr)) then
call C_F_PROCPOINTER(itt_heap_record_fort_ptr, heap_record_ptr)
call heap_record_ptr(heapmask)
end if
end subroutine itt_heap_record
end module ittnotify

4327
deps/v8/third_party/ittapi/include/ittnotify.h vendored Normal file
View File

File diff suppressed because it is too large Load Diff

642
deps/v8/third_party/ittapi/include/jitprofiling.h vendored Normal file
View File

@ -0,0 +1,642 @@
/*
Copyright (C) 2005-2019 Intel Corporation
SPDX-License-Identifier: GPL-2.0-only OR BSD-3-Clause
*/
#ifndef __JITPROFILING_H__
#define __JITPROFILING_H__
/**
* @brief JIT Profiling APIs
*
* The JIT Profiling API is used to report information about just-in-time
* generated code that can be used by performance tools. The user inserts
* calls in the code generator to report information before JIT-compiled
* code goes to execution. This information is collected at runtime and used
* by tools like Intel(R) VTune(TM) Amplifier to display performance metrics
* associated with JIT-compiled code.
*
* These APIs can be used to\n
* - **Profile trace-based and method-based JIT-compiled
* code**. Some examples of environments that you can profile with these APIs:
* dynamic JIT compilation of JavaScript code traces, JIT execution in OpenCL(TM)
* software technology, Java/.NET managed execution environments, and custom
* ISV JIT engines.
* @code
* #include <jitprofiling.h>
*
* if (iJIT_IsProfilingActive != iJIT_SAMPLING_ON) {
* return;
* }
*
* iJIT_Method_Load jmethod = {0};
* jmethod.method_id = iJIT_GetNewMethodID();
* jmethod.method_name = "method_name";
* jmethod.class_file_name = "class_name";
* jmethod.source_file_name = "source_file_name";
* jmethod.method_load_address = code_addr;
* jmethod.method_size = code_size;
*
* iJIT_NotifyEvent(iJVM_EVENT_TYPE_METHOD_LOAD_FINISHED, (void*)&jmethod);
* iJIT_NotifyEvent(iJVM_EVENT_TYPE_SHUTDOWN, NULL);
* @endcode
*
* * Expected behavior:
* * If any iJVM_EVENT_TYPE_METHOD_LOAD_FINISHED event overwrites an
* already reported method, then such a method becomes invalid and its
* memory region is treated as unloaded. VTune Amplifier displays the metrics
* collected by the method until it is overwritten.
* * If supplied line number information contains multiple source lines for
* the same assembly instruction (code location), then VTune Amplifier picks up
* the first line number.
* * Dynamically generated code can be associated with a module name.
* Use the iJIT_Method_Load_V2 structure.\n
* Clarification of some cases:
* * If you register a function with the same method ID multiple times,
* specifying different module names, then the VTune Amplifier picks up
* the module name registered first. If you want to distinguish the same
* function between different JIT engines, supply different method IDs for
* each function. Other symbolic information (for example, source file)
* can be identical.
*
* - **Analyze split functions** (multiple joint or disjoint code regions
* belonging to the same function) **including re-JIT**
* with potential overlapping of code regions in time, which is common in
* resource-limited environments.
* @code
* #include <jitprofiling.h>
*
* unsigned int method_id = iJIT_GetNewMethodID();
*
* iJIT_Method_Load a = {0};
* a.method_id = method_id;
* a.method_load_address = 0x100;
* a.method_size = 0x20;
*
* iJIT_Method_Load b = {0};
* b.method_id = method_id;
* b.method_load_address = 0x200;
* b.method_size = 0x30;
*
* iJIT_NotifyEvent(iJVM_EVENT_TYPE_METHOD_LOAD_FINISHED, (void*)&a);
* iJIT_NotifyEvent(iJVM_EVENT_TYPE_METHOD_LOAD_FINISHED, (void*)&b);
* @endcode
*
* * Expected behaviour:
* * If a iJVM_EVENT_TYPE_METHOD_LOAD_FINISHED event overwrites an
* already reported method, then such a method becomes invalid and
* its memory region is treated as unloaded.
* * All code regions reported with the same method ID are considered as
* belonging to the same method. Symbolic information (method name,
* source file name) will be taken from the first notification, and all
* subsequent notifications with the same method ID will be processed
* only for line number table information. So, the VTune Amplifier will map
* samples to a source line using the line number table from the current
* notification while taking the source file name from the very first one.\n
* Clarification of some cases:\n
* * If you register a second code region with a different source file
* name and the same method ID, then this information will be saved and
* will not be considered as an extension of the first code region, but
* VTune Amplifier will use the source file of the first code region and map
* performance metrics incorrectly.
* * If you register a second code region with the same source file as
* for the first region and the same method ID, then the source file will be
* discarded but VTune Amplifier will map metrics to the source file correctly.
* * If you register a second code region with a null source file and
* the same method ID, then provided line number info will be associated
* with the source file of the first code region.
*
* - **Explore inline functions** including multi-level hierarchy of
* nested inline methods which shows how performance metrics are distributed through them.
* @code
* #include <jitprofiling.h>
*
* // method_id parent_id
* // [-- c --] 3000 2000
* // [---- d -----] 2001 1000
* // [---- b ----] 2000 1000
* // [------------ a ----------------] 1000 n/a
*
* iJIT_Method_Load a = {0};
* a.method_id = 1000;
*
* iJIT_Method_Inline_Load b = {0};
* b.method_id = 2000;
* b.parent_method_id = 1000;
*
* iJIT_Method_Inline_Load c = {0};
* c.method_id = 3000;
* c.parent_method_id = 2000;
*
* iJIT_Method_Inline_Load d = {0};
* d.method_id = 2001;
* d.parent_method_id = 1000;
*
* iJIT_NotifyEvent(iJVM_EVENT_TYPE_METHOD_LOAD_FINISHED, (void*)&a);
* iJIT_NotifyEvent(iJVM_EVENT_TYPE_METHOD_INLINE_LOAD_FINISHED, (void*)&b);
* iJIT_NotifyEvent(iJVM_EVENT_TYPE_METHOD_INLINE_LOAD_FINISHED, (void*)&c);
* iJIT_NotifyEvent(iJVM_EVENT_TYPE_METHOD_INLINE_LOAD_FINISHED, (void*)&d);
* @endcode
*
* * Requirements:
* * Each inline (iJIT_Method_Inline_Load) method should be associated
* with two method IDs: one for itself; one for its immediate parent.
* * Address regions of inline methods of the same parent method cannot
* overlap each other.
* * Execution of the parent method must not be started until it and all
* its inline methods are reported.
* * Expected behaviour:
* * In case of nested inline methods an order of
* iJVM_EVENT_TYPE_METHOD_INLINE_LOAD_FINISHED events is not important.
* * If any event overwrites either inline method or top parent method,
* then the parent, including inline methods, becomes invalid and its memory
* region is treated as unloaded.
*
* **Life time of allocated data**\n
* The client sends an event notification to the agent with event-specific
* data, which is a structure. The pointers in the structure refer to memory
* allocated by the client, which responsible for releasing it. The pointers are
* used by the iJIT_NotifyEvent method to copy client's data in a trace file,
* and they are not used after the iJIT_NotifyEvent method returns.
*/
/**
* @defgroup jitapi JIT Profiling
* @ingroup internal
* @{
*/
/**
* @brief Enumerator for the types of notifications
*/
typedef enum iJIT_jvm_event
{
iJVM_EVENT_TYPE_SHUTDOWN = 2, /**<\brief Send this to shutdown the agent.
* Use NULL for event data. */
iJVM_EVENT_TYPE_METHOD_LOAD_FINISHED = 13, /**<\brief Send when dynamic code is
* JIT compiled and loaded into
* memory by the JIT engine, but
* before the code is executed.
* Use iJIT_Method_Load as event
* data. */
/** @cond exclude_from_documentation */
iJVM_EVENT_TYPE_METHOD_UNLOAD_START, /**<\brief Send when compiled dynamic
* code is being unloaded from memory.
* Use iJIT_Method_Load as event data.*/
/** @endcond */
iJVM_EVENT_TYPE_METHOD_UPDATE, /**<\brief Send to provide new content for
* a previously reported dynamic code.
* The previous content will be invalidated
* starting from the time of the notification.
* Use iJIT_Method_Load as event data but
* required fields are following:
* - method_id identify the code to update.
* - method_load_address specify start address
* within identified code range
* where update should be started.
* - method_size specify length of updated code
* range. */
iJVM_EVENT_TYPE_METHOD_INLINE_LOAD_FINISHED, /**<\brief Send when an inline dynamic
* code is JIT compiled and loaded
* into memory by the JIT engine,
* but before the parent code region
* starts executing.
* Use iJIT_Method_Inline_Load as event data.*/
/** @cond exclude_from_documentation */
iJVM_EVENT_TYPE_METHOD_UPDATE_V2,
/** @endcond */
iJVM_EVENT_TYPE_METHOD_LOAD_FINISHED_V2 = 21, /**<\brief Send when a dynamic code is
* JIT compiled and loaded into
* memory by the JIT engine, but
* before the code is executed.
* Use iJIT_Method_Load_V2 as event data. */
iJVM_EVENT_TYPE_METHOD_LOAD_FINISHED_V3 /**<\brief Send when a dynamic code is
* JIT compiled and loaded into
* memory by the JIT engine, but
* before the code is executed.
* Use iJIT_Method_Load_V3 as event data. */
} iJIT_JVM_EVENT;
/**
* @brief Enumerator for the agent's mode
*/
typedef enum _iJIT_IsProfilingActiveFlags
{
iJIT_NOTHING_RUNNING = 0x0000, /**<\brief The agent is not running;
* iJIT_NotifyEvent calls will
* not be processed. */
iJIT_SAMPLING_ON = 0x0001, /**<\brief The agent is running and
* ready to process notifications. */
} iJIT_IsProfilingActiveFlags;
/**
* @brief Description of a single entry in the line number information of a code region.
* @details A table of line number entries gives information about how the reported code region
* is mapped to source file.
* Intel(R) VTune(TM) Amplifier uses line number information to attribute
* the samples (virtual address) to a line number. \n
* It is acceptable to report different code addresses for the same source line:
* @code
* Offset LineNumber
* 1 2
* 12 4
* 15 2
* 18 1
* 21 30
*
* VTune Amplifier constructs the following table using the client data
*
* Code subrange Line number
* 0-1 2
* 1-12 4
* 12-15 2
* 15-18 1
* 18-21 30
* @endcode
*/
typedef struct _LineNumberInfo
{
unsigned int Offset; /**<\brief Offset from the begining of the code region. */
unsigned int LineNumber; /**<\brief Matching source line number offset (from beginning of source file). */
} *pLineNumberInfo, LineNumberInfo;
/**
* @brief Enumerator for the code architecture.
*/
typedef enum _iJIT_CodeArchitecture
{
iJIT_CA_NATIVE = 0, /**<\brief Native to the process architecture that is calling it. */
iJIT_CA_32, /**<\brief 32-bit machine code. */
iJIT_CA_64 /**<\brief 64-bit machine code. */
} iJIT_CodeArchitecture;
#pragma pack(push, 8)
/**
* @brief Description of a JIT-compiled method
* @details When you use the iJIT_Method_Load structure to describe
* the JIT compiled method, use iJVM_EVENT_TYPE_METHOD_LOAD_FINISHED
* as an event type to report it.
*/
typedef struct _iJIT_Method_Load
{
unsigned int method_id; /**<\brief Unique method ID. Cannot be 0.
* You must either use the API function
* iJIT_GetNewMethodID to get a valid and unique
* method ID, or else manage ID uniqueness
* and correct range by yourself.\n
* You must use the same method ID for all code
* regions of the same method, otherwise different
* method IDs specify different methods. */
char* method_name; /**<\brief The name of the method. It can be optionally
* prefixed with its class name and appended with
* its complete signature. Can't be NULL. */
void* method_load_address; /**<\brief The start virtual address of the method code
* region. If NULL, data provided with
* event are not accepted. */
unsigned int method_size; /**<\brief The code size of the method in memory.
* If 0, then data provided with the event are not
* accepted. */
unsigned int line_number_size; /**<\brief The number of entries in the line number
* table.0 if none. */
pLineNumberInfo line_number_table; /**<\brief Pointer to the line numbers info
* array. Can be NULL if
* line_number_size is 0. See
* LineNumberInfo Structure for a
* description of a single entry in
* the line number info array */
unsigned int class_id; /**<\brief This field is obsolete. */
char* class_file_name; /**<\brief Class name. Can be NULL.*/
char* source_file_name; /**<\brief Source file name. Can be NULL.*/
} *piJIT_Method_Load, iJIT_Method_Load;
/**
* @brief Description of a JIT-compiled method
* @details When you use the iJIT_Method_Load_V2 structure to describe
* the JIT compiled method, use iJVM_EVENT_TYPE_METHOD_LOAD_FINISHED_V2
* as an event type to report it.
*/
typedef struct _iJIT_Method_Load_V2
{
unsigned int method_id; /**<\brief Unique method ID. Cannot be 0.
* You must either use the API function
* iJIT_GetNewMethodID to get a valid and unique
* method ID, or else manage ID uniqueness
* and correct range by yourself.\n
* You must use the same method ID for all code
* regions of the same method, otherwise different
* method IDs specify different methods. */
char* method_name; /**<\brief The name of the method. It can be optionally
* prefixed with its class name and appended with
* its complete signature. Can't be NULL. */
void* method_load_address; /**<\brief The start virtual address of the method code
* region. If NULL, then data provided with the
* event are not accepted. */
unsigned int method_size; /**<\brief The code size of the method in memory.
* If 0, then data provided with the event are not
* accepted. */
unsigned int line_number_size; /**<\brief The number of entries in the line number
* table. 0 if none. */
pLineNumberInfo line_number_table; /**<\brief Pointer to the line numbers info
* array. Can be NULL if
* line_number_size is 0. See
* LineNumberInfo Structure for a
* description of a single entry in
* the line number info array. */
char* class_file_name; /**<\brief Class name. Can be NULL. */
char* source_file_name; /**<\brief Source file name. Can be NULL. */
char* module_name; /**<\brief Module name. Can be NULL.
The module name can be useful for distinguishing among
different JIT engines. VTune Amplifier will display
reported methods grouped by specific module. */
} *piJIT_Method_Load_V2, iJIT_Method_Load_V2;
/**
* @brief Description of a JIT-compiled method
* @details The iJIT_Method_Load_V3 structure is the same as iJIT_Method_Load_V2
* with a newly introduced 'arch' field that specifies architecture of the code region.
* When you use the iJIT_Method_Load_V3 structure to describe
* the JIT compiled method, use iJVM_EVENT_TYPE_METHOD_LOAD_FINISHED_V3
* as an event type to report it.
*/
typedef struct _iJIT_Method_Load_V3
{
unsigned int method_id; /**<\brief Unique method ID. Cannot be 0.
* You must either use the API function
* iJIT_GetNewMethodID to get a valid and unique
* method ID, or manage ID uniqueness
* and correct range by yourself.\n
* You must use the same method ID for all code
* regions of the same method, otherwise they are
* treated as regions of different methods. */
char* method_name; /**<\brief The name of the method. It can be optionally
* prefixed with its class name and appended with
* its complete signature. Cannot be NULL. */
void* method_load_address; /**<\brief The start virtual address of the method code
* region. If NULL, then data provided with the
* event are not accepted. */
unsigned int method_size; /**<\brief The code size of the method in memory.
* If 0, then data provided with the event are not
* accepted. */
unsigned int line_number_size; /**<\brief The number of entries in the line number
* table. 0 if none. */
pLineNumberInfo line_number_table; /**<\brief Pointer to the line numbers info
* array. Can be NULL if
* line_number_size is 0. See
* LineNumberInfo Structure for a
* description of a single entry in
* the line number info array. */
char* class_file_name; /**<\brief Class name. Can be NULL. */
char* source_file_name; /**<\brief Source file name. Can be NULL. */
char* module_name; /**<\brief Module name. Can be NULL.
* The module name can be useful for distinguishing among
* different JIT engines. VTune Amplifier will display
* reported methods grouped by specific module. */
iJIT_CodeArchitecture module_arch; /**<\brief Architecture of the method's code region.
* By default, it is the same as the process
* architecture that is calling it.
* For example, you can use it if your 32-bit JIT
* engine generates 64-bit code.
*
* If JIT engine reports both 32-bit and 64-bit types
* of methods then VTune Amplifier splits the methods
* with the same module name but with different
* architectures in two different modules. VTune Amplifier
* modifies the original name provided with a 64-bit method
* version by ending it with '(64)' */
} *piJIT_Method_Load_V3, iJIT_Method_Load_V3;
/**
* @brief Description of an inline JIT-compiled method
* @details When you use the_iJIT_Method_Inline_Load structure to describe
* the JIT compiled method, use iJVM_EVENT_TYPE_METHOD_INLINE_LOAD_FINISHED
* as an event type to report it.
*/
typedef struct _iJIT_Method_Inline_Load
{
unsigned int method_id; /**<\brief Unique method ID. Cannot be 0.
* You must either use the API function
* iJIT_GetNewMethodID to get a valid and unique
* method ID, or else manage ID uniqueness
* and correct range by yourself. */
unsigned int parent_method_id; /**<\brief Unique immediate parent's method ID.
* Cannot be 0.
* You must either use the API function
* iJIT_GetNewMethodID to get a valid and unique
* method ID, or else manage ID uniqueness
* and correct range by yourself. */
char* method_name; /**<\brief The name of the method. It can be optionally
* prefixed with its class name and appended with
* its complete signature. Can't be NULL. */
void* method_load_address; /** <\brief The virtual address on which the method
* is inlined. If NULL, then data provided with
* the event are not accepted. */
unsigned int method_size; /**<\brief The code size of the method in memory.
* If 0, then data provided with the event are not
* accepted. */
unsigned int line_number_size; /**<\brief The number of entries in the line number
* table. 0 if none. */
pLineNumberInfo line_number_table; /**<\brief Pointer to the line numbers info
* array. Can be NULL if
* line_number_size is 0. See
* LineNumberInfo Structure for a
* description of a single entry in
* the line number info array */
char* class_file_name; /**<\brief Class name. Can be NULL.*/
char* source_file_name; /**<\brief Source file name. Can be NULL.*/
} *piJIT_Method_Inline_Load, iJIT_Method_Inline_Load;
/** @cond exclude_from_documentation */
/**
* @brief Description of a segment type
* @details Use the segment type to specify a type of data supplied
* with the iJVM_EVENT_TYPE_METHOD_UPDATE_V2 event to be applied to
* a certain code trace.
*/
typedef enum _iJIT_SegmentType
{
iJIT_CT_UNKNOWN = 0,
iJIT_CT_CODE, /**<\brief Executable code. */
iJIT_CT_DATA, /**<\brief Data (not executable code).
* VTune Amplifier uses the format string
* (see iJIT_Method_Update) to represent
* this data in the VTune Amplifier GUI */
iJIT_CT_KEEP, /**<\brief Use the previous markup for the trace.
* Can be used for the following
* iJVM_EVENT_TYPE_METHOD_UPDATE_V2 events,
* if the type of the previously reported segment
* type is the same. */
iJIT_CT_EOF
} iJIT_SegmentType;
/**
* @brief Description of a dynamic update of the content within JIT-compiled method
* @details The JIT engine may generate the methods that are updated at runtime
* partially by mixed (data + executable code) content. When you use the iJIT_Method_Update
* structure to describe the update of the content within a JIT-compiled method,
* use iJVM_EVENT_TYPE_METHOD_UPDATE_V2 as an event type to report it.
*
* On the first Update event, VTune Amplifier copies the original code range reported by
* the iJVM_EVENT_TYPE_METHOD_LOAD event, then modifies it with the supplied bytes and
* adds the modified range to the original method. For next update events, VTune Amplifier
* does the same but it uses the latest modified version of a code region for update.
* Eventually, VTune Amplifier GUI displays multiple code ranges for the method reported by
* the iJVM_EVENT_TYPE_METHOD_LOAD event.
* Notes:
* - Multiple update events with different types for the same trace are allowed
* but they must be reported for the same code ranges.
* Example,
* @code
* [-- data---] Allowed
* [-- code --] Allowed
* [code] Ignored
* [-- data---] Allowed
* [-- code --] Allowed
* [------------ trace ---------]
* @endcode
* - The types of previously reported events can be changed but they must be reported
* for the same code ranges.
* Example,
* @code
* [-- data---] Allowed
* [-- code --] Allowed
* [-- data---] Allowed
* [-- code --] Allowed
* [------------ trace ---------]
* @endcode
*/
typedef struct _iJIT_Method_Update
{
void* load_address; /**<\brief Start address of the update within a method */
unsigned int size; /**<\brief The update size */
iJIT_SegmentType type; /**<\brief Type of the update */
const char* data_format; /**<\brief C string that contains a format string
* that follows the same specifications as format in printf.
* The format string is used for iJIT_CT_CODE only
* and cannot be NULL.
* Format can be changed on the fly. */
} *piJIT_Method_Update, iJIT_Method_Update;
/** @endcond */
#pragma pack(pop)
/** @cond exclude_from_documentation */
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
#ifndef JITAPI_CDECL
# if defined WIN32 || defined _WIN32
# define JITAPI_CDECL __cdecl
# else /* defined WIN32 || defined _WIN32 */
# if defined _M_IX86 || defined __i386__
# define JITAPI_CDECL __attribute__ ((cdecl))
# else /* _M_IX86 || __i386__ */
# define JITAPI_CDECL /* actual only on x86_64 platform */
# endif /* _M_IX86 || __i386__ */
# endif /* defined WIN32 || defined _WIN32 */
#endif /* JITAPI_CDECL */
#define JITAPI JITAPI_CDECL
/** @endcond */
/**
* @brief Generates a new unique method ID.
*
* You must use this API to obtain unique and valid method IDs for methods or
* traces reported to the agent if you don't have your own mechanism to generate
* unique method IDs.
*
* @return a new unique method ID. When out of unique method IDs, this API
* returns 0, which is not an accepted value.
*/
unsigned int JITAPI iJIT_GetNewMethodID(void);
/**
* @brief Returns the current mode of the agent.
*
* @return iJIT_SAMPLING_ON, indicating that agent is running, or
* iJIT_NOTHING_RUNNING if no agent is running.
*/
iJIT_IsProfilingActiveFlags JITAPI iJIT_IsProfilingActive(void);
/**
* @brief Reports infomation about JIT-compiled code to the agent.
*
* The reported information is used to attribute samples obtained from any
* Intel(R) VTune(TM) Amplifier collector. This API needs to be called
* after JIT compilation and before the first entry into the JIT-compiled
* code.
*
* @param[in] event_type - type of the data sent to the agent
* @param[in] EventSpecificData - pointer to event-specific data
*
* @returns 1 on success, otherwise 0.
*/
int JITAPI iJIT_NotifyEvent(iJIT_JVM_EVENT event_type, void *EventSpecificData);
#ifdef __cplusplus
}
#endif /* __cplusplus */
/** @endcond */
/** @} jitapi group */
#endif /* __JITPROFILING_H__ */

992
deps/v8/third_party/ittapi/include/legacy/ittnotify.h vendored Normal file
View File

@ -0,0 +1,992 @@
/*
Copyright (C) 2005-2019 Intel Corporation
SPDX-License-Identifier: GPL-2.0-only OR BSD-3-Clause
*/
#ifndef _LEGACY_ITTNOTIFY_H_
#define _LEGACY_ITTNOTIFY_H_
/**
* @file
* @brief Legacy User API functions and types
*/
/** @cond exclude_from_documentation */
#ifndef ITT_OS_WIN
# define ITT_OS_WIN 1
#endif /* ITT_OS_WIN */
#ifndef ITT_OS_LINUX
# define ITT_OS_LINUX 2
#endif /* ITT_OS_LINUX */
#ifndef ITT_OS_MAC
# define ITT_OS_MAC 3
#endif /* ITT_OS_MAC */
#ifndef ITT_OS_FREEBSD
# define ITT_OS_FREEBSD 4
#endif /* ITT_OS_FREEBSD */
#ifndef ITT_OS
# if defined WIN32 || defined _WIN32
# define ITT_OS ITT_OS_WIN
# elif defined( __APPLE__ ) && defined( __MACH__ )
# define ITT_OS ITT_OS_MAC
# elif defined( __FreeBSD__ )
# define ITT_OS ITT_OS_FREEBSD
# else
# define ITT_OS ITT_OS_LINUX
# endif
#endif /* ITT_OS */
#ifndef ITT_PLATFORM_WIN
# define ITT_PLATFORM_WIN 1
#endif /* ITT_PLATFORM_WIN */
#ifndef ITT_PLATFORM_POSIX
# define ITT_PLATFORM_POSIX 2
#endif /* ITT_PLATFORM_POSIX */
#ifndef ITT_PLATFORM_MAC
# define ITT_PLATFORM_MAC 3
#endif /* ITT_PLATFORM_MAC */
#ifndef ITT_PLATFORM_FREEBSD
# define ITT_PLATFORM_FREEBSD 4
#endif /* ITT_PLATFORM_FREEBSD */
#ifndef ITT_PLATFORM
# if ITT_OS==ITT_OS_WIN
# define ITT_PLATFORM ITT_PLATFORM_WIN
# elif ITT_OS==ITT_OS_MAC
# define ITT_PLATFORM ITT_PLATFORM_MAC
# elif ITT_OS==ITT_OS_FREEBSD
# define ITT_PLATFORM ITT_PLATFORM_FREEBSD
# else
# define ITT_PLATFORM ITT_PLATFORM_POSIX
# endif
#endif /* ITT_PLATFORM */
#if defined(_UNICODE) && !defined(UNICODE)
#define UNICODE
#endif
#include <stddef.h>
#if ITT_PLATFORM==ITT_PLATFORM_WIN
#include <tchar.h>
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#include <stdint.h>
#if defined(UNICODE) || defined(_UNICODE)
#include <wchar.h>
#endif /* UNICODE || _UNICODE */
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#ifndef ITTAPI_CDECL
# if ITT_PLATFORM==ITT_PLATFORM_WIN
# define ITTAPI_CDECL __cdecl
# else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
# if defined _M_IX86 || defined __i386__
# define ITTAPI_CDECL __attribute__ ((cdecl))
# else /* _M_IX86 || __i386__ */
# define ITTAPI_CDECL /* actual only on x86 platform */
# endif /* _M_IX86 || __i386__ */
# endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#endif /* ITTAPI_CDECL */
#ifndef STDCALL
# if ITT_PLATFORM==ITT_PLATFORM_WIN
# define STDCALL __stdcall
# else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
# if defined _M_IX86 || defined __i386__
# define STDCALL __attribute__ ((stdcall))
# else /* _M_IX86 || __i386__ */
# define STDCALL /* supported only on x86 platform */
# endif /* _M_IX86 || __i386__ */
# endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#endif /* STDCALL */
#define ITTAPI ITTAPI_CDECL
#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) */
#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_INLINE static
#define ITT_INLINE_ATTRIBUTE __attribute__((unused))
#else /* __STRICT_ANSI__ */
#define ITT_INLINE static inline
#define ITT_INLINE_ATTRIBUTE __attribute__((always_inline, unused))
#endif /* __STRICT_ANSI__ */
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
/** @endcond */
/** @cond exclude_from_documentation */
/* Helper macro for joining tokens */
#define ITT_JOIN_AUX(p,n) p##n
#define ITT_JOIN(p,n) ITT_JOIN_AUX(p,n)
#ifdef ITT_MAJOR
#undef ITT_MAJOR
#endif
#ifdef ITT_MINOR
#undef ITT_MINOR
#endif
#define ITT_MAJOR 3
#define ITT_MINOR 0
/* Standard versioning of a token with major and minor version numbers */
#define ITT_VERSIONIZE(x) \
ITT_JOIN(x, \
ITT_JOIN(_, \
ITT_JOIN(ITT_MAJOR, \
ITT_JOIN(_, ITT_MINOR))))
#ifndef INTEL_ITTNOTIFY_PREFIX
# define INTEL_ITTNOTIFY_PREFIX __itt_
#endif /* INTEL_ITTNOTIFY_PREFIX */
#ifndef INTEL_ITTNOTIFY_POSTFIX
# define INTEL_ITTNOTIFY_POSTFIX _ptr_
#endif /* INTEL_ITTNOTIFY_POSTFIX */
#define ITTNOTIFY_NAME_AUX(n) ITT_JOIN(INTEL_ITTNOTIFY_PREFIX,n)
#define ITTNOTIFY_NAME(n) ITT_VERSIONIZE(ITTNOTIFY_NAME_AUX(ITT_JOIN(n,INTEL_ITTNOTIFY_POSTFIX)))
#define ITTNOTIFY_VOID(n) (!ITTNOTIFY_NAME(n)) ? (void)0 : ITTNOTIFY_NAME(n)
#define ITTNOTIFY_DATA(n) (!ITTNOTIFY_NAME(n)) ? 0 : ITTNOTIFY_NAME(n)
#define ITTNOTIFY_VOID_D0(n,d) (!(d)->flags) ? (void)0 : (!ITTNOTIFY_NAME(n)) ? (void)0 : ITTNOTIFY_NAME(n)(d)
#define ITTNOTIFY_VOID_D1(n,d,x) (!(d)->flags) ? (void)0 : (!ITTNOTIFY_NAME(n)) ? (void)0 : ITTNOTIFY_NAME(n)(d,x)
#define ITTNOTIFY_VOID_D2(n,d,x,y) (!(d)->flags) ? (void)0 : (!ITTNOTIFY_NAME(n)) ? (void)0 : ITTNOTIFY_NAME(n)(d,x,y)
#define ITTNOTIFY_VOID_D3(n,d,x,y,z) (!(d)->flags) ? (void)0 : (!ITTNOTIFY_NAME(n)) ? (void)0 : ITTNOTIFY_NAME(n)(d,x,y,z)
#define ITTNOTIFY_VOID_D4(n,d,x,y,z,a) (!(d)->flags) ? (void)0 : (!ITTNOTIFY_NAME(n)) ? (void)0 : ITTNOTIFY_NAME(n)(d,x,y,z,a)
#define ITTNOTIFY_VOID_D5(n,d,x,y,z,a,b) (!(d)->flags) ? (void)0 : (!ITTNOTIFY_NAME(n)) ? (void)0 : ITTNOTIFY_NAME(n)(d,x,y,z,a,b)
#define ITTNOTIFY_VOID_D6(n,d,x,y,z,a,b,c) (!(d)->flags) ? (void)0 : (!ITTNOTIFY_NAME(n)) ? (void)0 : ITTNOTIFY_NAME(n)(d,x,y,z,a,b,c)
#define ITTNOTIFY_DATA_D0(n,d) (!(d)->flags) ? 0 : (!ITTNOTIFY_NAME(n)) ? 0 : ITTNOTIFY_NAME(n)(d)
#define ITTNOTIFY_DATA_D1(n,d,x) (!(d)->flags) ? 0 : (!ITTNOTIFY_NAME(n)) ? 0 : ITTNOTIFY_NAME(n)(d,x)
#define ITTNOTIFY_DATA_D2(n,d,x,y) (!(d)->flags) ? 0 : (!ITTNOTIFY_NAME(n)) ? 0 : ITTNOTIFY_NAME(n)(d,x,y)
#define ITTNOTIFY_DATA_D3(n,d,x,y,z) (!(d)->flags) ? 0 : (!ITTNOTIFY_NAME(n)) ? 0 : ITTNOTIFY_NAME(n)(d,x,y,z)
#define ITTNOTIFY_DATA_D4(n,d,x,y,z,a) (!(d)->flags) ? 0 : (!ITTNOTIFY_NAME(n)) ? 0 : ITTNOTIFY_NAME(n)(d,x,y,z,a)
#define ITTNOTIFY_DATA_D5(n,d,x,y,z,a,b) (!(d)->flags) ? 0 : (!ITTNOTIFY_NAME(n)) ? 0 : ITTNOTIFY_NAME(n)(d,x,y,z,a,b)
#define ITTNOTIFY_DATA_D6(n,d,x,y,z,a,b,c) (!(d)->flags) ? 0 : (!ITTNOTIFY_NAME(n)) ? 0 : ITTNOTIFY_NAME(n)(d,x,y,z,a,b,c)
#ifdef ITT_STUB
#undef ITT_STUB
#endif
#ifdef ITT_STUBV
#undef ITT_STUBV
#endif
#define ITT_STUBV(api,type,name,args) \
typedef type (api* ITT_JOIN(ITTNOTIFY_NAME(name),_t)) args; \
extern ITT_JOIN(ITTNOTIFY_NAME(name),_t) ITTNOTIFY_NAME(name);
#define ITT_STUB ITT_STUBV
/** @endcond */
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
/**
* @defgroup legacy Legacy API
* @{
* @}
*/
/**
* @defgroup legacy_control Collection Control
* @ingroup legacy
* General behavior: application continues to run, but no profiling information is being collected
*
* Pausing occurs not only for the current thread but for all process as well as spawned processes
* - Intel(R) Parallel Inspector and Intel(R) Inspector XE:
* - Does not analyze or report errors that involve memory access.
* - Other errors are reported as usual. Pausing data collection in
* Intel(R) Parallel Inspector and Intel(R) Inspector XE
* only pauses tracing and analyzing memory access.
* It does not pause tracing or analyzing threading APIs.
* .
* - Intel(R) Parallel Amplifier and Intel(R) VTune(TM) Amplifier XE:
* - Does continue to record when new threads are started.
* .
* - Other effects:
* - Possible reduction of runtime overhead.
* .
* @{
*/
#ifndef _ITTNOTIFY_H_
/** @brief Pause collection */
void ITTAPI __itt_pause(void);
/** @brief Resume collection */
void ITTAPI __itt_resume(void);
/** @brief Detach collection */
void ITTAPI __itt_detach(void);
/** @cond exclude_from_documentation */
#ifndef INTEL_NO_MACRO_BODY
#ifndef INTEL_NO_ITTNOTIFY_API
ITT_STUBV(ITTAPI, void, pause, (void))
ITT_STUBV(ITTAPI, void, resume, (void))
ITT_STUBV(ITTAPI, void, detach, (void))
#define __itt_pause ITTNOTIFY_VOID(pause)
#define __itt_pause_ptr ITTNOTIFY_NAME(pause)
#define __itt_resume ITTNOTIFY_VOID(resume)
#define __itt_resume_ptr ITTNOTIFY_NAME(resume)
#define __itt_detach ITTNOTIFY_VOID(detach)
#define __itt_detach_ptr ITTNOTIFY_NAME(detach)
#else /* INTEL_NO_ITTNOTIFY_API */
#define __itt_pause()
#define __itt_pause_ptr 0
#define __itt_resume()
#define __itt_resume_ptr 0
#define __itt_detach()
#define __itt_detach_ptr 0
#endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */
#define __itt_pause_ptr 0
#define __itt_resume_ptr 0
#define __itt_detach_ptr 0
#endif /* INTEL_NO_MACRO_BODY */
/** @endcond */
#endif /* _ITTNOTIFY_H_ */
/** @} legacy_control group */
/**
* @defgroup legacy_threads Threads
* @ingroup legacy
* Threads group
* @warning Legacy API
* @{
*/
/**
* @deprecated Legacy API
* @brief Set name to be associated with thread in analysis GUI.
* @return __itt_err upon failure (name or namelen being null,name and namelen mismatched)
*/
#if ITT_PLATFORM==ITT_PLATFORM_WIN
int LIBITTAPI __itt_thr_name_setA(const char *name, int namelen);
int LIBITTAPI __itt_thr_name_setW(const wchar_t *name, int namelen);
#if defined(UNICODE) || defined(_UNICODE)
# define __itt_thr_name_set __itt_thr_name_setW
# define __itt_thr_name_set_ptr __itt_thr_name_setW_ptr
#else
# define __itt_thr_name_set __itt_thr_name_setA
# define __itt_thr_name_set_ptr __itt_thr_name_setA_ptr
#endif /* UNICODE */
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
int LIBITTAPI __itt_thr_name_set(const char *name, int namelen);
#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(LIBITTAPI, int, thr_name_setA, (const char *name, int namelen))
ITT_STUB(LIBITTAPI, int, thr_name_setW, (const wchar_t *name, int namelen))
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
ITT_STUB(LIBITTAPI, int, thr_name_set, (const char *name, int namelen))
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#if ITT_PLATFORM==ITT_PLATFORM_WIN
#define __itt_thr_name_setA ITTNOTIFY_DATA(thr_name_setA)
#define __itt_thr_name_setA_ptr ITTNOTIFY_NAME(thr_name_setA)
#define __itt_thr_name_setW ITTNOTIFY_DATA(thr_name_setW)
#define __itt_thr_name_setW_ptr ITTNOTIFY_NAME(thr_name_setW)
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#define __itt_thr_name_set ITTNOTIFY_DATA(thr_name_set)
#define __itt_thr_name_set_ptr ITTNOTIFY_NAME(thr_name_set)
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#else /* INTEL_NO_ITTNOTIFY_API */
#if ITT_PLATFORM==ITT_PLATFORM_WIN
#define __itt_thr_name_setA(name, namelen)
#define __itt_thr_name_setA_ptr 0
#define __itt_thr_name_setW(name, namelen)
#define __itt_thr_name_setW_ptr 0
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#define __itt_thr_name_set(name, namelen)
#define __itt_thr_name_set_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_thr_name_setA_ptr 0
#define __itt_thr_name_setW_ptr 0
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#define __itt_thr_name_set_ptr 0
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#endif /* INTEL_NO_MACRO_BODY */
/** @endcond */
/**
* @deprecated Legacy API
* @brief Mark current thread as ignored from this point on, for the duration of its existence.
*/
void LIBITTAPI __itt_thr_ignore(void);
/** @cond exclude_from_documentation */
#ifndef INTEL_NO_MACRO_BODY
#ifndef INTEL_NO_ITTNOTIFY_API
ITT_STUBV(LIBITTAPI, void, thr_ignore, (void))
#define __itt_thr_ignore ITTNOTIFY_VOID(thr_ignore)
#define __itt_thr_ignore_ptr ITTNOTIFY_NAME(thr_ignore)
#else /* INTEL_NO_ITTNOTIFY_API */
#define __itt_thr_ignore()
#define __itt_thr_ignore_ptr 0
#endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */
#define __itt_thr_ignore_ptr 0
#endif /* INTEL_NO_MACRO_BODY */
/** @endcond */
/** @} legacy_threads group */
/**
* @defgroup legacy_sync Synchronization
* @ingroup legacy
* Synchronization group
* @warning Legacy API
* @{
*/
/**
* @hideinitializer
* @brief possible value of attribute argument for sync object type
*/
#define __itt_attr_barrier 1
/**
* @hideinitializer
* @brief possible value of attribute argument for sync object type
*/
#define __itt_attr_mutex 2
/**
* @deprecated Legacy API
* @brief Assign a name to a sync object using char or Unicode string
* @param[in] addr - pointer to the sync object. You should use a real pointer to your object
* to make sure that the values don't clash with other object addresses
* @param[in] objtype - null-terminated object type string. If NULL is passed, the object will
* be assumed to be of generic "User Synchronization" type
* @param[in] objname - null-terminated object name string. If NULL, no name will be assigned
* to the object -- you can use the __itt_sync_rename call later to assign
* the name
* @param[in] attribute - one of [#__itt_attr_barrier, #__itt_attr_mutex] values which defines the
* exact semantics of how prepare/acquired/releasing calls work.
*/
#if ITT_PLATFORM==ITT_PLATFORM_WIN
void ITTAPI __itt_sync_set_nameA(void *addr, const char *objtype, const char *objname, int attribute);
void ITTAPI __itt_sync_set_nameW(void *addr, const wchar_t *objtype, const wchar_t *objname, int attribute);
#if defined(UNICODE) || defined(_UNICODE)
# define __itt_sync_set_name __itt_sync_set_nameW
# define __itt_sync_set_name_ptr __itt_sync_set_nameW_ptr
#else /* UNICODE */
# define __itt_sync_set_name __itt_sync_set_nameA
# define __itt_sync_set_name_ptr __itt_sync_set_nameA_ptr
#endif /* UNICODE */
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
void ITTAPI __itt_sync_set_name(void *addr, const char* objtype, const char* objname, int attribute);
#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_STUBV(ITTAPI, void, sync_set_nameA, (void *addr, const char *objtype, const char *objname, int attribute))
ITT_STUBV(ITTAPI, void, sync_set_nameW, (void *addr, const wchar_t *objtype, const wchar_t *objname, int attribute))
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
ITT_STUBV(ITTAPI, void, sync_set_name, (void *addr, const char *objtype, const char *objname, int attribute))
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#if ITT_PLATFORM==ITT_PLATFORM_WIN
#define __itt_sync_set_nameA ITTNOTIFY_VOID(sync_set_nameA)
#define __itt_sync_set_nameA_ptr ITTNOTIFY_NAME(sync_set_nameA)
#define __itt_sync_set_nameW ITTNOTIFY_VOID(sync_set_nameW)
#define __itt_sync_set_nameW_ptr ITTNOTIFY_NAME(sync_set_nameW)
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#define __itt_sync_set_name ITTNOTIFY_VOID(sync_set_name)
#define __itt_sync_set_name_ptr ITTNOTIFY_NAME(sync_set_name)
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#else /* INTEL_NO_ITTNOTIFY_API */
#if ITT_PLATFORM==ITT_PLATFORM_WIN
#define __itt_sync_set_nameA(addr, objtype, objname, attribute)
#define __itt_sync_set_nameA_ptr 0
#define __itt_sync_set_nameW(addr, objtype, objname, attribute)
#define __itt_sync_set_nameW_ptr 0
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#define __itt_sync_set_name(addr, objtype, objname, attribute)
#define __itt_sync_set_name_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_sync_set_nameA_ptr 0
#define __itt_sync_set_nameW_ptr 0
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#define __itt_sync_set_name_ptr 0
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#endif /* INTEL_NO_MACRO_BODY */
/** @endcond */
/**
* @deprecated Legacy API
* @brief Assign a name and type to a sync object using char or Unicode string
* @param[in] addr - pointer to the sync object. You should use a real pointer to your object
* to make sure that the values don't clash with other object addresses
* @param[in] objtype - null-terminated object type string. If NULL is passed, the object will
* be assumed to be of generic "User Synchronization" type
* @param[in] objname - null-terminated object name string. If NULL, no name will be assigned
* to the object -- you can use the __itt_sync_rename call later to assign
* the name
* @param[in] typelen, namelen - a length of string for appropriate objtype and objname parameter
* @param[in] attribute - one of [#__itt_attr_barrier, #__itt_attr_mutex] values which defines the
* exact semantics of how prepare/acquired/releasing calls work.
* @return __itt_err upon failure (name or namelen being null,name and namelen mismatched)
*/
#if ITT_PLATFORM==ITT_PLATFORM_WIN
int LIBITTAPI __itt_notify_sync_nameA(void *addr, const char *objtype, int typelen, const char *objname, int namelen, int attribute);
int LIBITTAPI __itt_notify_sync_nameW(void *addr, const wchar_t *objtype, int typelen, const wchar_t *objname, int namelen, int attribute);
#if defined(UNICODE) || defined(_UNICODE)
# define __itt_notify_sync_name __itt_notify_sync_nameW
#else
# define __itt_notify_sync_name __itt_notify_sync_nameA
#endif
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
int LIBITTAPI __itt_notify_sync_name(void *addr, const char *objtype, int typelen, const char *objname, int namelen, int attribute);
#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(LIBITTAPI, int, notify_sync_nameA, (void *addr, const char *objtype, int typelen, const char *objname, int namelen, int attribute))
ITT_STUB(LIBITTAPI, int, notify_sync_nameW, (void *addr, const wchar_t *objtype, int typelen, const wchar_t *objname, int namelen, int attribute))
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
ITT_STUB(LIBITTAPI, int, notify_sync_name, (void *addr, const char *objtype, int typelen, const char *objname, int namelen, int attribute))
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#if ITT_PLATFORM==ITT_PLATFORM_WIN
#define __itt_notify_sync_nameA ITTNOTIFY_DATA(notify_sync_nameA)
#define __itt_notify_sync_nameA_ptr ITTNOTIFY_NAME(notify_sync_nameA)
#define __itt_notify_sync_nameW ITTNOTIFY_DATA(notify_sync_nameW)
#define __itt_notify_sync_nameW_ptr ITTNOTIFY_NAME(notify_sync_nameW)
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#define __itt_notify_sync_name ITTNOTIFY_DATA(notify_sync_name)
#define __itt_notify_sync_name_ptr ITTNOTIFY_NAME(notify_sync_name)
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#else /* INTEL_NO_ITTNOTIFY_API */
#if ITT_PLATFORM==ITT_PLATFORM_WIN
#define __itt_notify_sync_nameA(addr, objtype, typelen, objname, namelen, attribute)
#define __itt_notify_sync_nameA_ptr 0
#define __itt_notify_sync_nameW(addr, objtype, typelen, objname, namelen, attribute)
#define __itt_notify_sync_nameW_ptr 0
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#define __itt_notify_sync_name(addr, objtype, typelen, objname, namelen, attribute)
#define __itt_notify_sync_name_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_notify_sync_nameA_ptr 0
#define __itt_notify_sync_nameW_ptr 0
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#define __itt_notify_sync_name_ptr 0
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#endif /* INTEL_NO_MACRO_BODY */
/** @endcond */
/**
* @deprecated Legacy API
* @brief Enter spin loop on user-defined sync object
*/
void LIBITTAPI __itt_notify_sync_prepare(void* addr);
/** @cond exclude_from_documentation */
#ifndef INTEL_NO_MACRO_BODY
#ifndef INTEL_NO_ITTNOTIFY_API
ITT_STUBV(LIBITTAPI, void, notify_sync_prepare, (void *addr))
#define __itt_notify_sync_prepare ITTNOTIFY_VOID(notify_sync_prepare)
#define __itt_notify_sync_prepare_ptr ITTNOTIFY_NAME(notify_sync_prepare)
#else /* INTEL_NO_ITTNOTIFY_API */
#define __itt_notify_sync_prepare(addr)
#define __itt_notify_sync_prepare_ptr 0
#endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */
#define __itt_notify_sync_prepare_ptr 0
#endif /* INTEL_NO_MACRO_BODY */
/** @endcond */
/**
* @deprecated Legacy API
* @brief Quit spin loop without acquiring spin object
*/
void LIBITTAPI __itt_notify_sync_cancel(void *addr);
/** @cond exclude_from_documentation */
#ifndef INTEL_NO_MACRO_BODY
#ifndef INTEL_NO_ITTNOTIFY_API
ITT_STUBV(LIBITTAPI, void, notify_sync_cancel, (void *addr))
#define __itt_notify_sync_cancel ITTNOTIFY_VOID(notify_sync_cancel)
#define __itt_notify_sync_cancel_ptr ITTNOTIFY_NAME(notify_sync_cancel)
#else /* INTEL_NO_ITTNOTIFY_API */
#define __itt_notify_sync_cancel(addr)
#define __itt_notify_sync_cancel_ptr 0
#endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */
#define __itt_notify_sync_cancel_ptr 0
#endif /* INTEL_NO_MACRO_BODY */
/** @endcond */
/**
* @deprecated Legacy API
* @brief Successful spin loop completion (sync object acquired)
*/
void LIBITTAPI __itt_notify_sync_acquired(void *addr);
/** @cond exclude_from_documentation */
#ifndef INTEL_NO_MACRO_BODY
#ifndef INTEL_NO_ITTNOTIFY_API
ITT_STUBV(LIBITTAPI, void, notify_sync_acquired, (void *addr))
#define __itt_notify_sync_acquired ITTNOTIFY_VOID(notify_sync_acquired)
#define __itt_notify_sync_acquired_ptr ITTNOTIFY_NAME(notify_sync_acquired)
#else /* INTEL_NO_ITTNOTIFY_API */
#define __itt_notify_sync_acquired(addr)
#define __itt_notify_sync_acquired_ptr 0
#endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */
#define __itt_notify_sync_acquired_ptr 0
#endif /* INTEL_NO_MACRO_BODY */
/** @endcond */
/**
* @deprecated Legacy API
* @brief Start sync object releasing code. Is called before the lock release call.
*/
void LIBITTAPI __itt_notify_sync_releasing(void* addr);
/** @cond exclude_from_documentation */
#ifndef INTEL_NO_MACRO_BODY
#ifndef INTEL_NO_ITTNOTIFY_API
ITT_STUBV(LIBITTAPI, void, notify_sync_releasing, (void *addr))
#define __itt_notify_sync_releasing ITTNOTIFY_VOID(notify_sync_releasing)
#define __itt_notify_sync_releasing_ptr ITTNOTIFY_NAME(notify_sync_releasing)
#else /* INTEL_NO_ITTNOTIFY_API */
#define __itt_notify_sync_releasing(addr)
#define __itt_notify_sync_releasing_ptr 0
#endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */
#define __itt_notify_sync_releasing_ptr 0
#endif /* INTEL_NO_MACRO_BODY */
/** @endcond */
/** @} legacy_sync group */
#ifndef _ITTNOTIFY_H_
/**
* @defgroup legacy_events Events
* @ingroup legacy
* Events group
* @{
*/
/** @brief user event type */
typedef int __itt_event;
/**
* @brief Create an event notification
* @note name or namelen being null/name and namelen not matching, user event feature not enabled
* @return non-zero event identifier upon success and __itt_err otherwise
*/
#if ITT_PLATFORM==ITT_PLATFORM_WIN
__itt_event LIBITTAPI __itt_event_createA(const char *name, int namelen);
__itt_event LIBITTAPI __itt_event_createW(const wchar_t *name, int namelen);
#if defined(UNICODE) || defined(_UNICODE)
# define __itt_event_create __itt_event_createW
# define __itt_event_create_ptr __itt_event_createW_ptr
#else
# define __itt_event_create __itt_event_createA
# define __itt_event_create_ptr __itt_event_createA_ptr
#endif /* UNICODE */
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
__itt_event LIBITTAPI __itt_event_create(const char *name, int namelen);
#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(LIBITTAPI, __itt_event, event_createA, (const char *name, int namelen))
ITT_STUB(LIBITTAPI, __itt_event, event_createW, (const wchar_t *name, int namelen))
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
ITT_STUB(LIBITTAPI, __itt_event, event_create, (const char *name, int namelen))
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#if ITT_PLATFORM==ITT_PLATFORM_WIN
#define __itt_event_createA ITTNOTIFY_DATA(event_createA)
#define __itt_event_createA_ptr ITTNOTIFY_NAME(event_createA)
#define __itt_event_createW ITTNOTIFY_DATA(event_createW)
#define __itt_event_createW_ptr ITTNOTIFY_NAME(event_createW)
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#define __itt_event_create ITTNOTIFY_DATA(event_create)
#define __itt_event_create_ptr ITTNOTIFY_NAME(event_create)
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#else /* INTEL_NO_ITTNOTIFY_API */
#if ITT_PLATFORM==ITT_PLATFORM_WIN
#define __itt_event_createA(name, namelen) (__itt_event)0
#define __itt_event_createA_ptr 0
#define __itt_event_createW(name, namelen) (__itt_event)0
#define __itt_event_createW_ptr 0
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#define __itt_event_create(name, namelen) (__itt_event)0
#define __itt_event_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_event_createA_ptr 0
#define __itt_event_createW_ptr 0
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#define __itt_event_create_ptr 0
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#endif /* INTEL_NO_MACRO_BODY */
/** @endcond */
/**
* @brief Record an event occurrence.
* @return __itt_err upon failure (invalid event id/user event feature not enabled)
*/
int LIBITTAPI __itt_event_start(__itt_event event);
/** @cond exclude_from_documentation */
#ifndef INTEL_NO_MACRO_BODY
#ifndef INTEL_NO_ITTNOTIFY_API
ITT_STUB(LIBITTAPI, int, event_start, (__itt_event event))
#define __itt_event_start ITTNOTIFY_DATA(event_start)
#define __itt_event_start_ptr ITTNOTIFY_NAME(event_start)
#else /* INTEL_NO_ITTNOTIFY_API */
#define __itt_event_start(event) (int)0
#define __itt_event_start_ptr 0
#endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */
#define __itt_event_start_ptr 0
#endif /* INTEL_NO_MACRO_BODY */
/** @endcond */
/**
* @brief Record an event end occurrence.
* @note It is optional if events do not have durations.
* @return __itt_err upon failure (invalid event id/user event feature not enabled)
*/
int LIBITTAPI __itt_event_end(__itt_event event);
/** @cond exclude_from_documentation */
#ifndef INTEL_NO_MACRO_BODY
#ifndef INTEL_NO_ITTNOTIFY_API
ITT_STUB(LIBITTAPI, int, event_end, (__itt_event event))
#define __itt_event_end ITTNOTIFY_DATA(event_end)
#define __itt_event_end_ptr ITTNOTIFY_NAME(event_end)
#else /* INTEL_NO_ITTNOTIFY_API */
#define __itt_event_end(event) (int)0
#define __itt_event_end_ptr 0
#endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */
#define __itt_event_end_ptr 0
#endif /* INTEL_NO_MACRO_BODY */
/** @endcond */
/** @} legacy_events group */
#endif /* _ITTNOTIFY_H_ */
/**
* @defgroup legacy_memory Memory Accesses
* @ingroup legacy
*/
/**
* @deprecated Legacy API
* @brief Inform the tool of memory accesses on reading
*/
void LIBITTAPI __itt_memory_read(void *addr, size_t size);
/** @cond exclude_from_documentation */
#ifndef INTEL_NO_MACRO_BODY
#ifndef INTEL_NO_ITTNOTIFY_API
ITT_STUBV(LIBITTAPI, void, memory_read, (void *addr, size_t size))
#define __itt_memory_read ITTNOTIFY_VOID(memory_read)
#define __itt_memory_read_ptr ITTNOTIFY_NAME(memory_read)
#else /* INTEL_NO_ITTNOTIFY_API */
#define __itt_memory_read(addr, size)
#define __itt_memory_read_ptr 0
#endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */
#define __itt_memory_read_ptr 0
#endif /* INTEL_NO_MACRO_BODY */
/** @endcond */
/**
* @deprecated Legacy API
* @brief Inform the tool of memory accesses on writing
*/
void LIBITTAPI __itt_memory_write(void *addr, size_t size);
/** @cond exclude_from_documentation */
#ifndef INTEL_NO_MACRO_BODY
#ifndef INTEL_NO_ITTNOTIFY_API
ITT_STUBV(LIBITTAPI, void, memory_write, (void *addr, size_t size))
#define __itt_memory_write ITTNOTIFY_VOID(memory_write)
#define __itt_memory_write_ptr ITTNOTIFY_NAME(memory_write)
#else /* INTEL_NO_ITTNOTIFY_API */
#define __itt_memory_write(addr, size)
#define __itt_memory_write_ptr 0
#endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */
#define __itt_memory_write_ptr 0
#endif /* INTEL_NO_MACRO_BODY */
/** @endcond */
/**
* @deprecated Legacy API
* @brief Inform the tool of memory accesses on updating
*/
void LIBITTAPI __itt_memory_update(void *address, size_t size);
/** @cond exclude_from_documentation */
#ifndef INTEL_NO_MACRO_BODY
#ifndef INTEL_NO_ITTNOTIFY_API
ITT_STUBV(LIBITTAPI, void, memory_update, (void *addr, size_t size))
#define __itt_memory_update ITTNOTIFY_VOID(memory_update)
#define __itt_memory_update_ptr ITTNOTIFY_NAME(memory_update)
#else /* INTEL_NO_ITTNOTIFY_API */
#define __itt_memory_update(addr, size)
#define __itt_memory_update_ptr 0
#endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */
#define __itt_memory_update_ptr 0
#endif /* INTEL_NO_MACRO_BODY */
/** @endcond */
/** @} legacy_memory group */
/**
* @defgroup legacy_state Thread and Object States
* @ingroup legacy
*/
/** @brief state type */
typedef int __itt_state_t;
/** @cond exclude_from_documentation */
typedef enum __itt_obj_state {
__itt_obj_state_err = 0,
__itt_obj_state_clr = 1,
__itt_obj_state_set = 2,
__itt_obj_state_use = 3
} __itt_obj_state_t;
typedef enum __itt_thr_state {
__itt_thr_state_err = 0,
__itt_thr_state_clr = 1,
__itt_thr_state_set = 2
} __itt_thr_state_t;
typedef enum __itt_obj_prop {
__itt_obj_prop_watch = 1,
__itt_obj_prop_ignore = 2,
__itt_obj_prop_sharable = 3
} __itt_obj_prop_t;
typedef enum __itt_thr_prop {
__itt_thr_prop_quiet = 1
} __itt_thr_prop_t;
/** @endcond */
/**
* @deprecated Legacy API
* @brief managing thread and object states
*/
__itt_state_t LIBITTAPI __itt_state_get(void);
/** @cond exclude_from_documentation */
#ifndef INTEL_NO_MACRO_BODY
#ifndef INTEL_NO_ITTNOTIFY_API
ITT_STUB(ITTAPI, __itt_state_t, state_get, (void))
#define __itt_state_get ITTNOTIFY_DATA(state_get)
#define __itt_state_get_ptr ITTNOTIFY_NAME(state_get)
#else /* INTEL_NO_ITTNOTIFY_API */
#define __itt_state_get(void) (__itt_state_t)0
#define __itt_state_get_ptr 0
#endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */
#define __itt_state_get_ptr 0
#endif /* INTEL_NO_MACRO_BODY */
/** @endcond */
/**
* @deprecated Legacy API
* @brief managing thread and object states
*/
__itt_state_t LIBITTAPI __itt_state_set(__itt_state_t s);
/** @cond exclude_from_documentation */
#ifndef INTEL_NO_MACRO_BODY
#ifndef INTEL_NO_ITTNOTIFY_API
ITT_STUB(ITTAPI, __itt_state_t, state_set, (__itt_state_t s))
#define __itt_state_set ITTNOTIFY_DATA(state_set)
#define __itt_state_set_ptr ITTNOTIFY_NAME(state_set)
#else /* INTEL_NO_ITTNOTIFY_API */
#define __itt_state_set(s) (__itt_state_t)0
#define __itt_state_set_ptr 0
#endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */
#define __itt_state_set_ptr 0
#endif /* INTEL_NO_MACRO_BODY */
/** @endcond */
/**
* @deprecated Legacy API
* @brief managing thread and object modes
*/
__itt_thr_state_t LIBITTAPI __itt_thr_mode_set(__itt_thr_prop_t p, __itt_thr_state_t s);
/** @cond exclude_from_documentation */
#ifndef INTEL_NO_MACRO_BODY
#ifndef INTEL_NO_ITTNOTIFY_API
ITT_STUB(ITTAPI, __itt_thr_state_t, thr_mode_set, (__itt_thr_prop_t p, __itt_thr_state_t s))
#define __itt_thr_mode_set ITTNOTIFY_DATA(thr_mode_set)
#define __itt_thr_mode_set_ptr ITTNOTIFY_NAME(thr_mode_set)
#else /* INTEL_NO_ITTNOTIFY_API */
#define __itt_thr_mode_set(p, s) (__itt_thr_state_t)0
#define __itt_thr_mode_set_ptr 0
#endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */
#define __itt_thr_mode_set_ptr 0
#endif /* INTEL_NO_MACRO_BODY */
/** @endcond */
/**
* @deprecated Legacy API
* @brief managing thread and object modes
*/
__itt_obj_state_t LIBITTAPI __itt_obj_mode_set(__itt_obj_prop_t p, __itt_obj_state_t s);
/** @cond exclude_from_documentation */
#ifndef INTEL_NO_MACRO_BODY
#ifndef INTEL_NO_ITTNOTIFY_API
ITT_STUB(ITTAPI, __itt_obj_state_t, obj_mode_set, (__itt_obj_prop_t p, __itt_obj_state_t s))
#define __itt_obj_mode_set ITTNOTIFY_DATA(obj_mode_set)
#define __itt_obj_mode_set_ptr ITTNOTIFY_NAME(obj_mode_set)
#else /* INTEL_NO_ITTNOTIFY_API */
#define __itt_obj_mode_set(p, s) (__itt_obj_state_t)0
#define __itt_obj_mode_set_ptr 0
#endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */
#define __itt_obj_mode_set_ptr 0
#endif /* INTEL_NO_MACRO_BODY */
/** @endcond */
/** @} legacy_state group */
/**
* @defgroup frames Frames
* @ingroup legacy
* Frames group
* @{
*/
/**
* @brief opaque structure for frame identification
*/
typedef struct __itt_frame_t *__itt_frame;
/**
* @brief Create a global frame with given domain
*/
#if ITT_PLATFORM==ITT_PLATFORM_WIN
__itt_frame ITTAPI __itt_frame_createA(const char *domain);
__itt_frame ITTAPI __itt_frame_createW(const wchar_t *domain);
#if defined(UNICODE) || defined(_UNICODE)
# define __itt_frame_create __itt_frame_createW
# define __itt_frame_create_ptr __itt_frame_createW_ptr
#else /* UNICODE */
# define __itt_frame_create __itt_frame_createA
# define __itt_frame_create_ptr __itt_frame_createA_ptr
#endif /* UNICODE */
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
__itt_frame ITTAPI __itt_frame_create(const char *domain);
#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_frame, frame_createA, (const char *domain))
ITT_STUB(ITTAPI, __itt_frame, frame_createW, (const wchar_t *domain))
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
ITT_STUB(ITTAPI, __itt_frame, frame_create, (const char *domain))
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#if ITT_PLATFORM==ITT_PLATFORM_WIN
#define __itt_frame_createA ITTNOTIFY_DATA(frame_createA)
#define __itt_frame_createA_ptr ITTNOTIFY_NAME(frame_createA)
#define __itt_frame_createW ITTNOTIFY_DATA(frame_createW)
#define __itt_frame_createW_ptr ITTNOTIFY_NAME(frame_createW)
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#define __itt_frame_create ITTNOTIFY_DATA(frame_create)
#define __itt_frame_create_ptr ITTNOTIFY_NAME(frame_create)
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#else /* INTEL_NO_ITTNOTIFY_API */
#if ITT_PLATFORM==ITT_PLATFORM_WIN
#define __itt_frame_createA(domain)
#define __itt_frame_createA_ptr 0
#define __itt_frame_createW(domain)
#define __itt_frame_createW_ptr 0
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#define __itt_frame_create(domain)
#define __itt_frame_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_frame_createA_ptr 0
#define __itt_frame_createW_ptr 0
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#define __itt_frame_create_ptr 0
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#endif /* INTEL_NO_MACRO_BODY */
/** @endcond */
/** @brief Record a frame begin occurrence. */
void ITTAPI __itt_frame_begin(__itt_frame frame);
/** @brief Record a frame end occurrence. */
void ITTAPI __itt_frame_end (__itt_frame frame);
/** @cond exclude_from_documentation */
#ifndef INTEL_NO_MACRO_BODY
#ifndef INTEL_NO_ITTNOTIFY_API
ITT_STUBV(ITTAPI, void, frame_begin, (__itt_frame frame))
ITT_STUBV(ITTAPI, void, frame_end, (__itt_frame frame))
#define __itt_frame_begin ITTNOTIFY_VOID(frame_begin)
#define __itt_frame_begin_ptr ITTNOTIFY_NAME(frame_begin)
#define __itt_frame_end ITTNOTIFY_VOID(frame_end)
#define __itt_frame_end_ptr ITTNOTIFY_NAME(frame_end)
#else /* INTEL_NO_ITTNOTIFY_API */
#define __itt_frame_begin(frame)
#define __itt_frame_begin_ptr 0
#define __itt_frame_end(frame)
#define __itt_frame_end_ptr 0
#endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */
#define __itt_frame_begin_ptr 0
#define __itt_frame_end_ptr 0
#endif /* INTEL_NO_MACRO_BODY */
/** @endcond */
/** @} frames group */
#ifdef __cplusplus
}
#endif /* __cplusplus */
#endif /* _LEGACY_ITTNOTIFY_H_ */

19
deps/v8/third_party/ittapi/include/libittnotify.h vendored Normal file
View File

@ -0,0 +1,19 @@
/*
Copyright (C) 2005-2019 Intel Corporation
SPDX-License-Identifier: GPL-2.0-only OR BSD-3-Clause
*/
#ifndef _LIBITTNOTIFY_H_
#define _LIBITTNOTIFY_H_
#ifndef __ITT_INTERNAL_INCLUDE
# if defined WIN32 || defined _WIN32
# pragma message("WARNING!!! Include file libittnotify.h is deprecated and should not be included anymore")
# else /* WIN32 */
# warning "Include file libittnotify.h is deprecated and should not be included anymore"
# endif /* WIN32 */
#endif /* __ITT_INTERNAL_INCLUDE */
#include "legacy/ittnotify.h"
#endif /* _LIBITTNOTIFY_H_ */

3
deps/v8/third_party/ittapi/ittapi-rs/.gitignore vendored Normal file
View File

@ -0,0 +1,3 @@
/target
**/*.rs.bk
Cargo.lock

1
deps/v8/third_party/ittapi/ittapi-rs/CMakeLists.txt vendored Symbolic link
View File

@ -0,0 +1 @@
../CMakeLists.txt

22
deps/v8/third_party/ittapi/ittapi-rs/Cargo.toml vendored Normal file
View File

@ -0,0 +1,22 @@
[package]
name = "ittapi-rs"
version = "0.1.5"
authors = ["Johnnie Birch <45402135+jlb6740@users.noreply.github.com>"]
edition = "2018"
description = "Rust bindings for ittapi"
license-file = "LICENSES/"
documentation = "https://docs.rs/ittapi-rs"
homepage = "https://github.com/intel/ittapi/ittapi-rs"
repository = "https://github.com/intel/ittapi"
[dependencies]
[features]
force_32 = []
[build-dependencies]
cmake = "0.1.42"
[dev-dependencies]
bindgen = "0.52.0"
diff = "0.1"

1
deps/v8/third_party/ittapi/ittapi-rs/LICENSES vendored Symbolic link
View File

@ -0,0 +1 @@
../LICENSES/

14
deps/v8/third_party/ittapi/ittapi-rs/README.md vendored Normal file
View File

@ -0,0 +1,14 @@
# ittapi-rs
This package creates Rust bindings for ittapi. Ittapi is used for instrumentation and tracking and just-in-time profiling.
Note the building of this package is currently only supported (tested) on a couple of Linux platforms (recent Ubuntu and Fedora builds) but support for other platforms is intended and contributions are welcomed.
# Build the package
cargo build
** Note This package uses bindgen which in turn requires recent versions of cmake and llvm to be installed. For Fedora, "yum install llvm-devel" was needed to bring in llvm-config.
** Also note building this package requires rust nightly.
# Publish the package to crates.io
cargo publish

37
deps/v8/third_party/ittapi/ittapi-rs/build.rs vendored Normal file
View File

@ -0,0 +1,37 @@
#![allow(unused)]
use cmake::Config;
use std::env;
use std::path::PathBuf;
#[cfg(target_os = "windows")]
fn main() {}
#[cfg(not(target_os = "windows"))]
fn main() {
let out_dir = env::var("OUT_DIR").unwrap();
let out_path = PathBuf::from(out_dir);
#[cfg(not(feature = "force_32"))]
{
let _ittnotify_64 = Config::new("./")
.generator("Unix Makefiles")
.no_build_target(true)
.build();
println!("cargo:rustc-link-search={}/build/bin/", out_path.display());
println!("cargo:rustc-link-lib=static=ittnotify");
}
#[cfg(feature = "force_32")]
#[cfg(not(any(target_os = "ios", target_os = "macos")))]
{
let _ittnotify_32 = Config::new("./")
.generator("Unix Makefiles")
.define("FORCE_32", "ON")
.no_build_target(true)
.build();
println!("cargo:rustc-link-search={}/build/bin/", out_path.display());
println!("cargo:rustc-link-lib=static=ittnotify32");
}
}

1
deps/v8/third_party/ittapi/ittapi-rs/include vendored Symbolic link
View File

@ -0,0 +1 @@
../include/

1
deps/v8/third_party/ittapi/ittapi-rs/src/ittnotify vendored Symbolic link
View File

@ -0,0 +1 @@
../../src/ittnotify

2987
deps/v8/third_party/ittapi/ittapi-rs/src/ittnotify_bindings.rs vendored Normal file
View File

File diff suppressed because it is too large Load Diff

1002
deps/v8/third_party/ittapi/ittapi-rs/src/jitprofiling_bindings.rs vendored Normal file
View File

File diff suppressed because it is too large Load Diff

4
deps/v8/third_party/ittapi/ittapi-rs/src/lib.rs vendored Normal file
View File

@ -0,0 +1,4 @@
#![allow(non_snake_case, non_camel_case_types, non_upper_case_globals)]
#![allow(unused)]
include!("ittnotify_bindings.rs");
include!("jitprofiling_bindings.rs");

68
deps/v8/third_party/ittapi/ittapi-rs/tests/bindgen-up-to-date.rs vendored Normal file
View File

@ -0,0 +1,68 @@
// This is a smoke test for pre-generated `src/ittapi-bindings.rs` and
// `src/jitprofiling-bindings.rs` files to see that they don't need to be
// updated. We check in a generated version so downstream consumers don't
// have to get `bindgen` working themselves.
//
// If bindgen or ittapi.h or jitprofiling.h change you can run tests with
// `BLESS=1` (inpired by a similiar pach for binaryen) to regenerate the
// source files, otherwise this can test on CI that the file doesn't need
// to be regenerated.
#![allow(non_snake_case, non_camel_case_types, non_upper_case_globals)]
#![allow(unused)]
#[test]
fn test_ittnotify_bindings_up_to_date() {
let expected = bindgen::Builder::default()
.rustfmt_bindings(true)
.header("./include/ittnotify.h")
.generate()
.expect("Unable to generate ittnotify bindings.")
.to_string();
if std::env::var("BLESS").is_ok() {
std::fs::write("src/ittnotify_bindings.rs", expected).unwrap();
} else {
let actual = include_str!("../src/ittnotify_bindings.rs");
if expected == actual {
return;
}
for diff in diff::lines(&expected, &actual) {
match diff {
diff::Result::Both(_, s) => println!(" {}", s),
diff::Result::Left(s) => println!("-{}", s),
diff::Result::Right(s) => println!("+{}", s),
}
}
panic!("differences found, need to regenerate ittnotify bindings");
}
}
#[test]
fn test_jitprofiling_bindings_up_to_date() {
let expected = bindgen::Builder::default()
.rustfmt_bindings(true)
.header("./include/jitprofiling.h")
.generate()
.expect("Unable to generate jitprofiling bindings")
.to_string();
if std::env::var("BLESS").is_ok() {
std::fs::write("src/jitprofiling_bindings.rs", expected).unwrap();
} else {
let actual = include_str!("../src/jitprofiling_bindings.rs");
if expected == actual {
return;
}
for diff in diff::lines(&expected, &actual) {
match diff {
diff::Result::Both(_, s) => println!(" {}", s),
diff::Result::Left(s) => println!("-{}", s),
diff::Result::Right(s) => println!("+{}", s),
}
}
panic!("differences found, need to regenerate jitprofiling bindings");
}
}

25
deps/v8/third_party/ittapi/src/ittnotify/disable_warnings.h vendored Normal file
View File

@ -0,0 +1,25 @@
/*
Copyright (C) 2005-2019 Intel Corporation
SPDX-License-Identifier: GPL-2.0-only OR BSD-3-Clause
*/
#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 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 */
#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 declaration */
#pragma warning (disable: 1419) /* external declaration in primary source file */
#endif /* __INTEL_COMPILER */

585
deps/v8/third_party/ittapi/src/ittnotify/ittnotify_config.h vendored Normal file
View File

@ -0,0 +1,585 @@
/*
Copyright (C) 2005-2019 Intel Corporation
SPDX-License-Identifier: GPL-2.0-only OR BSD-3-Clause
*/
#ifndef _ITTNOTIFY_CONFIG_H_
#define _ITTNOTIFY_CONFIG_H_
/** @cond exclude_from_documentation */
#ifndef ITT_OS_WIN
# define ITT_OS_WIN 1
#endif /* ITT_OS_WIN */
#ifndef ITT_OS_LINUX
# define ITT_OS_LINUX 2
#endif /* ITT_OS_LINUX */
#ifndef ITT_OS_MAC
# define ITT_OS_MAC 3
#endif /* ITT_OS_MAC */
#ifndef ITT_OS_FREEBSD
# define ITT_OS_FREEBSD 4
#endif /* ITT_OS_FREEBSD */
#ifndef ITT_OS
# if defined WIN32 || defined _WIN32
# define ITT_OS ITT_OS_WIN
# elif defined( __APPLE__ ) && defined( __MACH__ )
# define ITT_OS ITT_OS_MAC
# elif defined( __FreeBSD__ )
# define ITT_OS ITT_OS_FREEBSD
# else
# define ITT_OS ITT_OS_LINUX
# endif
#endif /* ITT_OS */
#ifndef ITT_PLATFORM_WIN
# define ITT_PLATFORM_WIN 1
#endif /* ITT_PLATFORM_WIN */
#ifndef ITT_PLATFORM_POSIX
# define ITT_PLATFORM_POSIX 2
#endif /* ITT_PLATFORM_POSIX */
#ifndef ITT_PLATFORM_MAC
# define ITT_PLATFORM_MAC 3
#endif /* ITT_PLATFORM_MAC */
#ifndef ITT_PLATFORM_FREEBSD
# define ITT_PLATFORM_FREEBSD 4
#endif /* ITT_PLATFORM_FREEBSD */
#ifndef ITT_PLATFORM
# if ITT_OS==ITT_OS_WIN
# define ITT_PLATFORM ITT_PLATFORM_WIN
# elif ITT_OS==ITT_OS_MAC
# define ITT_PLATFORM ITT_PLATFORM_MAC
# elif ITT_OS==ITT_OS_FREEBSD
# define ITT_PLATFORM ITT_PLATFORM_FREEBSD
# else
# define ITT_PLATFORM ITT_PLATFORM_POSIX
# endif
#endif /* ITT_PLATFORM */
#if defined(_UNICODE) && !defined(UNICODE)
#define UNICODE
#endif
#include <stddef.h>
#if ITT_PLATFORM==ITT_PLATFORM_WIN
#include <tchar.h>
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#include <stdint.h>
#if defined(UNICODE) || defined(_UNICODE)
#include <wchar.h>
#endif /* UNICODE || _UNICODE */
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#ifndef ITTAPI_CDECL
# if ITT_PLATFORM==ITT_PLATFORM_WIN
# define ITTAPI_CDECL __cdecl
# else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
# if defined _M_IX86 || defined __i386__
# define ITTAPI_CDECL __attribute__ ((cdecl))
# else /* _M_IX86 || __i386__ */
# define ITTAPI_CDECL /* actual only on x86 platform */
# endif /* _M_IX86 || __i386__ */
# endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#endif /* ITTAPI_CDECL */
#ifndef STDCALL
# if ITT_PLATFORM==ITT_PLATFORM_WIN
# define STDCALL __stdcall
# else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
# if defined _M_IX86 || defined __i386__
# define STDCALL __attribute__ ((stdcall))
# else /* _M_IX86 || __i386__ */
# define STDCALL /* supported only on x86 platform */
# endif /* _M_IX86 || __i386__ */
# endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#endif /* STDCALL */
#define ITTAPI ITTAPI_CDECL
#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) */
#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_INLINE static
#define ITT_INLINE_ATTRIBUTE __attribute__((unused))
#else /* __STRICT_ANSI__ */
#define ITT_INLINE static inline
#define ITT_INLINE_ATTRIBUTE __attribute__((always_inline, unused))
#endif /* __STRICT_ANSI__ */
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
/** @endcond */
#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 */
#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_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
# 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_EXTERN_C /* nothing */
# define ITT_EXTERN_C_BEGIN /* nothing */
# define ITT_EXTERN_C_END /* nothing */
#endif /* __cplusplus */
#define ITT_TO_STR_AUX(x) #x
#define ITT_TO_STR(x) ITT_TO_STR_AUX(x)
#define __ITT_BUILD_ASSERT(expr, suffix) do { \
static char __itt_build_check_##suffix[(expr) ? 1 : -1]; \
__itt_build_check_##suffix[0] = 0; \
} 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 20180723
#ifndef API_VERSION_NUM
#define API_VERSION_NUM 3.18.13
#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;
#define MUTEX_INITIALIZER { 0 }
#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 */
#endif /* _GNU_SOURCE */
#ifndef __USE_UNIX98
#define __USE_UNIX98 1 /* need for PTHREAD_MUTEX_RECURSIVE, on SLES11.1 with gcc 4.3.4 wherein pthread.h missing dependency on __USE_XOPEN2K8 */
#endif /*__USE_UNIX98*/
#include <pthread.h>
typedef void* lib_t;
typedef pthread_t TIDT;
typedef pthread_mutex_t mutex_t;
#define MUTEX_INITIALIZER PTHREAD_MUTEX_INITIALIZER
#define _strong_alias(name, aliasname) \
extern __typeof (name) aliasname __attribute__ ((alias (#name)));
#define strong_alias(name, aliasname) _strong_alias(name, aliasname)
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#if ITT_PLATFORM==ITT_PLATFORM_WIN
#define __itt_get_proc(lib, name) GetProcAddress(lib, name)
#define __itt_mutex_init(mutex) InitializeCriticalSection(mutex)
#define __itt_mutex_lock(mutex) EnterCriticalSection(mutex)
#define __itt_mutex_unlock(mutex) LeaveCriticalSection(mutex)
#define __itt_load_lib(name) LoadLibraryA(name)
#define __itt_unload_lib(handle) FreeLibrary(handle)
#define __itt_system_error() (int)GetLastError()
#define __itt_fstrcmp(s1, s2) lstrcmpA(s1, s2)
#define __itt_fstrnlen(s, l) strnlen_s(s, l)
#define __itt_fstrcpyn(s1, b, s2, l) strncpy_s(s1, b, s2, l)
#define __itt_fstrdup(s) _strdup(s)
#define __itt_thread_id() GetCurrentThreadId()
#define __itt_thread_yield() SwitchToThread()
#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 InterlockedIncrement(ptr);
}
#endif /* ITT_SIMPLE_INIT */
#define DL_SYMBOLS (1)
#define PTHREAD_SYMBOLS (1)
#else /* ITT_PLATFORM!=ITT_PLATFORM_WIN */
#define __itt_get_proc(lib, name) dlsym(lib, name)
#define __itt_mutex_init(mutex) {\
pthread_mutexattr_t mutex_attr; \
int error_code = pthread_mutexattr_init(&mutex_attr); \
if (error_code) \
__itt_report_error(__itt_error_system, "pthread_mutexattr_init", \
error_code); \
error_code = pthread_mutexattr_settype(&mutex_attr, \
PTHREAD_MUTEX_RECURSIVE); \
if (error_code) \
__itt_report_error(__itt_error_system, "pthread_mutexattr_settype", \
error_code); \
error_code = pthread_mutex_init(mutex, &mutex_attr); \
if (error_code) \
__itt_report_error(__itt_error_system, "pthread_mutex_init", \
error_code); \
error_code = pthread_mutexattr_destroy(&mutex_attr); \
if (error_code) \
__itt_report_error(__itt_error_system, "pthread_mutexattr_destroy", \
error_code); \
}
#define __itt_mutex_lock(mutex) pthread_mutex_lock(mutex)
#define __itt_mutex_unlock(mutex) pthread_mutex_unlock(mutex)
#define __itt_load_lib(name) dlopen(name, RTLD_LAZY)
#define __itt_unload_lib(handle) dlclose(handle)
#define __itt_system_error() errno
#define __itt_fstrcmp(s1, s2) strcmp(s1, s2)
/* makes customer code define safe APIs for SDL_STRNLEN_S and SDL_STRNCPY_S */
#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) { \
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;
}
#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 /* ITT_SIMPLE_INIT */
void* dlopen(const char*, int) __attribute__((weak));
void* dlsym(void*, const char*) __attribute__((weak));
int dlclose(void*) __attribute__((weak));
#define DL_SYMBOLS (dlopen && dlsym && dlclose)
int pthread_mutex_init(pthread_mutex_t*, const pthread_mutexattr_t*) __attribute__((weak));
int pthread_mutex_lock(pthread_mutex_t*) __attribute__((weak));
int pthread_mutex_unlock(pthread_mutex_t*) __attribute__((weak));
int pthread_mutex_destroy(pthread_mutex_t*) __attribute__((weak));
int pthread_mutexattr_init(pthread_mutexattr_t*) __attribute__((weak));
int pthread_mutexattr_settype(pthread_mutexattr_t*, int) __attribute__((weak));
int pthread_mutexattr_destroy(pthread_mutexattr_t*) __attribute__((weak));
pthread_t pthread_self(void) __attribute__((weak));
#define PTHREAD_SYMBOLS (pthread_mutex_init && pthread_mutex_lock && pthread_mutex_unlock && pthread_mutex_destroy && pthread_mutexattr_init && pthread_mutexattr_settype && pthread_mutexattr_destroy && pthread_self)
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
typedef enum {
__itt_collection_normal = 0,
__itt_collection_paused = 1
} __itt_collection_state;
typedef enum {
__itt_thread_normal = 0,
__itt_thread_ignored = 1
} __itt_thread_state;
#pragma pack(push, 8)
typedef struct ___itt_thread_info
{
const char* nameA; /*!< Copy of original name in ASCII. */
#if defined(UNICODE) || defined(_UNICODE)
const wchar_t* nameW; /*!< Copy of original name in UNICODE. */
#else /* UNICODE || _UNICODE */
void* nameW;
#endif /* UNICODE || _UNICODE */
TIDT tid;
__itt_thread_state state; /*!< Thread state (paused or normal) */
int extra1; /*!< Reserved to the runtime */
void* extra2; /*!< Reserved to the runtime */
struct ___itt_thread_info* next;
} __itt_thread_info;
#include "ittnotify_types.h" /* For __itt_group_id definition */
typedef struct ___itt_api_info_20101001
{
const char* name;
void** func_ptr;
void* init_func;
__itt_group_id group;
} __itt_api_info_20101001;
typedef struct ___itt_api_info
{
const char* name;
void** func_ptr;
void* init_func;
void* null_func;
__itt_group_id group;
} __itt_api_info;
typedef struct __itt_counter_info
{
const char* nameA; /*!< Copy of original name in ASCII. */
#if defined(UNICODE) || defined(_UNICODE)
const wchar_t* nameW; /*!< Copy of original name in UNICODE. */
#else /* UNICODE || _UNICODE */
void* nameW;
#endif /* UNICODE || _UNICODE */
const char* domainA; /*!< Copy of original name in ASCII. */
#if defined(UNICODE) || defined(_UNICODE)
const wchar_t* domainW; /*!< Copy of original name in UNICODE. */
#else /* UNICODE || _UNICODE */
void* domainW;
#endif /* UNICODE || _UNICODE */
int type;
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;
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;
} __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) { \
h->tid = t; \
h->nameA = NULL; \
h->nameW = n ? _wcsdup(n) : NULL; \
h->state = s; \
h->extra1 = 0; /* reserved */ \
h->extra2 = NULL; /* reserved */ \
h->next = NULL; \
if (h_tail == NULL) \
(gptr)->thread_list = h; \
else \
h_tail->next = h; \
} \
}
#define NEW_THREAD_INFO_A(gptr,h,h_tail,t,s,n) { \
h = (__itt_thread_info*)malloc(sizeof(__itt_thread_info)); \
if (h != NULL) { \
h->tid = t; \
h->nameA = n ? __itt_fstrdup(n) : NULL; \
h->nameW = NULL; \
h->state = s; \
h->extra1 = 0; /* reserved */ \
h->extra2 = NULL; /* reserved */ \
h->next = NULL; \
if (h_tail == NULL) \
(gptr)->thread_list = h; \
else \
h_tail->next = h; \
} \
}
#define NEW_DOMAIN_W(gptr,h,h_tail,name) { \
h = (__itt_domain*)malloc(sizeof(__itt_domain)); \
if (h != NULL) { \
h->flags = 1; /* domain is enabled by default */ \
h->nameA = NULL; \
h->nameW = name ? _wcsdup(name) : NULL; \
h->extra1 = 0; /* reserved */ \
h->extra2 = NULL; /* reserved */ \
h->next = NULL; \
if (h_tail == NULL) \
(gptr)->domain_list = h; \
else \
h_tail->next = h; \
} \
}
#define NEW_DOMAIN_A(gptr,h,h_tail,name) { \
h = (__itt_domain*)malloc(sizeof(__itt_domain)); \
if (h != NULL) { \
h->flags = 1; /* domain is enabled by default */ \
h->nameA = name ? __itt_fstrdup(name) : NULL; \
h->nameW = NULL; \
h->extra1 = 0; /* reserved */ \
h->extra2 = NULL; /* reserved */ \
h->next = NULL; \
if (h_tail == NULL) \
(gptr)->domain_list = h; \
else \
h_tail->next = h; \
} \
}
#define NEW_STRING_HANDLE_W(gptr,h,h_tail,name) { \
h = (__itt_string_handle*)malloc(sizeof(__itt_string_handle)); \
if (h != NULL) { \
h->strA = NULL; \
h->strW = name ? _wcsdup(name) : NULL; \
h->extra1 = 0; /* reserved */ \
h->extra2 = NULL; /* reserved */ \
h->next = NULL; \
if (h_tail == NULL) \
(gptr)->string_list = h; \
else \
h_tail->next = h; \
} \
}
#define NEW_STRING_HANDLE_A(gptr,h,h_tail,name) { \
h = (__itt_string_handle*)malloc(sizeof(__itt_string_handle)); \
if (h != NULL) { \
h->strA = name ? __itt_fstrdup(name) : NULL; \
h->strW = NULL; \
h->extra1 = 0; /* reserved */ \
h->extra2 = NULL; /* reserved */ \
h->next = NULL; \
if (h_tail == NULL) \
(gptr)->string_list = h; \
else \
h_tail->next = h; \
} \
}
#define NEW_COUNTER_W(gptr,h,h_tail,name,domain,type) { \
h = (__itt_counter_info_t*)malloc(sizeof(__itt_counter_info_t)); \
if (h != NULL) { \
h->nameA = NULL; \
h->nameW = name ? _wcsdup(name) : NULL; \
h->domainA = NULL; \
h->domainW = name ? _wcsdup(domain) : NULL; \
h->type = type; \
h->index = 0; \
h->next = NULL; \
if (h_tail == NULL) \
(gptr)->counter_list = h; \
else \
h_tail->next = h; \
} \
}
#define NEW_COUNTER_A(gptr,h,h_tail,name,domain,type) { \
h = (__itt_counter_info_t*)malloc(sizeof(__itt_counter_info_t)); \
if (h != NULL) { \
h->nameA = name ? __itt_fstrdup(name) : NULL; \
h->nameW = NULL; \
h->domainA = domain ? __itt_fstrdup(domain) : NULL; \
h->domainW = NULL; \
h->type = type; \
h->index = 0; \
h->next = NULL; \
if (h_tail == NULL) \
(gptr)->counter_list = h; \
else \
h_tail->next = h; \
} \
}
#endif /* _ITTNOTIFY_CONFIG_H_ */

1359
deps/v8/third_party/ittapi/src/ittnotify/ittnotify_static.c vendored Normal file
View File

File diff suppressed because it is too large Load Diff

346
deps/v8/third_party/ittapi/src/ittnotify/ittnotify_static.h vendored Normal file
View File

@ -0,0 +1,346 @@
/*
Copyright (C) 2005-2019 Intel Corporation
SPDX-License-Identifier: GPL-2.0-only OR BSD-3-Clause
*/
#include "ittnotify_config.h"
#ifndef ITT_FORMAT_DEFINED
# ifndef ITT_FORMAT
# define ITT_FORMAT
# endif /* ITT_FORMAT */
# ifndef ITT_NO_PARAMS
# define ITT_NO_PARAMS
# endif /* ITT_NO_PARAMS */
#endif /* ITT_FORMAT_DEFINED */
/*
* parameters for macro expected:
* ITT_STUB(api, type, func_name, arguments, params, func_name_in_dll, group, printf_fmt)
*/
#ifdef __ITT_INTERNAL_INIT
#ifndef __ITT_INTERNAL_BODY
#if ITT_PLATFORM==ITT_PLATFORM_WIN
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(ITTAPI, __itt_string_handle*, string_handle_create, (const char *name), (ITT_FORMAT name), string_handle_create, __itt_group_structure, "\"%s\"")
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#if ITT_PLATFORM==ITT_PLATFORM_WIN
ITT_STUB(ITTAPI, __itt_counter, counter_createA, (const char *name, const char *domain), (ITT_FORMAT name, domain), counter_createA, __itt_group_counter, "\"%s\", \"%s\"")
ITT_STUB(ITTAPI, __itt_counter, counter_createW, (const wchar_t *name, const wchar_t *domain), (ITT_FORMAT name, domain), counter_createW, __itt_group_counter, "\"%s\", \"%s\"")
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
ITT_STUB(ITTAPI, __itt_counter, counter_create, (const char *name, const char *domain), (ITT_FORMAT name, domain), counter_create, __itt_group_counter, "\"%s\", \"%s\"")
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#if ITT_PLATFORM==ITT_PLATFORM_WIN
ITT_STUB(ITTAPI, __itt_counter, counter_create_typedA, (const char *name, const char *domain, __itt_metadata_type type), (ITT_FORMAT name, domain, type), counter_create_typedA, __itt_group_counter, "\"%s\", \"%s\", %d")
ITT_STUB(ITTAPI, __itt_counter, counter_create_typedW, (const wchar_t *name, const wchar_t *domain, __itt_metadata_type type), (ITT_FORMAT name, domain, type), counter_create_typedW, __itt_group_counter, "\"%s\", \"%s\", %d")
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
ITT_STUB(ITTAPI, __itt_counter, counter_create_typed, (const char *name, const char *domain, __itt_metadata_type type), (ITT_FORMAT name, domain, type), counter_create_typed, __itt_group_counter, "\"%s\", \"%s\", %d")
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
ITT_STUBV(ITTAPI, void, pause, (void), (ITT_NO_PARAMS), pause, __itt_group_control | __itt_group_legacy, "no args")
ITT_STUBV(ITTAPI, void, resume, (void), (ITT_NO_PARAMS), resume, __itt_group_control | __itt_group_legacy, "no args")
#if ITT_PLATFORM==ITT_PLATFORM_WIN
ITT_STUBV(ITTAPI, void, thread_set_nameA, (const char *name), (ITT_FORMAT name), thread_set_nameA, __itt_group_thread, "\"%s\"")
ITT_STUBV(ITTAPI, void, thread_set_nameW, (const wchar_t *name), (ITT_FORMAT name), thread_set_nameW, __itt_group_thread, "\"%S\"")
#else /* ITT_PLATFORM!=ITT_PLATFORM_WIN */
ITT_STUBV(ITTAPI, void, thread_set_name, (const char *name), (ITT_FORMAT name), thread_set_name, __itt_group_thread, "\"%s\"")
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
ITT_STUBV(ITTAPI, void, thread_ignore, (void), (ITT_NO_PARAMS), thread_ignore, __itt_group_thread, "no args")
#if ITT_PLATFORM==ITT_PLATFORM_WIN
ITT_STUB(LIBITTAPI, int, thr_name_setA, (const char *name, int namelen), (ITT_FORMAT name, namelen), thr_name_setA, __itt_group_thread | __itt_group_legacy, "\"%s\", %d")
ITT_STUB(LIBITTAPI, int, thr_name_setW, (const wchar_t *name, int namelen), (ITT_FORMAT name, namelen), thr_name_setW, __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")
#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_group_control | __itt_group_legacy, "no args")
#if ITT_PLATFORM==ITT_PLATFORM_WIN
ITT_STUBV(ITTAPI, void, sync_createA, (void *addr, const char *objtype, const char *objname, int attribute), (ITT_FORMAT addr, objtype, objname, attribute), sync_createA, __itt_group_sync | __itt_group_fsync, "%p, \"%s\", \"%s\", %x")
ITT_STUBV(ITTAPI, void, sync_createW, (void *addr, const wchar_t *objtype, const wchar_t *objname, int attribute), (ITT_FORMAT addr, objtype, objname, attribute), sync_createW, __itt_group_sync | __itt_group_fsync, "%p, \"%S\", \"%S\", %x")
ITT_STUBV(ITTAPI, void, sync_renameA, (void *addr, const char *name), (ITT_FORMAT addr, name), sync_renameA, __itt_group_sync | __itt_group_fsync, "%p, \"%s\"")
ITT_STUBV(ITTAPI, void, sync_renameW, (void *addr, const wchar_t *name), (ITT_FORMAT addr, name), sync_renameW, __itt_group_sync | __itt_group_fsync, "%p, \"%S\"")
#else /* ITT_PLATFORM!=ITT_PLATFORM_WIN */
ITT_STUBV(ITTAPI, void, sync_create, (void *addr, const char *objtype, const char *objname, int attribute), (ITT_FORMAT addr, objtype, objname, attribute), sync_create, __itt_group_sync | __itt_group_fsync, "%p, \"%s\", \"%s\", %x")
ITT_STUBV(ITTAPI, void, sync_rename, (void *addr, const char *name), (ITT_FORMAT addr, name), sync_rename, __itt_group_sync | __itt_group_fsync, "%p, \"%s\"")
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
ITT_STUBV(ITTAPI, void, sync_destroy, (void *addr), (ITT_FORMAT addr), sync_destroy, __itt_group_sync | __itt_group_fsync, "%p")
ITT_STUBV(ITTAPI, void, sync_prepare, (void* addr), (ITT_FORMAT addr), sync_prepare, __itt_group_sync, "%p")
ITT_STUBV(ITTAPI, void, sync_cancel, (void *addr), (ITT_FORMAT addr), sync_cancel, __itt_group_sync, "%p")
ITT_STUBV(ITTAPI, void, sync_acquired, (void *addr), (ITT_FORMAT addr), sync_acquired, __itt_group_sync, "%p")
ITT_STUBV(ITTAPI, void, sync_releasing, (void* addr), (ITT_FORMAT addr), sync_releasing, __itt_group_sync, "%p")
ITT_STUBV(ITTAPI, void, suppress_push, (unsigned int mask), (ITT_FORMAT mask), suppress_push, __itt_group_suppress, "%p")
ITT_STUBV(ITTAPI, void, suppress_pop, (void), (ITT_NO_PARAMS), suppress_pop, __itt_group_suppress, "no args")
ITT_STUBV(ITTAPI, void, suppress_mark_range, (__itt_suppress_mode_t mode, unsigned int mask, void * address, size_t size),(ITT_FORMAT mode, mask, address, size), suppress_mark_range, __itt_group_suppress, "%d, %p, %p, %d")
ITT_STUBV(ITTAPI, void, suppress_clear_range,(__itt_suppress_mode_t mode, unsigned int mask, void * address, size_t size),(ITT_FORMAT mode, mask, address, size), suppress_clear_range,__itt_group_suppress, "%d, %p, %p, %d")
ITT_STUBV(ITTAPI, void, fsync_prepare, (void* addr), (ITT_FORMAT addr), sync_prepare, __itt_group_fsync, "%p")
ITT_STUBV(ITTAPI, void, fsync_cancel, (void *addr), (ITT_FORMAT addr), sync_cancel, __itt_group_fsync, "%p")
ITT_STUBV(ITTAPI, void, fsync_acquired, (void *addr), (ITT_FORMAT addr), sync_acquired, __itt_group_fsync, "%p")
ITT_STUBV(ITTAPI, void, fsync_releasing, (void* addr), (ITT_FORMAT addr), sync_releasing, __itt_group_fsync, "%p")
ITT_STUBV(ITTAPI, void, model_site_begin, (__itt_model_site *site, __itt_model_site_instance *instance, const char *name), (ITT_FORMAT site, instance, name), model_site_begin, __itt_group_model, "%p, %p, \"%s\"")
ITT_STUBV(ITTAPI, void, model_site_end, (__itt_model_site *site, __itt_model_site_instance *instance), (ITT_FORMAT site, instance), model_site_end, __itt_group_model, "%p, %p")
ITT_STUBV(ITTAPI, void, model_task_begin, (__itt_model_task *task, __itt_model_task_instance *instance, const char *name), (ITT_FORMAT task, instance, name), model_task_begin, __itt_group_model, "%p, %p, \"%s\"")
ITT_STUBV(ITTAPI, void, model_task_end, (__itt_model_task *task, __itt_model_task_instance *instance), (ITT_FORMAT task, instance), model_task_end, __itt_group_model, "%p, %p")
ITT_STUBV(ITTAPI, void, model_lock_acquire, (void *lock), (ITT_FORMAT lock), model_lock_acquire, __itt_group_model, "%p")
ITT_STUBV(ITTAPI, void, model_lock_release, (void *lock), (ITT_FORMAT lock), model_lock_release, __itt_group_model, "%p")
ITT_STUBV(ITTAPI, void, model_record_allocation, (void *addr, size_t size), (ITT_FORMAT addr, size), model_record_allocation, __itt_group_model, "%p, %d")
ITT_STUBV(ITTAPI, void, model_record_deallocation, (void *addr), (ITT_FORMAT addr), model_record_deallocation, __itt_group_model, "%p")
ITT_STUBV(ITTAPI, void, model_induction_uses, (void* addr, size_t size), (ITT_FORMAT addr, size), model_induction_uses, __itt_group_model, "%p, %d")
ITT_STUBV(ITTAPI, void, model_reduction_uses, (void* addr, size_t size), (ITT_FORMAT addr, size), model_reduction_uses, __itt_group_model, "%p, %d")
ITT_STUBV(ITTAPI, void, model_observe_uses, (void* addr, size_t size), (ITT_FORMAT addr, size), model_observe_uses, __itt_group_model, "%p, %d")
ITT_STUBV(ITTAPI, void, model_clear_uses, (void* addr), (ITT_FORMAT addr), model_clear_uses, __itt_group_model, "%p")
#ifndef __ITT_INTERNAL_BODY
#if ITT_PLATFORM==ITT_PLATFORM_WIN
ITT_STUBV(ITTAPI, void, model_site_beginW, (const wchar_t *name), (ITT_FORMAT name), model_site_beginW, __itt_group_model, "\"%s\"")
ITT_STUBV(ITTAPI, void, model_task_beginW, (const wchar_t *name), (ITT_FORMAT name), model_task_beginW, __itt_group_model, "\"%s\"")
ITT_STUBV(ITTAPI, void, model_iteration_taskW, (const wchar_t *name), (ITT_FORMAT name), model_iteration_taskW, __itt_group_model, "\"%s\"")
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
ITT_STUBV(ITTAPI, void, model_site_beginA, (const char *name), (ITT_FORMAT name), model_site_beginA, __itt_group_model, "\"%s\"")
ITT_STUBV(ITTAPI, void, model_site_beginAL, (const char *name, size_t len), (ITT_FORMAT name, len), model_site_beginAL, __itt_group_model, "\"%s\", %d")
ITT_STUBV(ITTAPI, void, model_task_beginA, (const char *name), (ITT_FORMAT name), model_task_beginA, __itt_group_model, "\"%s\"")
ITT_STUBV(ITTAPI, void, model_task_beginAL, (const char *name, size_t len), (ITT_FORMAT name, len), model_task_beginAL, __itt_group_model, "\"%s\", %d")
ITT_STUBV(ITTAPI, void, model_iteration_taskA, (const char *name), (ITT_FORMAT name), model_iteration_taskA, __itt_group_model, "\"%s\"")
ITT_STUBV(ITTAPI, void, model_iteration_taskAL, (const char *name, size_t len), (ITT_FORMAT name, len), model_iteration_taskAL, __itt_group_model, "\"%s\", %d")
ITT_STUBV(ITTAPI, void, model_site_end_2, (void), (ITT_NO_PARAMS), model_site_end_2, __itt_group_model, "no args")
ITT_STUBV(ITTAPI, void, model_task_end_2, (void), (ITT_NO_PARAMS), model_task_end_2, __itt_group_model, "no args")
ITT_STUBV(ITTAPI, void, model_lock_acquire_2, (void *lock), (ITT_FORMAT lock), model_lock_acquire_2, __itt_group_model, "%p")
ITT_STUBV(ITTAPI, void, model_lock_release_2, (void *lock), (ITT_FORMAT lock), model_lock_release_2, __itt_group_model, "%p")
ITT_STUBV(ITTAPI, void, model_aggregate_task, (size_t count), (ITT_FORMAT count), model_aggregate_task, __itt_group_model, "%d")
ITT_STUBV(ITTAPI, void, model_disable_push, (__itt_model_disable x), (ITT_FORMAT x), model_disable_push, __itt_group_model, "%p")
ITT_STUBV(ITTAPI, void, model_disable_pop, (void), (ITT_NO_PARAMS), model_disable_pop, __itt_group_model, "no args")
#endif /* __ITT_INTERNAL_BODY */
#ifndef __ITT_INTERNAL_BODY
#if ITT_PLATFORM==ITT_PLATFORM_WIN
ITT_STUB(ITTAPI, __itt_heap_function, heap_function_createA, (const char *name, const char *domain), (ITT_FORMAT name, domain), heap_function_createA, __itt_group_heap, "\"%s\", \"%s\"")
ITT_STUB(ITTAPI, __itt_heap_function, heap_function_createW, (const wchar_t *name, const wchar_t *domain), (ITT_FORMAT name, domain), heap_function_createW, __itt_group_heap, "\"%s\", \"%s\"")
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
ITT_STUB(ITTAPI, __itt_heap_function, heap_function_create, (const char *name, const char *domain), (ITT_FORMAT name, domain), heap_function_create, __itt_group_heap, "\"%s\", \"%s\"")
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#endif /* __ITT_INTERNAL_BODY */
ITT_STUBV(ITTAPI, void, heap_allocate_begin, (__itt_heap_function h, size_t size, int initialized), (ITT_FORMAT h, size, initialized), heap_allocate_begin, __itt_group_heap, "%p, %lu, %d")
ITT_STUBV(ITTAPI, void, heap_allocate_end, (__itt_heap_function h, void** addr, size_t size, int initialized), (ITT_FORMAT h, addr, size, initialized), heap_allocate_end, __itt_group_heap, "%p, %p, %lu, %d")
ITT_STUBV(ITTAPI, void, heap_free_begin, (__itt_heap_function h, void* addr), (ITT_FORMAT h, addr), heap_free_begin, __itt_group_heap, "%p, %p")
ITT_STUBV(ITTAPI, void, heap_free_end, (__itt_heap_function h, void* addr), (ITT_FORMAT h, addr), heap_free_end, __itt_group_heap, "%p, %p")
ITT_STUBV(ITTAPI, void, heap_reallocate_begin, (__itt_heap_function h, void* addr, size_t new_size, int initialized), (ITT_FORMAT h, addr, new_size, initialized), heap_reallocate_begin, __itt_group_heap, "%p, %p, %lu, %d")
ITT_STUBV(ITTAPI, void, heap_reallocate_end, (__itt_heap_function h, void* addr, void** new_addr, size_t new_size, int initialized), (ITT_FORMAT h, addr, new_addr, new_size, initialized), heap_reallocate_end, __itt_group_heap, "%p, %p, %p, %lu, %d")
ITT_STUBV(ITTAPI, void, heap_internal_access_begin, (void), (ITT_NO_PARAMS), heap_internal_access_begin, __itt_group_heap, "no args")
ITT_STUBV(ITTAPI, void, heap_internal_access_end, (void), (ITT_NO_PARAMS), heap_internal_access_end, __itt_group_heap, "no args")
ITT_STUBV(ITTAPI, void, heap_record_memory_growth_begin, (void), (ITT_NO_PARAMS), heap_record_memory_growth_begin, __itt_group_heap, "no args")
ITT_STUBV(ITTAPI, void, heap_record_memory_growth_end, (void), (ITT_NO_PARAMS), heap_record_memory_growth_end, __itt_group_heap, "no args")
ITT_STUBV(ITTAPI, void, heap_reset_detection, (unsigned int reset_mask), (ITT_FORMAT reset_mask), heap_reset_detection, __itt_group_heap, "%u")
ITT_STUBV(ITTAPI, void, heap_record, (unsigned int record_mask), (ITT_FORMAT record_mask), heap_record, __itt_group_heap, "%u")
ITT_STUBV(ITTAPI, void, id_create, (const __itt_domain *domain, __itt_id id), (ITT_FORMAT domain, id), id_create, __itt_group_structure, "%p, %lu")
ITT_STUBV(ITTAPI, void, id_destroy, (const __itt_domain *domain, __itt_id id), (ITT_FORMAT domain, id), id_destroy, __itt_group_structure, "%p, %lu")
ITT_STUB(ITTAPI, __itt_timestamp, get_timestamp, (void), (ITT_NO_PARAMS), get_timestamp, __itt_group_structure, "no args")
ITT_STUBV(ITTAPI, void, region_begin, (const __itt_domain *domain, __itt_id id, __itt_id parent, __itt_string_handle *name), (ITT_FORMAT domain, id, parent, name), region_begin, __itt_group_structure, "%p, %lu, %lu, %p")
ITT_STUBV(ITTAPI, void, region_end, (const __itt_domain *domain, __itt_id id), (ITT_FORMAT domain, id), region_end, __itt_group_structure, "%p, %lu")
#ifndef __ITT_INTERNAL_BODY
ITT_STUBV(ITTAPI, void, frame_begin_v3, (const __itt_domain *domain, __itt_id *id), (ITT_FORMAT domain, id), frame_begin_v3, __itt_group_structure, "%p, %p")
ITT_STUBV(ITTAPI, void, frame_end_v3, (const __itt_domain *domain, __itt_id *id), (ITT_FORMAT domain, id), frame_end_v3, __itt_group_structure, "%p, %p")
ITT_STUBV(ITTAPI, void, frame_submit_v3, (const __itt_domain *domain, __itt_id *id, __itt_timestamp begin, __itt_timestamp end), (ITT_FORMAT domain, id, begin, end), frame_submit_v3, __itt_group_structure, "%p, %p, %lu, %lu")
#endif /* __ITT_INTERNAL_BODY */
ITT_STUBV(ITTAPI, void, task_group, (const __itt_domain *domain, __itt_id id, __itt_id parent, __itt_string_handle *name), (ITT_FORMAT domain, id, parent, name), task_group, __itt_group_structure, "%p, %lu, %lu, %p")
ITT_STUBV(ITTAPI, void, task_begin, (const __itt_domain *domain, __itt_id id, __itt_id parent, __itt_string_handle *name), (ITT_FORMAT domain, id, parent, name), task_begin, __itt_group_structure, "%p, %lu, %lu, %p")
ITT_STUBV(ITTAPI, void, task_begin_fn, (const __itt_domain *domain, __itt_id id, __itt_id parent, void* fn), (ITT_FORMAT domain, id, parent, fn), task_begin_fn, __itt_group_structure, "%p, %lu, %lu, %p")
ITT_STUBV(ITTAPI, void, task_end, (const __itt_domain *domain), (ITT_FORMAT domain), task_end, __itt_group_structure, "%p")
ITT_STUBV(ITTAPI, void, counter_inc_v3, (const __itt_domain *domain, __itt_string_handle *name), (ITT_FORMAT domain, name), counter_inc_v3, __itt_group_structure, "%p, %p")
ITT_STUBV(ITTAPI, void, counter_inc_delta_v3, (const __itt_domain *domain, __itt_string_handle *name, unsigned long long value), (ITT_FORMAT domain, name, value), counter_inc_delta_v3, __itt_group_structure, "%p, %p, %lu")
ITT_STUBV(ITTAPI, void, counter_dec_v3, (const __itt_domain *domain, __itt_string_handle *name), (ITT_FORMAT domain, name), counter_dec_v3, __itt_group_structure, "%p, %p")
ITT_STUBV(ITTAPI, void, counter_dec_delta_v3, (const __itt_domain *domain, __itt_string_handle *name, unsigned long long value), (ITT_FORMAT domain, name, value), counter_dec_delta_v3, __itt_group_structure, "%p, %p, %lu")
ITT_STUBV(ITTAPI, void, marker, (const __itt_domain *domain, __itt_id id, __itt_string_handle *name, __itt_scope scope), (ITT_FORMAT domain, id, name, scope), marker, __itt_group_structure, "%p, %lu, %p, %d")
ITT_STUBV(ITTAPI, void, metadata_add, (const __itt_domain *domain, __itt_id id, __itt_string_handle *key, __itt_metadata_type type, size_t count, void *data), (ITT_FORMAT domain, id, key, type, count, data), metadata_add, __itt_group_structure, "%p, %lu, %p, %d, %lu, %p")
#if ITT_PLATFORM==ITT_PLATFORM_WIN
ITT_STUBV(ITTAPI, void, metadata_str_addA, (const __itt_domain *domain, __itt_id id, __itt_string_handle *key, const char* data, size_t length), (ITT_FORMAT domain, id, key, data, length), metadata_str_addA, __itt_group_structure, "%p, %lu, %p, %p, %lu")
ITT_STUBV(ITTAPI, void, metadata_str_addW, (const __itt_domain *domain, __itt_id id, __itt_string_handle *key, const wchar_t* data, size_t length), (ITT_FORMAT domain, id, key, data, length), metadata_str_addW, __itt_group_structure, "%p, %lu, %p, %p, %lu")
#else /* ITT_PLATFORM!=ITT_PLATFORM_WIN */
ITT_STUBV(ITTAPI, void, metadata_str_add, (const __itt_domain *domain, __itt_id id, __itt_string_handle *key, const char* data, size_t length), (ITT_FORMAT domain, id, key, data, length), metadata_str_add, __itt_group_structure, "%p, %lu, %p, %p, %lu")
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
ITT_STUBV(ITTAPI, void, relation_add_to_current, (const __itt_domain *domain, __itt_relation relation, __itt_id tail), (ITT_FORMAT domain, relation, tail), relation_add_to_current, __itt_group_structure, "%p, %lu, %p")
ITT_STUBV(ITTAPI, void, relation_add, (const __itt_domain *domain, __itt_id head, __itt_relation relation, __itt_id tail), (ITT_FORMAT domain, head, relation, tail), relation_add, __itt_group_structure, "%p, %p, %lu, %p")
#ifndef __ITT_INTERNAL_BODY
#if ITT_PLATFORM==ITT_PLATFORM_WIN
ITT_STUB(LIBITTAPI, __itt_event, event_createA, (const char *name, int namelen), (ITT_FORMAT name, namelen), event_createA, __itt_group_mark | __itt_group_legacy, "\"%s\", %d")
ITT_STUB(LIBITTAPI, __itt_event, event_createW, (const wchar_t *name, int namelen), (ITT_FORMAT name, namelen), event_createW, __itt_group_mark | __itt_group_legacy, "\"%S\", %d")
#else /* ITT_PLATFORM!=ITT_PLATFORM_WIN */
ITT_STUB(LIBITTAPI, __itt_event, event_create, (const char *name, int namelen), (ITT_FORMAT name, namelen), event_create, __itt_group_mark | __itt_group_legacy, "\"%s\", %d")
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
ITT_STUB(LIBITTAPI, int, event_start, (__itt_event event), (ITT_FORMAT event), event_start, __itt_group_mark | __itt_group_legacy, "%d")
ITT_STUB(LIBITTAPI, int, event_end, (__itt_event event), (ITT_FORMAT event), event_end, __itt_group_mark | __itt_group_legacy, "%d")
#endif /* __ITT_INTERNAL_BODY */
#ifndef __ITT_INTERNAL_BODY
#if ITT_PLATFORM==ITT_PLATFORM_WIN
ITT_STUBV(ITTAPI, void, sync_set_nameA, (void *addr, const char *objtype, const char *objname, int attribute), (ITT_FORMAT addr, objtype, objname, attribute), sync_set_nameA, __itt_group_sync | __itt_group_fsync | __itt_group_legacy, "%p, \"%s\", \"%s\", %x")
ITT_STUBV(ITTAPI, void, sync_set_nameW, (void *addr, const wchar_t *objtype, const wchar_t *objname, int attribute), (ITT_FORMAT addr, objtype, objname, attribute), sync_set_nameW, __itt_group_sync | __itt_group_fsync | __itt_group_legacy, "%p, \"%S\", \"%S\", %x")
#else /* ITT_PLATFORM!=ITT_PLATFORM_WIN */
ITT_STUBV(ITTAPI, void, sync_set_name, (void *addr, const char *objtype, const char *objname, int attribute), (ITT_FORMAT addr, objtype, objname, attribute), sync_set_name, __itt_group_sync | __itt_group_fsync | __itt_group_legacy, "p, \"%s\", \"%s\", %x")
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#if ITT_PLATFORM==ITT_PLATFORM_WIN
ITT_STUB(LIBITTAPI, int, notify_sync_nameA, (void *p, const char *objtype, int typelen, const char *objname, int namelen, int attribute), (ITT_FORMAT p, objtype, typelen, objname, namelen, attribute), notify_sync_nameA, __itt_group_sync | __itt_group_fsync | __itt_group_legacy, "%p, \"%s\", %d, \"%s\", %d, %x")
ITT_STUB(LIBITTAPI, int, notify_sync_nameW, (void *p, const wchar_t *objtype, int typelen, const wchar_t *objname, int namelen, int attribute), (ITT_FORMAT p, objtype, typelen, objname, namelen, attribute), notify_sync_nameW, __itt_group_sync | __itt_group_fsync | __itt_group_legacy, "%p, \"%S\", %d, \"%S\", %d, %x")
#else /* ITT_PLATFORM!=ITT_PLATFORM_WIN */
ITT_STUB(LIBITTAPI, int, notify_sync_name, (void *p, const char *objtype, int typelen, const char *objname, int namelen, int attribute), (ITT_FORMAT p, objtype, typelen, objname, namelen, attribute), notify_sync_name, __itt_group_sync | __itt_group_fsync | __itt_group_legacy, "%p, \"%s\", %d, \"%s\", %d, %x")
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
ITT_STUBV(LIBITTAPI, void, notify_sync_prepare, (void *p), (ITT_FORMAT p), notify_sync_prepare, __itt_group_sync | __itt_group_fsync | __itt_group_legacy, "%p")
ITT_STUBV(LIBITTAPI, void, notify_sync_cancel, (void *p), (ITT_FORMAT p), notify_sync_cancel, __itt_group_sync | __itt_group_fsync | __itt_group_legacy, "%p")
ITT_STUBV(LIBITTAPI, void, notify_sync_acquired, (void *p), (ITT_FORMAT p), notify_sync_acquired, __itt_group_sync | __itt_group_fsync | __itt_group_legacy, "%p")
ITT_STUBV(LIBITTAPI, void, notify_sync_releasing, (void *p), (ITT_FORMAT p), notify_sync_releasing, __itt_group_sync | __itt_group_fsync | __itt_group_legacy, "%p")
#endif /* __ITT_INTERNAL_BODY */
ITT_STUBV(LIBITTAPI, void, memory_read, (void *addr, size_t size), (ITT_FORMAT addr, size), memory_read, __itt_group_legacy, "%p, %lu")
ITT_STUBV(LIBITTAPI, void, memory_write, (void *addr, size_t size), (ITT_FORMAT addr, size), memory_write, __itt_group_legacy, "%p, %lu")
ITT_STUBV(LIBITTAPI, void, memory_update, (void *addr, size_t size), (ITT_FORMAT addr, size), memory_update, __itt_group_legacy, "%p, %lu")
ITT_STUB(LIBITTAPI, __itt_state_t, state_get, (void), (ITT_NO_PARAMS), state_get, __itt_group_legacy, "no args")
ITT_STUB(LIBITTAPI, __itt_state_t, state_set, (__itt_state_t s), (ITT_FORMAT s), state_set, __itt_group_legacy, "%d")
ITT_STUB(LIBITTAPI, __itt_obj_state_t, obj_mode_set, (__itt_obj_prop_t p, __itt_obj_state_t s), (ITT_FORMAT p, s), obj_mode_set, __itt_group_legacy, "%d, %d")
ITT_STUB(LIBITTAPI, __itt_thr_state_t, thr_mode_set, (__itt_thr_prop_t p, __itt_thr_state_t s), (ITT_FORMAT p, s), thr_mode_set, __itt_group_legacy, "%d, %d")
#ifndef __ITT_INTERNAL_BODY
#if ITT_PLATFORM==ITT_PLATFORM_WIN
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_STUBV(ITTAPI, void, counter_inc, (__itt_counter id), (ITT_FORMAT id), counter_inc, __itt_group_counter, "%p")
ITT_STUBV(ITTAPI, void, counter_inc_delta, (__itt_counter id, unsigned long long value), (ITT_FORMAT id, value), counter_inc_delta, __itt_group_counter, "%p, %lu")
ITT_STUBV(ITTAPI, void, counter_dec, (__itt_counter id), (ITT_FORMAT id), counter_dec, __itt_group_counter, "%p")
ITT_STUBV(ITTAPI, void, counter_dec_delta, (__itt_counter id, unsigned long long value), (ITT_FORMAT id, value), counter_dec_delta, __itt_group_counter, "%p, %lu")
ITT_STUBV(ITTAPI, void, counter_set_value, (__itt_counter id, void *value_ptr), (ITT_FORMAT id, value_ptr), counter_set_value, __itt_group_counter, "%p, %p")
ITT_STUBV(ITTAPI, void, counter_set_value_ex, (__itt_counter id, __itt_clock_domain *clock_domain, unsigned long long timestamp, void *value_ptr), (ITT_FORMAT id, clock_domain, timestamp, value_ptr), counter_set_value_ex, __itt_group_counter, "%p, %p, %llu, %p")
#ifndef __ITT_INTERNAL_BODY
#if ITT_PLATFORM==ITT_PLATFORM_WIN
ITT_STUB(ITTAPI, __itt_mark_type, mark_createA, (const char *name), (ITT_FORMAT name), mark_createA, __itt_group_mark, "\"%s\"")
ITT_STUB(ITTAPI, __itt_mark_type, mark_createW, (const wchar_t *name), (ITT_FORMAT name), mark_createW, __itt_group_mark, "\"%S\"")
#else /* ITT_PLATFORM!=ITT_PLATFORM_WIN */
ITT_STUB(ITTAPI, __itt_mark_type, mark_create, (const char *name), (ITT_FORMAT name), mark_create, __itt_group_mark, "\"%s\"")
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#endif /* __ITT_INTERNAL_BODY */
#if ITT_PLATFORM==ITT_PLATFORM_WIN
ITT_STUB(ITTAPI, int, markA, (__itt_mark_type mt, const char *parameter), (ITT_FORMAT mt, parameter), markA, __itt_group_mark, "%d, \"%s\"")
ITT_STUB(ITTAPI, int, markW, (__itt_mark_type mt, const wchar_t *parameter), (ITT_FORMAT mt, parameter), markW, __itt_group_mark, "%d, \"%S\"")
#else /* ITT_PLATFORM!=ITT_PLATFORM_WIN */
ITT_STUB(ITTAPI, int, mark, (__itt_mark_type mt, const char *parameter), (ITT_FORMAT mt, parameter), mark, __itt_group_mark, "%d, \"%s\"")
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
ITT_STUB(ITTAPI, int, mark_off, (__itt_mark_type mt), (ITT_FORMAT mt), mark_off, __itt_group_mark, "%d")
#if ITT_PLATFORM==ITT_PLATFORM_WIN
ITT_STUB(ITTAPI, int, mark_globalA, (__itt_mark_type mt, const char *parameter), (ITT_FORMAT mt, parameter), mark_globalA, __itt_group_mark, "%d, \"%s\"")
ITT_STUB(ITTAPI, int, mark_globalW, (__itt_mark_type mt, const wchar_t *parameter), (ITT_FORMAT mt, parameter), mark_globalW, __itt_group_mark, "%d, \"%S\"")
#else /* ITT_PLATFORM!=ITT_PLATFORM_WIN */
ITT_STUB(ITTAPI, int, mark_global, (__itt_mark_type mt, const char *parameter), (ITT_FORMAT mt, parameter), mark_global, __itt_group_mark, "%d, \"%S\"")
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
ITT_STUB(ITTAPI, int, mark_global_off, (__itt_mark_type mt), (ITT_FORMAT mt), mark_global_off, __itt_group_mark, "%d")
#ifndef __ITT_INTERNAL_BODY
ITT_STUB(ITTAPI, __itt_caller, stack_caller_create, (void), (ITT_NO_PARAMS), stack_caller_create, __itt_group_stitch, "no args")
#endif /* __ITT_INTERNAL_BODY */
ITT_STUBV(ITTAPI, void, stack_caller_destroy, (__itt_caller id), (ITT_FORMAT id), stack_caller_destroy, __itt_group_stitch, "%p")
ITT_STUBV(ITTAPI, void, stack_callee_enter, (__itt_caller id), (ITT_FORMAT id), stack_callee_enter, __itt_group_stitch, "%p")
ITT_STUBV(ITTAPI, void, stack_callee_leave, (__itt_caller id), (ITT_FORMAT id), stack_callee_leave, __itt_group_stitch, "%p")
ITT_STUB(ITTAPI, __itt_clock_domain*, clock_domain_create, (__itt_get_clock_info_fn fn, void* fn_data), (ITT_FORMAT fn, fn_data), clock_domain_create, __itt_group_structure, "%p, %p")
ITT_STUBV(ITTAPI, void, clock_domain_reset, (void), (ITT_NO_PARAMS), clock_domain_reset, __itt_group_structure, "no args")
ITT_STUBV(ITTAPI, void, id_create_ex, (const __itt_domain *domain, __itt_clock_domain* clock_domain, unsigned long long timestamp, __itt_id id), (ITT_FORMAT domain, clock_domain, timestamp, id), id_create_ex, __itt_group_structure, "%p, %p, %lu, %lu")
ITT_STUBV(ITTAPI, void, id_destroy_ex, (const __itt_domain *domain, __itt_clock_domain* clock_domain, unsigned long long timestamp, __itt_id id), (ITT_FORMAT domain, clock_domain, timestamp, id), id_destroy_ex, __itt_group_structure, "%p, %p, %lu, %lu")
ITT_STUBV(ITTAPI, void, task_begin_ex, (const __itt_domain *domain, __itt_clock_domain* clock_domain, unsigned long long timestamp, __itt_id id, __itt_id parentid, __itt_string_handle *name), (ITT_FORMAT domain, clock_domain, timestamp, id, parentid, name), task_begin_ex, __itt_group_structure, "%p, %p, %lu, %lu, %lu, %p")
ITT_STUBV(ITTAPI, void, task_begin_fn_ex, (const __itt_domain *domain, __itt_clock_domain* clock_domain, unsigned long long timestamp, __itt_id id, __itt_id parentid, void* fn), (ITT_FORMAT domain, clock_domain, timestamp, id, parentid, fn), task_begin_fn_ex, __itt_group_structure, "%p, %p, %lu, %lu, %lu, %p")
ITT_STUBV(ITTAPI, void, task_end_ex, (const __itt_domain *domain, __itt_clock_domain* clock_domain, unsigned long long timestamp), (ITT_FORMAT domain, clock_domain, timestamp), task_end_ex, __itt_group_structure, "%p, %p, %lu")
ITT_STUBV(ITTAPI, void, task_begin_overlapped, (const __itt_domain *domain, __itt_id id, __itt_id parent, __itt_string_handle *name), (ITT_FORMAT domain, id, parent, name), task_begin_overlapped, __itt_group_structure, "%p, %lu, %lu, %p")
ITT_STUBV(ITTAPI, void, task_begin_overlapped_ex, (const __itt_domain *domain, __itt_clock_domain* clock_domain, unsigned long long timestamp, __itt_id id, __itt_id parentid, __itt_string_handle *name), (ITT_FORMAT domain, clock_domain, timestamp, id, parentid, name), task_begin_overlapped_ex, __itt_group_structure, "%p, %p, %lu, %lu, %lu, %p")
ITT_STUBV(ITTAPI, void, task_end_overlapped, (const __itt_domain *domain, __itt_id id), (ITT_FORMAT domain, id), task_end_overlapped, __itt_group_structure, "%p, %lu")
ITT_STUBV(ITTAPI, void, task_end_overlapped_ex, (const __itt_domain *domain, __itt_clock_domain* clock_domain, unsigned long long timestamp, __itt_id id), (ITT_FORMAT domain, clock_domain, timestamp, id), task_end_overlapped_ex, __itt_group_structure, "%p, %p, %lu, %lu")
ITT_STUBV(ITTAPI, void, marker_ex, (const __itt_domain *domain, __itt_clock_domain* clock_domain, unsigned long long timestamp, __itt_id id, __itt_string_handle *name, __itt_scope scope), (ITT_FORMAT domain, clock_domain, timestamp, id, name, scope), marker_ex, __itt_group_structure, "%p, %p, %lu, %lu, %p, %d")
ITT_STUBV(ITTAPI, void, metadata_add_with_scope, (const __itt_domain *domain, __itt_scope scope, __itt_string_handle *key, __itt_metadata_type type, size_t count, void *data), (ITT_FORMAT domain, scope, key, type, count, data), metadata_add_with_scope, __itt_group_structure, "%p, %d, %p, %d, %lu, %p")
#if ITT_PLATFORM==ITT_PLATFORM_WIN
ITT_STUBV(ITTAPI, void, metadata_str_add_with_scopeA, (const __itt_domain *domain, __itt_scope scope, __itt_string_handle *key, const char *data, size_t length), (ITT_FORMAT domain, scope, key, data, length), metadata_str_add_with_scopeA, __itt_group_structure, "%p, %d, %p, %p, %lu")
ITT_STUBV(ITTAPI, void, metadata_str_add_with_scopeW, (const __itt_domain *domain, __itt_scope scope, __itt_string_handle *key, const wchar_t *data, size_t length), (ITT_FORMAT domain, scope, key, data, length), metadata_str_add_with_scopeW, __itt_group_structure, "%p, %d, %p, %p, %lu")
#else /* ITT_PLATFORM!=ITT_PLATFORM_WIN */
ITT_STUBV(ITTAPI, void, metadata_str_add_with_scope, (const __itt_domain *domain, __itt_scope scope, __itt_string_handle *key, const char *data, size_t length), (ITT_FORMAT domain, scope, key, data, length), metadata_str_add_with_scope, __itt_group_structure, "%p, %d, %p, %p, %lu")
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
ITT_STUBV(ITTAPI, void, relation_add_to_current_ex, (const __itt_domain *domain, __itt_clock_domain* clock_domain, unsigned long long timestamp, __itt_relation relation, __itt_id tail), (ITT_FORMAT domain, clock_domain, timestamp, relation, tail), relation_add_to_current_ex, __itt_group_structure, "%p, %p, %lu, %d, %lu")
ITT_STUBV(ITTAPI, void, relation_add_ex, (const __itt_domain *domain, __itt_clock_domain* clock_domain, unsigned long long timestamp, __itt_id head, __itt_relation relation, __itt_id tail), (ITT_FORMAT domain, clock_domain, timestamp, head, relation, tail), relation_add_ex, __itt_group_structure, "%p, %p, %lu, %lu, %d, %lu")
ITT_STUB(ITTAPI, __itt_track_group*, track_group_create, (__itt_string_handle* name, __itt_track_group_type track_group_type), (ITT_FORMAT name, track_group_type), track_group_create, __itt_group_structure, "%p, %d")
ITT_STUB(ITTAPI, __itt_track*, track_create, (__itt_track_group* track_group,__itt_string_handle* name, __itt_track_type track_type), (ITT_FORMAT track_group, name, track_type), track_create, __itt_group_structure, "%p, %p, %d")
ITT_STUBV(ITTAPI, void, set_track, (__itt_track *track), (ITT_FORMAT track), set_track, __itt_group_structure, "%p")
#ifndef __ITT_INTERNAL_BODY
ITT_STUB(ITTAPI, const char*, api_version, (void), (ITT_NO_PARAMS), api_version, __itt_group_all & ~__itt_group_legacy, "no args")
#endif /* __ITT_INTERNAL_BODY */
#ifndef __ITT_INTERNAL_BODY
#if ITT_PLATFORM==ITT_PLATFORM_WIN
ITT_STUB(ITTAPI, int, av_saveA, (void *data, int rank, const int *dimensions, int type, const char *filePath, int columnOrder), (ITT_FORMAT data, rank, dimensions, type, filePath, columnOrder), av_saveA, __itt_group_arrays, "%p, %d, %p, %d, \"%s\", %d")
ITT_STUB(ITTAPI, int, av_saveW, (void *data, int rank, const int *dimensions, int type, const wchar_t *filePath, int columnOrder), (ITT_FORMAT data, rank, dimensions, type, filePath, columnOrder), av_saveW, __itt_group_arrays, "%p, %d, %p, %d, \"%S\", %d")
#else /* ITT_PLATFORM!=ITT_PLATFORM_WIN */
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 */
#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_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_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_module, "%p, %p, %p")
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
ITT_STUBV(ITTAPI, void, module_unload, (void *start_addr), (ITT_FORMAT start_addr), module_unload, __itt_group_module, "%p")
#endif /* __ITT_INTERNAL_INIT */

65
deps/v8/third_party/ittapi/src/ittnotify/ittnotify_types.h vendored Normal file
View File

@ -0,0 +1,65 @@
/*
Copyright (C) 2005-2019 Intel Corporation
SPDX-License-Identifier: GPL-2.0-only OR BSD-3-Clause
*/
#ifndef _ITTNOTIFY_TYPES_H_
#define _ITTNOTIFY_TYPES_H_
typedef enum ___itt_group_id
{
__itt_group_none = 0,
__itt_group_legacy = 1<<0,
__itt_group_control = 1<<1,
__itt_group_thread = 1<<2,
__itt_group_mark = 1<<3,
__itt_group_sync = 1<<4,
__itt_group_fsync = 1<<5,
__itt_group_jit = 1<<6,
__itt_group_model = 1<<7,
__itt_group_splitter_min = 1<<7,
__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;
} __itt_group_list;
#pragma pack(pop)
#define ITT_GROUP_LIST(varname) \
static __itt_group_list varname[] = { \
{ __itt_group_all, "all" }, \
{ __itt_group_control, "control" }, \
{ __itt_group_thread, "thread" }, \
{ __itt_group_mark, "mark" }, \
{ __itt_group_sync, "sync" }, \
{ __itt_group_fsync, "fsync" }, \
{ __itt_group_jit, "jit" }, \
{ __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_ */

764
deps/v8/third_party/ittapi/src/ittnotify/ittptmark32.S vendored Normal file
View File

@ -0,0 +1,764 @@
/* <copyright>
This file is provided under a dual BSD/GPLv2 license. When using or
redistributing this file, you may do so under either license.
GPL LICENSE SUMMARY
Copyright (c) 2017-2020 Intel Corporation. All rights reserved.
This program is free software; you can redistribute it and/or modify
it under the terms of version 2 of the GNU General Public License as
published by the Free Software Foundation.
This program is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
The full GNU General Public License is included in this distribution
in the file called LICENSE.GPL.
Contact Information:
http://software.intel.com/en-us/articles/intel-vtune-amplifier-xe/
BSD LICENSE
Copyright (c) 2017-2020 Intel Corporation. All rights reserved.
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* 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.
* Neither the name of Intel Corporation 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
OWNER 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.
</copyright> */
// /////////////////////////////////////////////////////////////////////////
////// Intel Processor Trace Marker Functionality
////////////////////////////////////////////////////////////////////////////
.text
.align 16
.globl __itt_pt_mark
.globl __itt_pt_event
.globl __itt_pt_mark_event
.globl __itt_pt_mark_threshold
.globl __itt_pt_byte
.globl __itt_pt_write
/// void __itt_pt_mark(unsigned char index);
__itt_pt_mark:
movzbl 4(%esp), %eax
// and $0xff, %eax
lea __itt_pt_mark_call_table(,%eax,4), %eax
jmp *%eax
.align 4
.long 0, 1, 2, 3 // GUID
.long 0xfadefade
__itt_pt_mark_call_table:
/// .fill 256,4,(0x0000c2c3 | (( . - __itt_pt_mark_call_table) << 14))
ret
ret $0x0
ret
ret $0x1
ret
ret $0x2
ret
ret $0x3
ret
ret $0x4
ret
ret $0x5
ret
ret $0x6
ret
ret $0x7
ret
ret $0x8
ret
ret $0x9
ret
ret $0xa
ret
ret $0xb
ret
ret $0xc
ret
ret $0xd
ret
ret $0xe
ret
ret $0xf
ret
ret $0x10
ret
ret $0x11
ret
ret $0x12
ret
ret $0x13
ret
ret $0x14
ret
ret $0x15
ret
ret $0x16
ret
ret $0x17
ret
ret $0x18
ret
ret $0x19
ret
ret $0x1a
ret
ret $0x1b
ret
ret $0x1c
ret
ret $0x1d
ret
ret $0x1e
ret
ret $0x1f
ret
ret $0x20
ret
ret $0x21
ret
ret $0x22
ret
ret $0x23
ret
ret $0x24
ret
ret $0x25
ret
ret $0x26
ret
ret $0x27
ret
ret $0x28
ret
ret $0x29
ret
ret $0x2a
ret
ret $0x2b
ret
ret $0x2c
ret
ret $0x2d
ret
ret $0x2e
ret
ret $0x2f
ret
ret $0x30
ret
ret $0x31
ret
ret $0x32
ret
ret $0x33
ret
ret $0x34
ret
ret $0x35
ret
ret $0x36
ret
ret $0x37
ret
ret $0x38
ret
ret $0x39
ret
ret $0x3a
ret
ret $0x3b
ret
ret $0x3c
ret
ret $0x3d
ret
ret $0x3e
ret
ret $0x3f
ret
ret $0x40
ret
ret $0x41
ret
ret $0x42
ret
ret $0x43
ret
ret $0x44
ret
ret $0x45
ret
ret $0x46
ret
ret $0x47
ret
ret $0x48
ret
ret $0x49
ret
ret $0x4a
ret
ret $0x4b
ret
ret $0x4c
ret
ret $0x4d
ret
ret $0x4e
ret
ret $0x4f
ret
ret $0x50
ret
ret $0x51
ret
ret $0x52
ret
ret $0x53
ret
ret $0x54
ret
ret $0x55
ret
ret $0x56
ret
ret $0x57
ret
ret $0x58
ret
ret $0x59
ret
ret $0x5a
ret
ret $0x5b
ret
ret $0x5c
ret
ret $0x5d
ret
ret $0x5e
ret
ret $0x5f
ret
ret $0x60
ret
ret $0x61
ret
ret $0x62
ret
ret $0x63
ret
ret $0x64
ret
ret $0x65
ret
ret $0x66
ret
ret $0x67
ret
ret $0x68
ret
ret $0x69
ret
ret $0x6a
ret
ret $0x6b
ret
ret $0x6c
ret
ret $0x6d
ret
ret $0x6e
ret
ret $0x6f
ret
ret $0x70
ret
ret $0x71
ret
ret $0x72
ret
ret $0x73
ret
ret $0x74
ret
ret $0x75
ret
ret $0x76
ret
ret $0x77
ret
ret $0x78
ret
ret $0x79
ret
ret $0x7a
ret
ret $0x7b
ret
ret $0x7c
ret
ret $0x7d
ret
ret $0x7e
ret
ret $0x7f
ret
ret $0x80
ret
ret $0x81
ret
ret $0x82
ret
ret $0x83
ret
ret $0x84
ret
ret $0x85
ret
ret $0x86
ret
ret $0x87
ret
ret $0x88
ret
ret $0x89
ret
ret $0x8a
ret
ret $0x8b
ret
ret $0x8c
ret
ret $0x8d
ret
ret $0x8e
ret
ret $0x8f
ret
ret $0x90
ret
ret $0x91
ret
ret $0x92
ret
ret $0x93
ret
ret $0x94
ret
ret $0x95
ret
ret $0x96
ret
ret $0x97
ret
ret $0x98
ret
ret $0x99
ret
ret $0x9a
ret
ret $0x9b
ret
ret $0x9c
ret
ret $0x9d
ret
ret $0x9e
ret
ret $0x9f
ret
ret $0xa0
ret
ret $0xa1
ret
ret $0xa2
ret
ret $0xa3
ret
ret $0xa4
ret
ret $0xa5
ret
ret $0xa6
ret
ret $0xa7
ret
ret $0xa8
ret
ret $0xa9
ret
ret $0xaa
ret
ret $0xab
ret
ret $0xac
ret
ret $0xad
ret
ret $0xae
ret
ret $0xaf
ret
ret $0xb0
ret
ret $0xb1
ret
ret $0xb2
ret
ret $0xb3
ret
ret $0xb4
ret
ret $0xb5
ret
ret $0xb6
ret
ret $0xb7
ret
ret $0xb8
ret
ret $0xb9
ret
ret $0xba
ret
ret $0xbb
ret
ret $0xbc
ret
ret $0xbd
ret
ret $0xbe
ret
ret $0xbf
ret
ret $0xc0
ret
ret $0xc1
ret
ret $0xc2
ret
ret $0xc3
ret
ret $0xc4
ret
ret $0xc5
ret
ret $0xc6
ret
ret $0xc7
ret
ret $0xc8
ret
ret $0xc9
ret
ret $0xca
ret
ret $0xcb
ret
ret $0xcc
ret
ret $0xcd
ret
ret $0xce
ret
ret $0xcf
ret
ret $0xd0
ret
ret $0xd1
ret
ret $0xd2
ret
ret $0xd3
ret
ret $0xd4
ret
ret $0xd5
ret
ret $0xd6
ret
ret $0xd7
ret
ret $0xd8
ret
ret $0xd9
ret
ret $0xda
ret
ret $0xdb
ret
ret $0xdc
ret
ret $0xdd
ret
ret $0xde
ret
ret $0xdf
ret
ret $0xe0
ret
ret $0xe1
ret
ret $0xe2
ret
ret $0xe3
ret
ret $0xe4
ret
ret $0xe5
ret
ret $0xe6
ret
ret $0xe7
ret
ret $0xe8
ret
ret $0xe9
ret
ret $0xea
ret
ret $0xeb
ret
ret $0xec
ret
ret $0xed
ret
ret $0xee
ret
ret $0xef
ret
ret $0xf0
ret
ret $0xf1
ret
ret $0xf2
ret
ret $0xf3
ret
ret $0xf4
ret
ret $0xf5
ret
ret $0xf6
ret
ret $0xf7
ret
ret $0xf8
ret
ret $0xf9
ret
ret $0xfa
ret
ret $0xfb
ret
ret $0xfc
ret
ret $0xfd
ret
ret $0xfe
ret
ret $0xff
.align 16
__itt_pt_byte:
movl 4(%esp), %ecx
__itt_pt_byte_:
and $0xff, %ecx
lea __itt_pt_byte_call_table(,%ecx,1), %ecx
jmp *%ecx
.align 4
.long 0, 1, 2, 3 // GUID
.long 0xfadedeaf
__itt_pt_byte_call_table:
.fill 256,1,0xc3
.align 16
__itt_pt_event:
push %ecx
mov 8(%esp), %ecx
rdpmc
mov %al,%cl
call __itt_pt_byte_
shr $8,%eax
mov %al,%cl
call __itt_pt_byte_
shr $8,%eax
mov %al,%cl
call __itt_pt_byte_
shr $8,%eax
mov %al,%cl
call __itt_pt_byte_
mov %dl,%cl
call __itt_pt_byte_
shr $8,%edx
mov %dl,%cl
call __itt_pt_byte_
shr $8,%edx
mov %dl,%cl
call __itt_pt_byte_
shr $8,%edx
mov %dl,%cl
call __itt_pt_byte_
pop %ecx
ret
.align 16
__itt_pt_mark_event:
testl $1,4(%esp)
jnz odd
pushl $0
call __itt_pt_event
add $2,%esp
jmp __itt_pt_mark
odd:
pushl 4(%esp)
call __itt_pt_mark
add $2,%esp
movl $0,4(%esp)
jmp __itt_pt_event
.align 16
__itt_pt_flush:
lea __itt_pt_mark_flush_1,%eax
jmp *%eax
.align 16
nop
__itt_pt_mark_flush_1:
lea __itt_pt_mark_flush_2,%eax
jmp *%eax
.align 16
nop
nop
__itt_pt_mark_flush_2:
lea __itt_pt_mark_flush_3,%eax
jmp *%eax
.align 16
nop
nop
nop
__itt_pt_mark_flush_3:
ret
.align 16
// int __itt_pt_mark_threshold(unsigned char index, unsigned long long* tmp, int threshold);
__itt_pt_mark_threshold:
// 4(%esp) == index
// 8(%esp) == tmp
// 12(%esp) == threshold
xor %edx,%edx
xor %eax,%eax
testl $1,4(%esp)
jnz mark_end
mark_begin:
mov $((1 << 30) + 1),%ecx
rdpmc
mov 8(%esp), %ecx
mov %eax, (%ecx)
mov %edx,4(%ecx)
jmp __itt_pt_mark
mark_end:
mov $((1 << 30) + 1),%ecx
rdpmc
mov 8(%esp), %ecx
sub (%ecx), %eax
sbb 4(%ecx), %edx
sub 12(%esp), %eax // threshold
jnc found
sbb $0, %edx
jnc found
jmp __itt_pt_mark
found:
call __itt_pt_mark
jmp __itt_pt_flush
// PTWRITE
.align 16
// void __itt_pt_write(unsigned long long value);
.long 0, 1, 2, 3 // GUID
__itt_pt_write:
// ptwrite dword ptr [esp + 4]
.byte 0xF3, 0x0F, 0xAE, 0x64, 0x24, 0x04
ret

255
deps/v8/third_party/ittapi/src/ittnotify/ittptmark32.asm vendored Normal file
View File

@ -0,0 +1,255 @@
COMMENT @
<copyright>
This file is provided under a dual BSD/GPLv2 license. When using or
redistributing this file, you may do so under either license.
GPL LICENSE SUMMARY
Copyright (c) 2017-2020 Intel Corporation. All rights reserved.
This program is free software; you can redistribute it and/or modify
it under the terms of version 2 of the GNU General Public License as
published by the Free Software Foundation.
This program is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
The full GNU General Public License is included in this distribution
in the file called LICENSE.GPL.
Contact Information:
http://software.intel.com/en-us/articles/intel-vtune-amplifier-xe/
BSD LICENSE
Copyright (c) 2017-2020 Intel Corporation. All rights reserved.
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* 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.
* Neither the name of Intel Corporation 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
OWNER 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.
</copyright>
@
;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; ;;; Intel Processor Trace Marker Functionality
;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
.686p
.xmm
.model FLAT
_TEXT segment
public ___itt_pt_mark
public ___itt_pt_event
public ___itt_pt_mark_event
public ___itt_pt_mark_threshold
public ___itt_pt_write
public ___itt_pt_byte
align 10h
;;; void __itt_pt_mark(unsigned char index);
___itt_pt_mark proc near
movzx eax,byte ptr [esp + 4]
lea eax,__itt_pt_mark_call_table[eax * 4]
jmp eax
align 04h
dd 0, 1, 2, 3 ;;; GUID
dd 0fadefadeh ;;; magic marker
__itt_pt_mark_call_table:
dd 256 dup(0000c2c3h OR (( $ - offset __itt_pt_mark_call_table) SHL 14))
___itt_pt_mark endp
___itt_pt_byte proc near
mov ecx,[esp + 4]
___itt_pt_byte_::
and ecx,0ffh
lea ecx,__itt_pt_byte_call_table[ecx]
jmp ecx
align 04h
dd 0, 1, 2, 3 ;;; GUID
dd 0fadedeafh ;;; magic marker
__itt_pt_byte_call_table:
db 256 dup(0c3h)
___itt_pt_byte endp
align 10h
___itt_pt_event proc near
push ecx
mov ecx,[esp + 8]
rdpmc
mov cl,al
call ___itt_pt_byte_
mov cl,ah
call ___itt_pt_byte_
shr eax,16
mov cl,al
call ___itt_pt_byte_
mov cl,ah
call ___itt_pt_byte_
mov cl,dl
call ___itt_pt_byte_
mov cl,dh
call ___itt_pt_byte_
shr edx,16
mov cl,dl
call ___itt_pt_byte_
mov cl,dh
call ___itt_pt_byte_
pop ecx
ret
___itt_pt_event endp
align 10h
___itt_pt_mark_event proc near
test byte ptr [esp + 4],1
jnz odd
push 0
call ___itt_pt_event
add esp,4
jmp ___itt_pt_mark
odd:
push dword ptr [esp + 4]
call ___itt_pt_mark
add esp,4
mov dword ptr [esp + 4],0
jmp ___itt_pt_event
___itt_pt_mark_event endp
align 10h
___itt_pt_flush proc near
lea eax,offset __itt_pt_mark_flush_1
jmp eax
align 10h
nop
__itt_pt_mark_flush_1:
lea eax,offset __itt_pt_mark_flush_2
jmp eax
align 10h
nop
nop
__itt_pt_mark_flush_2:
lea eax,offset __itt_pt_mark_flush_3
jmp eax
align 10h
nop
nop
nop
__itt_pt_mark_flush_3:
ret
___itt_pt_flush endp
align 10h
;;; int __itt_pt_mark_threshold(unsigned char index, unsigned long long* tmp, int threshold);
___itt_pt_mark_threshold proc near
test byte ptr [esp + 4],1 ;;; index
jnz mark_end
mark_begin:
mov ecx,(1 SHL 30) + 1
rdpmc
mov ecx,[esp + 8] ;;; tmp
mov [ecx + 0],eax
mov [ecx + 4],edx
jmp ___itt_pt_mark
mark_end:
mov ecx,(1 SHL 30) + 1
rdpmc
mov ecx,[esp + 8] ;;; tmp
sub eax,[ecx + 0]
sbb edx,[ecx + 4]
or edx,edx
jnz found
cmp edx,[esp + 12] ;;; threshold
jnc found
jmp ___itt_pt_mark
found:
call ___itt_pt_mark
jmp ___itt_pt_flush
___itt_pt_mark_threshold endp
;;; PTWRITE
align 10h
;;; void __itt_pt_write(unsigned long long value);
dd 0, 1, 2, 3 ;;; GUID
___itt_pt_write proc
;;; ptwrite dword ptr [esp + 4]
db 0F3h, 0Fh, 0AEh, 64h, 24h, 04h
ret
___itt_pt_write endp
;;;
_TEXT ends
end

766
deps/v8/third_party/ittapi/src/ittnotify/ittptmark64.S vendored Normal file
View File

@ -0,0 +1,766 @@
/* <copyright>
This file is provided under a dual BSD/GPLv2 license. When using or
redistributing this file, you may do so under either license.
GPL LICENSE SUMMARY
Copyright (c) 2017-2020 Intel Corporation. All rights reserved.
This program is free software; you can redistribute it and/or modify
it under the terms of version 2 of the GNU General Public License as
published by the Free Software Foundation.
This program is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
The full GNU General Public License is included in this distribution
in the file called LICENSE.GPL.
Contact Information:
http://software.intel.com/en-us/articles/intel-vtune-amplifier-xe/
BSD LICENSE
Copyright (c) 2017-2020 Intel Corporation. All rights reserved.
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* 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.
* Neither the name of Intel Corporation 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
OWNER 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.
</copyright> */
// /////////////////////////////////////////////////////////////////////////
////// Intel Processor Trace Marker Functionality
////////////////////////////////////////////////////////////////////////////
.text
.align 16
.globl __itt_pt_mark
.globl __itt_pt_event
.globl __itt_pt_mark_event
.globl __itt_pt_mark_threshold
.globl __itt_pt_byte
.globl __itt_pt_write
/// void __itt_pt_mark(unsigned char index);
__itt_pt_mark:
__itt_pt_mark_int:
and $0xff, %rdi
call __itt_pt_mark_pic
__itt_pt_mark_pic:
popq %rax
lea (__itt_pt_mark_call_table - __itt_pt_mark_pic) (%rax,%rdi,4), %rdi
jmp *%rdi
.long 0, 1, 2, 3 // GUID
.long 0xfadefade
__itt_pt_mark_call_table:
retq
retq $0x0
retq
retq $0x1
retq
retq $0x2
retq
retq $0x3
retq
retq $0x4
retq
retq $0x5
retq
retq $0x6
retq
retq $0x7
retq
retq $0x8
retq
retq $0x9
retq
retq $0xa
retq
retq $0xb
retq
retq $0xc
retq
retq $0xd
retq
retq $0xe
retq
retq $0xf
retq
retq $0x10
retq
retq $0x11
retq
retq $0x12
retq
retq $0x13
retq
retq $0x14
retq
retq $0x15
retq
retq $0x16
retq
retq $0x17
retq
retq $0x18
retq
retq $0x19
retq
retq $0x1a
retq
retq $0x1b
retq
retq $0x1c
retq
retq $0x1d
retq
retq $0x1e
retq
retq $0x1f
retq
retq $0x20
retq
retq $0x21
retq
retq $0x22
retq
retq $0x23
retq
retq $0x24
retq
retq $0x25
retq
retq $0x26
retq
retq $0x27
retq
retq $0x28
retq
retq $0x29
retq
retq $0x2a
retq
retq $0x2b
retq
retq $0x2c
retq
retq $0x2d
retq
retq $0x2e
retq
retq $0x2f
retq
retq $0x30
retq
retq $0x31
retq
retq $0x32
retq
retq $0x33
retq
retq $0x34
retq
retq $0x35
retq
retq $0x36
retq
retq $0x37
retq
retq $0x38
retq
retq $0x39
retq
retq $0x3a
retq
retq $0x3b
retq
retq $0x3c
retq
retq $0x3d
retq
retq $0x3e
retq
retq $0x3f
retq
retq $0x40
retq
retq $0x41
retq
retq $0x42
retq
retq $0x43
retq
retq $0x44
retq
retq $0x45
retq
retq $0x46
retq
retq $0x47
retq
retq $0x48
retq
retq $0x49
retq
retq $0x4a
retq
retq $0x4b
retq
retq $0x4c
retq
retq $0x4d
retq
retq $0x4e
retq
retq $0x4f
retq
retq $0x50
retq
retq $0x51
retq
retq $0x52
retq
retq $0x53
retq
retq $0x54
retq
retq $0x55
retq
retq $0x56
retq
retq $0x57
retq
retq $0x58
retq
retq $0x59
retq
retq $0x5a
retq
retq $0x5b
retq
retq $0x5c
retq
retq $0x5d
retq
retq $0x5e
retq
retq $0x5f
retq
retq $0x60
retq
retq $0x61
retq
retq $0x62
retq
retq $0x63
retq
retq $0x64
retq
retq $0x65
retq
retq $0x66
retq
retq $0x67
retq
retq $0x68
retq
retq $0x69
retq
retq $0x6a
retq
retq $0x6b
retq
retq $0x6c
retq
retq $0x6d
retq
retq $0x6e
retq
retq $0x6f
retq
retq $0x70
retq
retq $0x71
retq
retq $0x72
retq
retq $0x73
retq
retq $0x74
retq
retq $0x75
retq
retq $0x76
retq
retq $0x77
retq
retq $0x78
retq
retq $0x79
retq
retq $0x7a
retq
retq $0x7b
retq
retq $0x7c
retq
retq $0x7d
retq
retq $0x7e
retq
retq $0x7f
retq
retq $0x80
retq
retq $0x81
retq
retq $0x82
retq
retq $0x83
retq
retq $0x84
retq
retq $0x85
retq
retq $0x86
retq
retq $0x87
retq
retq $0x88
retq
retq $0x89
retq
retq $0x8a
retq
retq $0x8b
retq
retq $0x8c
retq
retq $0x8d
retq
retq $0x8e
retq
retq $0x8f
retq
retq $0x90
retq
retq $0x91
retq
retq $0x92
retq
retq $0x93
retq
retq $0x94
retq
retq $0x95
retq
retq $0x96
retq
retq $0x97
retq
retq $0x98
retq
retq $0x99
retq
retq $0x9a
retq
retq $0x9b
retq
retq $0x9c
retq
retq $0x9d
retq
retq $0x9e
retq
retq $0x9f
retq
retq $0xa0
retq
retq $0xa1
retq
retq $0xa2
retq
retq $0xa3
retq
retq $0xa4
retq
retq $0xa5
retq
retq $0xa6
retq
retq $0xa7
retq
retq $0xa8
retq
retq $0xa9
retq
retq $0xaa
retq
retq $0xab
retq
retq $0xac
retq
retq $0xad
retq
retq $0xae
retq
retq $0xaf
retq
retq $0xb0
retq
retq $0xb1
retq
retq $0xb2
retq
retq $0xb3
retq
retq $0xb4
retq
retq $0xb5
retq
retq $0xb6
retq
retq $0xb7
retq
retq $0xb8
retq
retq $0xb9
retq
retq $0xba
retq
retq $0xbb
retq
retq $0xbc
retq
retq $0xbd
retq
retq $0xbe
retq
retq $0xbf
retq
retq $0xc0
retq
retq $0xc1
retq
retq $0xc2
retq
retq $0xc3
retq
retq $0xc4
retq
retq $0xc5
retq
retq $0xc6
retq
retq $0xc7
retq
retq $0xc8
retq
retq $0xc9
retq
retq $0xca
retq
retq $0xcb
retq
retq $0xcc
retq
retq $0xcd
retq
retq $0xce
retq
retq $0xcf
retq
retq $0xd0
retq
retq $0xd1
retq
retq $0xd2
retq
retq $0xd3
retq
retq $0xd4
retq
retq $0xd5
retq
retq $0xd6
retq
retq $0xd7
retq
retq $0xd8
retq
retq $0xd9
retq
retq $0xda
retq
retq $0xdb
retq
retq $0xdc
retq
retq $0xdd
retq
retq $0xde
retq
retq $0xdf
retq
retq $0xe0
retq
retq $0xe1
retq
retq $0xe2
retq
retq $0xe3
retq
retq $0xe4
retq
retq $0xe5
retq
retq $0xe6
retq
retq $0xe7
retq
retq $0xe8
retq
retq $0xe9
retq
retq $0xea
retq
retq $0xeb
retq
retq $0xec
retq
retq $0xed
retq
retq $0xee
retq
retq $0xef
retq
retq $0xf0
retq
retq $0xf1
retq
retq $0xf2
retq
retq $0xf3
retq
retq $0xf4
retq
retq $0xf5
retq
retq $0xf6
retq
retq $0xf7
retq
retq $0xf8
retq
retq $0xf9
retq
retq $0xfa
retq
retq $0xfb
retq
retq $0xfc
retq
retq $0xfd
retq
retq $0xfe
retq
retq $0xff
.align 16
__itt_pt_byte:
__itt_pt_byte_int:
and $0xff, %rdi
call __itt_pt_byte_pic
__itt_pt_byte_pic:
popq %rcx
lea (__itt_pt_byte_call_table - __itt_pt_byte_pic) (%rcx,%rdi,1), %rdi
jmp *%rdi
.align 4
.long 0, 1, 2, 3 // GUID
.long 0xfadedeaf
__itt_pt_byte_call_table:
.fill 256,1,0xc3
.align 16
__itt_pt_event:
__itt_pt_event_int:
pushq %rcx
mov %rdi,%rcx
rdpmc
xor %rdi, %rdi
mov %al, %dil
call __itt_pt_byte_int
shr $8, %eax
mov %al, %dil
call __itt_pt_byte_int
shr $8, %eax
mov %al, %dil
call __itt_pt_byte_int
shr $8, %eax
mov %al, %dil
call __itt_pt_byte_int
mov %dl, %dil
call __itt_pt_byte_int
shr $8, %edx
mov %dl, %dil
call __itt_pt_byte_int
shr $8, %edx
mov %dl, %dil
call __itt_pt_byte_int
shr $8, %edx
mov %dl, %dil
call __itt_pt_byte_int
popq %rcx
ret
.align 16
__itt_pt_mark_event:
test $1, %rdi
jnz odd
mov %rdi, %rsi
xor %rdi,%rdi
call __itt_pt_event_int
mov %rsi, %rdi
jmp __itt_pt_mark_int
odd:
call __itt_pt_mark_int
xor %rdi,%rdi
jmp __itt_pt_event_int
.align 16
__itt_pt_flush:
call __itt_pt_flush_pic
__itt_pt_flush_pic:
popq %rdx
lea (__itt_pt_mark_flush_1 - __itt_pt_flush_pic) (%rdx), %rax
jmp *%rax
.align 16
nop
__itt_pt_mark_flush_1:
lea (__itt_pt_mark_flush_2 - __itt_pt_flush_pic) (%rdx), %rax
jmp *%rax
.align 16
nop
nop
__itt_pt_mark_flush_2:
lea (__itt_pt_mark_flush_3 - __itt_pt_flush_pic) (%rdx), %rax
jmp *%rax
.align 16
nop
nop
nop
__itt_pt_mark_flush_3:
ret
.align 16
// int __itt_pt_mark_threshold(unsigned char index, unsigned long long* tmp, int threshold);
__itt_pt_mark_threshold:
// rdi == index
// rsi == tmp
// rdx == threshold
mov %rdx, %r8 // r8 = threshold
xor %rdx, %rdx
xor %rax, %rax
test $1, %rdi
jnz mark_end
mark_begin:
mov $((1 << 30) + 1),%rcx
rdpmc
shl $32, %rdx
or %rax, %rdx
mov %rdx, (%rsi)
jmp __itt_pt_mark_int
mark_end:
mov $((1 << 30) + 1),%rcx
rdpmc
shl $32, %rdx
or %rax, %rdx
sub (%rsi), %rdx
cmp %r8, %rdx // threshold
jnc found
jmp __itt_pt_mark_int
found:
call __itt_pt_mark_int
jmp __itt_pt_flush
// PTWRITE
.align 16
// void __itt_pt_write(unsigned long long value);
.long 0, 1, 2, 3 // GUID
__itt_pt_write:
// ptwrite rcx
.byte 0xF3, 0x48, 0x0F, 0xAE, 0xE1
ret

251
deps/v8/third_party/ittapi/src/ittnotify/ittptmark64.asm vendored Normal file
View File

@ -0,0 +1,251 @@
COMMENT @
<copyright>
This file is provided under a dual BSD/GPLv2 license. When using or
redistributing this file, you may do so under either license.
GPL LICENSE SUMMARY
Copyright (c) 2017-2020 Intel Corporation. All rights reserved.
This program is free software; you can redistribute it and/or modify
it under the terms of version 2 of the GNU General Public License as
published by the Free Software Foundation.
This program is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
The full GNU General Public License is included in this distribution
in the file called LICENSE.GPL.
Contact Information:
http://software.intel.com/en-us/articles/intel-vtune-amplifier-xe/
BSD LICENSE
Copyright (c) 2017-2020 Intel Corporation. All rights reserved.
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* 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.
* Neither the name of Intel Corporation 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
OWNER 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.
</copyright>
@
;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; ;;; Intel Processor Trace Marker Functionality
;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
_TEXT segment
public __itt_pt_mark
public __itt_pt_event
public __itt_pt_mark_event
public __itt_pt_mark_threshold
public __itt_pt_write
public __itt_pt_byte
align 10h
;;; void __itt_pt_mark(unsigned char index);
__itt_pt_mark proc
and rcx,0ffh
lea r10,offset __itt_pt_mark_call_table
lea rcx,[r10 + rcx * 4]
jmp rcx
align 04h
dd 0, 1, 2, 3 ;;; GUID
dd 0fadefadeh ;;; magic marker
__itt_pt_mark_call_table:
dd 256 dup(0000c2c3h OR (( $ - offset __itt_pt_mark_call_table) SHL 14))
__itt_pt_mark endp
align 10h
__itt_pt_byte proc
and rcx,0ffh
lea r10,offset __itt_pt_byte_call_table
add rcx,r10
jmp rcx
align 04h
dd 0, 1, 2, 3 ;;; GUID
dd 0fadedeafh ;;; magic marker
__itt_pt_byte_call_table:
db 256 dup(0c3h)
__itt_pt_byte endp
align 10h
__itt_pt_event proc
rdpmc
mov cl,al
call __itt_pt_byte
mov cl,ah
call __itt_pt_byte
shr eax,16
mov cl,al
call __itt_pt_byte
mov cl,ah
call __itt_pt_byte
mov cl,dl
call __itt_pt_byte
mov cl,dh
call __itt_pt_byte
shr edx,16
mov cl,dl
call __itt_pt_byte
mov cl,dh
call __itt_pt_byte
ret
__itt_pt_event endp
align 10h
__itt_pt_mark_event proc
test rcx,1
jnz odd
mov r8,rcx
xor rcx,rcx
call __itt_pt_event
mov rcx,r8
jmp __itt_pt_mark
odd:
call __itt_pt_mark
xor rcx,rcx
jmp __itt_pt_event
__itt_pt_mark_event endp
align 10h
__itt_pt_flush proc
lea rax,offset __itt_pt_mark_flush_1
jmp rax
align 10h
nop
__itt_pt_mark_flush_1:
lea rax,offset __itt_pt_mark_flush_2
jmp rax
align 10h
nop
nop
__itt_pt_mark_flush_2:
lea rax,offset __itt_pt_mark_flush_3
jmp rax
align 10h
nop
nop
nop
__itt_pt_mark_flush_3:
ret
__itt_pt_flush endp
align 10h
;;; int __itt_pt_mark_threshold(unsigned char index, unsigned long long* tmp, int threshold);
__itt_pt_mark_threshold proc
mov r9,rcx ;;; index
mov r10,rdx ;;; tmp
xor rdx,rdx
xor rax,rax
test rcx,1
jnz mark_end
mark_begin:
mov rcx,(1 SHL 30) + 1
rdpmc
shl rdx,32
or rdx,rax
mov [r10],rdx
mov rcx,r9
jmp __itt_pt_mark
mark_end:
mov rcx,(1 SHL 30) + 1
rdpmc
shl rdx,32
or rdx,rax
sub rdx,[r10]
cmp rdx,r8 ;;; threshold
mov rcx,r9
jnc found
jmp __itt_pt_mark
found:
call __itt_pt_mark
jmp __itt_pt_flush
__itt_pt_mark_threshold endp
;;; PTWRITE
align 10h
;;; void __itt_pt_write(unsigned long long value);
dd 0, 1, 2, 3 ;;; GUID
__itt_pt_write proc
;;; ptwrite rcx
db 0F3h, 48h, 0Fh, 0AEh, 0E1h
ret
__itt_pt_write endp
;;;
_TEXT ends
end

268
deps/v8/third_party/ittapi/src/ittnotify/jitprofiling.c vendored Normal file
View File

@ -0,0 +1,268 @@
/*
Copyright (C) 2005-2019 Intel Corporation
SPDX-License-Identifier: GPL-2.0-only OR BSD-3-Clause
*/
#include "ittnotify_config.h"
#if ITT_PLATFORM==ITT_PLATFORM_WIN
#include <windows.h>
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#if ITT_PLATFORM != ITT_PLATFORM_MAC && ITT_PLATFORM != ITT_PLATFORM_FREEBSD
#include <malloc.h>
#endif
#include <stdlib.h>
#include "jitprofiling.h"
static const char rcsid[] = "\n@(#) $Revision$\n";
#define DLL_ENVIRONMENT_VAR "VS_PROFILER"
#ifndef NEW_DLL_ENVIRONMENT_VAR
#if ITT_ARCH==ITT_ARCH_IA32
#define NEW_DLL_ENVIRONMENT_VAR "INTEL_JIT_PROFILER32"
#else
#define NEW_DLL_ENVIRONMENT_VAR "INTEL_JIT_PROFILER64"
#endif
#endif /* NEW_DLL_ENVIRONMENT_VAR */
#if ITT_PLATFORM==ITT_PLATFORM_WIN
#define DEFAULT_DLLNAME "JitPI.dll"
HINSTANCE m_libHandle = NULL;
#elif ITT_PLATFORM==ITT_PLATFORM_MAC
#define DEFAULT_DLLNAME "libJitPI.dylib"
void* m_libHandle = NULL;
#else
#define DEFAULT_DLLNAME "libJitPI.so"
void* m_libHandle = NULL;
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
/* default location of JIT profiling agent on Android */
#define ANDROID_JIT_AGENT_PATH "/data/intel/libittnotify.so"
/* the function pointers */
typedef unsigned int(JITAPI *TPInitialize)(void);
static TPInitialize FUNC_Initialize=NULL;
typedef unsigned int(JITAPI *TPNotify)(unsigned int, void*);
static TPNotify FUNC_NotifyEvent=NULL;
static iJIT_IsProfilingActiveFlags executionMode = iJIT_NOTHING_RUNNING;
/* end collector dll part. */
/* loadiJIT_Funcs() : this function is called just in the beginning
* and is responsible to load the functions from BistroJavaCollector.dll
* result:
* on success: the functions loads, iJIT_DLL_is_missing=0, return value = 1
* on failure: the functions are NULL, iJIT_DLL_is_missing=1, return value = 0
*/
static int loadiJIT_Funcs(void);
/* global representing whether the collector can't be loaded */
static int iJIT_DLL_is_missing = 0;
ITT_EXTERN_C int JITAPI
iJIT_NotifyEvent(iJIT_JVM_EVENT event_type, void *EventSpecificData)
{
int ReturnValue = 0;
/* initialization part - the collector has not been loaded yet. */
if (!FUNC_NotifyEvent)
{
if (iJIT_DLL_is_missing)
return 0;
if (!loadiJIT_Funcs())
return 0;
}
if (event_type == iJVM_EVENT_TYPE_METHOD_LOAD_FINISHED ||
event_type == iJVM_EVENT_TYPE_METHOD_UPDATE)
{
if (((piJIT_Method_Load)EventSpecificData)->method_id == 0)
return 0;
}
else if (event_type == iJVM_EVENT_TYPE_METHOD_LOAD_FINISHED_V2)
{
if (((piJIT_Method_Load_V2)EventSpecificData)->method_id == 0)
return 0;
}
else if (event_type == iJVM_EVENT_TYPE_METHOD_LOAD_FINISHED_V3)
{
if (((piJIT_Method_Load_V3)EventSpecificData)->method_id == 0)
return 0;
}
else if (event_type == iJVM_EVENT_TYPE_METHOD_INLINE_LOAD_FINISHED)
{
if (((piJIT_Method_Inline_Load)EventSpecificData)->method_id == 0 ||
((piJIT_Method_Inline_Load)EventSpecificData)->parent_method_id == 0)
return 0;
}
ReturnValue = (int)FUNC_NotifyEvent(event_type, EventSpecificData);
return ReturnValue;
}
ITT_EXTERN_C iJIT_IsProfilingActiveFlags JITAPI iJIT_IsProfilingActive()
{
if (!iJIT_DLL_is_missing)
{
loadiJIT_Funcs();
}
return executionMode;
}
/* This function loads the collector dll and the relevant functions.
* on success: all functions load, iJIT_DLL_is_missing = 0, return value = 1
* on failure: all functions are NULL, iJIT_DLL_is_missing = 1, return value = 0
*/
static int loadiJIT_Funcs()
{
static int bDllWasLoaded = 0;
char *dllName = (char*)rcsid; /* !! Just to avoid unused code elimination */
#if ITT_PLATFORM==ITT_PLATFORM_WIN
DWORD dNameLength = 0;
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
if(bDllWasLoaded)
{
/* dll was already loaded, no need to do it for the second time */
return 1;
}
/* Assumes that the DLL will not be found */
iJIT_DLL_is_missing = 1;
FUNC_NotifyEvent = NULL;
if (m_libHandle)
{
#if ITT_PLATFORM==ITT_PLATFORM_WIN
FreeLibrary(m_libHandle);
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
dlclose(m_libHandle);
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
m_libHandle = NULL;
}
/* Try to get the dll name from the environment */
#if ITT_PLATFORM==ITT_PLATFORM_WIN
dNameLength = GetEnvironmentVariableA(NEW_DLL_ENVIRONMENT_VAR, NULL, 0);
if (dNameLength)
{
DWORD envret = 0;
dllName = (char*)malloc(sizeof(char) * (dNameLength + 1));
if(dllName != NULL)
{
envret = GetEnvironmentVariableA(NEW_DLL_ENVIRONMENT_VAR,
dllName, dNameLength);
if (envret)
{
/* Try to load the dll from the PATH... */
m_libHandle = LoadLibraryExA(dllName,
NULL, LOAD_WITH_ALTERED_SEARCH_PATH);
}
free(dllName);
}
} else {
/* Try to use old VS_PROFILER variable */
dNameLength = GetEnvironmentVariableA(DLL_ENVIRONMENT_VAR, NULL, 0);
if (dNameLength)
{
DWORD envret = 0;
dllName = (char*)malloc(sizeof(char) * (dNameLength + 1));
if(dllName != NULL)
{
envret = GetEnvironmentVariableA(DLL_ENVIRONMENT_VAR,
dllName, dNameLength);
if (envret)
{
/* Try to load the dll from the PATH... */
m_libHandle = LoadLibraryA(dllName);
}
free(dllName);
}
}
}
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
dllName = getenv(NEW_DLL_ENVIRONMENT_VAR);
if (!dllName)
dllName = getenv(DLL_ENVIRONMENT_VAR);
#if defined(__ANDROID__) || defined(ANDROID)
if (!dllName)
dllName = ANDROID_JIT_AGENT_PATH;
#endif
if (dllName)
{
/* Try to load the dll from the PATH... */
if (DL_SYMBOLS)
{
m_libHandle = dlopen(dllName, RTLD_LAZY);
}
}
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
if (!m_libHandle)
{
#if ITT_PLATFORM==ITT_PLATFORM_WIN
m_libHandle = LoadLibraryA(DEFAULT_DLLNAME);
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
if (DL_SYMBOLS)
{
m_libHandle = dlopen(DEFAULT_DLLNAME, RTLD_LAZY);
}
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
}
/* if the dll wasn't loaded - exit. */
if (!m_libHandle)
{
iJIT_DLL_is_missing = 1; /* don't try to initialize
* JIT agent the second time
*/
return 0;
}
#if ITT_PLATFORM==ITT_PLATFORM_WIN
FUNC_NotifyEvent = (TPNotify)GetProcAddress(m_libHandle, "NotifyEvent");
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
FUNC_NotifyEvent = (TPNotify)dlsym(m_libHandle, "NotifyEvent");
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
if (!FUNC_NotifyEvent)
{
FUNC_Initialize = NULL;
return 0;
}
#if ITT_PLATFORM==ITT_PLATFORM_WIN
FUNC_Initialize = (TPInitialize)GetProcAddress(m_libHandle, "Initialize");
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
FUNC_Initialize = (TPInitialize)dlsym(m_libHandle, "Initialize");
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
if (!FUNC_Initialize)
{
FUNC_NotifyEvent = NULL;
return 0;
}
executionMode = (iJIT_IsProfilingActiveFlags)FUNC_Initialize();
bDllWasLoaded = 1;
iJIT_DLL_is_missing = 0; /* DLL is ok. */
return 1;
}
ITT_EXTERN_C unsigned int JITAPI iJIT_GetNewMethodID()
{
static unsigned int methodID = 1;
if (methodID == 0)
return 0; /* ERROR : this is not a valid value */
return methodID++;
}

14
deps/v8/third_party/ittapi/src/ittnotify_refcol/Makefile vendored Normal file
View File

@ -0,0 +1,14 @@
INCLUDE_DIR = ../../include/
SRC_DIR = ../ittnotify/
SOURCE_NAME = itt_refcol_impl.c
OBJ_NAME = itt_refcol_impl.o
LIB_NAME = libittrefcol.so
CC ?= gcc
CFLAGS = -I$(INCLUDE_DIR) -I$(SRC_DIR)
build:
$(CC) -fPIC $(CFLAGS) -c $(SOURCE_NAME)
$(CC) -shared -o $(LIB_NAME) $(OBJ_NAME)
clean:
rm $(OBJ_NAME) $(LIB_NAME)

26
deps/v8/third_party/ittapi/src/ittnotify_refcol/README.md vendored Normal file
View File

@ -0,0 +1,26 @@
This is a reference implementation of the ITT API _dynamic part_
that performs tracing data from ITT API functions calls to log files.
To use this solution it is requered to build it like a shared library and add
full library path to the `INTEL_LIBITTNOTIFY64/INTEL_LIBITTNOTIFY32` environment variable:
```
make
export INTEL_LIBITTNOTIFY64=<build_dir>/libittnotify_refcol.so
```
Temp directory is used by default to save log files.
To change log directory use the `INTEL_LIBITTNOTIFY_LOG_DIR` environment variable:
```
export INTEL_LIBITTNOTIFY_LOG_DIR=<log_dir>
```
This implementation adds logging of some of the ITT API functions calls.
Adding logging of the other ITT API functions calls are welcome.
The solution provides 4 functions with different log levels
that takes printf format for logging:
```
LOG_FUNC_CALL_INFO(const char *msg_format, ...);
LOG_FUNC_CALL_WARN(const char *msg_format, ...);
LOG_FUNC_CALL_ERROR(const char *msg_format, ...);
LOG_FUNC_CALL_FATAL(const char *msg_format, ...);
```

277
deps/v8/third_party/ittapi/src/ittnotify_refcol/itt_refcol_impl.c vendored Normal file
View File

@ -0,0 +1,277 @@
#include <stdio.h>
#include <stdarg.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#define INTEL_NO_MACRO_BODY
#define INTEL_ITTNOTIFY_API_PRIVATE
#include "ittnotify.h"
#include "ittnotify_config.h"
#define LOG_BUFFER_MAX_SIZE 256
static const char* env_log_dir = "INTEL_LIBITTNOTIFY_LOG_DIR";
static const char* log_level_str[] = {"INFO", "WARN", "ERROR", "FATAL_ERROR"};
enum {
LOG_LVL_INFO,
LOG_LVL_WARN,
LOG_LVL_ERROR,
LOG_LVL_FATAL
};
static struct ref_collector_logger {
char* file_name;
uint8_t init_state;
} g_ref_collector_logger = {NULL, 0};
char* log_file_name_generate()
{
time_t time_now = time(NULL);
struct tm* time_info = localtime(&time_now);
char* log_file_name = malloc(sizeof(char) * (LOG_BUFFER_MAX_SIZE/2));
sprintf(log_file_name,"libittnotify_refcol_%d%d%d%d%d%d.log",
time_info->tm_year+1900, time_info->tm_mon+1, time_info->tm_mday,
time_info->tm_hour, time_info->tm_min, time_info->tm_sec);
return log_file_name;
}
void ref_col_init()
{
if (!g_ref_collector_logger.init_state)
{
static char file_name_buffer[LOG_BUFFER_MAX_SIZE*2];
char* log_dir = getenv(env_log_dir);
char* log_file = log_file_name_generate();
if (log_dir != NULL)
{
#ifdef _WIN32
sprintf(file_name_buffer,"%s\\%s", log_dir, log_file);
#else
sprintf(file_name_buffer,"%s/%s", log_dir, log_file);
#endif
}
else
{
#ifdef _WIN32
char* temp_dir = getenv("TEMP");
if (temp_dir != NULL)
{
sprintf(file_name_buffer,"%s\\%s", temp_dir, log_file);
}
#else
sprintf(file_name_buffer,"/tmp/%s", log_file);
#endif
}
g_ref_collector_logger.file_name = file_name_buffer;
g_ref_collector_logger.init_state = 1;
}
}
static void fill_func_ptr_per_lib(__itt_global* p)
{
__itt_api_info* api_list = (__itt_api_info*)p->api_list_ptr;
for (int i = 0; api_list[i].name != NULL; i++)
{
*(api_list[i].func_ptr) = (void*)__itt_get_proc(p->lib, api_list[i].name);
if (*(api_list[i].func_ptr) == NULL)
{
*(api_list[i].func_ptr) = api_list[i].null_func;
}
}
}
ITT_EXTERN_C void ITTAPI __itt_api_init(__itt_global* p, __itt_group_id init_groups)
{
if (p != NULL)
{
fill_func_ptr_per_lib(p);
ref_col_init();
}
else
{
printf("ERROR: Failed to initialize dynamic library\n");
}
}
void log_func_call(uint8_t log_level, const char* function_name, const char* message_format, ...)
{
if (g_ref_collector_logger.init_state)
{
FILE * pLogFile = NULL;
char log_buffer[LOG_BUFFER_MAX_SIZE];
uint32_t result_len = 0;
va_list message_args;
result_len += sprintf(log_buffer, "[%s] %s(...) - ", log_level_str[log_level] ,function_name);
va_start(message_args, message_format);
vsnprintf(log_buffer + result_len, LOG_BUFFER_MAX_SIZE - result_len, message_format, message_args);
pLogFile = fopen(g_ref_collector_logger.file_name, "a");
if (!pLogFile)
{
printf("ERROR: Cannot open file: %s\n", g_ref_collector_logger.file_name);
return;
}
fprintf(pLogFile, "%s\n", log_buffer);
fclose(pLogFile);
}
else
{
return;
}
}
#define LOG_FUNC_CALL_INFO(...) log_func_call(LOG_LVL_INFO, __FUNCTION__, __VA_ARGS__)
#define LOG_FUNC_CALL_WARN(...) log_func_call(LOG_LVL_WARN, __FUNCTION__, __VA_ARGS__)
#define LOG_FUNC_CALL_ERROR(...) log_func_call(LOG_LVL_ERROR, __FUNCTION__, __VA_ARGS__)
#define LOG_FUNC_CALL_FATAL(...) log_func_call(LOG_LVL_FATAL, __FUNCTION__, __VA_ARGS__)
/* ------------------------------------------------------------------------------ */
/* The code below is a reference implementation of the ITT API dynamic collector. */
/* This implementation is designed to log ITTAPI functions calls.*/
/* ------------------------------------------------------------------------------ */
char* get_metadata_elements(size_t size, __itt_metadata_type type, void* metadata)
{
char* metadata_str = malloc(sizeof(char) * LOG_BUFFER_MAX_SIZE);
*metadata_str = '\0';
switch (type)
{
case __itt_metadata_u64:
for (uint16_t i = 0; i < size; i++)
sprintf(metadata_str, "%s%llu;", metadata_str, ((uint64_t*)metadata)[i]);
break;
case __itt_metadata_s64:
for (uint16_t i = 0; i < size; i++)
sprintf(metadata_str, "%s%lld;", metadata_str, ((int64_t*)metadata)[i]);
break;
case __itt_metadata_u32:
for (uint16_t i = 0; i < size; i++)
sprintf(metadata_str, "%s%lu;", metadata_str, ((uint32_t*)metadata)[i]);
break;
case __itt_metadata_s32:
for (uint16_t i = 0; i < size; i++)
sprintf(metadata_str, "%s%ld;", metadata_str, ((int32_t*)metadata)[i]);
break;
case __itt_metadata_u16:
for (uint16_t i = 0; i < size; i++)
sprintf(metadata_str, "%s%u;", metadata_str, ((uint16_t*)metadata)[i]);
break;
case __itt_metadata_s16:
for (uint16_t i = 0; i < size; i++)
sprintf(metadata_str, "%s%d;", metadata_str, ((int16_t*)metadata)[i]);
break;
case __itt_metadata_float:
for (uint16_t i = 0; i < size; i++)
sprintf(metadata_str, "%s%f;", metadata_str, ((float*)metadata)[i]);
break;
case __itt_metadata_double:
for (uint16_t i = 0; i < size; i++)
sprintf(metadata_str, "%s%lf;", metadata_str, ((double*)metadata)[i]);
break;
default:
printf("ERROR: Unknow metadata type\n");
}
return metadata_str;
}
ITT_EXTERN_C void ITTAPI __itt_pause(void)
{
LOG_FUNC_CALL_INFO("function call");
}
ITT_EXTERN_C void ITTAPI __itt_resume(void)
{
LOG_FUNC_CALL_INFO("function call");
}
ITT_EXTERN_C void ITTAPI __itt_detach(void)
{
LOG_FUNC_CALL_INFO("function call");
}
ITT_EXTERN_C void ITTAPI __itt_frame_begin_v3(const __itt_domain *domain, __itt_id *id)
{
if (domain != NULL)
{
LOG_FUNC_CALL_INFO("functions args: domain_name=%s", domain->nameA);
}
else
{
LOG_FUNC_CALL_WARN("Incorrect function call");
}
}
ITT_EXTERN_C void ITTAPI __itt_frame_end_v3(const __itt_domain *domain, __itt_id *id)
{
if (domain != NULL)
{
LOG_FUNC_CALL_INFO("functions args: domain_name=%s", domain->nameA);
}
else
{
LOG_FUNC_CALL_WARN("Incorrect function call");
}
}
ITT_EXTERN_C void ITTAPI __itt_frame_submit_v3(const __itt_domain *domain, __itt_id *id,
__itt_timestamp begin, __itt_timestamp end)
{
if (domain != NULL)
{
LOG_FUNC_CALL_INFO("functions args: domain_name=%s, time_begin=%lu, time_end=%llu",
domain->nameA, (uint64_t*)id, begin, end);
}
else
{
LOG_FUNC_CALL_WARN("Incorrect function call");
}
}
ITT_EXTERN_C void ITTAPI __itt_task_begin(
const __itt_domain *domain, __itt_id taskid, __itt_id parentid, __itt_string_handle *name)
{
if (domain != NULL && name != NULL)
{
LOG_FUNC_CALL_INFO("functions args: domain_name=%s handle_name=%s", domain->nameA, name->strA);
}
else
{
LOG_FUNC_CALL_WARN("Incorrect function call");
}
}
ITT_EXTERN_C void ITTAPI __itt_task_end(const __itt_domain *domain)
{
if (domain != NULL)
{
LOG_FUNC_CALL_INFO("functions args: domain_name=%s", domain->nameA);
}
else
{
LOG_FUNC_CALL_WARN("Incorrect function call");
}
}
ITT_EXTERN_C void __itt_metadata_add(const __itt_domain *domain, __itt_id id,
__itt_string_handle *key, __itt_metadata_type type, size_t count, void *data)
{
if (domain != NULL && count != 0)
{
LOG_FUNC_CALL_INFO("functions args: domain_name=%s metadata_size=%lu metadata[]=%s",
domain->nameA, count, get_metadata_elements(count, type, data));
}
else
{
LOG_FUNC_CALL_WARN("Incorrect function call");
}
}

1
node.gyp
View File

@ -22,6 +22,7 @@
'node_use_openssl%': 'true',
'node_shared_openssl%': 'false',
'node_v8_options%': '',
'node_enable_v8_vtunejit%': 'false',
'node_core_target_name%': 'node',
'node_lib_target_name%': 'libnode',
'node_intermediate_lib_type%': 'static_library',

8
node.gypi
View File

@ -125,6 +125,14 @@
],
}]],
}],
[ 'node_use_bundled_v8=="true" and \
node_enable_v8_vtunejit=="true" and (target_arch=="x64" or \
target_arch=="ia32" or target_arch=="x32")', {
'defines': [ 'NODE_ENABLE_VTUNE_PROFILING' ],
'dependencies': [
'tools/v8_gypfiles/v8vtune.gyp:v8_vtune'
],
}],
[ 'node_no_browser_globals=="true"', {
'defines': [ 'NODE_NO_BROWSER_GLOBALS' ],
} ],

8
src/api/environment.cc
View File

@ -12,7 +12,9 @@
#include "node_v8_platform-inl.h"
#include "node_wasm_web_api.h"
#include "uv.h"
#ifdef NODE_ENABLE_VTUNE_PROFILING
#include "../deps/v8/src/third_party/vtune/v8-vtune.h"
#endif
#if HAVE_INSPECTOR
#include "inspector/worker_inspector.h" // ParentInspectorHandle
#endif
@ -226,6 +228,10 @@ void SetIsolateCreateParamsForNode(Isolate::CreateParams* params) {
}
params->embedder_wrapper_object_index = BaseObject::InternalFields::kSlot;
params->embedder_wrapper_type_index = std::numeric_limits<int>::max();
#ifdef NODE_ENABLE_VTUNE_PROFILING
params->code_event_handler = vTune::GetVtuneCodeEventHandler();
#endif
}
void SetIsolateErrorHandlers(v8::Isolate* isolate, const IsolateSettings& s) {

4
src/node.cc
View File

@ -65,6 +65,10 @@
#include "inspector/worker_inspector.h" // ParentInspectorHandle
#endif
#ifdef NODE_ENABLE_VTUNE_PROFILING
#include "../deps/v8/src/third_party/vtune/v8-vtune.h"
#endif
#include "large_pages/node_large_page.h"
#if defined(__APPLE__) || defined(__linux__) || defined(_WIN32)

2
tools/license-builder.sh
View File

@ -36,6 +36,8 @@ licenseText="$(tail -n +3 "${rootdir}/deps/cares/LICENSE.md")"
addlicense "c-ares" "deps/cares" "$licenseText"
licenseText="$(cat "${rootdir}/deps/cjs-module-lexer/LICENSE")"
addlicense "cjs-module-lexer" "deps/cjs-module-lexer" "$licenseText"
licenseText="$(cat "${rootdir}/deps/v8/third_party/ittapi/LICENSES/BSD-3-Clause.txt")"
addlicense "ittapi" "deps/v8/third_party/ittapi" "$licenseText"
if [ -f "${rootdir}/deps/icu/LICENSE" ]; then
# ICU 57 and following. Drop the BOM
licenseText="$(sed -e '1s/^[^a-zA-Z ]*ICU/ICU/' -e :a -e 's/<[^>]*>//g;s/ / /g;s/ +$//;/</N;//ba' "${rootdir}/deps/icu/LICENSE")"

7
tools/v8_gypfiles/d8.gyp
View File

@ -6,6 +6,8 @@
'variables': {
'V8_ROOT': '../../deps/v8',
'v8_code': 1,
# Enable support for Intel VTune. Supported on ia32/x64 only
'v8_enable_vtunejit%': 0,
'v8_enable_i18n_support%': 1,
},
'includes': ['toolchain.gypi', 'features.gypi'],
@ -51,6 +53,11 @@
[ 'OS=="win"', {
'sources': [ '<(V8_ROOT)/src/d8/d8-windows.cc', ]
}],
['v8_enable_vtunejit==1', {
'dependencies': [
'v8vtune.gyp:v8_vtune',
],
}],
['v8_enable_i18n_support==1', {
'dependencies': [
'<(icu_gyp_path):icui18n',

6
tools/v8_gypfiles/features.gypi
View File

@ -111,6 +111,9 @@
# Sets -dENABLE_HUGEPAGE
'v8_enable_hugepage%': 0,
# Sets -dENABLE_VTUNE_JIT_INTERFACE.
'v8_enable_vtunejit%': 0,
# Currently set for node by common.gypi, avoiding default because of gyp file bug.
# Should be turned on only for debugging.
#'v8_enable_handle_zapping%': 0,
@ -308,6 +311,9 @@
['v8_enable_hugepage==1', {
'defines': ['ENABLE_HUGEPAGE',],
}],
['v8_enable_vtunejit==1', {
'defines': ['ENABLE_VTUNE_JIT_INTERFACE',],
}],
['v8_enable_pointer_compression==1', {
'defines': [
'V8_COMPRESS_POINTERS',

39
tools/v8_gypfiles/v8vtune.gyp Normal file
View File

@ -0,0 +1,39 @@
# Copyright 2012 the V8 project authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
{
'variables': {
'V8_ROOT': '../../deps/v8',
'v8_code': 1,
},
'includes': ['toolchain.gypi', 'features.gypi'],
'targets': [
{
'target_name': 'v8_vtune',
'type': 'static_library',
'sources': [
'<(V8_ROOT)/third_party/ittapi/src/ittnotify/ittnotify_config.h',
'<(V8_ROOT)/third_party/ittapi/src/ittnotify/ittnotify_types.h',
'<(V8_ROOT)/third_party/ittapi/src/ittnotify/jitprofiling.c',
'<(V8_ROOT)/third_party/ittapi/include/jitprofiling.h',
'<(V8_ROOT)/src/third_party/vtune/v8-vtune.h',
'<(V8_ROOT)/src/third_party/vtune/vtune-jit.cc',
'<(V8_ROOT)/src/third_party/vtune/vtune-jit.h',
],
'include_dirs': [
'<(V8_ROOT)/third_party/ittapi/include',
'<(V8_ROOT)/third_party/ittapi/src/ittnotify',
],
'direct_dependent_settings': {
'defines': ['ENABLE_VTUNE_JIT_INTERFACE',],
'conditions': [
['OS != "win"', {
'libraries': ['-ldl',],
}],
],
},
},
],
}

6
vcbuild.bat
View File

@ -52,6 +52,7 @@ set i18n_arg=
set download_arg=
set build_release=
set configure_flags=
set enable_vtune_arg=
set build_addons=
set dll=
set enable_static=
@ -137,6 +138,7 @@ if /i "%1"=="without-intl" set i18n_arg=none&goto arg-ok
if /i "%1"=="download-all" set download_arg="--download=all"&goto arg-ok
if /i "%1"=="ignore-flaky" set test_args=%test_args% --flaky-tests=dontcare&goto arg-ok
if /i "%1"=="dll" set dll=1&goto arg-ok
if /i "%1"=="enable-vtune" set enable_vtune_arg=1&goto arg-ok
if /i "%1"=="static" set enable_static=1&goto arg-ok
if /i "%1"=="no-NODE-OPTIONS" set no_NODE_OPTIONS=1&goto arg-ok
if /i "%1"=="debug-nghttp2" set debug_nghttp2=1&goto arg-ok
@ -190,6 +192,7 @@ if defined nocorepack set configure_flags=%configure_flags% --without-core
if defined ltcg set configure_flags=%configure_flags% --with-ltcg
if defined release_urlbase set configure_flags=%configure_flags% --release-urlbase=%release_urlbase%
if defined download_arg set configure_flags=%configure_flags% %download_arg%
if defined enable_vtune_arg set configure_flags=%configure_flags% --enable-vtune-profiling
if defined dll set configure_flags=%configure_flags% --shared
if defined enable_static set configure_flags=%configure_flags% --enable-static
if defined no_NODE_OPTIONS set configure_flags=%configure_flags% --without-node-options
@ -765,13 +768,14 @@ set exit_code=1
goto exit
:help
echo vcbuild.bat [debug/release] [msi] [doc] [test/test-all/test-addons/test-doc/test-js-native-api/test-node-api/test-benchmark/test-internet/test-pummel/test-simple/test-message/test-tick-processor/test-known-issues/test-node-inspect/test-check-deopts/test-npm/test-async-hooks/test-v8/test-v8-intl/test-v8-benchmarks/test-v8-all] [ignore-flaky] [static/dll] [noprojgen] [projgen] [small-icu/full-icu/without-intl] [nobuild] [nosnapshot] [nonpm] [nocorepack] [ltcg] [licensetf] [sign] [ia32/x86/x64/arm64] [vs2019/vs2022] [download-all] [lint/lint-ci/lint-js/lint-md] [lint-md-build] [package] [build-release] [upload] [no-NODE-OPTIONS] [link-module path-to-module] [debug-http2] [debug-nghttp2] [clean] [cctest] [no-cctest] [openssl-no-asm]
echo vcbuild.bat [debug/release] [msi] [doc] [test/test-all/test-addons/test-doc/test-js-native-api/test-node-api/test-benchmark/test-internet/test-pummel/test-simple/test-message/test-tick-processor/test-known-issues/test-node-inspect/test-check-deopts/test-npm/test-async-hooks/test-v8/test-v8-intl/test-v8-benchmarks/test-v8-all] [ignore-flaky] [static/dll] [noprojgen] [projgen] [small-icu/full-icu/without-intl] [nobuild] [nosnapshot] [nonpm] [nocorepack] [ltcg] [licensetf] [sign] [ia32/x86/x64/arm64] [vs2019/vs2022] [download-all] [enable-vtune] [lint/lint-ci/lint-js/lint-md] [lint-md-build] [package] [build-release] [upload] [no-NODE-OPTIONS] [link-module path-to-module] [debug-http2] [debug-nghttp2] [clean] [cctest] [no-cctest] [openssl-no-asm]
echo Examples:
echo vcbuild.bat : builds release build
echo vcbuild.bat debug : builds debug build
echo vcbuild.bat release msi : builds release build and MSI installer package
echo vcbuild.bat test : builds debug build and runs tests
echo vcbuild.bat build-release : builds the release distribution as used by nodejs.org
echo vcbuild.bat enable-vtune : builds Node.js with Intel VTune profiling support to profile JavaScript
echo vcbuild.bat link-module my_module.js : bundles my_module as built-in module
echo vcbuild.bat lint : runs the C++, documentation and JavaScript linter
echo vcbuild.bat no-cctest : skip building cctest.exe