# [ doc = "<\\brief Send this to shutdown the agent." ] # [ doc = " Use NULL for event data." ] pub const iJIT_jvm_event_iJVM_EVENT_TYPE_SHUTDOWN : iJIT_jvm_event = 2 ; # [ doc = "<\\brief Send when dynamic code is" ] # [ doc = " JIT compiled and loaded into" ] # [ doc = " memory by the JIT engine, but" ] # [ doc = " before the code is executed." ] # [ doc = " Use iJIT_Method_Load as event" ] # [ doc = " data." ] pub const iJIT_jvm_event_iJVM_EVENT_TYPE_METHOD_LOAD_FINISHED : iJIT_jvm_event = 13 ; # [ doc = "<\\brief Send when compiled dynamic" ] # [ doc = " code is being unloaded from memory." ] # [ doc = " Use iJIT_Method_Load as event data." ] pub const iJIT_jvm_event_iJVM_EVENT_TYPE_METHOD_UNLOAD_START : iJIT_jvm_event = 14 ; # [ doc = "<\\brief Send to provide new content for" ] # [ doc = " a previously reported dynamic code." ] # [ doc = " The previous content will be invalidated" ] # [ doc = " starting from the time of the notification." ] # [ doc = " Use iJIT_Method_Load as event data but" ] # [ doc = " required fields are following:" ] # [ doc = " - method_id identify the code to update." ] # [ doc = " - method_load_address specify start address" ] # [ doc = " within identified code range" ] # [ doc = " where update should be started." ] # [ doc = " - method_size specify length of updated code" ] # [ doc = " range." ] pub const iJIT_jvm_event_iJVM_EVENT_TYPE_METHOD_UPDATE : iJIT_jvm_event = 15 ; # [ doc = "<\\brief Send when an inline dynamic" ] # [ doc = " code is JIT compiled and loaded" ] # [ doc = " into memory by the JIT engine," ] # [ doc = " but before the parent code region" ] # [ doc = " starts executing." ] # [ doc = " Use iJIT_Method_Inline_Load as event data." ] pub const iJIT_jvm_event_iJVM_EVENT_TYPE_METHOD_INLINE_LOAD_FINISHED : iJIT_jvm_event = 16 ; # [ doc = " @cond exclude_from_documentation" ] pub const iJIT_jvm_event_iJVM_EVENT_TYPE_METHOD_UPDATE_V2 : iJIT_jvm_event = 17 ; # [ doc = "<\\brief Send when a dynamic code is" ] # [ doc = " JIT compiled and loaded into" ] # [ doc = " memory by the JIT engine, but" ] # [ doc = " before the code is executed." ] # [ doc = " Use iJIT_Method_Load_V2 as event data." ] pub const iJIT_jvm_event_iJVM_EVENT_TYPE_METHOD_LOAD_FINISHED_V2 : iJIT_jvm_event = 21 ; # [ doc = "<\\brief Send when a dynamic code is" ] # [ doc = " JIT compiled and loaded into" ] # [ doc = " memory by the JIT engine, but" ] # [ doc = " before the code is executed." ] # [ doc = " Use iJIT_Method_Load_V3 as event data." ] pub const iJIT_jvm_event_iJVM_EVENT_TYPE_METHOD_LOAD_FINISHED_V3 : iJIT_jvm_event = 22 ; # [ doc = " @brief Enumerator for the types of notifications" ] pub type iJIT_jvm_event = u32 ; pub use self :: iJIT_jvm_event as iJIT_JVM_EVENT ; # [ doc = "<\\brief The agent is not running;" ] # [ doc = " iJIT_NotifyEvent calls will" ] # [ doc = " not be processed." ] pub const _iJIT_IsProfilingActiveFlags_iJIT_NOTHING_RUNNING : _iJIT_IsProfilingActiveFlags = 0 ; # [ doc = "<\\brief The agent is running and" ] # [ doc = " ready to process notifications." ] pub const _iJIT_IsProfilingActiveFlags_iJIT_SAMPLING_ON : _iJIT_IsProfilingActiveFlags = 1 ; # [ doc = " @brief Enumerator for the agent's mode" ] pub type _iJIT_IsProfilingActiveFlags = u32 ; pub use self :: _iJIT_IsProfilingActiveFlags as iJIT_IsProfilingActiveFlags ; # [ doc = " @brief Description of a single entry in the line number information of a code region." ] # [ doc = " @details A table of line number entries gives information about how the reported code region" ] # [ doc = " is mapped to source file." ] # [ doc = " Intel(R) VTune(TM) Amplifier uses line number information to attribute" ] # [ doc = " the samples (virtual address) to a line number. \\n" ] # [ doc = " It is acceptable to report different code addresses for the same source line:" ] # [ doc = " @code" ] # [ doc = " Offset LineNumber" ] # [ doc = " 1 2" ] # [ doc = " 12 4" ] # [ doc = " 15 2" ] # [ doc = " 18 1" ] # [ doc = " 21 30" ] # [ doc = "" ] # [ doc = " VTune Amplifier constructs the following table using the client data" ] # [ doc = "" ] # [ doc = " Code subrange Line number" ] # [ doc = " 0-1 2" ] # [ doc = " 1-12 4" ] # [ doc = " 12-15 2" ] # [ doc = " 15-18 1" ] # [ doc = " 18-21 30" ] # [ doc = " @endcode" ] # [ repr ( C ) ] # [ derive ( Debug , Copy , Clone ) ] pub struct _LineNumberInfo { # [ doc = "<\\brief Offset from the begining of the code region." ] pub Offset : :: std :: os :: raw :: c_uint , # [ doc = "<\\brief Matching source line number offset (from beginning of source file)." ] pub LineNumber : :: std :: os :: raw :: c_uint , } # [ test ] fn bindgen_test_layout__LineNumberInfo ( ) { assert_eq ! ( :: std :: mem :: size_of :: < _LineNumberInfo > ( ) , 8usize , concat ! ( "Size of: " , stringify ! ( _LineNumberInfo ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < _LineNumberInfo > ( ) , 4usize , concat ! ( "Alignment of " , stringify ! ( _LineNumberInfo ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < _LineNumberInfo > ( ) ) ) . Offset as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( _LineNumberInfo ) , "::" , stringify ! ( Offset ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < _LineNumberInfo > ( ) ) ) . LineNumber as * const _ as usize } , 4usize , concat ! ( "Offset of field: " , stringify ! ( _LineNumberInfo ) , "::" , stringify ! ( LineNumber ) ) ) ; } pub type pLineNumberInfo = * mut _LineNumberInfo ; pub type LineNumberInfo = _LineNumberInfo ; # [ doc = "<\\brief Native to the process architecture that is calling it." ] pub const _iJIT_CodeArchitecture_iJIT_CA_NATIVE : _iJIT_CodeArchitecture = 0 ; # [ doc = "<\\brief 32-bit machine code." ] pub const _iJIT_CodeArchitecture_iJIT_CA_32 : _iJIT_CodeArchitecture = 1 ; # [ doc = "<\\brief 64-bit machine code." ] pub const _iJIT_CodeArchitecture_iJIT_CA_64 : _iJIT_CodeArchitecture = 2 ; # [ doc = " @brief Enumerator for the code architecture." ] pub type _iJIT_CodeArchitecture = u32 ; pub use self :: _iJIT_CodeArchitecture as iJIT_CodeArchitecture ; # [ doc = " @brief Description of a JIT-compiled method" ] # [ doc = " @details When you use the iJIT_Method_Load structure to describe" ] # [ doc = " the JIT compiled method, use iJVM_EVENT_TYPE_METHOD_LOAD_FINISHED" ] # [ doc = " as an event type to report it." ] # [ repr ( C ) ] # [ derive ( Debug , Copy , Clone ) ] pub struct _iJIT_Method_Load { # [ doc = "<\\brief Unique method ID. Cannot be 0." ] # [ doc = " You must either use the API function" ] # [ doc = " iJIT_GetNewMethodID to get a valid and unique" ] # [ doc = " method ID, or else manage ID uniqueness" ] # [ doc = " and correct range by yourself.\\n" ] # [ doc = " You must use the same method ID for all code" ] # [ doc = " regions of the same method, otherwise different" ] # [ doc = " method IDs specify different methods." ] pub method_id : :: std :: os :: raw :: c_uint , # [ doc = "<\\brief The name of the method. It can be optionally" ] # [ doc = " prefixed with its class name and appended with" ] # [ doc = " its complete signature. Can't be NULL." ] pub method_name : * mut :: std :: os :: raw :: c_char , # [ doc = "<\\brief The start virtual address of the method code" ] # [ doc = " region. If NULL, data provided with" ] # [ doc = " event are not accepted." ] pub method_load_address : * mut :: std :: os :: raw :: c_void , # [ doc = "<\\brief The code size of the method in memory." ] # [ doc = " If 0, then data provided with the event are not" ] # [ doc = " accepted." ] pub method_size : :: std :: os :: raw :: c_uint , # [ doc = "<\\brief The number of entries in the line number" ] # [ doc = " table.0 if none." ] pub line_number_size : :: std :: os :: raw :: c_uint , # [ doc = "<\\brief Pointer to the line numbers info" ] # [ doc = " array. Can be NULL if" ] # [ doc = " line_number_size is 0. See" ] # [ doc = " LineNumberInfo Structure for a" ] # [ doc = " description of a single entry in" ] # [ doc = " the line number info array" ] pub line_number_table : pLineNumberInfo , # [ doc = "<\\brief This field is obsolete." ] pub class_id : :: std :: os :: raw :: c_uint , # [ doc = "<\\brief Class name. Can be NULL." ] pub class_file_name : * mut :: std :: os :: raw :: c_char , # [ doc = "<\\brief Source file name. Can be NULL." ] pub source_file_name : * mut :: std :: os :: raw :: c_char , } # [ test ] fn bindgen_test_layout__iJIT_Method_Load ( ) { assert_eq ! ( :: std :: mem :: size_of :: < _iJIT_Method_Load > ( ) , 64usize , concat ! ( "Size of: " , stringify ! ( _iJIT_Method_Load ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < _iJIT_Method_Load > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( _iJIT_Method_Load ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < _iJIT_Method_Load > ( ) ) ) . method_id as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( _iJIT_Method_Load ) , "::" , stringify ! ( method_id ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < _iJIT_Method_Load > ( ) ) ) . method_name as * const _ as usize } , 8usize , concat ! ( "Offset of field: " , stringify ! ( _iJIT_Method_Load ) , "::" , stringify ! ( method_name ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < _iJIT_Method_Load > ( ) ) ) . method_load_address as * const _ as usize } , 16usize , concat ! ( "Offset of field: " , stringify ! ( _iJIT_Method_Load ) , "::" , stringify ! ( method_load_address ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < _iJIT_Method_Load > ( ) ) ) . method_size as * const _ as usize } , 24usize , concat ! ( "Offset of field: " , stringify ! ( _iJIT_Method_Load ) , "::" , stringify ! ( method_size ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < _iJIT_Method_Load > ( ) ) ) . line_number_size as * const _ as usize } , 28usize , concat ! ( "Offset of field: " , stringify ! ( _iJIT_Method_Load ) , "::" , stringify ! ( line_number_size ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < _iJIT_Method_Load > ( ) ) ) . line_number_table as * const _ as usize } , 32usize , concat ! ( "Offset of field: " , stringify ! ( _iJIT_Method_Load ) , "::" , stringify ! ( line_number_table ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < _iJIT_Method_Load > ( ) ) ) . class_id as * const _ as usize } , 40usize , concat ! ( "Offset of field: " , stringify ! ( _iJIT_Method_Load ) , "::" , stringify ! ( class_id ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < _iJIT_Method_Load > ( ) ) ) . class_file_name as * const _ as usize } , 48usize , concat ! ( "Offset of field: " , stringify ! ( _iJIT_Method_Load ) , "::" , stringify ! ( class_file_name ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < _iJIT_Method_Load > ( ) ) ) . source_file_name as * const _ as usize } , 56usize , concat ! ( "Offset of field: " , stringify ! ( _iJIT_Method_Load ) , "::" , stringify ! ( source_file_name ) ) ) ; } pub type piJIT_Method_Load = * mut _iJIT_Method_Load ; pub type iJIT_Method_Load = _iJIT_Method_Load ; # [ doc = " @brief Description of a JIT-compiled method" ] # [ doc = " @details When you use the iJIT_Method_Load_V2 structure to describe" ] # [ doc = " the JIT compiled method, use iJVM_EVENT_TYPE_METHOD_LOAD_FINISHED_V2" ] # [ doc = " as an event type to report it." ] # [ repr ( C ) ] # [ derive ( Debug , Copy , Clone ) ] pub struct _iJIT_Method_Load_V2 { # [ doc = "<\\brief Unique method ID. Cannot be 0." ] # [ doc = " You must either use the API function" ] # [ doc = " iJIT_GetNewMethodID to get a valid and unique" ] # [ doc = " method ID, or else manage ID uniqueness" ] # [ doc = " and correct range by yourself.\\n" ] # [ doc = " You must use the same method ID for all code" ] # [ doc = " regions of the same method, otherwise different" ] # [ doc = " method IDs specify different methods." ] pub method_id : :: std :: os :: raw :: c_uint , # [ doc = "<\\brief The name of the method. It can be optionally" ] # [ doc = " prefixed with its class name and appended with" ] # [ doc = " its complete signature. Can't be NULL." ] pub method_name : * mut :: std :: os :: raw :: c_char , # [ doc = "<\\brief The start virtual address of the method code" ] # [ doc = " region. If NULL, then data provided with the" ] # [ doc = " event are not accepted." ] pub method_load_address : * mut :: std :: os :: raw :: c_void , # [ doc = "<\\brief The code size of the method in memory." ] # [ doc = " If 0, then data provided with the event are not" ] # [ doc = " accepted." ] pub method_size : :: std :: os :: raw :: c_uint , # [ doc = "<\\brief The number of entries in the line number" ] # [ doc = " table. 0 if none." ] pub line_number_size : :: std :: os :: raw :: c_uint , # [ doc = "<\\brief Pointer to the line numbers info" ] # [ doc = " array. Can be NULL if" ] # [ doc = " line_number_size is 0. See" ] # [ doc = " LineNumberInfo Structure for a" ] # [ doc = " description of a single entry in" ] # [ doc = " the line number info array." ] pub line_number_table : pLineNumberInfo , # [ doc = "<\\brief Class name. Can be NULL." ] pub class_file_name : * mut :: std :: os :: raw :: c_char , # [ doc = "<\\brief Source file name. Can be NULL." ] pub source_file_name : * mut :: std :: os :: raw :: c_char , # [ doc = "<\\brief Module name. Can be NULL." ] # [ doc = "The module name can be useful for distinguishing among" ] # [ doc = "different JIT engines. VTune Amplifier will display" ] # [ doc = "reported methods grouped by specific module." ] pub module_name : * mut :: std :: os :: raw :: c_char , } # [ test ] fn bindgen_test_layout__iJIT_Method_Load_V2 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < _iJIT_Method_Load_V2 > ( ) , 64usize , concat ! ( "Size of: " , stringify ! ( _iJIT_Method_Load_V2 ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < _iJIT_Method_Load_V2 > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( _iJIT_Method_Load_V2 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < _iJIT_Method_Load_V2 > ( ) ) ) . method_id as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( _iJIT_Method_Load_V2 ) , "::" , stringify ! ( method_id ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < _iJIT_Method_Load_V2 > ( ) ) ) . method_name as * const _ as usize } , 8usize , concat ! ( "Offset of field: " , stringify ! ( _iJIT_Method_Load_V2 ) , "::" , stringify ! ( method_name ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < _iJIT_Method_Load_V2 > ( ) ) ) . method_load_address as * const _ as usize } , 16usize , concat ! ( "Offset of field: " , stringify ! ( _iJIT_Method_Load_V2 ) , "::" , stringify ! ( method_load_address ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < _iJIT_Method_Load_V2 > ( ) ) ) . method_size as * const _ as usize } , 24usize , concat ! ( "Offset of field: " , stringify ! ( _iJIT_Method_Load_V2 ) , "::" , stringify ! ( method_size ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < _iJIT_Method_Load_V2 > ( ) ) ) . line_number_size as * const _ as usize } , 28usize , concat ! ( "Offset of field: " , stringify ! ( _iJIT_Method_Load_V2 ) , "::" , stringify ! ( line_number_size ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < _iJIT_Method_Load_V2 > ( ) ) ) . line_number_table as * const _ as usize } , 32usize , concat ! ( "Offset of field: " , stringify ! ( _iJIT_Method_Load_V2 ) , "::" , stringify ! ( line_number_table ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < _iJIT_Method_Load_V2 > ( ) ) ) . class_file_name as * const _ as usize } , 40usize , concat ! ( "Offset of field: " , stringify ! ( _iJIT_Method_Load_V2 ) , "::" , stringify ! ( class_file_name ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < _iJIT_Method_Load_V2 > ( ) ) ) . source_file_name as * const _ as usize } , 48usize , concat ! ( "Offset of field: " , stringify ! ( _iJIT_Method_Load_V2 ) , "::" , stringify ! ( source_file_name ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < _iJIT_Method_Load_V2 > ( ) ) ) . module_name as * const _ as usize } , 56usize , concat ! ( "Offset of field: " , stringify ! ( _iJIT_Method_Load_V2 ) , "::" , stringify ! ( module_name ) ) ) ; } pub type piJIT_Method_Load_V2 = * mut _iJIT_Method_Load_V2 ; pub type iJIT_Method_Load_V2 = _iJIT_Method_Load_V2 ; # [ doc = " @brief Description of a JIT-compiled method" ] # [ doc = " @details The iJIT_Method_Load_V3 structure is the same as iJIT_Method_Load_V2" ] # [ doc = " with a newly introduced 'arch' field that specifies architecture of the code region." ] # [ doc = " When you use the iJIT_Method_Load_V3 structure to describe" ] # [ doc = " the JIT compiled method, use iJVM_EVENT_TYPE_METHOD_LOAD_FINISHED_V3" ] # [ doc = " as an event type to report it." ] # [ repr ( C ) ] # [ derive ( Debug , Copy , Clone ) ] pub struct _iJIT_Method_Load_V3 { # [ doc = "<\\brief Unique method ID. Cannot be 0." ] # [ doc = " You must either use the API function" ] # [ doc = " iJIT_GetNewMethodID to get a valid and unique" ] # [ doc = " method ID, or manage ID uniqueness" ] # [ doc = " and correct range by yourself.\\n" ] # [ doc = " You must use the same method ID for all code" ] # [ doc = " regions of the same method, otherwise they are" ] # [ doc = " treated as regions of different methods." ] pub method_id : :: std :: os :: raw :: c_uint , # [ doc = "<\\brief The name of the method. It can be optionally" ] # [ doc = " prefixed with its class name and appended with" ] # [ doc = " its complete signature. Cannot be NULL." ] pub method_name : * mut :: std :: os :: raw :: c_char , # [ doc = "<\\brief The start virtual address of the method code" ] # [ doc = " region. If NULL, then data provided with the" ] # [ doc = " event are not accepted." ] pub method_load_address : * mut :: std :: os :: raw :: c_void , # [ doc = "<\\brief The code size of the method in memory." ] # [ doc = " If 0, then data provided with the event are not" ] # [ doc = " accepted." ] pub method_size : :: std :: os :: raw :: c_uint , # [ doc = "<\\brief The number of entries in the line number" ] # [ doc = " table. 0 if none." ] pub line_number_size : :: std :: os :: raw :: c_uint , # [ doc = "<\\brief Pointer to the line numbers info" ] # [ doc = " array. Can be NULL if" ] # [ doc = " line_number_size is 0. See" ] # [ doc = " LineNumberInfo Structure for a" ] # [ doc = " description of a single entry in" ] # [ doc = " the line number info array." ] pub line_number_table : pLineNumberInfo , # [ doc = "<\\brief Class name. Can be NULL." ] pub class_file_name : * mut :: std :: os :: raw :: c_char , # [ doc = "<\\brief Source file name. Can be NULL." ] pub source_file_name : * mut :: std :: os :: raw :: c_char , # [ doc = "<\\brief Module name. Can be NULL." ] # [ doc = " The module name can be useful for distinguishing among" ] # [ doc = " different JIT engines. VTune Amplifier will display" ] # [ doc = " reported methods grouped by specific module." ] pub module_name : * mut :: std :: os :: raw :: c_char , # [ doc = "<\\brief Architecture of the method's code region." ] # [ doc = " By default, it is the same as the process" ] # [ doc = " architecture that is calling it." ] # [ doc = " For example, you can use it if your 32-bit JIT" ] # [ doc = " engine generates 64-bit code." ] # [ doc = "" ] # [ doc = " If JIT engine reports both 32-bit and 64-bit types" ] # [ doc = " of methods then VTune Amplifier splits the methods" ] # [ doc = " with the same module name but with different" ] # [ doc = " architectures in two different modules. VTune Amplifier" ] # [ doc = " modifies the original name provided with a 64-bit method" ] # [ doc = " version by ending it with '(64)'" ] pub module_arch : iJIT_CodeArchitecture , } # [ test ] fn bindgen_test_layout__iJIT_Method_Load_V3 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < _iJIT_Method_Load_V3 > ( ) , 72usize , concat ! ( "Size of: " , stringify ! ( _iJIT_Method_Load_V3 ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < _iJIT_Method_Load_V3 > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( _iJIT_Method_Load_V3 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < _iJIT_Method_Load_V3 > ( ) ) ) . method_id as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( _iJIT_Method_Load_V3 ) , "::" , stringify ! ( method_id ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < _iJIT_Method_Load_V3 > ( ) ) ) . method_name as * const _ as usize } , 8usize , concat ! ( "Offset of field: " , stringify ! ( _iJIT_Method_Load_V3 ) , "::" , stringify ! ( method_name ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < _iJIT_Method_Load_V3 > ( ) ) ) . method_load_address as * const _ as usize } , 16usize , concat ! ( "Offset of field: " , stringify ! ( _iJIT_Method_Load_V3 ) , "::" , stringify ! ( method_load_address ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < _iJIT_Method_Load_V3 > ( ) ) ) . method_size as * const _ as usize } , 24usize , concat ! ( "Offset of field: " , stringify ! ( _iJIT_Method_Load_V3 ) , "::" , stringify ! ( method_size ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < _iJIT_Method_Load_V3 > ( ) ) ) . line_number_size as * const _ as usize } , 28usize , concat ! ( "Offset of field: " , stringify ! ( _iJIT_Method_Load_V3 ) , "::" , stringify ! ( line_number_size ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < _iJIT_Method_Load_V3 > ( ) ) ) . line_number_table as * const _ as usize } , 32usize , concat ! ( "Offset of field: " , stringify ! ( _iJIT_Method_Load_V3 ) , "::" , stringify ! ( line_number_table ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < _iJIT_Method_Load_V3 > ( ) ) ) . class_file_name as * const _ as usize } , 40usize , concat ! ( "Offset of field: " , stringify ! ( _iJIT_Method_Load_V3 ) , "::" , stringify ! ( class_file_name ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < _iJIT_Method_Load_V3 > ( ) ) ) . source_file_name as * const _ as usize } , 48usize , concat ! ( "Offset of field: " , stringify ! ( _iJIT_Method_Load_V3 ) , "::" , stringify ! ( source_file_name ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < _iJIT_Method_Load_V3 > ( ) ) ) . module_name as * const _ as usize } , 56usize , concat ! ( "Offset of field: " , stringify ! ( _iJIT_Method_Load_V3 ) , "::" , stringify ! ( module_name ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < _iJIT_Method_Load_V3 > ( ) ) ) . module_arch as * const _ as usize } , 64usize , concat ! ( "Offset of field: " , stringify ! ( _iJIT_Method_Load_V3 ) , "::" , stringify ! ( module_arch ) ) ) ; } pub type piJIT_Method_Load_V3 = * mut _iJIT_Method_Load_V3 ; pub type iJIT_Method_Load_V3 = _iJIT_Method_Load_V3 ; # [ doc = " @brief Description of an inline JIT-compiled method" ] # [ doc = " @details When you use the_iJIT_Method_Inline_Load structure to describe" ] # [ doc = " the JIT compiled method, use iJVM_EVENT_TYPE_METHOD_INLINE_LOAD_FINISHED" ] # [ doc = " as an event type to report it." ] # [ repr ( C ) ] # [ derive ( Debug , Copy , Clone ) ] pub struct _iJIT_Method_Inline_Load { # [ doc = "<\\brief Unique method ID. Cannot be 0." ] # [ doc = " You must either use the API function" ] # [ doc = " iJIT_GetNewMethodID to get a valid and unique" ] # [ doc = " method ID, or else manage ID uniqueness" ] # [ doc = " and correct range by yourself." ] pub method_id : :: std :: os :: raw :: c_uint , # [ doc = "<\\brief Unique immediate parent's method ID." ] # [ doc = " Cannot be 0." ] # [ doc = " You must either use the API function" ] # [ doc = " iJIT_GetNewMethodID to get a valid and unique" ] # [ doc = " method ID, or else manage ID uniqueness" ] # [ doc = " and correct range by yourself." ] pub parent_method_id : :: std :: os :: raw :: c_uint , # [ doc = "<\\brief The name of the method. It can be optionally" ] # [ doc = " prefixed with its class name and appended with" ] # [ doc = " its complete signature. Can't be NULL." ] pub method_name : * mut :: std :: os :: raw :: c_char , pub method_load_address : * mut :: std :: os :: raw :: c_void , # [ doc = "<\\brief The code size of the method in memory." ] # [ doc = " If 0, then data provided with the event are not" ] # [ doc = " accepted." ] pub method_size : :: std :: os :: raw :: c_uint , # [ doc = "<\\brief The number of entries in the line number" ] # [ doc = " table. 0 if none." ] pub line_number_size : :: std :: os :: raw :: c_uint , # [ doc = "<\\brief Pointer to the line numbers info" ] # [ doc = " array. Can be NULL if" ] # [ doc = " line_number_size is 0. See" ] # [ doc = " LineNumberInfo Structure for a" ] # [ doc = " description of a single entry in" ] # [ doc = " the line number info array" ] pub line_number_table : pLineNumberInfo , # [ doc = "<\\brief Class name. Can be NULL." ] pub class_file_name : * mut :: std :: os :: raw :: c_char , # [ doc = "<\\brief Source file name. Can be NULL." ] pub source_file_name : * mut :: std :: os :: raw :: c_char , } # [ test ] fn bindgen_test_layout__iJIT_Method_Inline_Load ( ) { assert_eq ! ( :: std :: mem :: size_of :: < _iJIT_Method_Inline_Load > ( ) , 56usize , concat ! ( "Size of: " , stringify ! ( _iJIT_Method_Inline_Load ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < _iJIT_Method_Inline_Load > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( _iJIT_Method_Inline_Load ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < _iJIT_Method_Inline_Load > ( ) ) ) . method_id as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( _iJIT_Method_Inline_Load ) , "::" , stringify ! ( method_id ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < _iJIT_Method_Inline_Load > ( ) ) ) . parent_method_id as * const _ as usize } , 4usize , concat ! ( "Offset of field: " , stringify ! ( _iJIT_Method_Inline_Load ) , "::" , stringify ! ( parent_method_id ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < _iJIT_Method_Inline_Load > ( ) ) ) . method_name as * const _ as usize } , 8usize , concat ! ( "Offset of field: " , stringify ! ( _iJIT_Method_Inline_Load ) , "::" , stringify ! ( method_name ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < _iJIT_Method_Inline_Load > ( ) ) ) . method_load_address as * const _ as usize } , 16usize , concat ! ( "Offset of field: " , stringify ! ( _iJIT_Method_Inline_Load ) , "::" , stringify ! ( method_load_address ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < _iJIT_Method_Inline_Load > ( ) ) ) . method_size as * const _ as usize } , 24usize , concat ! ( "Offset of field: " , stringify ! ( _iJIT_Method_Inline_Load ) , "::" , stringify ! ( method_size ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < _iJIT_Method_Inline_Load > ( ) ) ) . line_number_size as * const _ as usize } , 28usize , concat ! ( "Offset of field: " , stringify ! ( _iJIT_Method_Inline_Load ) , "::" , stringify ! ( line_number_size ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < _iJIT_Method_Inline_Load > ( ) ) ) . line_number_table as * const _ as usize } , 32usize , concat ! ( "Offset of field: " , stringify ! ( _iJIT_Method_Inline_Load ) , "::" , stringify ! ( line_number_table ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < _iJIT_Method_Inline_Load > ( ) ) ) . class_file_name as * const _ as usize } , 40usize , concat ! ( "Offset of field: " , stringify ! ( _iJIT_Method_Inline_Load ) , "::" , stringify ! ( class_file_name ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < _iJIT_Method_Inline_Load > ( ) ) ) . source_file_name as * const _ as usize } , 48usize , concat ! ( "Offset of field: " , stringify ! ( _iJIT_Method_Inline_Load ) , "::" , stringify ! ( source_file_name ) ) ) ; } pub type piJIT_Method_Inline_Load = * mut _iJIT_Method_Inline_Load ; pub type iJIT_Method_Inline_Load = _iJIT_Method_Inline_Load ; pub const _iJIT_SegmentType_iJIT_CT_UNKNOWN : _iJIT_SegmentType = 0 ; # [ doc = "<\\brief Executable code." ] pub const _iJIT_SegmentType_iJIT_CT_CODE : _iJIT_SegmentType = 1 ; # [ doc = "<\\brief Data (not executable code)." ] # [ doc = " VTune Amplifier uses the format string" ] # [ doc = " (see iJIT_Method_Update) to represent" ] # [ doc = " this data in the VTune Amplifier GUI" ] pub const _iJIT_SegmentType_iJIT_CT_DATA : _iJIT_SegmentType = 2 ; # [ doc = "<\\brief Use the previous markup for the trace." ] # [ doc = " Can be used for the following" ] # [ doc = " iJVM_EVENT_TYPE_METHOD_UPDATE_V2 events," ] # [ doc = " if the type of the previously reported segment" ] # [ doc = " type is the same." ] pub const _iJIT_SegmentType_iJIT_CT_KEEP : _iJIT_SegmentType = 3 ; pub const _iJIT_SegmentType_iJIT_CT_EOF : _iJIT_SegmentType = 4 ; # [ doc = " @cond exclude_from_documentation */" ] # [ doc = " @brief Description of a segment type" ] # [ doc = " @details Use the segment type to specify a type of data supplied" ] # [ doc = " with the iJVM_EVENT_TYPE_METHOD_UPDATE_V2 event to be applied to" ] # [ doc = " a certain code trace." ] pub type _iJIT_SegmentType = u32 ; pub use self :: _iJIT_SegmentType as iJIT_SegmentType ; # [ doc = " @brief Description of a dynamic update of the content within JIT-compiled method" ] # [ doc = " @details The JIT engine may generate the methods that are updated at runtime" ] # [ doc = " partially by mixed (data + executable code) content. When you use the iJIT_Method_Update" ] # [ doc = " structure to describe the update of the content within a JIT-compiled method," ] # [ doc = " use iJVM_EVENT_TYPE_METHOD_UPDATE_V2 as an event type to report it." ] # [ doc = "" ] # [ doc = " On the first Update event, VTune Amplifier copies the original code range reported by" ] # [ doc = " the iJVM_EVENT_TYPE_METHOD_LOAD event, then modifies it with the supplied bytes and" ] # [ doc = " adds the modified range to the original method. For next update events, VTune Amplifier" ] # [ doc = " does the same but it uses the latest modified version of a code region for update." ] # [ doc = " Eventually, VTune Amplifier GUI displays multiple code ranges for the method reported by" ] # [ doc = " the iJVM_EVENT_TYPE_METHOD_LOAD event." ] # [ doc = " Notes:" ] # [ doc = " - Multiple update events with different types for the same trace are allowed" ] # [ doc = " but they must be reported for the same code ranges." ] # [ doc = " Example," ] # [ doc = " @code" ] # [ doc = " [-- data---] Allowed" ] # [ doc = " [-- code --] Allowed" ] # [ doc = " [code] Ignored" ] # [ doc = " [-- data---] Allowed" ] # [ doc = " [-- code --] Allowed" ] # [ doc = " [------------ trace ---------]" ] # [ doc = " @endcode" ] # [ doc = " - The types of previously reported events can be changed but they must be reported" ] # [ doc = " for the same code ranges." ] # [ doc = " Example," ] # [ doc = " @code" ] # [ doc = " [-- data---] Allowed" ] # [ doc = " [-- code --] Allowed" ] # [ doc = " [-- data---] Allowed" ] # [ doc = " [-- code --] Allowed" ] # [ doc = " [------------ trace ---------]" ] # [ doc = " @endcode" ] # [ repr ( C ) ] # [ derive ( Debug , Copy , Clone ) ] pub struct _iJIT_Method_Update { # [ doc = "<\\brief Start address of the update within a method" ] pub load_address : * mut :: std :: os :: raw :: c_void , # [ doc = "<\\brief The update size" ] pub size : :: std :: os :: raw :: c_uint , # [ doc = "<\\brief Type of the update" ] pub type_ : iJIT_SegmentType , # [ doc = "<\\brief C string that contains a format string" ] # [ doc = " that follows the same specifications as format in printf." ] # [ doc = " The format string is used for iJIT_CT_CODE only" ] # [ doc = " and cannot be NULL." ] # [ doc = " Format can be changed on the fly." ] pub data_format : * const :: std :: os :: raw :: c_char , } # [ test ] fn bindgen_test_layout__iJIT_Method_Update ( ) { assert_eq ! ( :: std :: mem :: size_of :: < _iJIT_Method_Update > ( ) , 24usize , concat ! ( "Size of: " , stringify ! ( _iJIT_Method_Update ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < _iJIT_Method_Update > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( _iJIT_Method_Update ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < _iJIT_Method_Update > ( ) ) ) . load_address as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( _iJIT_Method_Update ) , "::" , stringify ! ( load_address ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < _iJIT_Method_Update > ( ) ) ) . size as * const _ as usize } , 8usize , concat ! ( "Offset of field: " , stringify ! ( _iJIT_Method_Update ) , "::" , stringify ! ( size ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < _iJIT_Method_Update > ( ) ) ) . type_ as * const _ as usize } , 12usize , concat ! ( "Offset of field: " , stringify ! ( _iJIT_Method_Update ) , "::" , stringify ! ( type_ ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < _iJIT_Method_Update > ( ) ) ) . data_format as * const _ as usize } , 16usize , concat ! ( "Offset of field: " , stringify ! ( _iJIT_Method_Update ) , "::" , stringify ! ( data_format ) ) ) ; } pub type piJIT_Method_Update = * mut _iJIT_Method_Update ; pub type iJIT_Method_Update = _iJIT_Method_Update ; extern "C" { # [ doc = " @brief Generates a new unique method ID." ] # [ doc = "" ] # [ doc = " You must use this API to obtain unique and valid method IDs for methods or" ] # [ doc = " traces reported to the agent if you don't have your own mechanism to generate" ] # [ doc = " unique method IDs." ] # [ doc = "" ] # [ doc = " @return a new unique method ID. When out of unique method IDs, this API" ] # [ doc = " returns 0, which is not an accepted value." ] pub fn iJIT_GetNewMethodID ( ) -> :: std :: os :: raw :: c_uint ; } extern "C" { # [ doc = " @brief Returns the current mode of the agent." ] # [ doc = "" ] # [ doc = " @return iJIT_SAMPLING_ON, indicating that agent is running, or" ] # [ doc = " iJIT_NOTHING_RUNNING if no agent is running." ] pub fn iJIT_IsProfilingActive ( ) -> iJIT_IsProfilingActiveFlags ; } extern "C" { # [ doc = " @brief Reports infomation about JIT-compiled code to the agent." ] # [ doc = "" ] # [ doc = " The reported information is used to attribute samples obtained from any" ] # [ doc = " Intel(R) VTune(TM) Amplifier collector. This API needs to be called" ] # [ doc = " after JIT compilation and before the first entry into the JIT-compiled" ] # [ doc = " code." ] # [ doc = "" ] # [ doc = " @param[in] event_type - type of the data sent to the agent" ] # [ doc = " @param[in] EventSpecificData - pointer to event-specific data" ] # [ doc = "" ] # [ doc = " @returns 1 on success, otherwise 0." ] pub fn iJIT_NotifyEvent ( event_type : iJIT_JVM_EVENT , EventSpecificData : * mut :: std :: os :: raw :: c_void ) -> :: std :: os :: raw :: c_int ; }