//**********************************************************************` | |
//* This is an include file generated by Message Compiler. *` | |
//* *` | |
//* Copyright (c) Microsoft Corporation. All Rights Reserved. *` | |
//**********************************************************************` | |
#pragma once | |
//***************************************************************************** | |
// | |
// Notes on the ETW event code generated by MC: | |
// | |
// - Structures and arrays of structures are treated as an opaque binary blob. | |
// The caller is responsible for packing the data for the structure into a | |
// single region of memory, with no padding between values. The macro will | |
// have an extra parameter for the length of the blob. | |
// - Arrays of nul-terminated strings must be packed by the caller into a | |
// single binary blob containing the correct number of strings, with a nul | |
// after each string. The size of the blob is specified in characters, and | |
// includes the final nul. | |
// - Arrays of SID are treated as a single binary blob. The caller is | |
// responsible for packing the SID values into a single region of memory with | |
// no padding. | |
// - The length attribute on the data element in the manifest is significant | |
// for values with intype win:UnicodeString, win:AnsiString, or win:Binary. | |
// The length attribute must be specified for win:Binary, and is optional for | |
// win:UnicodeString and win:AnsiString (if no length is given, the strings | |
// are assumed to be nul-terminated). For win:UnicodeString, the length is | |
// measured in characters, not bytes. | |
// - For an array of win:UnicodeString, win:AnsiString, or win:Binary, the | |
// length attribute applies to every value in the array, so every value in | |
// the array must have the same length. The values in the array are provided | |
// to the macro via a single pointer -- the caller is responsible for packing | |
// all of the values into a single region of memory with no padding between | |
// values. | |
// - Values of type win:CountedUnicodeString, win:CountedAnsiString, and | |
// win:CountedBinary can be generated and collected on Vista or later. | |
// However, they may not decode properly without the Windows 10 2018 Fall | |
// Update. | |
// - Arrays of type win:CountedUnicodeString, win:CountedAnsiString, and | |
// win:CountedBinary must be packed by the caller into a single region of | |
// memory. The format for each item is a UINT16 byte-count followed by that | |
// many bytes of data. When providing the array to the generated macro, you | |
// must provide the total size of the packed array data, including the UINT16 | |
// sizes for each item. In the case of win:CountedUnicodeString, the data | |
// size is specified in WCHAR (16-bit) units. In the case of | |
// win:CountedAnsiString and win:CountedBinary, the data size is specified in | |
// bytes. | |
// | |
//***************************************************************************** | |
#include <wmistr.h> | |
#include <evntrace.h> | |
#include <evntprov.h> | |
#ifndef ETW_INLINE | |
#ifdef _ETW_KM_ | |
// In kernel mode, save stack space by never inlining templates. | |
#define ETW_INLINE DECLSPEC_NOINLINE __inline | |
#else | |
// In user mode, save code size by inlining templates as appropriate. | |
#define ETW_INLINE __inline | |
#endif | |
#endif // ETW_INLINE | |
#if defined(__cplusplus) | |
extern "C" { | |
#endif | |
// | |
// MCGEN_DISABLE_PROVIDER_CODE_GENERATION macro: | |
// Define this macro to have the compiler skip the generated functions in this | |
// header. | |
// | |
#ifndef MCGEN_DISABLE_PROVIDER_CODE_GENERATION | |
// | |
// MCGEN_USE_KERNEL_MODE_APIS macro: | |
// Controls whether the generated code uses kernel-mode or user-mode APIs. | |
// - Set to 0 to use Windows user-mode APIs such as EventRegister. | |
// - Set to 1 to use Windows kernel-mode APIs such as EtwRegister. | |
// Default is based on whether the _ETW_KM_ macro is defined (i.e. by wdm.h). | |
// Note that the APIs can also be overridden directly, e.g. by setting the | |
// MCGEN_EVENTWRITETRANSFER or MCGEN_EVENTREGISTER macros. | |
// | |
#ifndef MCGEN_USE_KERNEL_MODE_APIS | |
#ifdef _ETW_KM_ | |
#define MCGEN_USE_KERNEL_MODE_APIS 1 | |
#else | |
#define MCGEN_USE_KERNEL_MODE_APIS 0 | |
#endif | |
#endif // MCGEN_USE_KERNEL_MODE_APIS | |
// | |
// MCGEN_HAVE_EVENTSETINFORMATION macro: | |
// Controls how McGenEventSetInformation uses the EventSetInformation API. | |
// - Set to 0 to disable the use of EventSetInformation | |
// (McGenEventSetInformation will always return an error). | |
// - Set to 1 to directly invoke MCGEN_EVENTSETINFORMATION. | |
// - Set to 2 to to locate EventSetInformation at runtime via GetProcAddress | |
// (user-mode) or MmGetSystemRoutineAddress (kernel-mode). | |
// Default is determined as follows: | |
// - If MCGEN_EVENTSETINFORMATION has been customized, set to 1 | |
// (i.e. use MCGEN_EVENTSETINFORMATION). | |
// - Else if the target OS version has EventSetInformation, set to 1 | |
// (i.e. use MCGEN_EVENTSETINFORMATION). | |
// - Else set to 2 (i.e. try to dynamically locate EventSetInformation). | |
// Note that an McGenEventSetInformation function will only be generated if one | |
// or more provider in a manifest has provider traits. | |
// | |
#ifndef MCGEN_HAVE_EVENTSETINFORMATION | |
#ifdef MCGEN_EVENTSETINFORMATION // if MCGEN_EVENTSETINFORMATION has been customized, | |
#define MCGEN_HAVE_EVENTSETINFORMATION 1 // directly invoke MCGEN_EVENTSETINFORMATION(...). | |
#elif MCGEN_USE_KERNEL_MODE_APIS // else if using kernel-mode APIs, | |
#if NTDDI_VERSION >= 0x06040000 // if target OS is Windows 10 or later, | |
#define MCGEN_HAVE_EVENTSETINFORMATION 1 // directly invoke MCGEN_EVENTSETINFORMATION(...). | |
#else // else | |
#define MCGEN_HAVE_EVENTSETINFORMATION 2 // find "EtwSetInformation" via MmGetSystemRoutineAddress. | |
#endif // else (using user-mode APIs) | |
#else // if target OS and SDK is Windows 8 or later, | |
#if WINVER >= 0x0602 && defined(EVENT_FILTER_TYPE_SCHEMATIZED) | |
#define MCGEN_HAVE_EVENTSETINFORMATION 1 // directly invoke MCGEN_EVENTSETINFORMATION(...). | |
#else // else | |
#define MCGEN_HAVE_EVENTSETINFORMATION 2 // find "EventSetInformation" via GetModuleHandleExW/GetProcAddress. | |
#endif | |
#endif | |
#endif // MCGEN_HAVE_EVENTSETINFORMATION | |
// | |
// MCGEN Override Macros | |
// | |
// The following override macros may be defined before including this header | |
// to control the APIs used by this header: | |
// | |
// - MCGEN_EVENTREGISTER | |
// - MCGEN_EVENTUNREGISTER | |
// - MCGEN_EVENTSETINFORMATION | |
// - MCGEN_EVENTWRITETRANSFER | |
// | |
// If the the macro is undefined, the MC implementation will default to the | |
// corresponding ETW APIs. For example, if the MCGEN_EVENTREGISTER macro is | |
// undefined, the EventRegister[MyProviderName] macro will use EventRegister | |
// in user mode and will use EtwRegister in kernel mode. | |
// | |
// To prevent issues from conflicting definitions of these macros, the value | |
// of the override macro will be used as a suffix in certain internal function | |
// names. Because of this, the override macros must follow certain rules: | |
// | |
// - The macro must be defined before any MC-generated header is included and | |
// must not be undefined or redefined after any MC-generated header is | |
// included. Different translation units (i.e. different .c or .cpp files) | |
// may set the macros to different values, but within a translation unit | |
// (within a single .c or .cpp file), the macro must be set once and not | |
// changed. | |
// - The override must be an object-like macro, not a function-like macro | |
// (i.e. the override macro must not have a parameter list). | |
// - The override macro's value must be a simple identifier, i.e. must be | |
// something that starts with a letter or '_' and contains only letters, | |
// numbers, and '_' characters. | |
// - If the override macro's value is the name of a second object-like macro, | |
// the second object-like macro must follow the same rules. (The override | |
// macro's value can also be the name of a function-like macro, in which | |
// case the function-like macro does not need to follow the same rules.) | |
// | |
// For example, the following will cause compile errors: | |
// | |
// #define MCGEN_EVENTWRITETRANSFER MyNamespace::MyClass::MyFunction // Value has non-identifier characters (colon). | |
// #define MCGEN_EVENTWRITETRANSFER GetEventWriteFunctionPointer(7) // Value has non-identifier characters (parentheses). | |
// #define MCGEN_EVENTWRITETRANSFER(h,e,a,r,c,d) EventWrite(h,e,c,d) // Override is defined as a function-like macro. | |
// #define MY_OBJECT_LIKE_MACRO MyNamespace::MyClass::MyEventWriteFunction | |
// #define MCGEN_EVENTWRITETRANSFER MY_OBJECT_LIKE_MACRO // Evaluates to something with non-identifier characters (colon). | |
// | |
// The following would be ok: | |
// | |
// #define MCGEN_EVENTWRITETRANSFER MyEventWriteFunction1 // OK, suffix will be "MyEventWriteFunction1". | |
// #define MY_OBJECT_LIKE_MACRO MyEventWriteFunction2 | |
// #define MCGEN_EVENTWRITETRANSFER MY_OBJECT_LIKE_MACRO // OK, suffix will be "MyEventWriteFunction2". | |
// #define MY_FUNCTION_LIKE_MACRO(h,e,a,r,c,d) MyNamespace::MyClass::MyEventWriteFunction3(h,e,c,d) | |
// #define MCGEN_EVENTWRITETRANSFER MY_FUNCTION_LIKE_MACRO // OK, suffix will be "MY_FUNCTION_LIKE_MACRO". | |
// | |
#ifndef MCGEN_EVENTREGISTER | |
#if MCGEN_USE_KERNEL_MODE_APIS | |
#define MCGEN_EVENTREGISTER EtwRegister | |
#else | |
#define MCGEN_EVENTREGISTER EventRegister | |
#endif | |
#endif // MCGEN_EVENTREGISTER | |
#ifndef MCGEN_EVENTUNREGISTER | |
#if MCGEN_USE_KERNEL_MODE_APIS | |
#define MCGEN_EVENTUNREGISTER EtwUnregister | |
#else | |
#define MCGEN_EVENTUNREGISTER EventUnregister | |
#endif | |
#endif // MCGEN_EVENTUNREGISTER | |
#ifndef MCGEN_EVENTSETINFORMATION | |
#if MCGEN_USE_KERNEL_MODE_APIS | |
#define MCGEN_EVENTSETINFORMATION EtwSetInformation | |
#else | |
#define MCGEN_EVENTSETINFORMATION EventSetInformation | |
#endif | |
#endif // MCGEN_EVENTSETINFORMATION | |
#ifndef MCGEN_EVENTWRITETRANSFER | |
#if MCGEN_USE_KERNEL_MODE_APIS | |
#define MCGEN_EVENTWRITETRANSFER EtwWriteTransfer | |
#else | |
#define MCGEN_EVENTWRITETRANSFER EventWriteTransfer | |
#endif | |
#endif // MCGEN_EVENTWRITETRANSFER | |
// | |
// MCGEN_EVENT_ENABLED macro: | |
// Override to control how the EventWrite[EventName] macros determine whether | |
// an event is enabled. The default behavior is for EventWrite[EventName] to | |
// use the EventEnabled[EventName] macros. | |
// | |
#ifndef MCGEN_EVENT_ENABLED | |
#define MCGEN_EVENT_ENABLED(EventName) EventEnabled##EventName() | |
#endif | |
// | |
// MCGEN_EVENT_ENABLED_FORCONTEXT macro: | |
// Override to control how the EventWrite[EventName]_ForContext macros | |
// determine whether an event is enabled. The default behavior is for | |
// EventWrite[EventName]_ForContext to use the | |
// EventEnabled[EventName]_ForContext macros. | |
// | |
#ifndef MCGEN_EVENT_ENABLED_FORCONTEXT | |
#define MCGEN_EVENT_ENABLED_FORCONTEXT(pContext, EventName) EventEnabled##EventName##_ForContext(pContext) | |
#endif | |
// | |
// MCGEN_ENABLE_CHECK macro: | |
// Determines whether the specified event would be considered as enabled | |
// based on the state of the specified context. Slightly faster than calling | |
// McGenEventEnabled directly. | |
// | |
#ifndef MCGEN_ENABLE_CHECK | |
#define MCGEN_ENABLE_CHECK(Context, Descriptor) (Context.IsEnabled && McGenEventEnabled(&Context, &Descriptor)) | |
#endif | |
#if !defined(MCGEN_TRACE_CONTEXT_DEF) | |
#define MCGEN_TRACE_CONTEXT_DEF | |
// This structure is for use by MC-generated code and should not be used directly. | |
typedef struct _MCGEN_TRACE_CONTEXT | |
{ | |
TRACEHANDLE RegistrationHandle; | |
TRACEHANDLE Logger; // Used as pointer to provider traits. | |
ULONGLONG MatchAnyKeyword; | |
ULONGLONG MatchAllKeyword; | |
ULONG Flags; | |
ULONG IsEnabled; | |
UCHAR Level; | |
UCHAR Reserve; | |
USHORT EnableBitsCount; | |
PULONG EnableBitMask; | |
const ULONGLONG* EnableKeyWords; | |
const UCHAR* EnableLevel; | |
} MCGEN_TRACE_CONTEXT, *PMCGEN_TRACE_CONTEXT; | |
#endif // MCGEN_TRACE_CONTEXT_DEF | |
#if !defined(MCGEN_LEVEL_KEYWORD_ENABLED_DEF) | |
#define MCGEN_LEVEL_KEYWORD_ENABLED_DEF | |
// | |
// Determines whether an event with a given Level and Keyword would be | |
// considered as enabled based on the state of the specified context. | |
// Note that you may want to use MCGEN_ENABLE_CHECK instead of calling this | |
// function directly. | |
// | |
FORCEINLINE | |
BOOLEAN | |
McGenLevelKeywordEnabled( | |
_In_ PMCGEN_TRACE_CONTEXT EnableInfo, | |
_In_ UCHAR Level, | |
_In_ ULONGLONG Keyword | |
) | |
{ | |
// | |
// Check if the event Level is lower than the level at which | |
// the channel is enabled. | |
// If the event Level is 0 or the channel is enabled at level 0, | |
// all levels are enabled. | |
// | |
if ((Level <= EnableInfo->Level) || // This also covers the case of Level == 0. | |
(EnableInfo->Level == 0)) { | |
// | |
// Check if Keyword is enabled | |
// | |
if ((Keyword == (ULONGLONG)0) || | |
((Keyword & EnableInfo->MatchAnyKeyword) && | |
((Keyword & EnableInfo->MatchAllKeyword) == EnableInfo->MatchAllKeyword))) { | |
return TRUE; | |
} | |
} | |
return FALSE; | |
} | |
#endif // MCGEN_LEVEL_KEYWORD_ENABLED_DEF | |
#if !defined(MCGEN_EVENT_ENABLED_DEF) | |
#define MCGEN_EVENT_ENABLED_DEF | |
// | |
// Determines whether the specified event would be considered as enabled based | |
// on the state of the specified context. Note that you may want to use | |
// MCGEN_ENABLE_CHECK instead of calling this function directly. | |
// | |
FORCEINLINE | |
BOOLEAN | |
McGenEventEnabled( | |
_In_ PMCGEN_TRACE_CONTEXT EnableInfo, | |
_In_ PCEVENT_DESCRIPTOR EventDescriptor | |
) | |
{ | |
return McGenLevelKeywordEnabled(EnableInfo, EventDescriptor->Level, EventDescriptor->Keyword); | |
} | |
#endif // MCGEN_EVENT_ENABLED_DEF | |
#if !defined(MCGEN_CONTROL_CALLBACK) | |
#define MCGEN_CONTROL_CALLBACK | |
// This function is for use by MC-generated code and should not be used directly. | |
DECLSPEC_NOINLINE __inline | |
VOID | |
__stdcall | |
McGenControlCallbackV2( | |
_In_ LPCGUID SourceId, | |
_In_ ULONG ControlCode, | |
_In_ UCHAR Level, | |
_In_ ULONGLONG MatchAnyKeyword, | |
_In_ ULONGLONG MatchAllKeyword, | |
_In_opt_ PEVENT_FILTER_DESCRIPTOR FilterData, | |
_Inout_opt_ PVOID CallbackContext | |
) | |
/*++ | |
Routine Description: | |
This is the notification callback for Windows Vista and later. | |
Arguments: | |
SourceId - The GUID that identifies the session that enabled the provider. | |
ControlCode - The parameter indicates whether the provider | |
is being enabled or disabled. | |
Level - The level at which the event is enabled. | |
MatchAnyKeyword - The bitmask of keywords that the provider uses to | |
determine the category of events that it writes. | |
MatchAllKeyword - This bitmask additionally restricts the category | |
of events that the provider writes. | |
FilterData - The provider-defined data. | |
CallbackContext - The context of the callback that is defined when the provider | |
called EtwRegister to register itself. | |
Remarks: | |
ETW calls this function to notify provider of enable/disable | |
--*/ | |
{ | |
PMCGEN_TRACE_CONTEXT Ctx = (PMCGEN_TRACE_CONTEXT)CallbackContext; | |
ULONG Ix; | |
#ifndef MCGEN_PRIVATE_ENABLE_CALLBACK_V2 | |
UNREFERENCED_PARAMETER(SourceId); | |
UNREFERENCED_PARAMETER(FilterData); | |
#endif | |
if (Ctx == NULL) { | |
return; | |
} | |
switch (ControlCode) { | |
case EVENT_CONTROL_CODE_ENABLE_PROVIDER: | |
Ctx->Level = Level; | |
Ctx->MatchAnyKeyword = MatchAnyKeyword; | |
Ctx->MatchAllKeyword = MatchAllKeyword; | |
Ctx->IsEnabled = EVENT_CONTROL_CODE_ENABLE_PROVIDER; | |
for (Ix = 0; Ix < Ctx->EnableBitsCount; Ix += 1) { | |
if (McGenLevelKeywordEnabled(Ctx, Ctx->EnableLevel[Ix], Ctx->EnableKeyWords[Ix]) != FALSE) { | |
Ctx->EnableBitMask[Ix >> 5] |= (1 << (Ix % 32)); | |
} else { | |
Ctx->EnableBitMask[Ix >> 5] &= ~(1 << (Ix % 32)); | |
} | |
} | |
break; | |
case EVENT_CONTROL_CODE_DISABLE_PROVIDER: | |
Ctx->IsEnabled = EVENT_CONTROL_CODE_DISABLE_PROVIDER; | |
Ctx->Level = 0; | |
Ctx->MatchAnyKeyword = 0; | |
Ctx->MatchAllKeyword = 0; | |
if (Ctx->EnableBitsCount > 0) { | |
#pragma warning(suppress: 26451) // Arithmetic overflow cannot occur, no matter the value of EnableBitCount | |
RtlZeroMemory(Ctx->EnableBitMask, (((Ctx->EnableBitsCount - 1) / 32) + 1) * sizeof(ULONG)); | |
} | |
break; | |
default: | |
break; | |
} | |
#ifdef MCGEN_PRIVATE_ENABLE_CALLBACK_V2 | |
// | |
// Call user defined callback | |
// | |
MCGEN_PRIVATE_ENABLE_CALLBACK_V2( | |
SourceId, | |
ControlCode, | |
Level, | |
MatchAnyKeyword, | |
MatchAllKeyword, | |
FilterData, | |
CallbackContext | |
); | |
#endif // MCGEN_PRIVATE_ENABLE_CALLBACK_V2 | |
return; | |
} | |
#endif // MCGEN_CONTROL_CALLBACK | |
#ifndef _mcgen_PENABLECALLBACK | |
#if MCGEN_USE_KERNEL_MODE_APIS | |
#define _mcgen_PENABLECALLBACK PETWENABLECALLBACK | |
#else | |
#define _mcgen_PENABLECALLBACK PENABLECALLBACK | |
#endif | |
#endif // _mcgen_PENABLECALLBACK | |
#if !defined(_mcgen_PASTE2) | |
// This macro is for use by MC-generated code and should not be used directly. | |
#define _mcgen_PASTE2_imp(a, b) a##b | |
#define _mcgen_PASTE2(a, b) _mcgen_PASTE2_imp(a, b) | |
#endif // _mcgen_PASTE2 | |
#if !defined(_mcgen_PASTE3) | |
// This macro is for use by MC-generated code and should not be used directly. | |
#define _mcgen_PASTE3_imp(a, b, c) a##b##_##c | |
#define _mcgen_PASTE3(a, b, c) _mcgen_PASTE3_imp(a, b, c) | |
#endif // _mcgen_PASTE3 | |
// | |
// Macro validation | |
// | |
// Validate MCGEN_EVENTREGISTER: | |
// Trigger an error if MCGEN_EVENTREGISTER is not an unqualified (simple) identifier: | |
struct _mcgen_PASTE2(MCGEN_EVENTREGISTER_definition_must_be_an_unqualified_identifier_, MCGEN_EVENTREGISTER); | |
// Trigger an error if MCGEN_EVENTREGISTER is redefined: | |
typedef struct _mcgen_PASTE2(MCGEN_EVENTREGISTER_definition_must_be_an_unqualified_identifier_, MCGEN_EVENTREGISTER) | |
MCGEN_EVENTREGISTER_must_not_be_redefined_between_headers; | |
// Trigger an error if MCGEN_EVENTREGISTER is defined as a function-like macro: | |
typedef void MCGEN_EVENTREGISTER_must_not_be_a_functionLike_macro_MCGEN_EVENTREGISTER; | |
typedef int _mcgen_PASTE2(MCGEN_EVENTREGISTER_must_not_be_a_functionLike_macro_, MCGEN_EVENTREGISTER); | |
// Validate MCGEN_EVENTUNREGISTER: | |
// Trigger an error if MCGEN_EVENTUNREGISTER is not an unqualified (simple) identifier: | |
struct _mcgen_PASTE2(MCGEN_EVENTUNREGISTER_definition_must_be_an_unqualified_identifier_, MCGEN_EVENTUNREGISTER); | |
// Trigger an error if MCGEN_EVENTUNREGISTER is redefined: | |
typedef struct _mcgen_PASTE2(MCGEN_EVENTUNREGISTER_definition_must_be_an_unqualified_identifier_, MCGEN_EVENTUNREGISTER) | |
MCGEN_EVENTUNREGISTER_must_not_be_redefined_between_headers; | |
// Trigger an error if MCGEN_EVENTUNREGISTER is defined as a function-like macro: | |
typedef void MCGEN_EVENTUNREGISTER_must_not_be_a_functionLike_macro_MCGEN_EVENTUNREGISTER; | |
typedef int _mcgen_PASTE2(MCGEN_EVENTUNREGISTER_must_not_be_a_functionLike_macro_, MCGEN_EVENTUNREGISTER); | |
// Validate MCGEN_EVENTSETINFORMATION: | |
// Trigger an error if MCGEN_EVENTSETINFORMATION is not an unqualified (simple) identifier: | |
struct _mcgen_PASTE2(MCGEN_EVENTSETINFORMATION_definition_must_be_an_unqualified_identifier_, MCGEN_EVENTSETINFORMATION); | |
// Trigger an error if MCGEN_EVENTSETINFORMATION is redefined: | |
typedef struct _mcgen_PASTE2(MCGEN_EVENTSETINFORMATION_definition_must_be_an_unqualified_identifier_, MCGEN_EVENTSETINFORMATION) | |
MCGEN_EVENTSETINFORMATION_must_not_be_redefined_between_headers; | |
// Trigger an error if MCGEN_EVENTSETINFORMATION is defined as a function-like macro: | |
typedef void MCGEN_EVENTSETINFORMATION_must_not_be_a_functionLike_macro_MCGEN_EVENTSETINFORMATION; | |
typedef int _mcgen_PASTE2(MCGEN_EVENTSETINFORMATION_must_not_be_a_functionLike_macro_, MCGEN_EVENTSETINFORMATION); | |
// Validate MCGEN_EVENTWRITETRANSFER: | |
// Trigger an error if MCGEN_EVENTWRITETRANSFER is not an unqualified (simple) identifier: | |
struct _mcgen_PASTE2(MCGEN_EVENTWRITETRANSFER_definition_must_be_an_unqualified_identifier_, MCGEN_EVENTWRITETRANSFER); | |
// Trigger an error if MCGEN_EVENTWRITETRANSFER is redefined: | |
typedef struct _mcgen_PASTE2(MCGEN_EVENTWRITETRANSFER_definition_must_be_an_unqualified_identifier_, MCGEN_EVENTWRITETRANSFER) | |
MCGEN_EVENTWRITETRANSFER_must_not_be_redefined_between_headers;; | |
// Trigger an error if MCGEN_EVENTWRITETRANSFER is defined as a function-like macro: | |
typedef void MCGEN_EVENTWRITETRANSFER_must_not_be_a_functionLike_macro_MCGEN_EVENTWRITETRANSFER; | |
typedef int _mcgen_PASTE2(MCGEN_EVENTWRITETRANSFER_must_not_be_a_functionLike_macro_, MCGEN_EVENTWRITETRANSFER); | |
#ifndef McGenEventWrite_def | |
#define McGenEventWrite_def | |
// This macro is for use by MC-generated code and should not be used directly. | |
#define McGenEventWrite _mcgen_PASTE2(McGenEventWrite_, MCGEN_EVENTWRITETRANSFER) | |
// This function is for use by MC-generated code and should not be used directly. | |
DECLSPEC_NOINLINE __inline | |
ULONG __stdcall | |
McGenEventWrite( | |
_In_ PMCGEN_TRACE_CONTEXT Context, | |
_In_ PCEVENT_DESCRIPTOR Descriptor, | |
_In_opt_ LPCGUID ActivityId, | |
_In_range_(1, 128) ULONG EventDataCount, | |
_Pre_cap_(EventDataCount) EVENT_DATA_DESCRIPTOR* EventData | |
) | |
{ | |
const USHORT UNALIGNED* Traits; | |
// Some customized MCGEN_EVENTWRITETRANSFER macros might ignore ActivityId. | |
UNREFERENCED_PARAMETER(ActivityId); | |
Traits = (const USHORT UNALIGNED*)(UINT_PTR)Context->Logger; | |
if (Traits == NULL) { | |
EventData[0].Ptr = 0; | |
EventData[0].Size = 0; | |
EventData[0].Reserved = 0; | |
} else { | |
EventData[0].Ptr = (ULONG_PTR)Traits; | |
EventData[0].Size = *Traits; | |
EventData[0].Reserved = 2; // EVENT_DATA_DESCRIPTOR_TYPE_PROVIDER_METADATA | |
} | |
return MCGEN_EVENTWRITETRANSFER( | |
Context->RegistrationHandle, | |
Descriptor, | |
ActivityId, | |
NULL, | |
EventDataCount, | |
EventData); | |
} | |
#endif // McGenEventWrite_def | |
#if !defined(McGenEventRegisterUnregister) | |
#define McGenEventRegisterUnregister | |
// This macro is for use by MC-generated code and should not be used directly. | |
#define McGenEventRegister _mcgen_PASTE2(McGenEventRegister_, MCGEN_EVENTREGISTER) | |
#pragma warning(push) | |
#pragma warning(disable:6103) | |
// This function is for use by MC-generated code and should not be used directly. | |
DECLSPEC_NOINLINE __inline | |
ULONG __stdcall | |
McGenEventRegister( | |
_In_ LPCGUID ProviderId, | |
_In_opt_ _mcgen_PENABLECALLBACK EnableCallback, | |
_In_opt_ PVOID CallbackContext, | |
_Inout_ PREGHANDLE RegHandle | |
) | |
/*++ | |
Routine Description: | |
This function registers the provider with ETW. | |
Arguments: | |
ProviderId - Provider ID to register with ETW. | |
EnableCallback - Callback to be used. | |
CallbackContext - Context for the callback. | |
RegHandle - Pointer to registration handle. | |
Remarks: | |
Should not be called if the provider is already registered (i.e. should not | |
be called if *RegHandle != 0). Repeatedly registering a provider is a bug | |
and may indicate a race condition. However, for compatibility with previous | |
behavior, this function will return SUCCESS in this case. | |
--*/ | |
{ | |
ULONG Error; | |
if (*RegHandle != 0) | |
{ | |
Error = 0; // ERROR_SUCCESS | |
} | |
else | |
{ | |
Error = MCGEN_EVENTREGISTER(ProviderId, EnableCallback, CallbackContext, RegHandle); | |
} | |
return Error; | |
} | |
#pragma warning(pop) | |
// This macro is for use by MC-generated code and should not be used directly. | |
#define McGenEventUnregister _mcgen_PASTE2(McGenEventUnregister_, MCGEN_EVENTUNREGISTER) | |
// This function is for use by MC-generated code and should not be used directly. | |
DECLSPEC_NOINLINE __inline | |
ULONG __stdcall | |
McGenEventUnregister(_Inout_ PREGHANDLE RegHandle) | |
/*++ | |
Routine Description: | |
Unregister from ETW and set *RegHandle = 0. | |
Arguments: | |
RegHandle - the pointer to the provider registration handle | |
Remarks: | |
If provider has not been registered (i.e. if *RegHandle == 0), | |
return SUCCESS. It is safe to call McGenEventUnregister even if the | |
call to McGenEventRegister returned an error. | |
--*/ | |
{ | |
ULONG Error; | |
if(*RegHandle == 0) | |
{ | |
Error = 0; // ERROR_SUCCESS | |
} | |
else | |
{ | |
Error = MCGEN_EVENTUNREGISTER(*RegHandle); | |
*RegHandle = (REGHANDLE)0; | |
} | |
return Error; | |
} | |
#endif // McGenEventRegisterUnregister | |
#ifndef _mcgen_EVENT_BIT_SET | |
#if defined(_M_IX86) || defined(_M_X64) | |
// This macro is for use by MC-generated code and should not be used directly. | |
#define _mcgen_EVENT_BIT_SET(EnableBits, BitPosition) ((((const unsigned char*)EnableBits)[BitPosition >> 3] & (1u << (BitPosition & 7))) != 0) | |
#else // CPU type | |
// This macro is for use by MC-generated code and should not be used directly. | |
#define _mcgen_EVENT_BIT_SET(EnableBits, BitPosition) ((EnableBits[BitPosition >> 5] & (1u << (BitPosition & 31))) != 0) | |
#endif // CPU type | |
#endif // _mcgen_EVENT_BIT_SET | |
#endif // MCGEN_DISABLE_PROVIDER_CODE_GENERATION | |
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ | |
// Provider "Microsoft-Windows-DXCompiler-API" event count 16 | |
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ | |
// Provider GUID = 5c65fe8c-9f96-4bfd-9a87-9f8ebd45da64 | |
EXTERN_C __declspec(selectany) const GUID MICROSOFT_WINDOWS_DXCOMPILER_PROVIDER = {0x5c65fe8c, 0x9f96, 0x4bfd, {0x9a, 0x87, 0x9f, 0x8e, 0xbd, 0x45, 0xda, 0x64}}; | |
#ifndef MICROSOFT_WINDOWS_DXCOMPILER_PROVIDER_Traits | |
#define MICROSOFT_WINDOWS_DXCOMPILER_PROVIDER_Traits NULL | |
#endif // MICROSOFT_WINDOWS_DXCOMPILER_PROVIDER_Traits | |
// | |
// Channel | |
// | |
#define MICROSOFT_WINDOWS_DXCOMPILER_PROVIDER_CHANNEL_DXCompilerAnalytic 0x10 | |
#define MICROSOFT_WINDOWS_DXCOMPILER_PROVIDER_CHANNEL_DXCompilerAnalytic_KEYWORD 0x8000000000000000 | |
// | |
// Tasks | |
// | |
#define MICROSOFT_WINDOWS_DXCOMPILER_PROVIDER_TASK_DXCompilerInitialization 0x1 | |
#define MICROSOFT_WINDOWS_DXCOMPILER_PROVIDER_TASK_DXCompilerShutdown 0x2 | |
#define MICROSOFT_WINDOWS_DXCOMPILER_PROVIDER_TASK_DXCompilerCreateInstance 0x3 | |
#define MICROSOFT_WINDOWS_DXCOMPILER_PROVIDER_TASK_DXCompilerIntelliSenseParse 0x4 | |
#define MICROSOFT_WINDOWS_DXCOMPILER_PROVIDER_TASK_DXCompilerCompile 0x5 | |
#define MICROSOFT_WINDOWS_DXCOMPILER_PROVIDER_TASK_DXCompilerPreprocess 0x6 | |
#define MICROSOFT_WINDOWS_DXCOMPILER_PROVIDER_TASK_DXCompilerDisassemble 0x7 | |
#define MICROSOFT_WINDOWS_DXCOMPILER_PROVIDER_TASK_DxcValidation 0x8 | |
// | |
// Event Descriptors | |
// | |
EXTERN_C __declspec(selectany) const EVENT_DESCRIPTOR DXCompilerInitialization_Start = {0x0, 0x0, 0x10, 0x4, 0x1, 0x1, 0x8000000000000000}; | |
#define DXCompilerInitialization_Start_value 0x0 | |
EXTERN_C __declspec(selectany) const EVENT_DESCRIPTOR DXCompilerInitialization_Stop = {0x1, 0x0, 0x10, 0x4, 0x2, 0x1, 0x8000000000000000}; | |
#define DXCompilerInitialization_Stop_value 0x1 | |
EXTERN_C __declspec(selectany) const EVENT_DESCRIPTOR DXCompilerShutdown_Start = {0x2, 0x0, 0x10, 0x4, 0x1, 0x2, 0x8000000000000000}; | |
#define DXCompilerShutdown_Start_value 0x2 | |
EXTERN_C __declspec(selectany) const EVENT_DESCRIPTOR DXCompilerShutdown_Stop = {0x3, 0x0, 0x10, 0x4, 0x2, 0x2, 0x8000000000000000}; | |
#define DXCompilerShutdown_Stop_value 0x3 | |
EXTERN_C __declspec(selectany) const EVENT_DESCRIPTOR DXCompilerCreateInstance_Start = {0x4, 0x0, 0x10, 0x4, 0x1, 0x3, 0x8000000000000000}; | |
#define DXCompilerCreateInstance_Start_value 0x4 | |
EXTERN_C __declspec(selectany) const EVENT_DESCRIPTOR DXCompilerCreateInstance_Stop = {0x5, 0x0, 0x10, 0x4, 0x2, 0x3, 0x8000000000000000}; | |
#define DXCompilerCreateInstance_Stop_value 0x5 | |
EXTERN_C __declspec(selectany) const EVENT_DESCRIPTOR DXCompilerIntelliSenseParse_Start = {0x6, 0x0, 0x10, 0x4, 0x1, 0x4, 0x8000000000000000}; | |
#define DXCompilerIntelliSenseParse_Start_value 0x6 | |
EXTERN_C __declspec(selectany) const EVENT_DESCRIPTOR DXCompilerIntelliSenseParse_Stop = {0x7, 0x0, 0x10, 0x4, 0x2, 0x4, 0x8000000000000000}; | |
#define DXCompilerIntelliSenseParse_Stop_value 0x7 | |
EXTERN_C __declspec(selectany) const EVENT_DESCRIPTOR DXCompilerCompile_Start = {0x8, 0x0, 0x10, 0x4, 0x1, 0x5, 0x8000000000000000}; | |
#define DXCompilerCompile_Start_value 0x8 | |
EXTERN_C __declspec(selectany) const EVENT_DESCRIPTOR DXCompilerCompile_Stop = {0x9, 0x0, 0x10, 0x4, 0x2, 0x5, 0x8000000000000000}; | |
#define DXCompilerCompile_Stop_value 0x9 | |
EXTERN_C __declspec(selectany) const EVENT_DESCRIPTOR DXCompilerPreprocess_Start = {0xa, 0x0, 0x10, 0x4, 0x1, 0x6, 0x8000000000000000}; | |
#define DXCompilerPreprocess_Start_value 0xa | |
EXTERN_C __declspec(selectany) const EVENT_DESCRIPTOR DXCompilerPreprocess_Stop = {0xb, 0x0, 0x10, 0x4, 0x2, 0x6, 0x8000000000000000}; | |
#define DXCompilerPreprocess_Stop_value 0xb | |
EXTERN_C __declspec(selectany) const EVENT_DESCRIPTOR DXCompilerDisassemble_Start = {0xc, 0x0, 0x10, 0x4, 0x1, 0x7, 0x8000000000000000}; | |
#define DXCompilerDisassemble_Start_value 0xc | |
EXTERN_C __declspec(selectany) const EVENT_DESCRIPTOR DXCompilerDisassemble_Stop = {0xd, 0x0, 0x10, 0x4, 0x2, 0x7, 0x8000000000000000}; | |
#define DXCompilerDisassemble_Stop_value 0xd | |
EXTERN_C __declspec(selectany) const EVENT_DESCRIPTOR DxcValidation_Start = {0xe, 0x0, 0x10, 0x4, 0x1, 0x8, 0x8000000000000000}; | |
#define DxcValidation_Start_value 0xe | |
EXTERN_C __declspec(selectany) const EVENT_DESCRIPTOR DxcValidation_Stop = {0xf, 0x0, 0x10, 0x4, 0x2, 0x8, 0x8000000000000000}; | |
#define DxcValidation_Stop_value 0xf | |
// | |
// MCGEN_DISABLE_PROVIDER_CODE_GENERATION macro: | |
// Define this macro to have the compiler skip the generated functions in this | |
// header. | |
// | |
#ifndef MCGEN_DISABLE_PROVIDER_CODE_GENERATION | |
// | |
// Event Enablement Bits | |
// These variables are for use by MC-generated code and should not be used directly. | |
// | |
EXTERN_C __declspec(selectany) DECLSPEC_CACHEALIGN ULONG Microsoft_Windows_DXCompiler_APIEnableBits[1]; | |
EXTERN_C __declspec(selectany) const ULONGLONG Microsoft_Windows_DXCompiler_APIKeywords[1] = {0x8000000000000000}; | |
EXTERN_C __declspec(selectany) const unsigned char Microsoft_Windows_DXCompiler_APILevels[1] = {4}; | |
// | |
// Provider context | |
// | |
EXTERN_C __declspec(selectany) MCGEN_TRACE_CONTEXT MICROSOFT_WINDOWS_DXCOMPILER_PROVIDER_Context = {0, (ULONG_PTR)MICROSOFT_WINDOWS_DXCOMPILER_PROVIDER_Traits, 0, 0, 0, 0, 0, 0, 1, Microsoft_Windows_DXCompiler_APIEnableBits, Microsoft_Windows_DXCompiler_APIKeywords, Microsoft_Windows_DXCompiler_APILevels}; | |
// | |
// Provider REGHANDLE | |
// | |
#define Microsoft_Windows_DXCompiler_APIHandle (MICROSOFT_WINDOWS_DXCOMPILER_PROVIDER_Context.RegistrationHandle) | |
// | |
// This macro is set to 0, indicating that the EventWrite[Name] macros do not | |
// have an Activity parameter. This is controlled by the -km and -um options. | |
// | |
#define MICROSOFT_WINDOWS_DXCOMPILER_PROVIDER_EventWriteActivity 0 | |
// | |
// Register with ETW using the control GUID specified in the manifest. | |
// Invoke this macro during module initialization (i.e. program startup, | |
// DLL process attach, or driver load) to initialize the provider. | |
// Note that if this function returns an error, the error means that | |
// will not work, but no action needs to be taken -- even if EventRegister | |
// returns an error, it is generally safe to use EventWrite and | |
// EventUnregister macros (they will be no-ops if EventRegister failed). | |
// | |
#ifndef EventRegisterMicrosoft_Windows_DXCompiler_API | |
#define EventRegisterMicrosoft_Windows_DXCompiler_API() McGenEventRegister(&MICROSOFT_WINDOWS_DXCOMPILER_PROVIDER, McGenControlCallbackV2, &MICROSOFT_WINDOWS_DXCOMPILER_PROVIDER_Context, &Microsoft_Windows_DXCompiler_APIHandle) | |
#endif | |
// | |
// Register with ETW using a specific control GUID (i.e. a GUID other than what | |
// is specified in the manifest). Advanced scenarios only. | |
// | |
#ifndef EventRegisterByGuidMicrosoft_Windows_DXCompiler_API | |
#define EventRegisterByGuidMicrosoft_Windows_DXCompiler_API(Guid) McGenEventRegister(&(Guid), McGenControlCallbackV2, &MICROSOFT_WINDOWS_DXCOMPILER_PROVIDER_Context, &Microsoft_Windows_DXCompiler_APIHandle) | |
#endif | |
// | |
// Unregister with ETW and close the provider. | |
// Invoke this macro during module shutdown (i.e. program exit, DLL process | |
// detach, or driver unload) to unregister the provider. | |
// Note that you MUST call EventUnregister before DLL or driver unload | |
// (not optional): failure to unregister a provider before DLL or driver unload | |
// will result in crashes. | |
// | |
#ifndef EventUnregisterMicrosoft_Windows_DXCompiler_API | |
#define EventUnregisterMicrosoft_Windows_DXCompiler_API() McGenEventUnregister(&Microsoft_Windows_DXCompiler_APIHandle) | |
#endif | |
// | |
// MCGEN_ENABLE_FORCONTEXT_CODE_GENERATION macro: | |
// Define this macro to enable support for caller-allocated provider context. | |
// | |
#ifdef MCGEN_ENABLE_FORCONTEXT_CODE_GENERATION | |
// | |
// Advanced scenarios: Caller-allocated provider context. | |
// Use when multiple differently-configured provider handles are needed, | |
// e.g. for container-aware drivers, one context per container. | |
// | |
// Usage: | |
// | |
// - Caller enables the feature before including this header, e.g. | |
// #define MCGEN_ENABLE_FORCONTEXT_CODE_GENERATION 1 | |
// - Caller allocates memory, e.g. pContext = malloc(sizeof(McGenContext_Microsoft_Windows_DXCompiler_API)); | |
// - Caller registers the provider, e.g. EventRegisterMicrosoft_Windows_DXCompiler_API_ForContext(pContext); | |
// - Caller writes events, e.g. EventWriteMyEvent_ForContext(pContext, ...); | |
// - Caller unregisters, e.g. EventUnregisterMicrosoft_Windows_DXCompiler_API_ForContext(pContext); | |
// - Caller frees memory, e.g. free(pContext); | |
// | |
typedef struct tagMcGenContext_Microsoft_Windows_DXCompiler_API { | |
// The fields of this structure are subject to change and should | |
// not be accessed directly. To access the provider's REGHANDLE, | |
// use Microsoft_Windows_DXCompiler_APIHandle_ForContext(pContext). | |
MCGEN_TRACE_CONTEXT Context; | |
ULONG EnableBits[1]; | |
} McGenContext_Microsoft_Windows_DXCompiler_API; | |
#define EventUnregisterMicrosoft_Windows_DXCompiler_API_ForContext(pContext) McGenEventUnregister(&(pContext)->Context.RegistrationHandle) | |
#define EventRegisterMicrosoft_Windows_DXCompiler_API_ForContext(pContext) _mcgen_PASTE2(_mcgen_RegisterForContext_Microsoft_Windows_DXCompiler_API_, MCGEN_EVENTREGISTER)(&MICROSOFT_WINDOWS_DXCOMPILER_PROVIDER, pContext) | |
#define EventRegisterByGuidMicrosoft_Windows_DXCompiler_API_ForContext(Guid, pContext) _mcgen_PASTE2(_mcgen_RegisterForContext_Microsoft_Windows_DXCompiler_API_, MCGEN_EVENTREGISTER)(&(Guid), pContext) | |
// | |
// Provider REGHANDLE for caller-allocated context. | |
// | |
#define Microsoft_Windows_DXCompiler_APIHandle_ForContext(pContext) ((pContext)->Context.RegistrationHandle) | |
// This function is for use by MC-generated code and should not be used directly. | |
// Initialize and register the caller-allocated context. | |
__inline | |
ULONG __stdcall | |
_mcgen_PASTE2(_mcgen_RegisterForContext_Microsoft_Windows_DXCompiler_API_, MCGEN_EVENTREGISTER)( | |
_In_ LPCGUID pProviderId, | |
_Out_ McGenContext_Microsoft_Windows_DXCompiler_API* pContext) | |
{ | |
RtlZeroMemory(pContext, sizeof(*pContext)); | |
pContext->Context.Logger = (ULONG_PTR)MICROSOFT_WINDOWS_DXCOMPILER_PROVIDER_Traits; | |
pContext->Context.EnableBitsCount = 1; | |
pContext->Context.EnableBitMask = pContext->EnableBits; | |
pContext->Context.EnableKeyWords = Microsoft_Windows_DXCompiler_APIKeywords; | |
pContext->Context.EnableLevel = Microsoft_Windows_DXCompiler_APILevels; | |
return McGenEventRegister( | |
pProviderId, | |
McGenControlCallbackV2, | |
&pContext->Context, | |
&pContext->Context.RegistrationHandle); | |
} | |
// This function is for use by MC-generated code and should not be used directly. | |
// Trigger a compile error if called with the wrong parameter type. | |
FORCEINLINE | |
_Ret_ McGenContext_Microsoft_Windows_DXCompiler_API* | |
_mcgen_CheckContextType_Microsoft_Windows_DXCompiler_API(_In_ McGenContext_Microsoft_Windows_DXCompiler_API* pContext) | |
{ | |
return pContext; | |
} | |
#endif // MCGEN_ENABLE_FORCONTEXT_CODE_GENERATION | |
// | |
// Enablement check macro for event "DXCompilerInitialization_Start" | |
// | |
#define EventEnabledDXCompilerInitialization_Start() _mcgen_EVENT_BIT_SET(Microsoft_Windows_DXCompiler_APIEnableBits, 0) | |
#define EventEnabledDXCompilerInitialization_Start_ForContext(pContext) _mcgen_EVENT_BIT_SET(_mcgen_CheckContextType_Microsoft_Windows_DXCompiler_API(pContext)->EnableBits, 0) | |
// | |
// Event write macros for event "DXCompilerInitialization_Start" | |
// | |
#define DxcEtw_DXCompilerInitialization_Start() \ | |
MCGEN_EVENT_ENABLED(DXCompilerInitialization_Start) \ | |
? _mcgen_TEMPLATE_FOR_DXCompilerInitialization_Start(&MICROSOFT_WINDOWS_DXCOMPILER_PROVIDER_Context, &DXCompilerInitialization_Start) : 0 | |
#define DxcEtw_DXCompilerInitialization_Start_AssumeEnabled() \ | |
_mcgen_TEMPLATE_FOR_DXCompilerInitialization_Start(&MICROSOFT_WINDOWS_DXCOMPILER_PROVIDER_Context, &DXCompilerInitialization_Start) | |
#define DxcEtw_DXCompilerInitialization_Start_ForContext(pContext) \ | |
MCGEN_EVENT_ENABLED_FORCONTEXT(pContext, DXCompilerInitialization_Start) \ | |
? _mcgen_TEMPLATE_FOR_DXCompilerInitialization_Start(&(pContext)->Context, &DXCompilerInitialization_Start) : 0 | |
#define DxcEtw_DXCompilerInitialization_Start_ForContextAssumeEnabled(pContext) \ | |
_mcgen_TEMPLATE_FOR_DXCompilerInitialization_Start(&_mcgen_CheckContextType_Microsoft_Windows_DXCompiler_API(pContext)->Context, &DXCompilerInitialization_Start) | |
// This macro is for use by MC-generated code and should not be used directly. | |
#define _mcgen_TEMPLATE_FOR_DXCompilerInitialization_Start _mcgen_PASTE2(McTemplateU0_, MCGEN_EVENTWRITETRANSFER) | |
// | |
// Enablement check macro for event "DXCompilerInitialization_Stop" | |
// | |
#define EventEnabledDXCompilerInitialization_Stop() _mcgen_EVENT_BIT_SET(Microsoft_Windows_DXCompiler_APIEnableBits, 0) | |
#define EventEnabledDXCompilerInitialization_Stop_ForContext(pContext) _mcgen_EVENT_BIT_SET(_mcgen_CheckContextType_Microsoft_Windows_DXCompiler_API(pContext)->EnableBits, 0) | |
// | |
// Event write macros for event "DXCompilerInitialization_Stop" | |
// | |
#define DxcEtw_DXCompilerInitialization_Stop(errorCode) \ | |
MCGEN_EVENT_ENABLED(DXCompilerInitialization_Stop) \ | |
? _mcgen_TEMPLATE_FOR_DXCompilerInitialization_Stop(&MICROSOFT_WINDOWS_DXCOMPILER_PROVIDER_Context, &DXCompilerInitialization_Stop, errorCode) : 0 | |
#define DxcEtw_DXCompilerInitialization_Stop_AssumeEnabled(errorCode) \ | |
_mcgen_TEMPLATE_FOR_DXCompilerInitialization_Stop(&MICROSOFT_WINDOWS_DXCOMPILER_PROVIDER_Context, &DXCompilerInitialization_Stop, errorCode) | |
#define DxcEtw_DXCompilerInitialization_Stop_ForContext(pContext, errorCode) \ | |
MCGEN_EVENT_ENABLED_FORCONTEXT(pContext, DXCompilerInitialization_Stop) \ | |
? _mcgen_TEMPLATE_FOR_DXCompilerInitialization_Stop(&(pContext)->Context, &DXCompilerInitialization_Stop, errorCode) : 0 | |
#define DxcEtw_DXCompilerInitialization_Stop_ForContextAssumeEnabled(pContext, errorCode) \ | |
_mcgen_TEMPLATE_FOR_DXCompilerInitialization_Stop(&_mcgen_CheckContextType_Microsoft_Windows_DXCompiler_API(pContext)->Context, &DXCompilerInitialization_Stop, errorCode) | |
// This macro is for use by MC-generated code and should not be used directly. | |
#define _mcgen_TEMPLATE_FOR_DXCompilerInitialization_Stop _mcgen_PASTE2(McTemplateU0d_, MCGEN_EVENTWRITETRANSFER) | |
// | |
// Enablement check macro for event "DXCompilerShutdown_Start" | |
// | |
#define EventEnabledDXCompilerShutdown_Start() _mcgen_EVENT_BIT_SET(Microsoft_Windows_DXCompiler_APIEnableBits, 0) | |
#define EventEnabledDXCompilerShutdown_Start_ForContext(pContext) _mcgen_EVENT_BIT_SET(_mcgen_CheckContextType_Microsoft_Windows_DXCompiler_API(pContext)->EnableBits, 0) | |
// | |
// Event write macros for event "DXCompilerShutdown_Start" | |
// | |
#define DxcEtw_DXCompilerShutdown_Start() \ | |
MCGEN_EVENT_ENABLED(DXCompilerShutdown_Start) \ | |
? _mcgen_TEMPLATE_FOR_DXCompilerShutdown_Start(&MICROSOFT_WINDOWS_DXCOMPILER_PROVIDER_Context, &DXCompilerShutdown_Start) : 0 | |
#define DxcEtw_DXCompilerShutdown_Start_AssumeEnabled() \ | |
_mcgen_TEMPLATE_FOR_DXCompilerShutdown_Start(&MICROSOFT_WINDOWS_DXCOMPILER_PROVIDER_Context, &DXCompilerShutdown_Start) | |
#define DxcEtw_DXCompilerShutdown_Start_ForContext(pContext) \ | |
MCGEN_EVENT_ENABLED_FORCONTEXT(pContext, DXCompilerShutdown_Start) \ | |
? _mcgen_TEMPLATE_FOR_DXCompilerShutdown_Start(&(pContext)->Context, &DXCompilerShutdown_Start) : 0 | |
#define DxcEtw_DXCompilerShutdown_Start_ForContextAssumeEnabled(pContext) \ | |
_mcgen_TEMPLATE_FOR_DXCompilerShutdown_Start(&_mcgen_CheckContextType_Microsoft_Windows_DXCompiler_API(pContext)->Context, &DXCompilerShutdown_Start) | |
// This macro is for use by MC-generated code and should not be used directly. | |
#define _mcgen_TEMPLATE_FOR_DXCompilerShutdown_Start _mcgen_PASTE2(McTemplateU0_, MCGEN_EVENTWRITETRANSFER) | |
// | |
// Enablement check macro for event "DXCompilerShutdown_Stop" | |
// | |
#define EventEnabledDXCompilerShutdown_Stop() _mcgen_EVENT_BIT_SET(Microsoft_Windows_DXCompiler_APIEnableBits, 0) | |
#define EventEnabledDXCompilerShutdown_Stop_ForContext(pContext) _mcgen_EVENT_BIT_SET(_mcgen_CheckContextType_Microsoft_Windows_DXCompiler_API(pContext)->EnableBits, 0) | |
// | |
// Event write macros for event "DXCompilerShutdown_Stop" | |
// | |
#define DxcEtw_DXCompilerShutdown_Stop(errorCode) \ | |
MCGEN_EVENT_ENABLED(DXCompilerShutdown_Stop) \ | |
? _mcgen_TEMPLATE_FOR_DXCompilerShutdown_Stop(&MICROSOFT_WINDOWS_DXCOMPILER_PROVIDER_Context, &DXCompilerShutdown_Stop, errorCode) : 0 | |
#define DxcEtw_DXCompilerShutdown_Stop_AssumeEnabled(errorCode) \ | |
_mcgen_TEMPLATE_FOR_DXCompilerShutdown_Stop(&MICROSOFT_WINDOWS_DXCOMPILER_PROVIDER_Context, &DXCompilerShutdown_Stop, errorCode) | |
#define DxcEtw_DXCompilerShutdown_Stop_ForContext(pContext, errorCode) \ | |
MCGEN_EVENT_ENABLED_FORCONTEXT(pContext, DXCompilerShutdown_Stop) \ | |
? _mcgen_TEMPLATE_FOR_DXCompilerShutdown_Stop(&(pContext)->Context, &DXCompilerShutdown_Stop, errorCode) : 0 | |
#define DxcEtw_DXCompilerShutdown_Stop_ForContextAssumeEnabled(pContext, errorCode) \ | |
_mcgen_TEMPLATE_FOR_DXCompilerShutdown_Stop(&_mcgen_CheckContextType_Microsoft_Windows_DXCompiler_API(pContext)->Context, &DXCompilerShutdown_Stop, errorCode) | |
// This macro is for use by MC-generated code and should not be used directly. | |
#define _mcgen_TEMPLATE_FOR_DXCompilerShutdown_Stop _mcgen_PASTE2(McTemplateU0d_, MCGEN_EVENTWRITETRANSFER) | |
// | |
// Enablement check macro for event "DXCompilerCreateInstance_Start" | |
// | |
#define EventEnabledDXCompilerCreateInstance_Start() _mcgen_EVENT_BIT_SET(Microsoft_Windows_DXCompiler_APIEnableBits, 0) | |
#define EventEnabledDXCompilerCreateInstance_Start_ForContext(pContext) _mcgen_EVENT_BIT_SET(_mcgen_CheckContextType_Microsoft_Windows_DXCompiler_API(pContext)->EnableBits, 0) | |
// | |
// Event write macros for event "DXCompilerCreateInstance_Start" | |
// | |
#define DxcEtw_DXCompilerCreateInstance_Start() \ | |
MCGEN_EVENT_ENABLED(DXCompilerCreateInstance_Start) \ | |
? _mcgen_TEMPLATE_FOR_DXCompilerCreateInstance_Start(&MICROSOFT_WINDOWS_DXCOMPILER_PROVIDER_Context, &DXCompilerCreateInstance_Start) : 0 | |
#define DxcEtw_DXCompilerCreateInstance_Start_AssumeEnabled() \ | |
_mcgen_TEMPLATE_FOR_DXCompilerCreateInstance_Start(&MICROSOFT_WINDOWS_DXCOMPILER_PROVIDER_Context, &DXCompilerCreateInstance_Start) | |
#define DxcEtw_DXCompilerCreateInstance_Start_ForContext(pContext) \ | |
MCGEN_EVENT_ENABLED_FORCONTEXT(pContext, DXCompilerCreateInstance_Start) \ | |
? _mcgen_TEMPLATE_FOR_DXCompilerCreateInstance_Start(&(pContext)->Context, &DXCompilerCreateInstance_Start) : 0 | |
#define DxcEtw_DXCompilerCreateInstance_Start_ForContextAssumeEnabled(pContext) \ | |
_mcgen_TEMPLATE_FOR_DXCompilerCreateInstance_Start(&_mcgen_CheckContextType_Microsoft_Windows_DXCompiler_API(pContext)->Context, &DXCompilerCreateInstance_Start) | |
// This macro is for use by MC-generated code and should not be used directly. | |
#define _mcgen_TEMPLATE_FOR_DXCompilerCreateInstance_Start _mcgen_PASTE2(McTemplateU0_, MCGEN_EVENTWRITETRANSFER) | |
// | |
// Enablement check macro for event "DXCompilerCreateInstance_Stop" | |
// | |
#define EventEnabledDXCompilerCreateInstance_Stop() _mcgen_EVENT_BIT_SET(Microsoft_Windows_DXCompiler_APIEnableBits, 0) | |
#define EventEnabledDXCompilerCreateInstance_Stop_ForContext(pContext) _mcgen_EVENT_BIT_SET(_mcgen_CheckContextType_Microsoft_Windows_DXCompiler_API(pContext)->EnableBits, 0) | |
// | |
// Event write macros for event "DXCompilerCreateInstance_Stop" | |
// | |
#define DxcEtw_DXCompilerCreateInstance_Stop(errorCode) \ | |
MCGEN_EVENT_ENABLED(DXCompilerCreateInstance_Stop) \ | |
? _mcgen_TEMPLATE_FOR_DXCompilerCreateInstance_Stop(&MICROSOFT_WINDOWS_DXCOMPILER_PROVIDER_Context, &DXCompilerCreateInstance_Stop, errorCode) : 0 | |
#define DxcEtw_DXCompilerCreateInstance_Stop_AssumeEnabled(errorCode) \ | |
_mcgen_TEMPLATE_FOR_DXCompilerCreateInstance_Stop(&MICROSOFT_WINDOWS_DXCOMPILER_PROVIDER_Context, &DXCompilerCreateInstance_Stop, errorCode) | |
#define DxcEtw_DXCompilerCreateInstance_Stop_ForContext(pContext, errorCode) \ | |
MCGEN_EVENT_ENABLED_FORCONTEXT(pContext, DXCompilerCreateInstance_Stop) \ | |
? _mcgen_TEMPLATE_FOR_DXCompilerCreateInstance_Stop(&(pContext)->Context, &DXCompilerCreateInstance_Stop, errorCode) : 0 | |
#define DxcEtw_DXCompilerCreateInstance_Stop_ForContextAssumeEnabled(pContext, errorCode) \ | |
_mcgen_TEMPLATE_FOR_DXCompilerCreateInstance_Stop(&_mcgen_CheckContextType_Microsoft_Windows_DXCompiler_API(pContext)->Context, &DXCompilerCreateInstance_Stop, errorCode) | |
// This macro is for use by MC-generated code and should not be used directly. | |
#define _mcgen_TEMPLATE_FOR_DXCompilerCreateInstance_Stop _mcgen_PASTE2(McTemplateU0d_, MCGEN_EVENTWRITETRANSFER) | |
// | |
// Enablement check macro for event "DXCompilerIntelliSenseParse_Start" | |
// | |
#define EventEnabledDXCompilerIntelliSenseParse_Start() _mcgen_EVENT_BIT_SET(Microsoft_Windows_DXCompiler_APIEnableBits, 0) | |
#define EventEnabledDXCompilerIntelliSenseParse_Start_ForContext(pContext) _mcgen_EVENT_BIT_SET(_mcgen_CheckContextType_Microsoft_Windows_DXCompiler_API(pContext)->EnableBits, 0) | |
// | |
// Event write macros for event "DXCompilerIntelliSenseParse_Start" | |
// | |
#define DxcEtw_DXCompilerIntelliSenseParse_Start() \ | |
MCGEN_EVENT_ENABLED(DXCompilerIntelliSenseParse_Start) \ | |
? _mcgen_TEMPLATE_FOR_DXCompilerIntelliSenseParse_Start(&MICROSOFT_WINDOWS_DXCOMPILER_PROVIDER_Context, &DXCompilerIntelliSenseParse_Start) : 0 | |
#define DxcEtw_DXCompilerIntelliSenseParse_Start_AssumeEnabled() \ | |
_mcgen_TEMPLATE_FOR_DXCompilerIntelliSenseParse_Start(&MICROSOFT_WINDOWS_DXCOMPILER_PROVIDER_Context, &DXCompilerIntelliSenseParse_Start) | |
#define DxcEtw_DXCompilerIntelliSenseParse_Start_ForContext(pContext) \ | |
MCGEN_EVENT_ENABLED_FORCONTEXT(pContext, DXCompilerIntelliSenseParse_Start) \ | |
? _mcgen_TEMPLATE_FOR_DXCompilerIntelliSenseParse_Start(&(pContext)->Context, &DXCompilerIntelliSenseParse_Start) : 0 | |
#define DxcEtw_DXCompilerIntelliSenseParse_Start_ForContextAssumeEnabled(pContext) \ | |
_mcgen_TEMPLATE_FOR_DXCompilerIntelliSenseParse_Start(&_mcgen_CheckContextType_Microsoft_Windows_DXCompiler_API(pContext)->Context, &DXCompilerIntelliSenseParse_Start) | |
// This macro is for use by MC-generated code and should not be used directly. | |
#define _mcgen_TEMPLATE_FOR_DXCompilerIntelliSenseParse_Start _mcgen_PASTE2(McTemplateU0_, MCGEN_EVENTWRITETRANSFER) | |
// | |
// Enablement check macro for event "DXCompilerIntelliSenseParse_Stop" | |
// | |
#define EventEnabledDXCompilerIntelliSenseParse_Stop() _mcgen_EVENT_BIT_SET(Microsoft_Windows_DXCompiler_APIEnableBits, 0) | |
#define EventEnabledDXCompilerIntelliSenseParse_Stop_ForContext(pContext) _mcgen_EVENT_BIT_SET(_mcgen_CheckContextType_Microsoft_Windows_DXCompiler_API(pContext)->EnableBits, 0) | |
// | |
// Event write macros for event "DXCompilerIntelliSenseParse_Stop" | |
// | |
#define DxcEtw_DXCompilerIntelliSenseParse_Stop(errorCode) \ | |
MCGEN_EVENT_ENABLED(DXCompilerIntelliSenseParse_Stop) \ | |
? _mcgen_TEMPLATE_FOR_DXCompilerIntelliSenseParse_Stop(&MICROSOFT_WINDOWS_DXCOMPILER_PROVIDER_Context, &DXCompilerIntelliSenseParse_Stop, errorCode) : 0 | |
#define DxcEtw_DXCompilerIntelliSenseParse_Stop_AssumeEnabled(errorCode) \ | |
_mcgen_TEMPLATE_FOR_DXCompilerIntelliSenseParse_Stop(&MICROSOFT_WINDOWS_DXCOMPILER_PROVIDER_Context, &DXCompilerIntelliSenseParse_Stop, errorCode) | |
#define DxcEtw_DXCompilerIntelliSenseParse_Stop_ForContext(pContext, errorCode) \ | |
MCGEN_EVENT_ENABLED_FORCONTEXT(pContext, DXCompilerIntelliSenseParse_Stop) \ | |
? _mcgen_TEMPLATE_FOR_DXCompilerIntelliSenseParse_Stop(&(pContext)->Context, &DXCompilerIntelliSenseParse_Stop, errorCode) : 0 | |
#define DxcEtw_DXCompilerIntelliSenseParse_Stop_ForContextAssumeEnabled(pContext, errorCode) \ | |
_mcgen_TEMPLATE_FOR_DXCompilerIntelliSenseParse_Stop(&_mcgen_CheckContextType_Microsoft_Windows_DXCompiler_API(pContext)->Context, &DXCompilerIntelliSenseParse_Stop, errorCode) | |
// This macro is for use by MC-generated code and should not be used directly. | |
#define _mcgen_TEMPLATE_FOR_DXCompilerIntelliSenseParse_Stop _mcgen_PASTE2(McTemplateU0d_, MCGEN_EVENTWRITETRANSFER) | |
// | |
// Enablement check macro for event "DXCompilerCompile_Start" | |
// | |
#define EventEnabledDXCompilerCompile_Start() _mcgen_EVENT_BIT_SET(Microsoft_Windows_DXCompiler_APIEnableBits, 0) | |
#define EventEnabledDXCompilerCompile_Start_ForContext(pContext) _mcgen_EVENT_BIT_SET(_mcgen_CheckContextType_Microsoft_Windows_DXCompiler_API(pContext)->EnableBits, 0) | |
// | |
// Event write macros for event "DXCompilerCompile_Start" | |
// | |
#define DxcEtw_DXCompilerCompile_Start() \ | |
MCGEN_EVENT_ENABLED(DXCompilerCompile_Start) \ | |
? _mcgen_TEMPLATE_FOR_DXCompilerCompile_Start(&MICROSOFT_WINDOWS_DXCOMPILER_PROVIDER_Context, &DXCompilerCompile_Start) : 0 | |
#define DxcEtw_DXCompilerCompile_Start_AssumeEnabled() \ | |
_mcgen_TEMPLATE_FOR_DXCompilerCompile_Start(&MICROSOFT_WINDOWS_DXCOMPILER_PROVIDER_Context, &DXCompilerCompile_Start) | |
#define DxcEtw_DXCompilerCompile_Start_ForContext(pContext) \ | |
MCGEN_EVENT_ENABLED_FORCONTEXT(pContext, DXCompilerCompile_Start) \ | |
? _mcgen_TEMPLATE_FOR_DXCompilerCompile_Start(&(pContext)->Context, &DXCompilerCompile_Start) : 0 | |
#define DxcEtw_DXCompilerCompile_Start_ForContextAssumeEnabled(pContext) \ | |
_mcgen_TEMPLATE_FOR_DXCompilerCompile_Start(&_mcgen_CheckContextType_Microsoft_Windows_DXCompiler_API(pContext)->Context, &DXCompilerCompile_Start) | |
// This macro is for use by MC-generated code and should not be used directly. | |
#define _mcgen_TEMPLATE_FOR_DXCompilerCompile_Start _mcgen_PASTE2(McTemplateU0_, MCGEN_EVENTWRITETRANSFER) | |
// | |
// Enablement check macro for event "DXCompilerCompile_Stop" | |
// | |
#define EventEnabledDXCompilerCompile_Stop() _mcgen_EVENT_BIT_SET(Microsoft_Windows_DXCompiler_APIEnableBits, 0) | |
#define EventEnabledDXCompilerCompile_Stop_ForContext(pContext) _mcgen_EVENT_BIT_SET(_mcgen_CheckContextType_Microsoft_Windows_DXCompiler_API(pContext)->EnableBits, 0) | |
// | |
// Event write macros for event "DXCompilerCompile_Stop" | |
// | |
#define DxcEtw_DXCompilerCompile_Stop(errorCode) \ | |
MCGEN_EVENT_ENABLED(DXCompilerCompile_Stop) \ | |
? _mcgen_TEMPLATE_FOR_DXCompilerCompile_Stop(&MICROSOFT_WINDOWS_DXCOMPILER_PROVIDER_Context, &DXCompilerCompile_Stop, errorCode) : 0 | |
#define DxcEtw_DXCompilerCompile_Stop_AssumeEnabled(errorCode) \ | |
_mcgen_TEMPLATE_FOR_DXCompilerCompile_Stop(&MICROSOFT_WINDOWS_DXCOMPILER_PROVIDER_Context, &DXCompilerCompile_Stop, errorCode) | |
#define DxcEtw_DXCompilerCompile_Stop_ForContext(pContext, errorCode) \ | |
MCGEN_EVENT_ENABLED_FORCONTEXT(pContext, DXCompilerCompile_Stop) \ | |
? _mcgen_TEMPLATE_FOR_DXCompilerCompile_Stop(&(pContext)->Context, &DXCompilerCompile_Stop, errorCode) : 0 | |
#define DxcEtw_DXCompilerCompile_Stop_ForContextAssumeEnabled(pContext, errorCode) \ | |
_mcgen_TEMPLATE_FOR_DXCompilerCompile_Stop(&_mcgen_CheckContextType_Microsoft_Windows_DXCompiler_API(pContext)->Context, &DXCompilerCompile_Stop, errorCode) | |
// This macro is for use by MC-generated code and should not be used directly. | |
#define _mcgen_TEMPLATE_FOR_DXCompilerCompile_Stop _mcgen_PASTE2(McTemplateU0d_, MCGEN_EVENTWRITETRANSFER) | |
// | |
// Enablement check macro for event "DXCompilerPreprocess_Start" | |
// | |
#define EventEnabledDXCompilerPreprocess_Start() _mcgen_EVENT_BIT_SET(Microsoft_Windows_DXCompiler_APIEnableBits, 0) | |
#define EventEnabledDXCompilerPreprocess_Start_ForContext(pContext) _mcgen_EVENT_BIT_SET(_mcgen_CheckContextType_Microsoft_Windows_DXCompiler_API(pContext)->EnableBits, 0) | |
// | |
// Event write macros for event "DXCompilerPreprocess_Start" | |
// | |
#define DxcEtw_DXCompilerPreprocess_Start() \ | |
MCGEN_EVENT_ENABLED(DXCompilerPreprocess_Start) \ | |
? _mcgen_TEMPLATE_FOR_DXCompilerPreprocess_Start(&MICROSOFT_WINDOWS_DXCOMPILER_PROVIDER_Context, &DXCompilerPreprocess_Start) : 0 | |
#define DxcEtw_DXCompilerPreprocess_Start_AssumeEnabled() \ | |
_mcgen_TEMPLATE_FOR_DXCompilerPreprocess_Start(&MICROSOFT_WINDOWS_DXCOMPILER_PROVIDER_Context, &DXCompilerPreprocess_Start) | |
#define DxcEtw_DXCompilerPreprocess_Start_ForContext(pContext) \ | |
MCGEN_EVENT_ENABLED_FORCONTEXT(pContext, DXCompilerPreprocess_Start) \ | |
? _mcgen_TEMPLATE_FOR_DXCompilerPreprocess_Start(&(pContext)->Context, &DXCompilerPreprocess_Start) : 0 | |
#define DxcEtw_DXCompilerPreprocess_Start_ForContextAssumeEnabled(pContext) \ | |
_mcgen_TEMPLATE_FOR_DXCompilerPreprocess_Start(&_mcgen_CheckContextType_Microsoft_Windows_DXCompiler_API(pContext)->Context, &DXCompilerPreprocess_Start) | |
// This macro is for use by MC-generated code and should not be used directly. | |
#define _mcgen_TEMPLATE_FOR_DXCompilerPreprocess_Start _mcgen_PASTE2(McTemplateU0_, MCGEN_EVENTWRITETRANSFER) | |
// | |
// Enablement check macro for event "DXCompilerPreprocess_Stop" | |
// | |
#define EventEnabledDXCompilerPreprocess_Stop() _mcgen_EVENT_BIT_SET(Microsoft_Windows_DXCompiler_APIEnableBits, 0) | |
#define EventEnabledDXCompilerPreprocess_Stop_ForContext(pContext) _mcgen_EVENT_BIT_SET(_mcgen_CheckContextType_Microsoft_Windows_DXCompiler_API(pContext)->EnableBits, 0) | |
// | |
// Event write macros for event "DXCompilerPreprocess_Stop" | |
// | |
#define DxcEtw_DXCompilerPreprocess_Stop(errorCode) \ | |
MCGEN_EVENT_ENABLED(DXCompilerPreprocess_Stop) \ | |
? _mcgen_TEMPLATE_FOR_DXCompilerPreprocess_Stop(&MICROSOFT_WINDOWS_DXCOMPILER_PROVIDER_Context, &DXCompilerPreprocess_Stop, errorCode) : 0 | |
#define DxcEtw_DXCompilerPreprocess_Stop_AssumeEnabled(errorCode) \ | |
_mcgen_TEMPLATE_FOR_DXCompilerPreprocess_Stop(&MICROSOFT_WINDOWS_DXCOMPILER_PROVIDER_Context, &DXCompilerPreprocess_Stop, errorCode) | |
#define DxcEtw_DXCompilerPreprocess_Stop_ForContext(pContext, errorCode) \ | |
MCGEN_EVENT_ENABLED_FORCONTEXT(pContext, DXCompilerPreprocess_Stop) \ | |
? _mcgen_TEMPLATE_FOR_DXCompilerPreprocess_Stop(&(pContext)->Context, &DXCompilerPreprocess_Stop, errorCode) : 0 | |
#define DxcEtw_DXCompilerPreprocess_Stop_ForContextAssumeEnabled(pContext, errorCode) \ | |
_mcgen_TEMPLATE_FOR_DXCompilerPreprocess_Stop(&_mcgen_CheckContextType_Microsoft_Windows_DXCompiler_API(pContext)->Context, &DXCompilerPreprocess_Stop, errorCode) | |
// This macro is for use by MC-generated code and should not be used directly. | |
#define _mcgen_TEMPLATE_FOR_DXCompilerPreprocess_Stop _mcgen_PASTE2(McTemplateU0d_, MCGEN_EVENTWRITETRANSFER) | |
// | |
// Enablement check macro for event "DXCompilerDisassemble_Start" | |
// | |
#define EventEnabledDXCompilerDisassemble_Start() _mcgen_EVENT_BIT_SET(Microsoft_Windows_DXCompiler_APIEnableBits, 0) | |
#define EventEnabledDXCompilerDisassemble_Start_ForContext(pContext) _mcgen_EVENT_BIT_SET(_mcgen_CheckContextType_Microsoft_Windows_DXCompiler_API(pContext)->EnableBits, 0) | |
// | |
// Event write macros for event "DXCompilerDisassemble_Start" | |
// | |
#define DxcEtw_DXCompilerDisassemble_Start() \ | |
MCGEN_EVENT_ENABLED(DXCompilerDisassemble_Start) \ | |
? _mcgen_TEMPLATE_FOR_DXCompilerDisassemble_Start(&MICROSOFT_WINDOWS_DXCOMPILER_PROVIDER_Context, &DXCompilerDisassemble_Start) : 0 | |
#define DxcEtw_DXCompilerDisassemble_Start_AssumeEnabled() \ | |
_mcgen_TEMPLATE_FOR_DXCompilerDisassemble_Start(&MICROSOFT_WINDOWS_DXCOMPILER_PROVIDER_Context, &DXCompilerDisassemble_Start) | |
#define DxcEtw_DXCompilerDisassemble_Start_ForContext(pContext) \ | |
MCGEN_EVENT_ENABLED_FORCONTEXT(pContext, DXCompilerDisassemble_Start) \ | |
? _mcgen_TEMPLATE_FOR_DXCompilerDisassemble_Start(&(pContext)->Context, &DXCompilerDisassemble_Start) : 0 | |
#define DxcEtw_DXCompilerDisassemble_Start_ForContextAssumeEnabled(pContext) \ | |
_mcgen_TEMPLATE_FOR_DXCompilerDisassemble_Start(&_mcgen_CheckContextType_Microsoft_Windows_DXCompiler_API(pContext)->Context, &DXCompilerDisassemble_Start) | |
// This macro is for use by MC-generated code and should not be used directly. | |
#define _mcgen_TEMPLATE_FOR_DXCompilerDisassemble_Start _mcgen_PASTE2(McTemplateU0_, MCGEN_EVENTWRITETRANSFER) | |
// | |
// Enablement check macro for event "DXCompilerDisassemble_Stop" | |
// | |
#define EventEnabledDXCompilerDisassemble_Stop() _mcgen_EVENT_BIT_SET(Microsoft_Windows_DXCompiler_APIEnableBits, 0) | |
#define EventEnabledDXCompilerDisassemble_Stop_ForContext(pContext) _mcgen_EVENT_BIT_SET(_mcgen_CheckContextType_Microsoft_Windows_DXCompiler_API(pContext)->EnableBits, 0) | |
// | |
// Event write macros for event "DXCompilerDisassemble_Stop" | |
// | |
#define DxcEtw_DXCompilerDisassemble_Stop(errorCode) \ | |
MCGEN_EVENT_ENABLED(DXCompilerDisassemble_Stop) \ | |
? _mcgen_TEMPLATE_FOR_DXCompilerDisassemble_Stop(&MICROSOFT_WINDOWS_DXCOMPILER_PROVIDER_Context, &DXCompilerDisassemble_Stop, errorCode) : 0 | |
#define DxcEtw_DXCompilerDisassemble_Stop_AssumeEnabled(errorCode) \ | |
_mcgen_TEMPLATE_FOR_DXCompilerDisassemble_Stop(&MICROSOFT_WINDOWS_DXCOMPILER_PROVIDER_Context, &DXCompilerDisassemble_Stop, errorCode) | |
#define DxcEtw_DXCompilerDisassemble_Stop_ForContext(pContext, errorCode) \ | |
MCGEN_EVENT_ENABLED_FORCONTEXT(pContext, DXCompilerDisassemble_Stop) \ | |
? _mcgen_TEMPLATE_FOR_DXCompilerDisassemble_Stop(&(pContext)->Context, &DXCompilerDisassemble_Stop, errorCode) : 0 | |
#define DxcEtw_DXCompilerDisassemble_Stop_ForContextAssumeEnabled(pContext, errorCode) \ | |
_mcgen_TEMPLATE_FOR_DXCompilerDisassemble_Stop(&_mcgen_CheckContextType_Microsoft_Windows_DXCompiler_API(pContext)->Context, &DXCompilerDisassemble_Stop, errorCode) | |
// This macro is for use by MC-generated code and should not be used directly. | |
#define _mcgen_TEMPLATE_FOR_DXCompilerDisassemble_Stop _mcgen_PASTE2(McTemplateU0d_, MCGEN_EVENTWRITETRANSFER) | |
// | |
// Enablement check macro for event "DxcValidation_Start" | |
// | |
#define EventEnabledDxcValidation_Start() _mcgen_EVENT_BIT_SET(Microsoft_Windows_DXCompiler_APIEnableBits, 0) | |
#define EventEnabledDxcValidation_Start_ForContext(pContext) _mcgen_EVENT_BIT_SET(_mcgen_CheckContextType_Microsoft_Windows_DXCompiler_API(pContext)->EnableBits, 0) | |
// | |
// Event write macros for event "DxcValidation_Start" | |
// | |
#define DxcEtw_DxcValidation_Start() \ | |
MCGEN_EVENT_ENABLED(DxcValidation_Start) \ | |
? _mcgen_TEMPLATE_FOR_DxcValidation_Start(&MICROSOFT_WINDOWS_DXCOMPILER_PROVIDER_Context, &DxcValidation_Start) : 0 | |
#define DxcEtw_DxcValidation_Start_AssumeEnabled() \ | |
_mcgen_TEMPLATE_FOR_DxcValidation_Start(&MICROSOFT_WINDOWS_DXCOMPILER_PROVIDER_Context, &DxcValidation_Start) | |
#define DxcEtw_DxcValidation_Start_ForContext(pContext) \ | |
MCGEN_EVENT_ENABLED_FORCONTEXT(pContext, DxcValidation_Start) \ | |
? _mcgen_TEMPLATE_FOR_DxcValidation_Start(&(pContext)->Context, &DxcValidation_Start) : 0 | |
#define DxcEtw_DxcValidation_Start_ForContextAssumeEnabled(pContext) \ | |
_mcgen_TEMPLATE_FOR_DxcValidation_Start(&_mcgen_CheckContextType_Microsoft_Windows_DXCompiler_API(pContext)->Context, &DxcValidation_Start) | |
// This macro is for use by MC-generated code and should not be used directly. | |
#define _mcgen_TEMPLATE_FOR_DxcValidation_Start _mcgen_PASTE2(McTemplateU0_, MCGEN_EVENTWRITETRANSFER) | |
// | |
// Enablement check macro for event "DxcValidation_Stop" | |
// | |
#define EventEnabledDxcValidation_Stop() _mcgen_EVENT_BIT_SET(Microsoft_Windows_DXCompiler_APIEnableBits, 0) | |
#define EventEnabledDxcValidation_Stop_ForContext(pContext) _mcgen_EVENT_BIT_SET(_mcgen_CheckContextType_Microsoft_Windows_DXCompiler_API(pContext)->EnableBits, 0) | |
// | |
// Event write macros for event "DxcValidation_Stop" | |
// | |
#define DxcEtw_DxcValidation_Stop(errorCode) \ | |
MCGEN_EVENT_ENABLED(DxcValidation_Stop) \ | |
? _mcgen_TEMPLATE_FOR_DxcValidation_Stop(&MICROSOFT_WINDOWS_DXCOMPILER_PROVIDER_Context, &DxcValidation_Stop, errorCode) : 0 | |
#define DxcEtw_DxcValidation_Stop_AssumeEnabled(errorCode) \ | |
_mcgen_TEMPLATE_FOR_DxcValidation_Stop(&MICROSOFT_WINDOWS_DXCOMPILER_PROVIDER_Context, &DxcValidation_Stop, errorCode) | |
#define DxcEtw_DxcValidation_Stop_ForContext(pContext, errorCode) \ | |
MCGEN_EVENT_ENABLED_FORCONTEXT(pContext, DxcValidation_Stop) \ | |
? _mcgen_TEMPLATE_FOR_DxcValidation_Stop(&(pContext)->Context, &DxcValidation_Stop, errorCode) : 0 | |
#define DxcEtw_DxcValidation_Stop_ForContextAssumeEnabled(pContext, errorCode) \ | |
_mcgen_TEMPLATE_FOR_DxcValidation_Stop(&_mcgen_CheckContextType_Microsoft_Windows_DXCompiler_API(pContext)->Context, &DxcValidation_Stop, errorCode) | |
// This macro is for use by MC-generated code and should not be used directly. | |
#define _mcgen_TEMPLATE_FOR_DxcValidation_Stop _mcgen_PASTE2(McTemplateU0d_, MCGEN_EVENTWRITETRANSFER) | |
#endif // MCGEN_DISABLE_PROVIDER_CODE_GENERATION | |
// | |
// MCGEN_DISABLE_PROVIDER_CODE_GENERATION macro: | |
// Define this macro to have the compiler skip the generated functions in this | |
// header. | |
// | |
#ifndef MCGEN_DISABLE_PROVIDER_CODE_GENERATION | |
// | |
// Template Functions | |
// | |
// | |
// Function for template "(default)" (and possibly others). | |
// This function is for use by MC-generated code and should not be used directly. | |
// | |
#ifndef McTemplateU0_def | |
#define McTemplateU0_def | |
ETW_INLINE | |
ULONG | |
_mcgen_PASTE2(McTemplateU0_, MCGEN_EVENTWRITETRANSFER)( | |
_In_ PMCGEN_TRACE_CONTEXT Context, | |
_In_ PCEVENT_DESCRIPTOR Descriptor | |
) | |
{ | |
#define McTemplateU0_ARGCOUNT 0 | |
EVENT_DATA_DESCRIPTOR EventData[McTemplateU0_ARGCOUNT + 1]; | |
return McGenEventWrite(Context, Descriptor, NULL, McTemplateU0_ARGCOUNT + 1, EventData); | |
} | |
#endif // McTemplateU0_def | |
// | |
// Function for template "OperationResultTemplate" (and possibly others). | |
// This function is for use by MC-generated code and should not be used directly. | |
// | |
#ifndef McTemplateU0d_def | |
#define McTemplateU0d_def | |
ETW_INLINE | |
ULONG | |
_mcgen_PASTE2(McTemplateU0d_, MCGEN_EVENTWRITETRANSFER)( | |
_In_ PMCGEN_TRACE_CONTEXT Context, | |
_In_ PCEVENT_DESCRIPTOR Descriptor, | |
_In_ const signed int _Arg0 | |
) | |
{ | |
#define McTemplateU0d_ARGCOUNT 1 | |
EVENT_DATA_DESCRIPTOR EventData[McTemplateU0d_ARGCOUNT + 1]; | |
EventDataDescCreate(&EventData[1],&_Arg0, sizeof(const signed int) ); | |
return McGenEventWrite(Context, Descriptor, NULL, McTemplateU0d_ARGCOUNT + 1, EventData); | |
} | |
#endif // McTemplateU0d_def | |
#endif // MCGEN_DISABLE_PROVIDER_CODE_GENERATION | |
#if defined(__cplusplus) | |
} | |
#endif | |
#define MSG_eventProviderName 0x90000001L |