Microsoft.VisualStudio.Debugger.Engine

Next class in the linked list maintained by the XapiRuntime

Immutable configuration for this component from a component configuration file.

Immutable configuration for this class from a component configuration file.

Result from GCHandle.FromIntPtr(GCHandle.Alloc(<object>)) of the managed instance.

Next class in the linked list maintained by the XapiRuntime

Immutable configuration for this component from a component configuration file.

Lock used around 'Synchronized' components. Only initialized for these components

[Optional] Directory where this component configuration was found. Dispatcher services will be null. Otherwise this will always end with a trailing slash and be non-null.

Callback that is fired whenever a native object is closed which has been marshalled into managed (m_ObjectGCHandle is non-zero)

Pointer to the location within the XapiThreadOperation where the managed dispatcher can store the XapiComponentInfo* while disposing managed data items. HRESULT return value

Callback which is fired from the implementation of a native 'Create' method in the case that the object is being created from managed code.

Pointer to the native object GCHandle return from InitializeForManagedCreate HRESULT return value

Release all managed classes by freeing the GCHandle's for each component.

Pointer to the head class info. True if deployment connection related components should be skipped

Tests to see if assembly for the given component can be loaded

Pointer to the XapiComponentInfo to test. S_OK on success, E_XAPI_COMPONENT_DLL_NOT_FOUND if the dll cannot be found; E_XAPI_COMPONENT_LOAD_FAILURE for other failures.

Callback that is fired whenever a native work list object which has been marshalled into managed (m_ObjectGCHandle is non-zero) is complete

Pointer to the location within the XapiThreadOperation where the managed dispatcher can store the component pointer while disposing managed data items. HRESULT return value

Callback that is fired to call a completion routine which is implemented in managed code.

GCHandle to a XapiManagedCompletionRoutineWrapper object. pointer to the native result structure which will be marshalled to managed code HRESULT return value

Interface into the managed dll. This is called from native after the managed dispatcher has been loaded.

Initialize the managed dll

Pointer to the function table that native will used to call into managed. Managed writes to this data structure. Number of methods inside the function table. This is passed to detect incompatibility between the managed and native dispatcher. HRESULT code

DkmDataContainer is a building block which is used throughout this API. It allows many of the objects in this API to contain 'virtual fields' which are added by any component in the system. This is similar to a type-safe version of the 'expando' concept in JScript. Rules for DkmDataContainer: 1. All the 'reference' objects in the system inherit from DkmDataContainer. Reference objects are tracked by the dispatcher component of this system, and at various marshalling points (managed->native, native->managed, remoting) the object reference identity is preserved. 'Value' objects do not inherit from DkmDataContainer because the system does not track these objects, so at any marshalling transition, the value of the object is copied. 2. The 'virtual fields' of these objects which inherit from DkmDataContainer are called data items. 3. Data items are PRIVATE to the component that added them. This feature cannot be used to share fields across component boundaries. 4. Data items are instances of a data item class. In managed code, data item classes inherit from DkmDataItem to identify them as a data item. In native code, data items inherit from IUnknown. 5. Usually, a component would never need to remove a data item. This is because data items are automatically removed when the container object is closed.

// Example data item class. In managed code, data items need to inherit from DkmDataItem class AliasLog : DkmDataItem { readonly string LogPath; readonly StreamWriter Writer; public AliasLog(string log) { LogPath = log; Writer = new StreamWriter(log); } // Data items can override the 'OnClose' method to receive notification when the data // container object (DkmClrAlias in our example) is closed. protected override void OnClose() { Writer.Close(); } } // Create a new instance of the example data item class AliasLog log = new AliasLog("c:\\foo.log"); // data items can be passed to a create method... DkmClrAlias alias = DkmClrAlias.Create("ExampleName", log); // ...or then can be added using SetDataItem alias.SetDataItem<AliasLog>(DkmDataCreationDisposition.CreateAlways, log); // then the value can be retrieved using GetDataItem AliasLog find = alias.GetDataItem<AliasLog>();

Variable used to lock updates to this object. When taken, this object cannot be closed.

Pointer to the native object. This is stored without an AddRef. Safety is guaranteed by having native call back into this object on close. m_pNativeObject should never be used without the lock taken.

Sentinel value use for m_pNativeObject in the case that the managed object is created before the native object

Initializes a managed object which was created in response to native->managed marshalling

Initialize a new object that is created when the managed object is created before the native object (the case that someone calls a 'Create' method from managed code).

[Optional] The data container object which comes from the create method The native data container item to be passed to the native create method.

Performs any necessary cleanup after a call

Return value from InitializeForManagedCreate

Callback which is fired from the implementation of a native 'Create' method in the case that the object is being created from managed code.

Pointer to the native object GCHandle return from InitializeForManagedCreate HRESULT return value

Callback that is fired whenever a native object is closed which has been marshalled into managed (m_ObjectGCHandle is non-zero)

Pointer to the location within the XapiThreadOperation where the managed dispatcher can store the component pointer while disposing managed data items. HRESULT return value

This function breaks the connection between the native and managed object. It clears m_pNativeObject, and clears m_pNativeObject->m_ObjectGCHandle

Used to invoke 'ManagedToNative' on an optional reference dispatcher object.

Obtain a pointer to the native object used to call into native. Zero is returned if the object has already been closed.

[Optional] Outgoing managed->native call [Optional] Native object

Obtain a pointer to the native object used to call into native

[Optional] Outgoing managed->native call Native object

Place a new item in the data container.

Type of a data item class. This class must derive from DkmDataItem. See DkmDataContainer definition for more information. Action to be taken if there is already an item of type T. Item to place in this container.

Gets the instance of 'T' which has been added to this container instance. If this container does not contain a 'T', this function will return null.

Type of a data item class. This class must derive from DkmDataItem. See DkmDataContainer definition for more information. [Optional] 'T' object associated with this container instance.

Remove the instance of 'T' from this container. It is usually unnecessary to call this method as a data container will automatically be emptied when the object is closed.

Type of a data item class. This class must derive from DkmDataItem. See DkmDataContainer definition for more information. False if this container did not have an instance of 'T'.

Returns true if a 'unloaded' event has been raised for this object (example: DkmThread::Unload is called) or if the object has been closed. Note that care must be used when checking this status as, without synchronization, the returned status may no longer be accurate the instruction after it is read.

'DkmDataItem' is the base class for all data item classes. See 'DkmDataContainer' for more information.

'OnClose' is invoked on all data items when a data container is closed. Derived classes may override this method if they need to perform any operation when the container class is closed (ex: free resources).

'OnContainerCreated' is called when this data item has been passed as the 'DataItem' argument to a 'Create' method. This allows the data item to obtain the newly created dispatcher object before this dispatcher object has been passed to any other component.

Function which fires when an asynchronous request completes.

Type of the result parameter Result of the asynchronous operation

Optional function which is fired when the work list is complete, including firing all completion routines.

Result of the asynchronous operation

Argument to DkmWorkList.BeginExecution to indicate where the work items in the work list should run.

Work list items should execute on the main request thread. This is the default value and is equivalent to the behavior before VS 2017 version 15.5.

Work list items should execute on a thread pool thread.

Priority class of worklists from High to Idle. @Note: Must be kept in sync with the managed definition.

Collection of asynchronous work items which are processed together. Work items are appended by calling any of the asynchronous methods throughout this API. Work items may be appended freely until the work list begins execution. Once execution has begun, additional work may only be appended from the implementation of a work item processing interface, or from a completion routine.

Managed delegate to fire when the work list is completed. Will be null if the work list object was created in native code or if the managed creator did not supply a delegate.

Pointer to the component info of the object that created this. Will be null if the work list was created in native code.

Variable used to lock updates to this object. When taken, this object cannot be closed.

Pointer to the native object. This is stored without an AddRef if the work list was created from native code (m_pManagedCreator is null). Safety is guaranteed by having native call back into this object on complete. m_pNativeObject should never be used without the lock taken.

Cache of the 'IsCanceled' value. This is used when m_pNativeObject is null.

Initializes a managed object from a native one. Unlike data contains, with work lists this function is called with both worklists created from a managed call to 'Create', and from native->managed marshalling.

Callback that is fired whenever a native object is closed which has been marshalled into managed (m_ObjectGCHandle is non-zero)

Pointer to the location within the XapiThreadOperation where the managed dispatcher can store the component pointer while disposing managed data items. HRESULT return value

This function breaks the connection between the native and managed object. It clears m_pNativeObject, and clears m_pNativeObject->m_ObjectGCHandle

Obtain a pointer to the native object used to call into native

[Optional] Outgoing managed->native call Native object

Creates a new empty work list object. Callers should append operations to the work list and then start execution ('BeginExecution' or 'Execute'). Once created, a WorkList object will continue to exist until its execution is completed, or until the request is canceled. So callers should ensure that 'Cancel' is called in the case of failure.

[In,Optional] Optional function which is fired when the work list is complete, including firing all completion routines. [Out] Result of this method call.

This property allows a component to determine if the current operation should be canceled. This will return true when called from a thread which is currently processing a work list, and when this work list has been canceled. This will throw if called from a completion routine or from a thread that is not currently processing an interface call.

foreach (var file in myfiles) { if (DkmWorkList.IsCurrentInstanceCanceled) throw new OperationCanceledException(); ProcessFile(file); }

This property allows a component processing a work item to determine if it is canceled, or for a completion routine to determine if the operation was canceled.

Begin execution of the items in this work list. This API will return immediately and completion routines are fired to return results. Callbacks will fire as results complete (unordered). This method may only be called by the component which created the object.

Indicates where the items in the work list should execute.

Indicates where the items in the work list should execute. Indicates the worklist priority.

Synchronously execute all items in the work list and return when processing is complete or has been canceled, including firing all completion routines. Callbacks will fire as results are complete (unordered). This method may only be called by the component which created the object. This method will throw if execution is already in progress.

Cancel execution of this work list. This API will return once all work on this work queue has stopped (worklist is canceled or completed). The request is ignored if the work list is already canceled. This method may only be called by the component which created the object. Note for components declared as 'Synchronized' in the component configuration: calling this API may implicitly release and then reacquire the lock around your component. Be mindful of possible state changes.

Cancel execution of this work list. The request is ignored if the work list is already canceled. This method may only be called by the component which created the object. This API was added in Visual Studio 15 Update 7 (DkmApiVersion.VS15Update7)

Indicates whether to block on all queued tasks firing completion routines. If true, this API will return once all work on this work queue has stopped (worklist is canceled or completed). Note for components declared as 'Synchronized' in the component configuration: calling this API may implicitly release and then reacquire the lock around your component. Be mindful of possible state changes. Otherwise this will begin cancellation and return without waiting for the work to be stopped.

Sets a string that can be used to describe the operation(s) performed by the worklist. This can be displayed when execution of other operations are blocked by this worklist. This API was introduced in Visual Studio 15 Update 7 (DkmApiVersion.VS15Update7).

A description of the work to be performed.

Convert a managed work list object to native

Convert a native work list object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Called from the native dispatcher to invoke a managed completion routine

GCHandle cookie to an instance of one of the derived classes pointer to the result structure. This will be marshalled by the derived class

DkmXmm128 represents the content of a 128-bit XMM register on x64 systems

Create a DkmXmm128 value from a UInt64 pair

Create a DkmXmm128 value from UInt32s

Create a DkmXmm128 value from double-precision floating point values

Create a DkmXmm128 value from single-precision floating point values

Static class containing settings which are global to the debugger process

Culture used by Visual Studio. This can be used to load resource dlls, format strings, etc.

[Optional] Visual Studio registry root (ex: Software\Microsoft\VisualStudio\10.0). Registry root is null in remote debugging scenarios. It will be non-null in pseudo-remote, and local debugging scenarios.

Retrieves the DkmClientUI signifying the UI that the engine is currently running from.

Identifier of the Client User Interface (Ex. Visual Studio IDE, Visual Studio Code).

Returns true when called from a worker process. Worker processes are used to load IDE-side Concord components outside of the IDE process. Components will load into worker processes only if: 1. They have opt-into loading there by setting 'WorkerProcessSupported' in their .vsdconfigxml file -and- 2. The object parameter of whatever interface they are implementing has an associated DkmWorkerProcessConnection This API was introduced in Visual Studio 16 Release to Manufacturing (RTM) version (DkmApiVersion.VS16RTM).

'true' if called from a worker process

Describes the event being processed.

Returns an enumeration code to indicate the type of event. May be helpful in diagnostic logging.

Returns an id for the event. May be helpful in diagnostic logging.

Returns the timestamp from QueryPerformanceCounter that is taken as soon as the event starts propogating. Note that if one event creates another event, this value is passed from the first event to ensure the timing matches relative to any other event that may occur. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

Describes the event being processed and provides the ability for a component to suppress this event.

This method is used to suppress event processing for this event. When called, the event will not be seen by components with a greater component level than the suppressing component.

Provides services from the Dispatcher for initializing threads.

Initialize a thread with the component manager. This is necessary when a component creates one or more worker threads. InitializeThread should only be called once, and must have a matching call to UninitializeThread.

Guid for the component initializing the thread. This Guid value is defined in the component's configuration file. Exception with code E_XAPI_ALREADY_INITIALIZED is thrown if the thread has already been initialized by a different component.

Guid for the component initializing the thread. This Guid value is defined in the component's configuration file. Returns true if the thread was previously initialized by this component. Callers can use this as a hint that UninitializeThread should not be called. Exception with code E_XAPI_ALREADY_INITIALIZED is thrown if the thread has already been initialized by a different component.

Initialize a thread with the component manager. InitializeThreadByHandle should only be called once, and must have a matching call to UninitializeThreadByHandle.

Handle for the component, obtained by FindComponentHandle Returns true if the thread was previously initialized by this component. Callers can use this as a hint that UninitializeThreadByHandle should not be called. Exception with code E_XAPI_ALREADY_INITIALIZED is thrown if the thread has already been initialized by a different component.

Searches for a component handle based on the Guid. This can be used to subsequent calls to InitializeThreadByHandle and UninitializeThreadByHandle without searching for the component again.

The component guid to search for. The component handle that represents the component specified by the Guid.

Undocumented

Clean up a thread which was previously initialized with a call to DkmComponentManager.InitializeThreadByThread.

Component handle obtained by FindComponentHandle

Clean up a thread which was previously initialized with a call to DkmComponentManager.InitializeThread.

Guid for the component which initializing the thread. This Guid value is defined in the component's configuration file. Thread is not initalized, is still processing other operations, or was initalized by a different component.

Obtains the component ID which is running on this thread.

Guid for the active component. This Guid value is defined in the component's configuration file. If no component is running, the return value will be Guid.Empty.

Release the component lock for a synchronized component. This can be very dangerous as it will allow component re-entrancy. The normal way to use this is to release the lock on a call that exits a compoent and retake the lock as soon as the call completes.

Relock a synchronized component after a call to ReleaseComponentLock. This can be very dangerous as it will allow component re-entrancy. The normal way to use this is to release the lock on a call that exits a compoent and retake the lock as soon as the call completes.

API to test the installed version of the Dispatcher.

Returns true if the version of the Dispatcher is greater than or equal to the specified API version.

This allows reporting of a non-fatal exception from a Concord component. This must be called from an exception filter.

[Required] Exception that triggered this non-fatal error [Required] String describing the source of the error (such as a component name), this will appear in the 4th parameter of the WER report after the module name A return value of false does not mean failure; false will be returned under normal operation. Returns true if the report was sent, false if no report was sent

Component id which can be used by IDE components that wish to call into the debugger engine API from their own worker threads. This value can be used to pass to DkmComponentManager.InitializeThread().

Instantiates the debuggee-side Custom Visualizer type in the debuggee and provides methods to access/modify the visualized object ('Visualizer Object'). Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: CompilerVendorId, EngineId, LanguageId, RuntimeId, SymbolProviderId. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

Instantiates the debuggee-side Custom Visualizer type in the debuggee process.

[In] The formatted result of a successful evaluation, ready to be displayed in an expression evaluation window. [In] The index of the selected visualizer. [Out,Optional] The type of the exception thrown, if any. [Out,Optional] The stack trace of the exception thrown, if any. [Out,Optional] The exception message, if any.

Releases the debuggee-side Custom Visualizer type in the debuggee process.

[In] The formatted result of a successful evaluation, ready to be displayed in an expression evaluation window. [Out] If the handle was successfully removed, return true. If no handle, return false.

Resolves an assembly name to the path of the assembly or to its raw bytes.

[In] The formatted result of a successful evaluation, ready to be displayed in an expression evaluation window. [In] The fully qualified name of the assembly to resolve. [Out,Optional] The path of the resolved assembly for local debugging. [Out,Optional] The byte array of the resolved assembly for remote debugging.

Executes the debuggee-side Custom Visualizer type's GetData(...) method.

[In] The formatted result of a successful evaluation, ready to be displayed in an expression evaluation window. [Out,Optional] The type of the exception thrown, if any. [Out,Optional] The stack trace of the exception thrown, if any. [Out,Optional] The exception message, if any. [Out,Optional] The raw bytes of the GetData(...) method marshalled as a byte array.

Executes the debuggee-side Custom Visualizer type's TransferData(...) method.

[In] The formatted result of a successful evaluation, ready to be displayed in an expression evaluation window. [In] The data to transfer to the debuggee-side Visualizer class. [Out,Optional] The type of the exception thrown, if any. [Out,Optional] The stack trace of the exception thrown, if any. [Out,Optional] The exception message, if any. [Out,Optional] The raw bytes of the result of the TransferData(...) method marshalled as a byte array.

Executes the debuggee-side Custom Visualizer type's CreateReplacementObject(...) method, and writes the result to the visualized object handle.

This interface is implemented the expression evaluator to allow an EE addin to callback to the expression evaluator. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: EngineId, RuntimeId, SourceId, SymbolProviderId, VisualizerId.

Allows custom expression evaluator addins to obtain the symbol interface for the type being visualized. This is not stored in the DkmVisualizedExpression directly to enable addins that live on the remote machine and do not depend on symbols.

[In] Dispatcher object used for custom visualization through a concord EE addin. [In] The GUID of the TypeSymbolInterface interface requested from the caller. For the Microsoft native C++ expression evaluator, this should be IID_IDiaSymbol. [Out] The symbol interface of the type that was used to evaluate the expression.

This method allows a visualizer addin use the expression evaluator to compile and evaluate the default value for an expression. The addin can use this result as-is or override fields by creating a new result. The addin can also choose to use the expression evaluator for expansion using the the get children callbacks.

[In] Dispatcher object used for custom visualization through a concord EE addin. [In] The inspection context to use for this evaluation. [In] The expression the visualizer addin to would like the expression evaluator to evaluate. [In] Stack frame to evaluate the expression in. [Out] Object containing the result of the evaluation. E_PROCESS_DESTROYED indicates that the process exited while attempting to evaluate.

This method will construct a default full name for a custom visualized child expression. This name will be the root expression's full name and an expand format string that will cause the expression evaluator to callback to the visualizer to obtain children. The DkmVisualizedExpression instance this is called on should be the parent visualized expression for a child and the root visualized expression for a root.

[In] Dispatcher object used for custom visualization through a concord EE addin. [In] The index of child for which this full name is created. Ignored in the case of a root item. [Out] The returned full name string.

This method allows a visualizer addin use the expression evaluator for expansion. The evaluation result contained within the visualized expression must have come from the expression evaluator via EvaluateExpressionCallback.

[In] Dispatcher object used for custom visualization through a concord EE addin. [In] The evaluation result returned from the expression evaluator for this expression. The expression evaluator can only control the expansion of evaluations it understands. [In] The initial number of children that the caller would like returned. This value can be zero if no children will be initially returned. This value may be larger than the number of children that this expression has, in which case all children should be returned. Very large or negative values should not be used as arrays can have extremely large sizes which would cause out-of-memory if all elements were requested. [In] The inspection context to use for computing the children. This may differ from the original inspection context with respect to settings, such as radix, evaluation flags, or timeout. [Out] The initial children to return. Each child must be closed by the caller when the caller is done. [Out] Context object used to enumerate the children. This object must be closed by the caller of this API when enumeration is complete.

This method allows a visualizer addin use the expression evaluator for expansion using the passed enumeration context. This is used to obtain local variables of a stack frame or child members from an evaluation result.

[In] Dispatcher object used for custom visualization through a concord EE addin. [In] Context object used to enumerate the children. [In] The zero-based index of the first item to obtain. [In] The number of items to try and return. This value may be larger than the total number of remaining items, in which case all remaining items should be returned. Very large or negative values should not be used as arrays can have extremely large sizes which would cause out-of-memory if all elements were requested. [Out] The DkmEvaluationResult items to return. Each item must be closed by the caller when the caller is done.

Modifies the value of the given evaluation result (assumed to be non-read-only) to match the given string. This is used after the user edits a value in any of the evaluation windows.

[In] Dispatcher object used for custom visualization through a concord EE addin. [In] The evaluation result returned from the expression evaluator for this expression. The expression evaluator can only control evaluations it understands. [In] Textual representation of value to assign to the evaluation result. [In] If a function evaluation is needed to assign the value, specifies the timeout to use. [Out,Optional] If the operation failed, this indicates the reason why. This value should be null if the operation succeeded. In native code, an S_OK return value is used when returning error text.

Interface responsible for providing information relevant for a data breakpoint. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: CompilerVendorId, EngineId, LanguageId, RuntimeId, SymbolProviderId. This API was introduced in Visual Studio 15 Update 8 (DkmApiVersion.VS15Update8).

Returns the data breakpoint information related to the evaluation result, if valid.

[In] The formatted result of a successful evaluation, ready to be displayed in an expression evaluation window. [Out,Optional] If the operation failed, this indicates the reason why. This value should be null if the operation succeeded. [Out] The data breakpoint information.

Extension to IDkmDataBreakpointInfoProvider to allow expression evaluators to provide a display name for data breakpoints. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: CompilerVendorId, EngineId, LanguageId, RuntimeId, SymbolProviderId. This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTM).

Gets the data breakpoint display name for the evaluation result.

[In] The formatted result of a successful evaluation, ready to be displayed in an expression evaluation window. [Out] The data breakpoint display name.

Allows providing additional nodes to be included in frame locals, identifiable by the pseudo register name. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: CompilerVendorId, EngineId, LanguageId, RuntimeId. This API was introduced in Visual Studio 15 Update 8 (DkmApiVersion.VS15Update8).

Gets the evaluation result for the pseudo local to be included among the frame locals.

[In] Represents a logical top level item in the 'Locals' window, whose value is obtaining using IDkmFramePseudoLocalProvider. Currently this is only used for optimized locals while .NET Debugging. WorkList which is currently being processed. This value can be used to check for cancelation or to append additional work. New work items will not begin executing until after this function returns. [In] The current inspection context. [In] The current frame. Routine to fire when the request is complete. This will be implicitly fired if the implementation returns failure from this interface method. The implementation must fire this method in all other scenarios.

Gets an enumeration context used to obtain the children of this evaluation result. This is used in all expression evaluation windows.

[In] The formatted result of an evaluation, ready to be displayed in an expression evaluation window. WorkList which is currently being processed. This value can be used to check for cancelation or to append additional work. New work items will not begin executing until after this function returns. [In] The initial number of children that the caller would like returned. This value can be zero if no children will be initially returned. This value may be larger than the number of children that this expression has, in which case all children should be returned. Very large or negative values should not be used as arrays can have extremely large sizes which would cause out-of-memory if all elements were requested. [In] The inspection context to use for computing the children. This may differ from the original inspection context with respect to settings, such as radix, evaluation flags, or timeout. Routine to fire when the request is complete. This will be implicitly fired if the implementation returns failure from this interface method. The implementation must fire this method in all other scenarios.

Obtain DkmEvaluationResult items from this enumeration context. This is used to obtain local variables of a stack frame or child members from an evaluation result.

[In] Context object used to enumerate child members of an evaluation result, or to enumerate local variables from a stack frame. This is logically similar to an enumerator, except that access to elements is index-based rather than sequential. WorkList which is currently being processed. This value can be used to check for cancelation or to append additional work. New work items will not begin executing until after this function returns. [In] The zero-based index of the first item to obtain. [In] The number of items to try and return. This value may be larger than the total number of remaining items, in which case all remaining items should be returned. Very large or negative values should not be used as arrays can have extremely large sizes which would cause out-of-memory if all elements were requested. Routine to fire when the request is complete. This will be implicitly fired if the implementation returns failure from this interface method. The implementation must fire this method in all other scenarios.

[In] The formatted result of an evaluation, ready to be displayed in an expression evaluation window. [Out,Optional] The underlying string value.

This interface allows a language extension to provide the ability to evaluate expressions on a group of threads. It should generally be implemented by all language extensions. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, CompilerVendorId, EngineId, LanguageId, RuntimeId.

Bind the input expression and evaluate it. Then format the resulting value for display in the debugger. This is used for data tips, the watch windows, the immediate window, etc.

[In] Options and target context to use while performing the inspection operation. WorkList which is currently being processed. This value can be used to check for cancelation or to append additional work. New work items will not begin executing until after this function returns. [In] The compute threads to use when executing the query. [In] Stack frame to match on compute threads. [In] Expression to evaluate. Routine to fire when the request is complete. This will be implicitly fired if the implementation returns failure from this interface method. The implementation must fire this method in all other scenarios.

Resolves a DkmILFailureReason into an error message. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: CompiledInspectionQueryKind, CompilerVendorId, EngineId, LanguageId, RuntimeId. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

Resolves a DkmILFailureReason into an error message. This is used to produce the error message for a condition breakpoint.

This interface allows an expression evaluator to specify intrinsic operations to be invoked through IL, which the EE is responsible for implementing. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: LanguageId, SourceId.

Executes an intrinsic function.

[In] Pops the arguments off the IL stack in reverse order (prior to the DkmILExecuteIntrinsic instruction, arguments should be pushed on the stack in order). Then, executes an EE-defined operation that makes use of these values. Then, pushes the result back onto the IL stack. [In] The stack frame context we are evaluating on. [In] The arguments supplied to the intrinsic function. [In,Optional] Optional array of IL-based subroutines that the intrinsic function may choose to invoke during its operation. [Out] If an error occurs, specifies the reason for the error. To indicate an error code whose meaning is specific to the particular intrinsic function being executed, return a value less than zero. [Out] The results of the evaluation to be pushed onto the IL stack (in order).

Executes an intrinsic function.

[In] Pops the arguments off the IL stack in reverse order (prior to the DkmILExecuteIntrinsic instruction, arguments should be pushed on the stack in order). Then, executes an EE-defined operation that makes use of these values. Then, pushes the result back onto the IL stack. [In] The stack frame context we are evaluating on. [In] Currently executing instruction query that this intrinsic function belongs to. [In] The arguments supplied to the intrinsic function. [In,Optional] Optional array of IL-based subroutines that the intrinsic function may choose to invoke during its operation. [Out] If an error occurs, specifies the reason for the error. To indicate an error code whose meaning is specific to the particular intrinsic function being executed, return a value less than zero. [Out] The results of the evaluation to be pushed onto the IL stack (in order).

This interface is implemented by languages to enable stepping behavior for async methods. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: CompilerVendorId, EngineId, LanguageId, RuntimeId.

This method returns the identity of an async method. This is used to set conditional breakpoints for stepping over an await expression.

[In] Pairing between an instruction address and the language that should be used to decode it. [In] Stack frame that provides the context of in which to evaluate the expression. [Out] The identity of the async method.

This method asks the language to set or clear a flag on the Task backing the async method. This flag enables stopping during step out of an async method.

[In] Pairing between an instruction address and the language that should be used to decode it. [In] Stack frame that provides the context of in which to evaluate the expression. [In] If true set the flag, else clear the flag.

This interface is implemented by expression evaluators which live or the target computer and wish to support conditional breakpoints. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: CompilerVendorId, EngineId, LanguageId, RuntimeId.

Parses an input breakpoint condition so that it can later be evaluated. If the breakpoint condition uses DkmBreakpointConditionOperator.BreakWhenTrue, the expression evaluator should require that the specified condition evaluates to a Boolean value. The created query must return only a single result. For BreakWhenTrue conditions, this must be either a 4-byte or 1-byte value, and any non-zero value is considered true.

[In] Represents a condition which is evaluated on the target computer. These objects are used for languages where the expression evaluator is implemented on the target. [Out,Optional] If the condition could not be parsed, this indicates the reason why. This value should be null if the compile succeeded.

Evaluates a condition to decide if the debugger should stop.

[In] Represents a condition which is evaluated on the target computer. These objects are used for languages where the expression evaluator is implemented on the target. [In] The stack frame to use when evaluating the condition. [Out] True if the breakpoint condition indicated that the IDE should stop. [Out,Optional] If the condition could not be evaluated, this indicates the reason why. This value should be null if the compile succeeded.

This interface allows a language extension to pre-compile breakpoint conditions so that the same expression may be quickly evaluated when the breakpoint is hit. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: CompilerVendorId, EngineId, LanguageId, RuntimeId.

This method is obsolete and should not be used.

[In] Pairing between an instruction address and the language that should be used to decode it. [In] Not used. [Out,Optional] Not used.

Compiles an input breakpoint condition into an inspection query which can be evaluated on the target computer. If the breakpoint condition uses DkmBreakpointConditionOperator.BreakWhenTrue, the expression evaluator should require that the specified condition evaluates to a Boolean value. The created query must return only a single result. For BreakWhenTrue conditions, this must be either a 4-byte or 1-byte value, and any non-zero value is considered true.

[In] Pairing between an instruction address and the language that should be used to decode it. [In] Breakpoint condition to compile. [Out,Optional] If the compilation failed, this indicates the reason why. This value should be null if the compile succeeded. If the compile does fail, S_FALSE is returned (native code only). [Out,Optional] The result of the compilation. This is null in the case that the compilation failed. In this case, ErrorText should indicate the reason for the failure.

This interface allows a language extension to provide the ability to evaluate expressions in the various data inspection windows of the debugger (watch, autos, immediate, memory, disassembly, etc). It should generally be implemented by all language extensions. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: CompilerVendorId, EngineId, LanguageId, RuntimeId.

Bind the input expression and evaluate it. Then format the resulting value for display in the debugger. This is used for data tips, the watch windows, the immediate window, etc.

[In] Options and target context to use while performing the inspection operation. WorkList which is currently being processed. This value can be used to check for cancelation or to append additional work. New work items will not begin executing until after this function returns. [In] DkmLanguageExpression represents an expression to be parsed and evaluated by an expression evaluator. [In] Stack frame to evaluate the expression in. Routine to fire when the request is complete. This will be implicitly fired if the implementation returns failure from this interface method. The implementation must fire this method in all other scenarios.

Gets an enumeration context used to obtain the children of this evaluation result. This is used in all expression evaluation windows.

Gets an enumeration context used to obtain the local variables of this stack frame. This is used in computing the locals window.

[In] Options and target context to use while performing the inspection operation. WorkList which is currently being processed. This value can be used to check for cancelation or to append additional work. New work items will not begin executing until after this function returns. [In] Stack frame to evaluate the expression in. Routine to fire when the request is complete. This will be implicitly fired if the implementation returns failure from this interface method. The implementation must fire this method in all other scenarios.

Provides information on the arguments of a stack frame. This is currently only exposed through the VS automation model (EnvDTE.StackFrame.Arguments).

[In] Options and target context to use while performing the inspection operation. WorkList which is currently being processed. This value can be used to check for cancelation or to append additional work. New work items will not begin executing until after this function returns. [In] Walked frames which the evaluator is requested to describe. Routine to fire when the request is complete. This will be implicitly fired if the implementation returns failure from this interface method. The implementation must fire this method in all other scenarios.

Obtain DkmEvaluationResult items from this enumeration context. This is used to obtain local variables of a stack frame or child members from an evaluation result.

Modifies the value of the given evaluation result (assumed to be non-read-only) to match the given string. This is used after the user edits a value in any of the evaluation windows.

[In] The formatted result of an evaluation, ready to be displayed in an expression evaluation window. [In] Textual representation of value to assign to the evaluation result. [In] If a function evaluation is needed to assign the value, specifies the timeout to use. [Out,Optional] If the operation failed, this indicates the reason why. This value should be null if the operation succeeded. In native code, an S_OK return value is used when returning error text.

[In] The formatted result of an evaluation, ready to be displayed in an expression evaluation window. [Out,Optional] The underlying string value.

This interface allows a language extension to format the display of function names in the call stack window. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, CompilerVendorId, EngineId, LanguageId, RuntimeId.

Provides a text representation for a stack frame. This is used when building the formatted call stack.

[In] Options and target context to use while performing the inspection operation. WorkList which is currently being processed. This value can be used to check for cancelation or to append additional work. New work items will not begin executing until after this function returns. [In] Walked frames which the evaluator is requested to describe. [In] Flags to indicate what information about the arguments should be included in the frame name. Routine to fire when the request is complete. This will be implicitly fired if the implementation returns failure from this interface method. The implementation must fire this method in all other scenarios.

Provides a text representation of the return type for one or more stack frame. This is currently only exposed through the VS automation model (EnvDTE.StackFrame.ReturnType).

[In] Options and target context to use while performing the inspection operation. WorkList which is currently being processed. This value can be used to check for cancelation or to append additional work. New work items will not begin executing until after this function returns. [In] Walked frames which the evaluator is requested to describe. Routine to fire when the request is complete. This will be implicitly fired if the implementation returns failure from this interface method. The implementation must fire this method in all other scenarios.

This interface allows a language extension to format the display of the 'Function' column in the breakpoints window, and other places that attempt to format an instruction address. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: CompilerVendorId, EngineId, LanguageId, RuntimeId.

Provides a text representation for a method symbol. This is used when describing an address in the UI, for example the 'Function' column in the breakpoints window.

[In] Pairing between an instruction address and the language that should be used to decode it. [In] Flags to indicate what information about the arguments should be included in the method name. As parameter values cannot be obtained without a stack frame and a stack frame is not available here, the "Values" flag will never be present. [Out] Language's representation of the name of this method.

This is an optional interface implemented by expression evaluators. It should be implemented by expression evaluators which return evaluation results with the 'CanHaveObjectId' flag. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: CompilerVendorId, EngineId, LanguageId, RuntimeId, SymbolProviderId.

Creates an object id for this particular expression.

[In] The formatted result of an evaluation, ready to be displayed in an expression evaluation window.

Destroys an object id for this particular expression.

[In] The formatted result of an evaluation, ready to be displayed in an expression evaluation window.

This interface allows a language extension to evaluate return values as collected by a runtime during stepping. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, CompilerVendorId, EngineId, LanguageId, RuntimeId.

Evaluates and formats a given DkmRawReturnValue using solely the provided data.

[In] Options and target context to use while performing the inspection operation. WorkList which is currently being processed. This value can be used to check for cancelation or to append additional work. New work items will not begin executing until after this function returns. [In] Stack frame that provides the context of in which to evaluate the expression. [In] Return value target and cached context. Routine to fire when the request is complete. This will be implicitly fired if the implementation returns failure from this interface method. The implementation must fire this method in all other scenarios.

This interface allows a language extension to evaluate return values as collected by a runtime during stepping. This is a replacement for IDkmLanguageReturnValueEvaluator that allows components to retrieve data items associated with the return value. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, CompilerVendorId, EngineId, LanguageId, RuntimeId. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

Evaluates and formats a given DkmRawReturnValue using solely the provided data.

[In] Options and target context to use while performing the inspection operation. WorkList which is currently being processed. This value can be used to check for cancelation or to append additional work. New work items will not begin executing until after this function returns. [In] Stack frame that provides the context of in which to evaluate the expression. [In] Return value target and cached context. Routine to fire when the request is complete. This will be implicitly fired if the implementation returns failure from this interface method. The implementation must fire this method in all other scenarios.

This interface allows a language extension to affect the Step-Into behavior of the native runtime. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: CompilerVendorId, EngineId, LanguageId, RuntimeId.

Called during a Step-Into to determine special behavior for a particular function.

[In] Pairing between an instruction address and the language that should be used to decode it. [Out] Flags which describe how to proceed with a Step-Into action.

Provides the IDE with the functionality add and remove favorite items on objects in the EE windows. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: CompilerVendorId, EngineId, LanguageId, RuntimeId, SymbolProviderId. This API was introduced in Visual Studio 16 Update 4 (DkmApiVersion.VS16Update4).

Adds the specified child to the collection of favorites items on the type of this result.

[In] The formatted result of a successful evaluation, ready to be displayed in an expression evaluation window. [In] The child item to be added.

Removes the specified child from the collection of favorite items on the type of this result.

[In] The formatted result of a successful evaluation, ready to be displayed in an expression evaluation window. [In] The child item to be removed.

This interface is implemented by expression evaluators which are loaded on the target computer to map between a function/address expression and the instructions which are represented by it. This is used to bind function breakpoints. In addition to expression evaluators, this interface may also be implemented by other components which may want to bind function breakpoints using data from the target process (ex: native export function breakpoints). Components filtering based on LanguageId and/or VendorId should ensure that Guid.Empty is one of the accepted values in their filter. See DkmRuntimeFunctionResolutionRequest.CompilerId for more information. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, CompilerVendorId, EngineId, LanguageId.

[In] DkmRuntimeFunctionResolutionRequest represents an expression to be parsed and evaluated by a runtime based expression evaluator and is bound to a particular process. Resolutions will send DkmModuleInstance::FunctionResolved events. WorkList which is currently being processed. This value can be used to check for cancelation or to append additional work. New work items will not begin executing until after this function returns.

This interface is implemented by symbol based expression evaluators to map between a function/address expression and the instructions which are represented by it. This is used to bind function breakpoints. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, CompilerVendorId, EngineId, LanguageId, SymbolProviderId.

Resolve an address string to zero or more address symbols. This is used to bind function breakpoints.

[In] DkmSymbolFunctionResolutionRequest represents an expression to be parsed and evaluated by a symbol based expression evaluator and is not bound to a particular process. Used to perform function breakpoint binds. [Out] DkmInstructionSymbol[] represents a method in the target process.

Optional interface to compiles an object visualization data from a human-readable form into a DkmCompiledVisualizationData object. Currently, this interface is implemented only by C++. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: CompilerVendorId, LanguageId. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

Compiles object visualization data from a human-readable form into a DkmCompiledVisualizationData object.

[In] Represents the results of parsing one or more visualization files. [In] List of full paths, on to the Visual Studio computer, that describe information to be used for object visualization. For C++, each item in the array should be the full path to a .natvis file you wish to use when formatting the results of the expression.

This interface is implemented by custom expression evaluator visualizers in order to customize the view of an expression programmatically. This is normally done to support visualizations that are not possible using the native visualizer syntax or to enable visualization without full symbolic information. The visualizer can take complete control of the expression including expansion of children, or it can obtain the default expression from the expression evaluator, modify it slightly but defer other operations such as expansion back to the EE. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: EngineId, RuntimeId, SourceId, SymbolProviderId, VisualizerId.

Evaluate a visualized expression returning a DkmEvaluationResult for it.

[In] Dispatcher object used for custom visualization through a concord EE addin. [Out,Optional] Object containing the result of the evaluation. This object must be closed by the caller when the caller is done with the object. The expression evaluator reserves the right to override this instance so do not rely on storing data items in the DkmEvaluationResult instance. Use the DkmVisualizedExpression instance as a data container instead.

Called by the expression evaluator when a visualized expression's children are being expanded, the the value is being set, or the underlying string is being obtained. If the visualizer addin wants complete control of the expression it should return false. It will then receive calls to GetChildren, GetItems, SetValueAsString, and GetUnderlyingString. If the visualizer addin wants to completely defer these operations to the expression evaluator, it should return true. It must also give the expression evaluator back the instance of DkmEvaluationResult that came from the EE via one of the IDkmCustomVisualizerCallback methods. Note that the addin MUST have obtained the default DkmEvaluationResult from the EE if it wants the EE to control the object. Returning true from this method is primarily used by visualizer addins that just tweak something small like the view of a value but don't want to modify expansion or setting values.

[In] Dispatcher object used for custom visualization through a concord EE addin. [Out] Return true to use default expansion, false otherwise. [Out,Optional] The instance of DkmEvaluationResult returned from a call to one of the methods of IDkmCustomVisualizerCallback. The expression evaluator can only control DkmEvaluationResults it understands.

Gets an enumeration context used to obtain the children of this evaluation result. This is used in all expression evaluation windows.

[In] Dispatcher object used for custom visualization through a concord EE addin. [In] The initial number of children that the caller would like returned. This value can be zero if no children will be initially returned. This value may be larger than the number of children that this expression has, in which case all children should be returned. Very large or negative values should not be used as arrays can have extremely large sizes which would cause out-of-memory if all elements were requested. [In] The inspection context to use for computing the children. This may differ from the original inspection context with respect to settings, such as radix, evaluation flags, or timeout. [Out] The initial children to return. [Out] Context object used to enumerate the children. This object must be closed by the caller of this API when enumeration is complete.

Called to obtain items from a instance of DkmEvaluationResultEnumContext created by an earlier call to GetChildren.

[In] Dispatcher object used for custom visualization through a concord EE addin. [In] The enum context to use for this call. This instance will have been returned from a previous call to DkmVisualizedExpression. [In] The zero-based index of the first item to obtain. [In] The number of items to try and return. This value may be larger than the total number of remaining items, in which case all remaining items should be returned. Very large or negative values should not be used as arrays can have extremely large sizes which would cause out-of-memory if all elements were requested. [Out] The DkmChildVisualizedExpression items to return.

Modifies the value of the given evaluation result (assumed to be non-read-only) to match the given string. This is used after the user edits a value in any of the evaluation windows.

[In] Dispatcher object used for custom visualization through a concord EE addin. [In] Textual representation of value to assign to the evaluation result. [In] If a function evaluation is needed to assign the value, specifies the timeout to use. [Out,Optional] If the operation failed, this indicates the reason why. This value should be null if the operation succeeded. In native code, an S_OK return value is used when returning error text.

[In] Dispatcher object used for custom visualization through a concord EE addin. [Out,Optional] The underlying string value.

Formats values and type names of evaluation results into string appropriate for the language being debugged. Compiler vendors can implement this interface to customize value formatting for their language. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: CompilerVendorId, LanguageId. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

Get the value string to display in the UI for the given DkmClrValue.

Gets the type name string to display in the UI for the given DkmClrType. This method will always return a value and is used in variable inspection windows.

[In] Options and target context to use while performing the inspection operation. [In] The type to get the name for. [In,Optional] The optional information provided by the expression compiler for identifying compiler intrinsic type information. [In,Optional] The optional format specifier(s) to use when formatting this result. [Out] The type name string.

Get the underlying string representation of the value.

Formats values of evaluation results into a string appropriate for the language being debugged. Compiler vendors can implement this interface to customize value formatting for their language. This interface is an addition to the IDkmClrFormatter interface. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: CompilerVendorId, LanguageId, SymbolProviderId. This API was introduced in Visual Studio 15 RTM (DkmApiVersion.VS15RTM).

Get the value string to display in the UI for the given DkmClrValue.

[In] A value resulting from a CLR inspection query. These values are used by a Result Formatter to generate DkmEvaluationResults. [In,Optional] The information provided by the expression compiler for identifying compiler intrinsic type information. [In] The inspection context for this evaluation. [In,Optional] The optional format specifier(s) to use when formatting this result. [Out] The value string.

Get the editable value string to display in the UI for the given DkmClrValue.

[In] A value resulting from a CLR inspection query. These values are used by a Result Formatter to generate DkmEvaluationResults. [In] The inspection context for this evaluation. [In,Optional] The information provided by the expression compiler for identifying compiler intrinsic type information. [Out] The editable value string.

Provides full names for certain expressions. Full names are used for the Add to Watch feature. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, CompilerVendorId, EngineId, LanguageId, RuntimeId. This API was introduced in Visual Studio 15 RTM (DkmApiVersion.VS15RTM).

Get the type name in a form valid in the language, if valid syntax. This method is for constructing valid full names with the ability to escape/return null if there is not a valid syntax.

[In] Options and target context to use while performing the inspection operation. [In] The type to get the name for. [In,Optional] The information provided by the expression compiler for identifying compiler intrinsic type information. [Out,Optional] The type name if the name can be represented as valid syntax.

Get an array index expression.

[In] Options and target context to use while performing the inspection operation. [In] Arguments to array expression. [Out] The array index expression.

Get a cast expression, if valid syntax.

[In] Options and target context to use while performing the inspection operation. [In] Expression being cast. [In] The type to get a cast expression for. [In,Optional] The information provided by the expression compiler for identifying compiler intrinsic type information. [In] Options for the cast expression to avoid parse errors or other results. [Out,Optional] The cast expression or null if the type name would be invalid syntax.

Get an object creation expression, if valid syntax.

[In] Options and target context to use while performing the inspection operation. [In] The type to get an object expression for. [In,Optional] The information provided by the expression compiler for identifying compiler intrinsic type information. [In] Arguments to constructor call. [Out,Optional] The object creation expression or null if the type name would be invalid syntax.

Get the identifier in a form valid in the language.

[In] Options and target context to use while performing the inspection operation. [In] String to test if valid identifier in the EE language. [Out,Optional] The identifier in the form valid in the given language or null if it cannot be represented as a valid identifier.

Get a member access expression, if it can be represented as valid syntax.

[In] Options and target context to use while performing the inspection operation. [In] The expression being dotted into. [In,Optional] The declaring type. This is required if either RequiresExplicitCast or IsStatic is true. [In,Optional] The information provided by the expression compiler for identifying compiler intrinsic type information (for the declaring type). [In] The name of the type member. [In] True if the expression must be explicitly cast to dot into the member. [In] True if the member is static. [Out,Optional] The member access expression or null if the expression cannot be represented as valid syntax.

Returns true if the expression may require parentheses when used as a sub-expression in the language.

[In] Options and target context to use while performing the inspection operation. [In] The string representing the expression to check. [Out] Whether the expression may require parentheses.

Splits the string into the expression and format specifier parts.

[In] Options and target context to use while performing the inspection operation. [In] The expression being split to expression and format specifier parts. [Out] The format specifier(s) to use when formatting this result. [Out] The expression without format specifiers.

Get the language specific expression for this/Me.

[In] Options and target context to use while performing the inspection operation. [Out] The language specific expression for this/Me.

Get the language specific expression for null (keyword).

[In] Options and target context to use while performing the inspection operation. [Out] The language specific expression for null (keyword).

Provides DkmEvaluationResults given DkmClrValues. Compiler vendors can implement this interface to change the way values are expanded and presented to the user. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: CompilerVendorId, LanguageId, SymbolProviderId. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

Format a DkmClrValue and return a DkmEvaluationResult.

[In] A value resulting from a CLR inspection query. These values are used by a Result Formatter to generate DkmEvaluationResults. WorkList which is currently being processed. This value can be used to check for cancelation or to append additional work. New work items will not begin executing until after this function returns. [In,Optional] The declared type if it is different from the runtime type. [In,Optional] The optional information provided by the expression compiler for identifying compiler intrinsic type information. [In] The inspection context for this evaluation. [In,Optional] The optional format specifier(s) to use when formatting this result. [In] The name of this result. This value is typically the expression being evaluated. [In,Optional] The full name of this result. This is the expression added to the Watch window if the user selects "Add to Watch". Routine to fire when the request is complete. This will be implicitly fired if the implementation returns failure from this interface method. The implementation must fire this method in all other scenarios.

Gets the underlying DkmClrValue from a DkmSuccessEvaluationResult, if it exists.

[In] The formatted result of a successful evaluation, ready to be displayed in an expression evaluation window. [Out,Optional] The DkmClrValue, if it exists.

Gets an enumeration context used to obtain the children of this evaluation result. This is used in all expression evaluation windows.

Obtain DkmEvaluationResult items from this enumeration context. This is used to obtain local variables of a stack frame or child members from an evaluation result.

[In] The formatted result of an evaluation, ready to be displayed in an expression evaluation window. [Out,Optional] The underlying string value.

Allows compilers for managed languages to compile expressions for use by the debugger to support expression evaluation and conditional breakpoints. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: CompilerVendorId, LanguageId. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

Compile the expression into MSIL code that can be executed by the CLR or debugger to evaluate the expression.

[In] DkmLanguageExpression represents an expression to be parsed and evaluated by an expression evaluator. [In] The code context to use for compiling the expression. [In,Optional] The inspection context for this evaluation. This value is null if there is no current evaluation context. An example of a time when there is no evaluation context is when compiling conditional breakpoints. [Out,Optional] Indicates any error compiling the expression. If the code compiles successfully, this value should be null. It should also be null for cases where the language or expression is not supported and the debug engine needs to fall back to the default implementation. In error cases, this value indicates the reason for the compile error and the caller should return S_OK. [Out,Optional] The compiled expression. If Result is null, and Error is not null, there was a compile error. If both are null, compilation of the expression is not supported and the debug engine needs to use the legacy expression evaluator.

Compile the given expression and generate code to assign the value of the expression to an L-Value.

[In] DkmLanguageExpression represents an expression to be parsed and evaluated by an expression evaluator. [In] The code context to use for compiling the expression. [In] The L-value of the assignment. This is the result of a previous evaluation. [Out,Optional] Indicates any error compiling the expression or the reason the assignment is invalid. If the compiler can generate code for the assignment, this value should be null. In error cases, this value indicates the reason for the compile error and the caller should return S_OK. [Out,Optional] The compiled assignment operation. If Result is null, and Error is not null, there was a compile error.

Get a DkmCompiledClrLocalsQuery to allow viewing of local variables.

[In] Options and target context to use while performing the inspection operation. [In] The code context to use for getting local variables. [In] If set to true, get a query for arguments only. [Out] The local variables query.

Allows compilers for managed languages to compile expressions for use by the debugger to support expression evaluation. This interface contains methods that are called from the monitor. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: CompilerVendorId, LanguageId. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

[In] DkmLanguageExpression represents an expression to be parsed and evaluated by an expression evaluator. [In] The module instance containing the type the DebuggerDisplayAttribute applies to. [In] The metadata token of the type the DebuggerDisplayAttribute applies to. [Out,Optional] Indicates any error compiling the expression. If the code compiles successfully, this value should be null. In error cases, this value indicates the reason for the compile error and the caller should return S_OK. [Out,Optional] The compiled display attribute. If Result is null, and Error is not null, there was a compile error.

This interface contains the API for performing an async-break on the debuggee process. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, TransportKind.

This method will tell the debug monitors to asynchronously break execution of the debuggee process. An AsyncBreakComplete event is sent after the operation is complete.

[In] DkmProcess represents a target process which is being debugged. The debugger debugs processes, so this is the basic unit of debugging. A DkmProcess can represent a system process or a virtual process such as minidumps. [In] If this is set to true, implementers should immediately enter break rather than trying to find a thread inside the process that is executing code.

This interface contains the API for writing out a dump file of the debuggee process. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, TransportKind.

This method will write out a memory dump of the process to the path specified.

[In] DkmProcess represents a target process which is being debugged. The debugger debugs processes, so this is the basic unit of debugging. A DkmProcess can represent a system process or a virtual process such as minidumps. [In] The type of dump to write. Either minidump or full-memory minidump. [In] The full path to where the minidump should be saved. In remote scenarios, this path is relative to the remote machine. [In,Optional] The thread to use for the minidump if there is no current exception.

IDkmExceptionController is implemented by runtime debug monitors which fire exception events (DkmExceptionInformation.OnDebugMonitorException()). Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, ExceptionCategory, RuntimeId.

Determines if processing for this exception may be modified by the debugger. For example, if this user has performed an action (such as set next statement) that required the exception to be implicitly squashed, this may return false. This method may also return false if the runtime does not permit the exception from being squashed.

Updates the state of the target process so that when execution is resumed, the target process will not continue standard exception processing (ex: handler search, stack unwinding). This method needs to be called before resuming execution.

[In] Provides information about an exception which was raised in the target process. This information includes details of what exception was raised and the current stage of exception processing.

IDkmExceptionFormatter is implemented by runtime debug monitors which fire exception events. Unlike IDkmExceptionController, there is generally a single implementation of IDkmExceptionFormatter for each exception category. For example, while multiple base debug monitor implementations are able to detect Win32 exceptions, there only needs to be one formatter implementation. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, ExceptionCategory, RuntimeId.

Provides a string description for an exception. This is used when tracing the exception to the output window.

IDkmExceptionWinRTErrorExtractor is called by the exception manager to extract WinRT enhanced error info from a JavaScript/CLR/C++/etc exception. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, ExceptionCategory, RuntimeId.

Provides developer-oriented additional information about the exception. This info should be displayed along with GetDescription and GetAdditionalInformation to clarify the cause of the error.

[In] Provides information about an exception which was raised in the target process. This information includes details of what exception was raised and the current stage of exception processing. [Out,Optional] RestrictedErrorInfo description of the exception. Due to security restrictions, this may not be available even if RestrictedErrorInfo is available for the exception. [Out,Optional] If present, used to retrieve IRestrictedErrorInfo via the RoResolvedRestrictedErrorInfoReference API. [Out,Optional] If present specifies the missing capability.

Interface to provide access to the runtime function table of a process. A default implementation is provided by Microsoft's Native Debug Monitor which is able to find function tables in loaded Win32 modules and dynamic PData in live processes. This interface may be implemented by base debug monitors to provide runtime function table access for non-live processes (ex: minidumps). Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, TransportKind.

Obtain the function table entry for the passed address. The format of the engine is dependent on the debuggee architecture.

[In] 'DkmNativeModuleInstance' is used for modules which contain CPU code and/or are loaded by the Win32 loader. [In] The address to search the function table for. Normally, each entry contains a start and an end address. Implementations should return the entry whose address range contains the requested address. [Out] The contents of the function table entry.

The method will return the contents of the IMAGE_RUNTIME_FUNCTION_ENTRY for an address if possible. For searching static entries, callers should call the equivalent method on DkmNativeModuleInstance.

[In] DkmProcess represents a target process which is being debugged. The debugger debugs processes, so this is the basic unit of debugging. A DkmProcess can represent a system process or a virtual process such as minidumps. [In] The virtual address for which to find a function table entry for. [Out] The base address for the runtime function table entry. [Out,Optional] The runtime function table entry for this address if found.

Interface implemented by debug monitors to perform any updates when the 'Disabled' property of a module changed. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, RuntimeId, SymbolProviderId, TransportKind.

Performs any updates needed when the 'Disabled' state changes.

Interface implemented by debug monitors that support debugging dumps to allow the UI to search for binaries that were not found when the dump originally loaded. The symbol path is updated by the UI if the user chooses a path when searching for the binary. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, RuntimeId, SymbolProviderId, TransportKind.

Attempt to load a binary that previously failed to load using updated symbol paths.

Provides services to set and remove breakpoints. This interface is implemented by the Debug Monitor for most runtimes. The implementation must use a data item to track the lifetime of each enabled DkmRuntimeBreakpoint so that it can implicitly disable the breakpoint when the DkmRuntimeBreakpoint is closed. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, RuntimeId, SourceId.

Enables a breakpoint. Breakpoints start off initially disabled, so this method must be called before the breakpoint can be set. Enabling a breakpoint is typically implemented in the debug monitor by modifying the state of the target process. For example inserting an 'int3' instruction into the code stream. If the breakpoint is already enabled, this operation has no effect. Once a breakpoint has been enabled, the debug monitor will raise a RuntimeBreakpoint event for this DkmRuntimeBreakpoint object whenever the trigger condition (ex: target instruction is executed) is met. Multiple DkmRuntimeBreakpoints may be set on the same instruction. In this case, the debug monitor will raise a different RuntimeBreakpoint event for each breakpoint object. Similarly, if a step complete and a breakpoint both complete on the same instruction, the debug monitor will raise both events.

[In] Low-level breakpoint object which is supported by debug monitors. E_BP_MODULE_UNLOADED indicates that the module instance specified by the breakpoint is no longer loaded. E_TEXT_SPAN_NOT_LOADED indicates that TextSpan is not currently loaded in the specified script document. E_RUNTIME_BREAKPOINT_ERROR indicates that an error has occurred in a monitor component while enabling the runtime breakpoint and that the monitor component has provided an error message via IDkmDataBreakpointErrorInfoClient.OnError.

Determines if the given DkmRuntimeBreakpoint could be enabled. This is used from within the breakpoints dialog to validate breakpoints before the dialog is closed.

[In] Low-level breakpoint object which is supported by debug monitors. E_BP_MODULE_UNLOADED indicates that the module instance specified by the breakpoint is no longer loaded. E_TEXT_SPAN_NOT_LOADED indicates that TextSpan is not currently loaded in the specified script document. E_RUNTIME_BREAKPOINT_ERROR indicates that an error has occurred in a monitor component while testing the runtime breakpoint and that the monitor component has provided an error message via IDkmDataBreakpointErrorInfoClient.OnError.

[In] Low-level breakpoint object which is supported by debug monitors.

Interface implemented by base debug monitors to allow resuming the process for a function evaluation. This interface contains the basic services utilized by 'ExecuteFuncEval'. Setup, cleanup, timeout handling, exception handling and completion detection are all handled by the higher-level debug monitors. This interface is not provided for CLR v2 debugging. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, TransportKind.

This method is used to resume the target process so that a function evaluation may occur. This function is called by a runtime debug monitor after it has setup a function evaluation in order to make the target process run. The runtime monitor will first update the thread context, update any necessary memory in the target process, and setup any detection that the function evaluation is completed. Callers of this method MUST always call EndFuncEvalExecution before returning from the operation that triggered the function evaluation. The behavior is undefined if a caller fails to do so. This method is implemented in the base debug monitor by first updating the target process to be in function evaluation mode (DkmThread.OnBeginFuncEvalExecution), then suspending and/or resuming threads as specified by the function evaluation flags and finally continuing the target process. This method may be called from any thread, however OnBeginFuncEvalExecution must be called from the stopping event thread, so the base debug monitor may need to perform as thread switch as part of the implementation of this method. The base debug monitor should not return from BeginFuncEvalExecution until after the target has been resumed.

[In] DkmThread represents a thread running in the target process. [In] Flags impacting how function evaluation requests are performed.

IDkmBaseNativeExecutionController is implemented by base debug monitors which support setting native breakpoints or single stepping over native instructions. It provides the advanced execution control primitives needed for CLR debugging. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, TransportKind.

API which may be called from a IDkmSingleStepCompleteReceived or IDkmRuntimeBreakpointReceived implementation to force the base DM to fire the EXCEPTION_BREAKPOINT or EXCEPTION_SINGLE_STEP exception in the target process when execution is resumed. Normally, the breakpoint or single step exception is implicitly suppressed. This allows the EXCEPTION_BREAKPOINT/EXCEPTION_SINGLE_STEP to be handled by exception handlers within the target process. This API will fail if the thread is not currently sitting at a step complete or breakpoint event.

[In] DkmThread represents a thread running in the target process. [In] Win32 exception code to raise. Currently, this must be EXCEPTION_BREAKPOINT or EXCEPTION_SINGLE_STEP.

This interface contains the API for resuming execution after the engine has sent a stopping event to the Visual Studio debugger package. This interface should only be implemented by Base Debug Monitor components. Unlike nearly all other interfaces, one implementation of this interface may not chain to another implementation. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, TransportKind.

This method is provided by base debug monitors to resume execution of the target process. This interface is always triggered by a request to resume the process by the Visual Studio Debugger UI/SDM. Concord components cannot resume the target process once a stopping event has been sent to the UI/SDM. Base debug monitors implement this by calling from the request thread onto the stopping event thread. On the stopping event thread, the base debug monitor calls DkmThread.OnContinueExecution and then modifies the target process so that it will resume. After the target is running, the base debug monitor signals the request thread so that ContinueExecution will return.

[In] DkmThread represents a thread running in the target process.

Gets the extended registers from the thread context. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, TransportKind.

Gets the extended registers from the thread context.

[In] DkmThread represents a thread running in the target process. [Out] An array of extended registers.

Sets the value of the extended register in the thread's context.

[In] DkmThread represents a thread running in the target process. [In] The CV constant of the register to set. For AVX, this can be any of the YMM register enumeration codes. The caller is expected to set the full YMM register (including the portions which are aliased on XMM registers). [In] The value to set the register to. The size of the byte array must match the width of the register being set.

Interface implemented by base debug monitors to provide instruction-level stepping primitives. This interface is consumed by runtime debug monitors to implement user-level execution control. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, SourceId.

Enable single step on a thread. When then single step completes, the SingleStepComplete event should be sent. The single step should reset after completion. Implementers should send one single step complete event per instance of DkmSingleStepRequest they receive. Callers must make a new request to single-step after this DkmSingleStepRequest is complete.

[In] DkmSingleStepRequest represents a request to single step a thread.

Disable single step on a thread.

[In] DkmSingleStepRequest represents a request to single step a thread.

Interface to support managed func-eval quick abort. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, RuntimeId, TransportKind.

Checks to see if we should load the FEQA DLL.

[In] Represents a CLR instance running in a target process. [In] DkmThread represents a thread running in the target process. [Out] Specifies if the FEQA DLL should be loaded. The hosting process could have loaded it already. [Out] Specifies the address in debuggee process. Valid only if AlreadyLoaded is false.

Notifies the result of the attempt to load the FEQA DLL.

[In] Represents a CLR instance running in a target process. [In] DkmThread represents a thread running in the target process. [In] Specifies if the FEQA DLL was successfully loaded.

Implemented by base debug monitors to provide access to the memory of the target process. This interface is also implemented by higher level components to provide memory caching. Base debug monitors are responsible for performing the memory I/O, maintaining a table of invisible writes, and providing events when the invisible write table is updated (via DkmProcess.OnInstructionPatchInserted/Removed). Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, TransportKind.

Read the memory of the target process.

[In] DkmProcess represents a target process which is being debugged. The debugger debugs processes, so this is the basic unit of debugging. A DkmProcess can represent a system process or a virtual process such as minidumps. [In] The base address from which to read the target process's memory. [In] Flags controlling the behavior of DkmProcess.ReadMemory and DkmProcess.ReadMemoryString. [In,Out] A buffer that receives the contents from the address space of the target process. On failure, the content of this buffer is unspecified. [Out] Indicates the number of bytes read from the target process. If DkmReadMemoryFlags.AllowPartialRead is clear, on success this value will always be exactly equal to the input size. If DkmReadMemoryFlags.AllowPartialRead is specified, on success, this value will be greater than zero. E_INVALID_MEMORY_ADDRESS indicates that the address is not valid. See 'DkmReadMemoryFlags.AllowPartialRead' documentation for more information.

Reads a null-terminated string from the target process process's memory. This can be used to read an ANSI or Unicode (UTF-8, UTF-16 or UTF-32) strings.

[In] DkmProcess represents a target process which is being debugged. The debugger debugs processes, so this is the basic unit of debugging. A DkmProcess can represent a system process or a virtual process such as minidumps. [In] The base address from which to read the target process's memory. [In] Flags controlling the behavior of DkmProcess.ReadMemory and DkmProcess.ReadMemoryString. [In] Number of bytes in each character. This should be set to 1 (ANSI/UTF-8), 2 (UTF-16) or 4 (UTF-32). [In] The maximum number of characters to read from the target process. When DkmReadMemoryFlags.AllowPartialRead is false, the request will fail if a null terminator isn't found within this range. This value should be reasonable. The Microsoft implementation will fail any request for more than 25 MBs of string memory. [Out] The value of the string which was read from the target process. If DkmReadMemoryFlags.AllowPartialRead is clear, this memory will always include the null termination character. If DkmReadMemoryFlags.AllowPartialRead is specified, this buffer will not contain the null termination character if the read was truncated. E_INVALID_MEMORY_ADDRESS indicates that the address is not valid. See 'DkmReadMemoryFlags.AllowPartialRead' documentation for more information. E_STRING_TOO_LONG indicates that the string could not be read within the specified maximum number of characters.

Writes memory to the target process. Before data transfer occurs, the system verifies that all data in the base address and memory of the specified size is accessible for write access, and if it is not accessible, the function raises an E_INVALID_MEMORY_ADDRESS error.

[In] DkmProcess represents a target process which is being debugged. The debugger debugs processes, so this is the basic unit of debugging. A DkmProcess can represent a system process or a virtual process such as minidumps. [In] The base address from which to write the target process's memory. [In] Data to be written in the address space of the specified process.

Write memory to the target process, but hide the write from calls to ReadMemory. This API may be used to patch instructions or data within the target process to implement debugger features. Before data transfer occurs, the system verifies that all data in the base address and memory of the specified size is accessible for write access, and if it is not accessible, the function raises an E_INVALID_MEMORY_ADDRESS error.

[In] DkmProcess represents a target process which is being debugged. The debugger debugs processes, so this is the basic unit of debugging. A DkmProcess can represent a system process or a virtual process such as minidumps. [In] The base address from which to write the target process's memory. [In] Data to be written in the address space of the specified process.

Interface implemented by base debug monitors to fire a symbols loaded event. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, RuntimeId, SymbolProviderId, TransportKind.

After a symbol provided has loaded symbols, this method will be invoked by the dispatcher to cause a ModuleSymbolsLoaded event to be raised. This method may be called on the event thread, in which case the base DM should simply call DkmModuleInstance.OnSymbolsLoaded. This method may also be called on the request thread, in which case the Base DM should transition to their event thread, call DkmModuleInstance.OnSymbolsLoaded and wait for that call to finish before returning.

Optional interface implemented by base debug debug monitors which use the same event thread for multiple processes. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, TransportKind. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

Wait until process debugger becomes initialized.

Process debugging became initialized.

Queries state about the debuggee process. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, TransportKind.

Obtains the number of active handles in the process.

Obtains the number of clock cycles that the debuggee has been running since ResetRunningTime() was last called.

Sets the running time counter to the specified value.

This interface contains the API for launching a new process under the debugger or attaching the debugger to an existing process. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, TransportKind.

Causes the debug monitor to attach to the process. Before this method returns, the debug monitor must start an event thread (or reuse an existing event thread) and create the DkmProcess object on the event thread. Creating the DkmProcess object will send a process create event. Note that this method may only be called in response to the Visual Studio debugger package requesting an attach. Components that wish to attach to another process should send a custom event to a visual studio package. From a package, an attach can be requested through the IVsDebugger.LaunchDebugTargets API.

[In] DkmProcessAttachRequest is used to describe the process that debugger should attach to. [Out] DkmProcess represents a target process which is being debugged. The debugger debugs processes, so this is the basic unit of debugging. A DkmProcess can represent a system process or a virtual process such as minidumps. E_ATTACH_USER_CANCELED indicates that the attach to process operation was canceled. Returning this error will suppress most error messages. So it can be used in combination with DkmUserMessage.Post or DkmCustomMessage.SendToVsService as a way of providing custom failure messages to the user.

Causes the debug monitor to create a new process under the debugger. The process should be left suspended until ResumeDebuggedProcess is called. The debug monitor must wait for ResumeDebuggedProcess before creating the DkmProcess object since it needs the UniqueProcessId value from the AD7 Layer. Note that this method may only be called in response to the Visual Studio debugger package requesting a launch. Components that wish to launch another process under the debugger should send a custom event to a visual studio package. From a package, a launch can be requested through the IVsDebugger.LaunchDebugTargets API.

[In] DkmProcessLaunchRequest is used to describe the process that debugger should launch. [Out] DkmLaunchedProcessInfo is returned from APIs that launch a process.

Causes the debug monitor to resume a launched process and create the DkmProcess object. The DkmProcess object will be created on the event thread and creating the object will send a process create event. Note that this method may only be called in response to the Visual Studio debugger package requesting a launch. Components that wish to launch another process under the debugger should send a custom event to a visual studio package. From a package, a launch can be requested through the IVsDebugger.LaunchDebugTargets API.

[In] DkmProcessLaunchRequest is used to describe the process that debugger should launch. [In] Value to assign to the 'DkmProcess.UniqueId' field. This Guid is generated by the port, and is used to uniquely identifies the process object. [Out] DkmProcess represents a target process which is being debugged. The debugger debugs processes, so this is the basic unit of debugging. A DkmProcess can represent a system process or a virtual process such as minidumps.

This interface contains the API for stop debugging. These interface must be implemented by base debug monitors. It is also possible to implement this interface in order to customize the stop debugging experience for a particular application. For example, a component could re-implement Terminate so that the debugger would gracefully shutdown the application instead of using the TerminateProcess Win32 API. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, TransportKind.

This method is called to tell the monitor to detach from the target process. This will trigger a ProcessExit event to be sent on the event thread.

This method is called to tell the monitor to terminate the target process. This will trigger a ProcessExit event to be sent on the event thread.

[In] DkmProcess represents a target process which is being debugged. The debugger debugs processes, so this is the basic unit of debugging. A DkmProcess can represent a system process or a virtual process such as minidumps. [In] The exit code to be used by the process and threads terminated as a result of this call. Use the GetExitCodeProcess function to retrieve a process's exit value. Use the GetExitCodeThread function to retrieve a thread's exit value.

Operations provided by a base debug monitor to obtain and update a thread's context (register values). Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, TransportKind.

Update the context (register values) of a thread.

[In] DkmThread represents a thread running in the target process. [In] A CONTEXT structure that contains the context to be set in the specified thread. The value of the ContextFlags member of this structure specifies which portions of a thread's context to set. Some values in the CONTEXT structure that cannot be specified are silently set to the correct value. This includes bits in the CPU status register that specify the privileged processor mode, global enabling bits in the debugging register, and other states that must be controlled by the operating system.

Obtain the current context (register values) of a thread.

[In] DkmThread represents a thread running in the target process. [In] Win32 flags indicating which portion of the CONTEXT object to obtain (ex: CONTEXT_FULL, CONTEXT_CONTROL, CONTEXT_INTEGER). [In,Out] A Win32 CONTEXT structure that contains the context of the specified thread. The value of the ContextFlags member of this structure specifies which portions of a thread's context to obtained.

Called to suspend or resume a thread and to obtain the current thread suspension count. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, TransportKind.

Suspend this thread.

[In] DkmThread represents a thread running in the target process. [In] Pass true if this suspension should be hidden in calls to GetSuspensionCount. This is useful for internal suspensions that should not be reported to the user such as thread slippage suspensions. [Out,Optional] The previous number of suspensions for this thread minus the ones internal to the debugger.

Resume this thread.

Return the current suspension count of this thread.

[In] DkmThread represents a thread running in the target process. [In] Pass true to return the true suspension count for the thread. Return false to only see the suspensions that occurred in the debuggee process or the one's that passed true for InternalSuspension to Suspend. [Out] The suspension count of thread. The internal thread suspension count is subtracted from this value if ShowInternal is false.

Return the total number of suspensions caused by the debugger (i.e. calls to DkmThread::Suspend without a call to DkmThread::Resume). This excludes any suspensions external to the debugger.

[In] DkmThread represents a thread running in the target process. [Out] The total number of suspensions caused by the debugger (i.e. calls to DkmThread::Suspend without a call to DkmThread::Resume). This excludes any suspensions external to the debugger.

Implemented by base debug monitors to allow allocation/free of virtual memory in the target process. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, TransportKind.

Reserves and/or commits a region of memory within the virtual address space of the target process. The function initializes the memory it allocates to zero, unless MEM_RESET is used. For additional information, see the VirtualAlloc Win32 API in MSDN.

[In] DkmProcess represents a target process which is being debugged. The debugger debugs processes, so this is the basic unit of debugging. A DkmProcess can represent a system process or a virtual process such as minidumps. [In] Address within the target process where the memory should be committed or reserved. This value is typically zero, in which case the system chooses an address. [In] The size of the region of memory to allocate, in bytes. The system will automatically round up to the next page boundary. [In] Indicates the type of allocation to perform. This is typically MEM_COMMIT | MEM_RESERVE (0x3000) which reserves and commits an allocation in one step. [In] The memory protection for the region of pages to be allocated. If the pages are being committed, you can specify any one of the memory protection constants (ex: PAGE_READWRITE, PAGE_EXECUTE). [Out] Base address of the allocated region of pages.

Releases and/or decommits a region of memory within the virtual address space of the target process. For additional information, see the VirtualFree Win32 API in MSDN.

[In] DkmProcess represents a target process which is being debugged. The debugger debugs processes, so this is the basic unit of debugging. A DkmProcess can represent a system process or a virtual process such as minidumps. [In] Address within the target process where the memory should be freed. [In] Number of bytes to decommit. To release a region of memory, this value must be zero. [In] Indicates the type of free operation to perform. This is typically MEM_RELEASE (0x8000), which releases the specified region of pages. After the operation, the pages are in the free state. MEM_DECOMMIT (0x4000) can be used instead to decommit the pages without releasing them.

Provides support for reading and writing memory. Unlike IDkmMemoryOperation, this Interface can be used when the process is running, and it will never cache results, so it should be used with care. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, TransportKind.

Read memory from the target process. This method differs from 'ReadMemory' in that this method can be called at any time (not just when the target is stopped) and the debugger will not try to cache the result of this operation.

[In] DkmProcess represents a target process which is being debugged. The debugger debugs processes, so this is the basic unit of debugging. A DkmProcess can represent a system process or a virtual process such as minidumps. [In] The base address from which to read the target process's memory. [In,Out] A buffer that receives the contents from the address space of the target process. On failure, the content of this buffer is unspecified. E_INVALID_MEMORY_ADDRESS indicates that one or more bytes of the request could not be read.

Write to the memory of the target process. This method differs from 'WriteMemory' in that this method can be called at any time (not just when the target is stopped) and the debugger will not try to cache the result of this operation. If any memory cannot be written to, an E_INVALID_MEMORY_ADDRESS error will be raised. Because the memory write may occur from run mode, this failure may happen after the copy operation has already begun, and thus may lead to memory corruption in the target process. For this reason, this function must be used with care, and failures may be fatal.

[In] DkmProcess represents a target process which is being debugged. The debugger debugs processes, so this is the basic unit of debugging. A DkmProcess can represent a system process or a virtual process such as minidumps. [In] The base address from which to write the target process's memory. [In] Data to be written in the address space of the specified process.

Exposes volatile properties of a thread such as priority and affinity mask. These values are expected to change over time and should not be cached by callers. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, TransportKind.

Get a thread's dynamic properties.

[In] DkmThread represents a thread running in the target process. [Out] The priority of the thread. The values returned correspond directly to the values defined for kernel32!GetThreadPriority. [Out] The affinity mask of the thread. The values returned correspond directly to the values defined for kernel32!SetThreadAffinityMask.

Get volatile flags about a thread. For instance, return if a thread is a user-mode scheduled thread.

[In] DkmThread represents a thread running in the target process. [Out] Volatile flags that apply to a thread. These values are expected to change over time and should not be cached by callers.

This interface allows debug monitors to provide additional information about CLR exceptions in the form of exception details. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: EngineId, ExceptionCategory, RuntimeId. This API was introduced in Visual Studio 15 Update 7 (DkmApiVersion.VS15Update7).

Get the ICorDebugValue for the exception object.

[In] Contains details about an exception or inner exception object. [Out] ICorDebug interface representing an exception.

Provides execution of compiled inspection queries. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: CompiledInspectionQueryKind, CompilerVendorId, EngineId, LanguageId, RuntimeId.

Executes a compiled inspection query and returns any results.

[In] Represents a query which is produced by an expression evaluator or similar component and set to the target computer to obtain information about the dynamic state of the program (ex: the current value of a register). Consumers of inspection queries should call Close() once it is known that the inspection query will no longer execute. [In,Optional] Optional array of parameter values to pass to the IL stream. [In] The stack frame context we are evaluating on. [In] This is the timeout to be used for potentially slow operations such as a function evaluation. This value is in milliseconds. [In] Flags impacting how function evaluation requests are performed. [Out] If an expected error occurs evaluating the DkmIL, indicates the reason for the failure. [Out] Results of the evaluations. Each ILEvaluationResult object contains an index that indicates which DkmILInstruction in the instructions parameter this result came from. NOTE: some instructions will not return a result.

IDkmDebugMonitorExceptionNotification is implemented by components that want to listen for the DebugMonitorException event. When this notification fires, the target process will be suspended and can be examined. The 'DebugMonitorException' event provides notification from debug monitors about exceptions which occur within the target process. This event notification is consumed by the exception manager, and by debug monitors operating at component levels above the debug monitor which detected the exception. Higher level components should use exception triggers instead. See DkmExceptionTrigger for more information. If the exception is sent unhandled (DkmExceptionProcessingStage.Unhandled is set) then the IDE will stop. Other exceptions may stop depending on any DkmExceptionTriggers set by the AD7 AL or other components. The AD7 AL reads the default set of triggers from %VSRegistryRoot%\AD7Metrics\Exception\%CategoryGuid%\*. DebugMonitorException events can be suppressed by calling DkmEventDescriptorS.Suppress(). Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, ExceptionCategory, RuntimeId.

OnDebugMonitorException is invoked as part of event processing. See interface definition for more information.

[In] Provides information about an exception which was raised in the target process. This information includes details of what exception was raised and the current stage of exception processing. WorkList to append additional event processing work to. This work list will begin execution after all listeners have been notifiied. The event will not finish until after the work list fully executes. [In] Describes the event being processed and provides the ability for a component to suppress this event.

IDkmExceptionContinuedNotification is implemented by components that want to listen for the ExceptionContinued event. When this notification fires, the target process will be suspended and can be examined. ExceptionContinued is sent by a debug monitor when execution is resumed in the target process and the given exception has not been squashed. In other words, the target process will continue with its standard exception processing. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, ExceptionCategory, RuntimeId.

OnExceptionContinued is invoked as part of event processing. See interface definition for more information.

[In] Provides information about an exception which was raised in the target process. This information includes details of what exception was raised and the current stage of exception processing. WorkList to append additional event processing work to. This work list will begin execution after all listeners have been notifiied. The event will not finish until after the work list fully executes. [In] Describes the event being processed.

This interface allows debug monitors to provide additional information about exceptions in the form of exception details. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: EngineId, ExceptionCategory, RuntimeId. This API was introduced in Visual Studio 15 RTM (DkmApiVersion.VS15RTM).

Get the exception details for this exception.

[In] Provides information about an exception which was raised in the target process. This information includes details of what exception was raised and the current stage of exception processing. [In] The inspection session used to track the lifetime of the exception details object. [Out] Contains details about an exception or inner exception object.

Gets a description for this message that can be formatted to contain bold/italic text. Text can be made bold by wrapping in "**" blocks or made italic by wrapping in "*" blocks. For example "**Bold Text:** Non-bold text - *Italic*".

[In] Contains details about an exception or inner exception object. [Out] The formatted description.

Gets the message associated with the exception. The message is not formatted.

[In] Contains details about an exception or inner exception object. [Out,Optional] The exception message.

Gets the type name of the exception.

[In] Contains details about an exception or inner exception object. [In] A value indicating whether to return the full name of the exception. [Out] The type name.

Gets the source for this exception. If no source is available, this method returns null.

[In] Contains details about an exception or inner exception object. [Out,Optional] The source string or null if not available. E_NODATA indicates that this exception does not have a source.

Gets the HResult code of this exception. If no stack trace is available, this method returns null.

[In] Contains details about an exception or inner exception object. [Out] The HResult of the exception. E_NODATA indicates that this exception does not have an HResult.

Gets the stack trace for this exception. If no stack trace is available, this method returns null.

[In] Contains details about an exception or inner exception object. [Out,Optional] The stack trace string or null if not available. E_NODATA indicates that this exception does not have a stack trace.

Gets the inner exception if available. If there is no inner exception, this method returns null.

[In] Contains details about an exception or inner exception object. [Out,Optional] The inner exception or null if not available. E_NODATA indicates that this exception does not hold inner exceptions.

Gets the expression that represents the exception object. If no such object is available, this method returns null.

[In] Contains details about an exception or inner exception object. [Out,Optional] Expression for exception object. E_NODATA indicates that there is no EE expression to evaluate to get details for the exception.

This interface allows for extended queries about an exception, specifically the original call stack. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: EngineId, ExceptionCategory, RuntimeId. This API was introduced in Visual Studio 16 Update 4 (DkmApiVersion.VS16Update4).

Gets the call stack for this exception.

[In] Contains details about an exception or inner exception object. [In] Specifies whether the call stack is formatted to contain bold/italic/hyperlinked text or not. [In] Flags to indicate what information about the arguments should be included when formulating the call stack. [In] Flags to indicate what filters should be considered when formulating the call stack. [Out] The instruction addresses referenced using 'navigate-to-context' links in formatted stack. Example: '[insert-description-here](navigate-to-context:0)' would indicate the first instruction address should be used. The first element of this array is used to decide if the exception is still at its original location. [Out] The call stack formatted in markdown.

This interface is implemented by debug monitors that provide support for unwinding exceptions to a specific frame. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, RuntimeId, SymbolProviderId, TransportKind.

InterceptCurrentException is used to unwind to this frame as if there was an exception handler at that frame.

[In] DkmStackWalkFrame represents a frame on a call stack which has been walked, but may not have been formatted or filtered. Formatted frames are represented by DkmStackFrame instead. [In] Specifies exception interception actions. [Out] Cookie that represents this intercept request. The value is returned when an exception interception completed event is sent.

Returns the address that represents the location if an exception were to be intercepted to this frame.

IDkmGPUSingleStepCompleteNotification is implemented by components that want to listen for the GPUSingleStepComplete event. IDkmGPUSingleStepCompleteNotification is invoked after all implementations of IDkmGPUSingleStepCompleteReceived. When this notification is called, the target process is stopped and implementers are able to either inspect the process or cause it to execute in a controlled manner (slip, func-eval). Sent when single stepping a GPU thread is complete. The event can be fired by a different thread from the request thread in the same warp. GPUSingleStepComplete events can be suppressed by calling DkmEventDescriptorS.Suppress(). Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, SourceId.

OnGPUSingleStepComplete is invoked as part of event processing. See interface definition for more information.

[In] DkmSingleStepRequest represents a request to single step a thread. [In] DkmThread represents a thread running in the target process. [In] Describes the event being processed and provides the ability for a component to suppress this event.

IDkmGPUSingleStepCompleteReceived is implemented by components that want to listen for the GPUSingleStepComplete event. IDkmGPUSingleStepCompleteReceived is invoked before IDkmGPUSingleStepCompleteNotification. From within this notification, it is not possible to cause the target process to execute (no func-eval, no slipping). Sent when single stepping a GPU thread is complete. The event can be fired by a different thread from the request thread in the same warp. GPUSingleStepComplete events can be suppressed by calling DkmEventDescriptorS.Suppress(). Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, SourceId.

OnGPUSingleStepCompleteReceived is invoked as part of event processing. See interface definition for more information.

Used to execute compiled group expression processing. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: CompiledInspectionQueryKind, CompilerVendorId, EngineId, LanguageId, RuntimeId.

Executes a compiled inspection query and returns any results.

[In] An inspection query compiled to one or more DkmIL instructions. [In] The stack frame context we are evaluating on. [In] The compute threads to use when executing the query. [In,Optional] Parameters to pass to each thread. The collection should be empty if unused, or have exactly as many members as the Threads parameter. [Out] Results of the evaluations.

Interface to provide runtime-specific CPU address resolution. This could be implemented either on server or client side (e.g. CLR native compilation). Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, RuntimeId.

[In] The DkmRuntimeInstance class represents an execution environment which is loaded into a DkmProcess and which contains code to be debugged. [In] Memory address where the native instruction is located. [Out] True if this address is the first address in the line's range. False otherwise. [Out] Abstract representation of an executable code location (ex: EIP value). If resolved, an Instruction Address will be within a particular module instance. An Instruction Address is always within a particular Runtime Instance.

Resolves a DkmInstructionAddress to a CPU InstructionAddress. This is the reverse mapping of ResolveCPUInstructionAddress. This API is currently only supported by CLR DkmRuntimeInstance objects.

[In] Abstract representation of an executable code location (ex: EIP value). If resolved, an Instruction Address will be within a particular module instance. An Instruction Address is always within a particular Runtime Instance. [Out] An array of the current CPU Instruction Addresses that map to this DkmInstructionAddress.

Interface to determine if a particular location is user code. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, RuntimeId, SymbolProviderId. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

Determines if a given instruction address is user code or not.

[In] Abstract representation of an executable code location (ex: EIP value). If resolved, an Instruction Address will be within a particular module instance. An Instruction Address is always within a particular Runtime Instance. WorkList which is currently being processed. This value can be used to check for cancelation or to append additional work. New work items will not begin executing until after this function returns. Routine to fire when the request is complete. This will be implicitly fired if the implementation returns failure from this interface method. The implementation must fire this method in all other scenarios.

Examines the portion of the stack which is from a particular DkmRuntimeInstance and returns frames from this runtime. IDkmMonitorStackWalk is used to do this walking on the target computer, and generally does this walk without symbols. It should be noted that accurate monitor stack walk generally requires either: 1. The runtime monitor to fully understand the calling convention of its underlying runtime AND the runtime employs some mechanism so that it doesn't need code from other runtimes which are on the stack to be walked. For example, the CLR maintains stack ranges so when managed code calls off into native, the CLR can still find the managed code without needing to walk through native. -or- 2. A uniform calling convention that all code needs to follow. For example, all code must follow a uniform calling convention on x64 and IA-64 versions of Windows. Microsoft will provide five implementations of IDkmMonitorStackWalk: 1. An implementation for ICorDebug v2 2. An implementation for ICorDebug v4 3. An implementation for x64/ia64 PDATA walking. 4. An implementation for ActiveScript. 5. A default implementation that bundles together unknown regions to be walked in the engine process. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, RuntimeId.

Initialize is invoked on each walker exactly once at the beginning of the walk process. This gives each walker a chance to initialize any state.

[In] DkmMonitorStackWalkContext allows the various components DkmSymbolStackWalkContext with this call stack. [In] Registers to attempt to walk from. [In] Size of the stack range that the debugger will attempt to walk through.

UpdatePosition is invoked by the stack merger after another walker has walked one or more frames, and so this walker must be updated before invoking WalkNextFrame. Runtimes that maintain their own internal stack range state within in the target process will likely have nothing to do within this method.

Attempt to walk the next stack frame. The DkmMonitorStackWalkResult structure indicates if this monitor was able to walk the frame.

[In] DkmMonitorStackWalkContext allows the various components DkmSymbolStackWalkContext with this call stack. [Out] Return result from IDkmMonitorStackWalk.

Called by Native IDkmSteppingCodePathDecoder implementer to enumerate Native CodePaths. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, RuntimeId, SymbolProviderId.

GetSteppingCallSites is called to get call sites reachable from an instruction.

[In] DkmNativeInstructionAddress is used for addresses that resolve to within a native module. This is used regardless as to if there are symbols for the module. [In] The stepping ranges to evaluate for call sites. [Out] DkmNativeSteppingCallSite[] specifies a call instruction and it's target..

IDkmOutOfBandExceptionNotification is implemented by components that want to listen for the OutOfBandException event. When this notification fires, the target process will be suspended and can be examined. The 'OutOfBandException' event provides notification from debug monitors about out-of-band exceptions which occur within the target process while managed/native interop debugging. This event notification is consumed by the exception manager. Out-of-band events can occur at any time (including when stopped) and must be continued immediately. OutOfBandException events can be suppressed by calling DkmEventDescriptorS.Suppress(). Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, ExceptionCategory, RuntimeId. This API was introduced in Visual Studio 11 Update 1 (DkmApiVersion.VS11FeaturePack1).

OnOutOfBandException is invoked as part of event processing. See interface definition for more information.

[In] Provides information about an exception which was raised in the target process. This information includes details of what exception was raised and the current stage of exception processing. WorkList to append additional event processing work to. This work list will begin execution after all listeners have been notifiied. The event will not finish until after the work list fully executes. [In] Describes the event being processed and provides the ability for a component to suppress this event.

Optional interface which can be implemented to customize the environment of the target process before it is started. It is possible to customize the environment from two points. From the IDE side, the caller of LaunchDebugTargets may specify an environment block. From the debug monitor side, this API can be implemented. This API is suggested if either the IDE side doesn't have enough information to correctly specify the environment, or if the extension doesn't control the call to LaunchDebugTargets. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: EngineId.

Obtains any environment variables which the extension would like to add.

[In] Settings supplied during a start debugging operation from a project system or other caller of LaunchDebugTargets (or various other start debugging APIs). [In] Enumeration of the scenarios where IDkmProcessLaunchEnvironmentFilter implementations are invoked. [Out,Optional] One or more environment variables which should be passed to the target process. Multiple variables are separated with an embedded null ('\0'). For example: "MyVariable1=1\0MyVariable2=12". Null or empty string are returned if the caller doesn't want to customize the environment block for this launch.

Optional interface which can be implemented to customize the environment of the target process before it is started. This is an updated version of IDkmProcessLaunchEnvironmentFilter which was added for Visual Studio 14.0 to provide additional information to environment filters. Visual Studio 14+ will call both the old and new API, so a component should generally not implement both interfaces. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: EngineId, TransportKind. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

Obtains any environment variables which the extension would like to add.

[In] DkmProcessLaunchEnvironmentFilterInputData is used to provide input to a IDkmProcessLaunchEnvironmentFilter140 implementation. It describes the process which is about to be started. [Out,Optional] One or more environment variables which should be passed to the target process. Multiple variables are separated with an embedded null ('\0'). For example: "MyVariable1=1\0MyVariable2=12". Null or empty string are returned if the caller doesn't want to customize the environment block for this launch.

Provides the ability to read or write a register value by CV constant. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, RuntimeId, TransportKind.

Sets the value of the register in the thread's context. Sub registers that are made up of larger registers are supported.

[In] The DkmRuntimeInstance class represents an execution environment which is loaded into a DkmProcess and which contains code to be debugged. [In] The stack frame the register is being set in. For most runtime instances, this is used to verify the stack frame is the top of the stack and stop the write if it isn't. [In] The CV constant of the register to set. [In] The value to set the register to. The size of the byte array must match the width of the register being set.

IDkmRuntimeSetNextStatement is the interface runtime monitors implement to support set next statement. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, RuntimeId, SymbolProviderId, TransportKind.

SetNextStatement moves the IP of a stack frame. The stack frame is always the leaf stack frame on a particular thread.

[In] DkmStackWalkFrame represents a frame on a call stack which has been walked, but may not have been formatted or filtered. Formatted frames are represented by DkmStackFrame instead. [In] Abstract representation of an executable code location (ex: EIP value). If resolved, an Instruction Address will be within a particular module instance. An Instruction Address is always within a particular Runtime Instance.

IDkmRuntimeStepper is the interface runtime monitors implement to support stepping. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, RuntimeId, TransportKind.

OwnsCurrentExecutionLocation is called by the stepping manager while it is searching for monitors to perform a step. If the current location in the debuggee is understood by this monitor it can return true here to take control of the step.

Step is called by the stepping manager after it determines this monitor is the correct monitor to perform the step.

StopStep is called by the stepping manager when the process is being continued to clear out any remaining stepping state for a stepper.

AfterSteppingArbitration is called by the stepping manager on the old controlling runtime instance after stepping arbitration is complete but before the next runtime instance starts stepping. This allows runtimes to clear any stepping state if another runtime took control. If no other runtime monitor claimed the current location, the original monitor should finish the step. This is indicated by NewControllingRuntimeInstance being null. For instance, a runtime instance may choose to step back out if a step-in landed in a location without symbols and no other runtime took control.

OnNewControllingRuntimeInstance is called by the stepping manager on all non-controlling runtime instances after step arbitration has selected a new controlling runtime instance.

StepControlRequested is called by the stepping manager when a non-controlling runtime instance detects that the thread has hit a transition into its runtime. If the current controlling runtime instance can stop stepping, it should set Granted to true. Actual control is not given until the requesting runtime calls DkmStepper.TakeStepControl. This two part process allows callers to request control of multiple steppers at the same time.

TakeStepControl is called by the stepping manager when a non-controlling runtime instance detects that the thread has hit a transition into its runtime. The stepping manager will forward the call to the current controlling runtime instance. The runtime instance requesting control should first call StepControlRequested on all steppers it wants control of. If they all set Granted to true, the runtime instance should then call this method on each stepper it is taking control of.

[In] The DkmRuntimeInstance class represents an execution environment which is loaded into a DkmProcess and which contains code to be debugged. [In] DkmStepper represents a request to step a thread. It facilitates shared object lifetime between the various runtime debug monitors that participate in stepping. [In] Set to true by the caller if it would like the current controlling runtime instance to leave guards in place to stop the step if necessary. For instance, this can be used to leave guard breakpoints after a call instruction so another runtime can step back out if the target of the call doesn't have source. However, any stepping state that affects the immediate step, such as trap flags, should be removed by the controlling runtime instance. [In] DkmStepArbitrationReason the reason step arbitration is occurring. [In] The calling runtime instance that wishes to take control of the step.

NotifyStepComplete is called by the stepping manager on all non-controlling runtime instances when a step is complete.

IDkmSingleStepCompleteNotification is implemented by components that want to listen for the SingleStepComplete event. IDkmSingleStepCompleteNotification is invoked after all implementations of IDkmSingleStepCompleteReceived. When this notification is called, the target process is stopped and implementers are able to either inspect the process or cause it to execute in a controlled manner (slip, func-eval). Sent when single stepping a thread is complete. SingleStepComplete events can be suppressed by calling DkmEventDescriptorS.Suppress(). Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, SourceId.

OnSingleStepComplete is invoked as part of event processing. See interface definition for more information.

[In] DkmSingleStepRequest represents a request to single step a thread. [In] Describes the event being processed and provides the ability for a component to suppress this event.

IDkmSingleStepCompleteReceived is implemented by components that want to listen for the SingleStepComplete event. IDkmSingleStepCompleteReceived is invoked before IDkmSingleStepCompleteNotification. From within this notification, it is not possible to cause the target process to execute (no func-eval, no slipping). Sent when single stepping a thread is complete. SingleStepComplete events can be suppressed by calling DkmEventDescriptorS.Suppress(). Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, SourceId.

OnSingleStepCompleteReceived is invoked as part of event processing. See interface definition for more information.

[In] DkmSingleStepRequest represents a request to single step a thread. [In] Describes the event being processed and provides the ability for a component to suppress this event.

This interface is implemented by components that contribute stack frames, and wish to provide an additional inspection interface for expression evaluators and other components that need to inspect the stack frame. NOTE: The data container API should not be used from the implementation of the returned custom interface. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, RuntimeId, SymbolProviderId, TransportKind.

GetFrameInspectionInterface is used to obtain a ICorDebugFrame or other implementation-specific interfaces which a component can use to deeply inspect the stack frame. The returned interface may ONLY be used to inspect the target process, and should NEVER be used to control execution (no stepping, no breakpoints, no continue, etc). Doing so is unsupported and will result in undefined behavior. NOTE: Using this method from managed code is not recommended for performance reasons. Marshalling of DkmStackWalkFrame between native and managed code is expensive. Use DkmRuntimeInstance.GetFrameInspectionInterface instead.

[In] DkmStackWalkFrame represents a frame on a call stack which has been walked, but may not have been formatted or filtered. Formatted frames are represented by DkmStackFrame instead. [In] DkmInspectionSession allows the various components which inspect data to store private data which is associated with a group of evaluations. [In] The GUID of the desired interface. IID_ICorDebugFrame can be used to obtain the CorDebug frame interface for a managed frame. Other debug monitors or stack walkers may provide their own interface. [Out] Returned frame interface. This may be cast to the interface pointer corresponding to 'InterfaceID'.

This interface is implemented by the managed debug monitor and provides access to the ICorDebugFrame. NOTE: The data container API should not be used from the implementation of the returned custom interface. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, RuntimeId, TransportKind. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

[In] Represents a CLR instance running in a target process. [In] The thread the stack frame came from. [In] The frame base of the stack frame to get the inspection interface for. [In] The GUID of the desired interface. IID_ICorDebugFrame can be used to obtain the CorDebug frame interface for a managed frame. [Out] Returned frame interface. This may be cast to the interface pointer corresponding to 'InterfaceID'.

This interface is implemented by runtime debug monitors to return the most recent WinRT exception information on the given thread. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, TransportKind. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

GetThreadCurrentWinRtErrorInfo is used to get the address of the current IErrorInfo object for this thread.

[In] DkmThread represents a thread running in the target process. [Out,Optional] Address of the current IErrorInfo object on this thread.

Used to determine a thread's category. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, RuntimeId, TransportKind.

Gets the Display Properties of the Thread including the Display Name and Thread Category.

[In] The DkmRuntimeInstance class represents an execution environment which is loaded into a DkmProcess and which contains code to be debugged. WorkList which is currently being processed. This value can be used to check for cancelation or to append additional work. New work items will not begin executing until after this function returns. [In] The Thread. Routine to fire when the request is complete. This will be implicitly fired if the implementation returns failure from this interface method. The implementation must fire this method in all other scenarios.

Used to determine a thread's name. Does not return the thread's display name. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, RuntimeId, TransportKind.

Compute the name of a thread.

[In] The DkmRuntimeInstance class represents an execution environment which is loaded into a DkmProcess and which contains code to be debugged. [In] The Thread. [Out,Optional] The Thread Name.

This interface contains methods implemented by the symbol provider to allow debug monitors to search for binaries on symbol servers and local disks. This is required because the symbol server APIs are not thread safe and the symbol provider owns access to them. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, TransportKind.

This method will search the local disk and any configured symbol servers for a binary that matches the parameters. The path to this file on the local disk is returned. If the file was on a symbol server, it is downloaded to a cache and the local path is returned.

[In] DkmProcess represents a target process which is being debugged. The debugger debugs processes, so this is the basic unit of debugging. A DkmProcess can represent a system process or a virtual process such as minidumps. [In] The original path to the exe stored in the minidump. [In] The path to the dump file. [In] The original path to the binary stored in the minidump. [In] The time date stamp of the binary in the time_t format. [In] The size of the image. [Out,Optional] The path on the local disk of the local (or downloaded) binary.

Extends binary locator functionality. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, TransportKind. This API was introduced in Visual Studio 11 Update 1 (DkmApiVersion.VS11FeaturePack1).

Called to initiate locating of binaries whose images might not have previously found or attempted to be loaded. This method will search the local disk and any configured symbol servers for a binary that matches the parameters. The path to this file on the local disk is returned. If the file was on a symbol server, it is downloaded to a cache and the local path is returned.

[In] DkmProcess represents a target process which is being debugged. The debugger debugs processes, so this is the basic unit of debugging. A DkmProcess can represent a system process or a virtual process such as minidumps. [In] The original path to the exe stored in the minidump. [In] The path to the dump file. [In] The original path to the binary stored in the minidump. [In] The time date stamp of the binary in the time_t format. [In] The size of the image. [Out,Optional] The path on the local disk of the local (or downloaded) binary.

Provides symbols needed for formatting disassembly. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: CompilerVendorId, LanguageId, SymbolProviderId, TransportKind. This API was introduced in Visual Studio 16 Update 3 (DkmApiVersion.VS16Update3).

Gets the RVA of the function containing the specified RVA.

Gets the symbol name for the RVA.

Fetches the linker fixup records for the module.

Gets the symbol name for the RVA.

Gets the symbol name for a register relative value.

This API is used to retrieve source code documents that are embedded in a symbol file. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: RuntimeId, SymbolProviderId. This API was introduced in Visual Studio 15 Update 5 (DkmApiVersion.VS15Update5).

Returns the embedded document containing this symbol. Returns S_FALSE if the embedded document does not exist.

[In] DkmInstructionSymbol represents a method in the target process. [Out,Optional] DkmEmbeddedDocument represents a source file embedded in a symbol file.

This API is used in vsdbg scenarios to determine if a given instruction is in an embedded document without obtaining the content of the document. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: RuntimeId, SymbolProviderId. This API was introduced in Visual Studio 15 Update 8 (DkmApiVersion.VS15Update8).

Tests if the given symbol has an embedded document. Embedded documents are when a source file (ex: main.cs) is embedded inside the symbol file (ex: example.pdb).

[In] DkmInstructionSymbol represents a method in the target process. [Out] True if the instruction symbol is in an embedded document.

This API is used to determine the number of inline frames at a location. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: RuntimeId, SymbolProviderId. This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTMPreview).

Returns the number of inline frames at the given instruction symbol.

[In] DkmInstructionSymbol represents a method in the target process. [In] Flags passed to DkmInstructionSymbol.GetBasicInfo and GetInlineFramesCount. [Out] The number of inline frames at the given RVA and frame.

This API is used to read inline symbol information. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: RuntimeId, SymbolProviderId. This API was introduced in Visual Studio 15 RTM (DkmApiVersion.VS15RTM).

[In] DkmInstructionSymbol represents a method in the target process. [In] Provides which inline frame to use. [Out] True if this address is the first address in the line's range. False otherwise. [Out,Optional] Source code position which corresponds to a code element. The could represent a location which has been extracted from a symbol (PDB) file, or it could be the location of a breakpoint in the IDE.

Interface to provide runtime-specific operations for instruction addresses. For native and managed instructions, this service is provided by the symbol provider. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, RuntimeId, SymbolProviderId.

Compares two instruction addresses and determines if they are within the same function.

[In] Abstract representation of an executable code location (ex: EIP value). If resolved, an Instruction Address will be within a particular module instance. An Instruction Address is always within a particular Runtime Instance. [In] An address to compare with this address. [Out] True if the two addresses are from the same function.

Interface implemented to provide Just-My-Code status for modules. To support the modules window, this interface should be implemented in an IDE component, but it can also be implemented on the monitor side if this is useful. Microsoft implements this interface on the monitor side for managed code, but not native. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, RuntimeId, SymbolProviderId, TransportKind. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

Determines if a module is considered user code.

This API is used to undecorate symbol names. Microsoft provides an implementation of this to undecorate symbol names in PDBs. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: CompilerVendorId, LanguageId, SymbolProviderId, TransportKind.

Undecorates a symbol name.

Determines if a given instruction address is user code or not.

[In] DkmNativeInstructionAddress is used for addresses that resolve to within a native module. This is used regardless as to if there are symbols for the module. WorkList which is currently being processed. This value can be used to check for cancelation or to append additional work. New work items will not begin executing until after this function returns. Routine to fire when the request is complete. This will be implicitly fired if the implementation returns failure from this interface method. The implementation must fire this method in all other scenarios.

Callback interface which is implemented by the PDB symbol provider for returning information about symbols to the base debug monitor. This interface should generally be implemented on the Visual Studio computer. Debug monitor side implementations may not be called. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: SymbolProviderId.

Returns address information to the native debug monitor.

[In] DkmNativeInstructionSymbol represents a native instruction within a module of the target process. DkmNativeInstructionSymbol are 1:1 with the underlying native instructions. So if there are two template instantiations of a method (ex: MyMethod<CString> and MyMethod<int>) if the linker merges the two instantiations into a single function through COMDAT folding then the methods will be identical. If the linker isn't able to merge the two instantiations then both user-level functions will appear as one DkmNativeInstructionSymbol. [In,Optional] Abstract representation of an executable code location (ex: EIP value). If resolved, an Instruction Address will be within a particular module instance. An Instruction Address is always within a particular Runtime Instance. [Out,Optional] DkmNativeAddressMetadata represents symbol based metadata about addresses. This includes if the address is a thunk, a prolog, or a trampoline.

Return the RVA for an S_PUBLIC32 for a particular name by string.

Optional interface that may be implemented by native symbol providers and consumed by the native DM to allow stepping. If not implemented, the native DM will fall back to IDkmNativeSymbolProviderCallback.GetNativeInstructionMetadataCallback and IDkmSymbolProviderCallback.GetSteppingRanges. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: RuntimeId, SymbolProviderId. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

Queries the symbol provider to determine the ranges of instructions which the base debug monitor should step through to implement a step.

[In] DkmNativeInstructionSymbol represents a native instruction within a module of the target process. DkmNativeInstructionSymbol are 1:1 with the underlying native instructions. So if there are two template instantiations of a method (ex: MyMethod<CString> and MyMethod<int>) if the linker merges the two instantiations into a single function through COMDAT folding then the methods will be identical. If the linker isn't able to merge the two instantiations then both user-level functions will appear as one DkmNativeInstructionSymbol. [In] Module instance which contains the current instruction symbol. [In,Optional] Instruction where the step began. May be null in unusual situations, such as beginning the step with no frames on the stack. Note that this is not necessarily a native instruction. [In] Indicates to the symbol provider the type of instructions to include in the 'no-step' regions. [In] True if the symbol provider should stop the stepping range when it encounters an inline functions. False otherwise. The Native DM will pass true for a step in so steps will stop in inline functions. It will pass false when doing a step-over so the stepper will not stop in inline functions. [Out] Array of ranges to step through. This array will be empty if there is no source information for the given instruction.

Called by the native DM to fetch data about an instruction which is used to decide how this instruction should be stepped.

[In] DkmNativeInstructionSymbol represents a native instruction within a module of the target process. DkmNativeInstructionSymbol are 1:1 with the underlying native instructions. So if there are two template instantiations of a method (ex: MyMethod<CString> and MyMethod<int>) if the linker merges the two instantiations into a single function through COMDAT folding then the methods will be identical. If the linker isn't able to merge the two instantiations then both user-level functions will appear as one DkmNativeInstructionSymbol. [In] Module instance which contains the current instruction symbol. [In,Optional] Instruction where the step began. May be null in unusual situations, such as beginning the step with no frames on the stack. Note that this is not necessarily a native instruction. [Out,Optional] DkmNativeAddressMetadata represents symbol based metadata about addresses. This includes if the address is a thunk, a prolog, or a trampoline.

Callback interface implemented by script symbol providers in order to support stepping customizations for languages that compile to JavaScript (or possibly other script languages as well). Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: RuntimeId, SymbolProviderId.

Call back implemented by the script symbol provider to tell the script debug monitor what to do next when stepping.

[In] DkmScriptInstructionSymbol is used to represent an executable statement in a script-based runtime environment such the Microsoft JavaScript engine. [In,Optional] The instruction symbol of the process at the time this step started. This will be NULL if the step originated on a thread with no frames. [In] true if the step is by line (instead of by statement). [Out] Enum value indicating the next action that the script dm should perform. NotImplementedException/E_NOTIMPL indicates that no symbol provider is available for the script symbol.

Allows the UI to query if the current instruction can be set to an address. Must be implemented on the Client side as it can be called in scenarios requiring a fast result such as dragging the IP in the debugger editor. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, RuntimeId, SymbolProviderId, TransportKind.

CanSetNextStatement determines if it is possible to move the IP of a stack frame. The stack frame is always the leaf stack frame on a particular thread. This API may only be implemented within the engine process. The Result out parameter should be S_OK or the value of a failed HRESULT that the UI can map to an error message.

[In] DkmStackWalkFrame represents a frame on a call stack which has been walked, but may not have been formatted or filtered. Formatted frames are represented by DkmStackFrame instead. [In] Abstract representation of an executable code location (ex: EIP value). If resolved, an Instruction Address will be within a particular module instance. An Instruction Address is always within a particular Runtime Instance. [Out] The error code to return to the UI. This should be S_OK or the value of a failed HRESULT that the UI can map to an error message.

This API is used to read Source Link information. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: CompilerVendorId, LanguageId, SymbolProviderId, TransportKind. This API was introduced in Visual Studio 15 RTM (DkmApiVersion.VS15RTM).

Returns SourceLink information from the symbol file for the requested file path.

This API is used to read information about source server data from a symbol provider. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: CompilerVendorId, LanguageId, SymbolProviderId, TransportKind.

Returns the contents of the source server stream data for a module if the stream exists.

Used by AD7 to get step into specific options. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: CompilerVendorId, LanguageId, RuntimeId, SymbolProviderId.

GetCodePaths is called to get step into specific targets.

[In] Object used for filtering for step into specific. [In] Specifies the current frame. [In] Specifies if code paths are for current statement or line. [Out] DkmSteppingCodePath[] represents a location that user can step to from current location.

Optional interface implemented by symbol providers that wish to provide multiple source mappings for the same instruction symbol - both a primary mapping, and a backup mapping in the case the primary document cannot be found. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: RuntimeId, SymbolProviderId. This API was introduced in Visual Studio 12 Update 3 (DkmApiVersion.VS12Update3).

[In] DkmInstructionSymbol represents a method in the target process. [In] Flags which affect the behavior of 'GetSourcePosition'. [Out] Associated source location for the instruction. Symbol provider doesn't support mapping this specified instruction to an alternate location.

This API is used to fetch the compiler id for a given symbol. It is implemented by symbol providers that support symbol stores where the binary may contain multiple languages. In other words, this interface only needs to be implemented when DkmModule.CompilerId is Guid.Empty/Guid.Empty. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: RuntimeId, SymbolProviderId.

Returns the compiler id (LanguageId/VendorId) of a given symbol. See DkmSymbol.GetCompilerId for a more detailed description.

[In] DkmInstructionSymbol represents a method in the target process. [In,Optional] A reference object describing the current inspection session. Common usage is for symbol providers to cache lookups using its data container. [Out] LanguageId/VendorId for the compiler which produced the code for this symbol. If this is unknown (ex: no symbols info for this block), both values will be Guid.Empty. Otherwise, both values should be non-zero.

Returns the compiler id (LanguageId/VendorId) of a given symbol. See DkmSymbol.GetCompilerId for a more detailed description.

This API is used to resolve symbols in the disassembly window. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: RuntimeId, SymbolProviderId.

Return the name of the symbol as it should appear in the disassembly window. For Microsoft C++ code, this is based on the public symbol name.

API implemented by symbol providers to allow the breakpoints manager and other components to query the collection of documents inside of a symbol store. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: CompilerVendorId, LanguageId, SymbolProviderId, TransportKind.

API implemented by symbol providers to allow the breakpoints manager and other components to query the 'document text span->symbol' map which is inside a symbol store. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: SymbolProviderId.

[In] Object which represents the result of a source file query against a symbol file (PDB). The resolved document object might encapsulate multiple document records with the symbol file. For example, in C++ compilation, each time that a header file is included there is another reference within the PDB. However, there is only one DkmResolvedDocument object for the header file. [In] The text range (lines/column) to search for. [In,Optional] The text to search for. When available, this will be provided if ResolvedDocument.TextRequested is set. [Out] The source location of each returned instruction symbol. The length of this array should be the same of the returned instruction symbol array. [Out] The found instruction symbols which are within the specified text span. E_TEXT_SPAN_NOT_LOADED indicates that TextSpan is not currently loaded in the specified script document. E_SCRIPT_SPAN_MAPPING_FAILED indicates that TextSpan could not be mapped to a location in the specified script document. E_SCRIPT_FILE_DIFFERENT_CONTENT indicates that the content in the script file loaded by the target process doesn't match the provided Text.

This API is used to retrieve raw bytes of the symbol file from the Remote side. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: CompilerVendorId, LanguageId, SymbolProviderId, TransportKind. This API was introduced in Visual Studio 14 Update 3 Micro Update (DkmApiVersion.VS14Update3MicroUpdate).

GetSymbolFileRawBytes is used to retrieve the raw bytes of a symbol file from the remote side. This is currently only supported for dynamic portable PDBs. This will return at most 10 MB.

This API is used to read information about a symbol. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: RuntimeId, SymbolProviderId.

Returns if this instruction symbol is in hidden code. For instance, in managed code, the line number 0xfeefee marks a source line as hidden.

[In] DkmInstructionSymbol represents a method in the target process. WorkList which is currently being processed. This value can be used to check for cancelation or to append additional work. New work items will not begin executing until after this function returns. [In] DkmInspectionSession allows the various components which inspect data to store private data which is associated with a group of evaluations. [In] Abstract representation of an executable code location (ex: EIP value). If resolved, an Instruction Address will be within a particular module instance. An Instruction Address is always within a particular Runtime Instance. Routine to fire when the request is complete. This will be implicitly fired if the implementation returns failure from this interface method. The implementation must fire this method in all other scenarios.

Interface implemented by symbol providers which deal with symbol search. In other words, this interface would not be implemented by symbol providers which deal only with symbol formats which are inside the debugged binary. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: SymbolProviderId, TransportKind.

Called to initiate loading of symbols for DkmModuleInstances whose symbols were not found when the module loaded.

Returns the path to the symbol file which backs a DkmModule object.

Obtain a localized a string description of the current symbol status.

Returns a string describing the various locations in which symbols were searched for, and the result of checking that location. This information is used to populate the 'Symbol Load Information' in the modules window.

Callback interface which is implemented by symbol providers to provide information from the symbol store to debug monitors. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: SymbolProviderId.

Queries the symbol provider to determine the ranges of instructions which the base debug monitor should step through to implement a step.

[In] DkmInstructionSymbol represents a method in the target process. [In] Indicates to the symbol provider the type of instructions to include in the 'no-step' regions. [In] True if the symbol provider should stop the stepping range when it encounters an inline functions. False otherwise. The Native DM will pass true for a step in so steps will stop in inline functions. It will pass false when doing a step-over so the stepper will not stop in inline functions. [Out] Array of ranges to step through. This array will be empty if there is no source information for the given instruction.

Queries the symbol provider to determine if we have line info. Used by debug monitor to decide if location can be considered user code.

[In] DkmInstructionSymbol represents a method in the target process. [Out] True if there is line info for this location.

GetEntryPointSymbols is used by the breakpoint manager to find the entry point symbol(s) in the launching executable. For managed code, this symbol is defined using ISymUnmanagedWriter::SetUserEntryPoint. For native code, this symbol is found by looking for the various 'main' function (main, WinMain, etc). A third can override the entry point either by implementing their own symbol provider or by implementing IDkmEntryPointQuery.

This method returns the IL offset range that contains the current IL offset as specified in the instruction address.

[In] DkmInstructionSymbol represents a method in the target process. [Out] A offset/size pair which is returned from the symbol provider to a debug monitor to indicate a range of instructions which the debugger should not stop at.

Search a module's symbols for a function with the specified name. Returns the RVA and size if it is found.

[In] DkmInstructionSymbol represents a method in the target process. [In] Flags which affect the behavior of 'GetSourcePosition'. [In,Optional] A reference object describing the current inspection session. Common usage is for symbol providers to cache lookups using its data container. [Out] True if this address is the first address in the line's range. False otherwise. [Out,Optional] Source code position which corresponds to a code element. The could represent a location which has been extracted from a symbol (PDB) file, or it could be the location of a breakpoint in the IDE.

Allows remote components to obtain source position information when the symbol provider is on the VS machine. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: RuntimeId, SymbolProviderId.

Determines if a frame is user or nonuser when such determination was not made when the frame was created. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, RuntimeId, SymbolProviderId, TransportKind. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

Determines whether or not a frame is user code.

[In] DkmStackWalkFrame represents a frame on a call stack which has been walked, but may not have been formatted or filtered. Formatted frames are represented by DkmStackFrame instead. [In,Optional] Optional inspection session which may be used for caching purposes. The same inspection session is reused when computing the user status of multiple frames in succession. [Out] True if the frame is library code that implements the throwing of exceptions. This will cause the frame to be collapsed if we are stopped here in response to an exception being thrown. [Out] True if the frame is user code, false if the frame is nonuser code.

IDkmAppDomainCreatedNotification is implemented by components that want to listen for the AppDomainCreated event. When this notification fires, the target process will be suspended and can be examined. AppDomainCreated is fired when an AppDomain is created by the target process. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, RuntimeId. This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTM).

OnAppDomainCreated is invoked as part of event processing. See interface definition for more information.

[In] DkmClrAppDomain represents a CLR app domain inside a process which is being debugged. WorkList to append additional event processing work to. This work list will begin execution after all listeners have been notifiied. The event will not finish until after the work list fully executes. [In] Describes the event being processed.

IDkmAppDomainUnloadedNotification is implemented by components that want to listen for the AppDomainUnloaded event. When this notification fires, the target process will be suspended and can be examined. AppDomainUnloaded is fired when an AppDomain is unloaded by the target process. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, RuntimeId. This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTM).

OnAppDomainUnloaded is invoked as part of event processing. See interface definition for more information.

IDkmAsyncBreakCompleteNotification is implemented by components that want to listen for the AsyncBreakComplete event. IDkmAsyncBreakCompleteNotification is invoked after all implementations of IDkmAsyncBreakCompleteReceived. When this notification is called, the target process is stopped and implementers are able to either inspect the process or cause it to execute in a controlled manner (slip, func-eval). Sent by a debug monitor after a request to async break the process has completed. AsyncBreakComplete events can be suppressed by calling DkmEventDescriptorS.Suppress(). Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, TransportKind.

OnAsyncBreakComplete is invoked as part of event processing. See interface definition for more information.

[In] DkmProcess represents a target process which is being debugged. The debugger debugs processes, so this is the basic unit of debugging. A DkmProcess can represent a system process or a virtual process such as minidumps. [In] Indicates the type of async-break that occurred. [In] DkmThread represents a thread running in the target process. [In] Describes the event being processed and provides the ability for a component to suppress this event.

IDkmAsyncBreakCompleteReceived is implemented by components that want to listen for the AsyncBreakComplete event. IDkmAsyncBreakCompleteReceived is invoked before IDkmAsyncBreakCompleteNotification. From within this notification, it is not possible to cause the target process to execute (no func-eval, no slipping). Sent by a debug monitor after a request to async break the process has completed. AsyncBreakComplete events can be suppressed by calling DkmEventDescriptorS.Suppress(). Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, TransportKind.

OnAsyncBreakCompleteReceived is invoked as part of event processing. See interface definition for more information.

[In] DkmProcess represents a target process which is being debugged. The debugger debugs processes, so this is the basic unit of debugging. A DkmProcess can represent a system process or a virtual process such as minidumps. [In] Indicates the type of async-break that occurred. [In] DkmThread represents a thread running in the target process. [In] Describes the event being processed and provides the ability for a component to suppress this event.

Provides notification that the process is about to continue execution. This function is called before any relevant steppers are initialized, so func-evals can be executed. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, TransportKind. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

Handler which is notified before the target process is resumed.

[In] DkmThread represents a thread running in the target process.

Provides notification that the process is about to be detached or terminated. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, TransportKind. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

Handler which is notified before the target process is terminated or detached.

IDkmBinaryLoadedNotification is implemented by components that want to listen for the BinaryLoaded event. When this notification fires, the target process will be suspended and can be examined. Indicates that we have successfully loaded the binary of a module in the minidump we are debugging. BinaryLoaded events can be suppressed by calling DkmEventDescriptorS.Suppress(). Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, RuntimeId, SymbolProviderId, TransportKind. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

OnBinaryLoaded is invoked as part of event processing. See interface definition for more information.

IDkmBinaryReloadOpportunityNotification is implemented by components that want to listen for the BinaryReloadOpportunity event. When this notification fires, the target process will be suspended and can be examined. While minidump debugging, raised by MinidumpBDM to relocate binary when user tries to manually load binary. BinaryReloadOpportunity events can be suppressed by calling DkmEventDescriptorS.Suppress(). Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, RuntimeId, SymbolProviderId, TransportKind. This API was introduced in Visual Studio 12 Update 2 (DkmApiVersion.VS12Update2).

OnBinaryReloadOpportunity is invoked as part of event processing. See interface definition for more information.

IDkmComputeKernelExitNotification is implemented by components that want to listen for the ComputeKernelExit event. The target process may continue to run during this notification. The event when a GPU compute kernel completes. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, TransportKind.

OnComputeKernelExit is invoked as part of event processing. See interface definition for more information.

[In] DkmGPUComputeKernel represents a GPU compute kernel running in the target process. [In] 32-bit value that the compute kernel returned on exit. [In] Describes the event being processed.

IDkmCustomStopNotification is implemented by components that want to listen for the CustomStop event. IDkmCustomStopNotification is invoked after all implementations of IDkmCustomStopReceived. When this notification is called, the target process is stopped and implementers are able to either inspect the process or cause it to execute in a controlled manner (slip, func-eval). The CustomStop event allows a concord component to raise a stopping event to a custom UI component or to a higher level Concord component. CustomStop events can be suppressed by calling DkmEventDescriptorS.Suppress(). Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, SourceId, TransportKind.

OnCustomStop is invoked as part of event processing. See interface definition for more information.

[In] Message structure used to pass information between custom debugger backend components and custom visual studio UI components (packages, add-ins, etc). [In] DkmThread represents a thread running in the target process. [In] Visual Studio service that this event should be sent to. A VS package must register this service id (ex: Software\Microsoft\VisualStudio\$(ver)\Services\{VsService}) and this package must implement the IVsCustomDebuggerStoppingEventHandler110 interface. [In] Describes the event being processed and provides the ability for a component to suppress this event.

IDkmCustomStopReceived is implemented by components that want to listen for the CustomStop event. IDkmCustomStopReceived is invoked before IDkmCustomStopNotification. From within this notification, it is not possible to cause the target process to execute (no func-eval, no slipping). The CustomStop event allows a concord component to raise a stopping event to a custom UI component or to a higher level Concord component. CustomStop events can be suppressed by calling DkmEventDescriptorS.Suppress(). Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, SourceId, TransportKind.

OnCustomStopReceived is invoked as part of event processing. See interface definition for more information.

IDkmEmbeddedBreakpointHitNotification is implemented by components that want to listen for the EmbeddedBreakpointHit event. IDkmEmbeddedBreakpointHitNotification is invoked after all implementations of IDkmEmbeddedBreakpointHitReceived. When this notification is called, the target process is stopped and implementers are able to either inspect the process or cause it to execute in a controlled manner (slip, func-eval). Sent by the exception manager when an embedded breakpoint exception is encountered. Components beneath the exception manager must listen for the platform specific exception event instead. EmbeddedBreakpointHit events can be suppressed. If this event reaches the AD7 layer, the debugger will enter break mode. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, TransportKind.

OnEmbeddedBreakpointHit is invoked as part of event processing. See interface definition for more information.

[In] DkmThread represents a thread running in the target process. [In,Optional] The address where the embedded breakpoint was hit. [In] If true, the UI will display an exception hit dialog for a breakpoint exception. If false, UI will simply break and the DkmInstructionAddress is not used. [In] Describes the event being processed and provides the ability for a component to suppress this event.

IDkmEmbeddedBreakpointHitReceived is implemented by components that want to listen for the EmbeddedBreakpointHit event. IDkmEmbeddedBreakpointHitReceived is invoked before IDkmEmbeddedBreakpointHitNotification. From within this notification, it is not possible to cause the target process to execute (no func-eval, no slipping). Sent by the exception manager when an embedded breakpoint exception is encountered. Components beneath the exception manager must listen for the platform specific exception event instead. EmbeddedBreakpointHit events can be suppressed. If this event reaches the AD7 layer, the debugger will enter break mode. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, TransportKind.

OnEmbeddedBreakpointHitReceived is invoked as part of event processing. See interface definition for more information.

IDkmExceptionTriggerHitNotification is implemented by components that want to listen for the ExceptionTriggerHit event. IDkmExceptionTriggerHitNotification is invoked after all implementations of IDkmExceptionTriggerHitReceived. When this notification is called, the target process is stopped and implementers are able to either inspect the process or cause it to execute in a controlled manner (slip, func-eval). The 'ExceptionTriggerHit' event provides notification that a previously set DkmExceptionTrigger has been met. ExceptionTriggerHit events can be suppressed by calling DkmEventDescriptorS.Suppress(). Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, ExceptionCategory, RuntimeId, SourceId.

OnExceptionTriggerHit is invoked as part of event processing. See interface definition for more information.

[In] Provides information about an exception trigger which was satisfied (hit) by an exception coming from the target process. [In] Describes the event being processed and provides the ability for a component to suppress this event.

IDkmExceptionTriggerHitReceived is implemented by components that want to listen for the ExceptionTriggerHit event. IDkmExceptionTriggerHitReceived is invoked before IDkmExceptionTriggerHitNotification. From within this notification, it is not possible to cause the target process to execute (no func-eval, no slipping). The 'ExceptionTriggerHit' event provides notification that a previously set DkmExceptionTrigger has been met. ExceptionTriggerHit events can be suppressed by calling DkmEventDescriptorS.Suppress(). Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, ExceptionCategory, RuntimeId, SourceId.

OnExceptionTriggerHitReceived is invoked as part of event processing. See interface definition for more information.

IDkmFuncEvalCompletedNotification is implemented by components that want to listen for the FuncEvalCompleted event. The target process may continue to run during this notification. The FuncEvalCompleted event is sent after a function evaluation has completed. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, TransportKind.

OnFuncEvalCompleted is invoked as part of event processing. See interface definition for more information.

[In] DkmThread represents a thread running in the target process. [In] Flags impacting how function evaluation requests are performed. [In] Describes the event being processed.

IDkmFuncEvalStartingNotification is implemented by components that want to listen for the FuncEvalStarting event. The target process may continue to run during this notification. The FuncEvalStarting event is sent just before a function evaluation is started. In the case of nested break state, each new function evaluation will trigger another FuncEvalStarting event. In this scenario, the target stops, and a user performs an evaluation from the immediate window which triggers a FuncEvalStarting event. The user hits a breakpoint within their evaluated function, the user does a second evaluation from there which triggers a second FuncEvalStarting event. The user lets both evaluations complete and this triggers two FuncEvalCompleted events. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, TransportKind.

OnFuncEvalStarting is invoked as part of event processing. See interface definition for more information.

[In] DkmThread represents a thread running in the target process. [In] Flags impacting how function evaluation requests are performed. [In] Describes the event being processed.

Interface implemented by components that want to find out when active (non-hidden) debugging of a hosting process (ex: my_app.vshost.exe) begins. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, TransportKind. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

This notification is called for hosting processes (processes that have DkmProcess.StartMethod == DkmStartMethod.AttachForHostingLaunch) when the user invokes an action that causes the debugger to begin active debugging of the process. The debugger will begin background debugging the hosting process soon after the solution opens. This notification gives components a chance to take some action just before active debugging begins.

IDkmInterceptExceptionCompletedNotification is implemented by components that want to listen for the InterceptExceptionCompleted event. IDkmInterceptExceptionCompletedNotification is invoked after all implementations of IDkmInterceptExceptionCompletedReceived. When this notification is called, the target process is stopped and implementers are able to either inspect the process or cause it to execute in a controlled manner (slip, func-eval). Sent by a debug monitor after an exception has been unwound to a specified frame. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, TransportKind.

OnInterceptExceptionCompleted is invoked as part of event processing. See interface definition for more information.

[In] DkmThread represents a thread running in the target process. [In] Cookie that was handed out when intercept exception request came in. [In] Describes the event being processed.

IDkmInterceptExceptionCompletedReceived is implemented by components that want to listen for the InterceptExceptionCompleted event. IDkmInterceptExceptionCompletedReceived is invoked before IDkmInterceptExceptionCompletedNotification. From within this notification, it is not possible to cause the target process to execute (no func-eval, no slipping). Sent by a debug monitor after an exception has been unwound to a specified frame. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, TransportKind.

OnInterceptExceptionCompletedReceived is invoked as part of event processing. See interface definition for more information.

[In] DkmThread represents a thread running in the target process. [In] Cookie that was handed out when intercept exception request came in. [In] Describes the event being processed.

IDkmLoadCompleteNotification is implemented by components that want to listen for the LoadComplete event. When this notification fires, the target process will be suspended and can be examined. LoadComplete is sent by the base debug monitor when launching or attaching to the process has completed. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, TransportKind.

OnLoadComplete is invoked as part of event processing. See interface definition for more information.

[In] DkmProcess represents a target process which is being debugged. The debugger debugs processes, so this is the basic unit of debugging. A DkmProcess can represent a system process or a virtual process such as minidumps. WorkList to append additional event processing work to. This work list will begin execution after all listeners have been notifiied. The event will not finish until after the work list fully executes. [In] Describes the event being processed.

IDkmModuleCreateNotification is implemented by components that want to listen for the ModuleCreate event. The target process may continue to run during this notification. ModuleCreate is sent when a symbol provider loads a new symbols, and thus a new DkmModule is created. A DkmModule will exist only for module instances that have symbols. ModuleCreate events can be suppressed. In this case the module will be invisible to components above the level where the module was suppressed. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: CompilerVendorId, LanguageId, SymbolProviderId, TransportKind.

OnModuleCreate is invoked as part of event processing. See interface definition for more information.

IDkmModuleInstanceLoadNotification is implemented by components that want to listen for the ModuleInstanceLoad event. When this notification fires, the target process will be suspended and can be examined. ModuleInstanceLoad is fired when a module is loaded by a target process. Among other things, this event is used for symbol providers to load symbols, and for the breakpoint manager to set breakpoints. ModuleInstanceLoad fires for all modules, even if there are no symbols loaded. ModuleInstanceLoad events can be suppressed. In this case the module will be invisible to components above the level where the module was suppressed. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, RuntimeId, SymbolProviderId, TransportKind.

OnModuleInstanceLoad is invoked as part of event processing. See interface definition for more information.

IDkmModuleInstanceUnloadNotification is implemented by components that want to listen for the ModuleInstanceUnload event. When this notification fires, the target process will be suspended and can be examined. ModuleInstanceUnload is sent when the monitor detects that a module has unloaded from within the target process. ModuleInstanceUnload events cannot be suppressed. However, if the ModuleLoad event was suppressed then ModuleUnload will stop processing at the level where ModuleLoad was suppressed. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, RuntimeId, SymbolProviderId, TransportKind.

OnModuleInstanceUnload is invoked as part of event processing. See interface definition for more information.

Components should implement this interface to be informed of when a module changes due to EnC or dynamically emitted code. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, RuntimeId, SymbolProviderId, TransportKind. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

This method is called when a module changes due to EnC or dynamically emitted code.

IDkmModuleSymbolsLoadedNotification is implemented by components that want to listen for the ModuleSymbolsLoaded event. When this notification fires, the target process will be suspended and can be examined. ModuleSymbolsLoaded is sent after symbols have been loaded for a particular module instance. This is sent either when symbols are loaded as a dll/exe loads in the target process, or after the user asks to reload symbols. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, RuntimeId, SymbolProviderId, TransportKind.

OnModuleSymbolsLoaded is invoked as part of event processing. See interface definition for more information.

[In] The Module Instance class represent a code bundle (ex: dll or exe) which is loaded into a particular process at a particular location. Module Instance objects are 1:1 with the execution environment's notion of a code bundle. For example, in native code, Module Instance objects are 1:1 with base address. [In] The DkmModule class represents a code bundle (ex: dll or exe) which is or once was loaded into one or more processes. The DkmModule class is the central object to the symbol APIs, and is 1:1 with the symbol handler's notation of what is loaded. If a code bundle loads into three different processes (or the same process but with three different base addresses or three different app domains) but the symbol handler thinks of all of these as being identical, there will be only one module object. [In] True if symbols are being reloaded for an existing module, False if this is happening as part of module load processing. WorkList to append additional event processing work to. This work list will begin execution after all listeners have been notifiied. The event will not finish until after the work list fully executes. [In] Describes the event being processed.

IDkmModuleSymbolsUpdatedNotification is implemented by components that want to listen for the ModuleSymbolsUpdated event. When this notification fires, the target process will be suspended and can be examined. ModuleSymbolsUpdated is sent by a debug monitor when dynamic code in the target process updates the symbol state. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, RuntimeId, SymbolProviderId, TransportKind.

OnModuleSymbolsUpdated is invoked as part of event processing. See interface definition for more information.

[In] The Module Instance class represent a code bundle (ex: dll or exe) which is loaded into a particular process at a particular location. Module Instance objects are 1:1 with the execution environment's notion of a code bundle. For example, in native code, Module Instance objects are 1:1 with base address. [In] The DkmModule class represents a code bundle (ex: dll or exe) which is or once was loaded into one or more processes. The DkmModule class is the central object to the symbol APIs, and is 1:1 with the symbol handler's notation of what is loaded. If a code bundle loads into three different processes (or the same process but with three different base addresses or three different app domains) but the symbol handler thinks of all of these as being identical, there will be only one module object. WorkList to append additional event processing work to. This work list will begin execution after all listeners have been notifiied. The event will not finish until after the work list fully executes. [In] Describes the event being processed.

Interface implemented by components to listen to Native ENC notifications. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, RuntimeId, SymbolProviderId, TransportKind. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

Fired from the Native ENC engine after an edit has been committed.

[In] 'DkmNativeModuleInstance' is used for modules which contain CPU code and/or are loaded by the Win32 loader.

Provides notification when the target process is about to be resumed from an out of band debug event while doing managed-native interop debugging on the in-process pipeline. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, TransportKind. This API was introduced in Visual Studio 11 Update 1 (DkmApiVersion.VS11FeaturePack1).

Handler which is notified before the target process is resumed.

Provides notification when the target process is about to be resumed. This will be fired after the user hits F5, begins a func-eval, a pausing event is complete (ex: module load) or a stopping event is complete. This primary purpose of this event is to allow components to flush any caches that they have. This notification may be fired from any thread, but will not be fired reentrantly. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, TransportKind.

Handler which is notified before the target process is resumed.

IDkmProcessCreateNotification is implemented by components that want to listen for the ProcessCreate event. When this notification fires, the target process will be suspended and can be examined. ProcessCreate is fired when a DkmProcess object is created. This indicates that the debugger has started attaching to the specified process. In launch scenarios, this event is fired before any code in the target process is allowed to run. Implementations can only crudely filter based on the type of code in the target process, and handlers also will run while the UI thread is blocked waiting for the engine to return. For these reasons, is is often better to listen for the RuntimeInstanceLoad event instead. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, TransportKind.

OnProcessCreate is invoked as part of event processing. See interface definition for more information.

[In] DkmProcess represents a target process which is being debugged. The debugger debugs processes, so this is the basic unit of debugging. A DkmProcess can represent a system process or a virtual process such as minidumps. WorkList to append additional event processing work to. This work list will begin execution after all listeners have been notifiied. The event will not finish until after the work list fully executes. [In] Describes the event being processed.

Provides notification that the process is about to pause or resume execution. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, TransportKind. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

Handler which is notified before the target process is paused. A process becomes paused when it hits a stopping event (such as user-set or internal breakpoint), or raises a pausing event (e.g. module load). It is not considered paused when it raises output debug strings, or other non-pausing events.

Handler which is notified before the target process is resumed. A process is resumed when the pausing event finishes processing, when the internal breakpoint is continued, or if the UI entered break mode, when the user decides to continue.

IDkmProcessExitNotification is implemented by components that want to listen for the ProcessExit event. The target process may continue to run during this notification. ProcessExit is fired when the debugger is no longer debugging the specified process. This can either be because the debugger has detached from the specified process or because the process exited. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, TransportKind.

OnProcessExit is invoked as part of event processing. See interface definition for more information.

[In] DkmProcess represents a target process which is being debugged. The debugger debugs processes, so this is the basic unit of debugging. A DkmProcess can represent a system process or a virtual process such as minidumps. [In] 32-bit value which the processed returned on exit. This is the same value that would be reported from the kernel32!GetExitCodeProcess. [In] Describes the event being processed.

IDkmProcessSnapshotAddedNotification is implemented by components that want to listen for the ProcessSnapshotAdded event. The target process may continue to run during this notification. ProcessSnapshotAdded is fired when a DkmProcessSnapshot is created and added to the associated DkmProcess. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, TransportKind. This API was introduced in Visual Studio 15 Update 6 (DkmApiVersion.VS15Update6).

OnProcessSnapshotAdded is invoked as part of event processing. See interface definition for more information.

IDkmProcessSnapshotRemovedNotification is implemented by components that want to listen for the ProcessSnapshotRemoved event. The target process may continue to run during this notification. ProcessSnapshotRemoved is fired when a DkmProcessSnapshot is removed from the associated DkmProcess. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, TransportKind. This API was introduced in Visual Studio 15 Update 6 (DkmApiVersion.VS15Update6).

OnProcessSnapshotRemoved is invoked as part of event processing. See interface definition for more information.

IDkmRecordedProcessQueryUpdatedNotification is implemented by components that want to listen for the RecordedProcessQueryUpdated event. When this notification fires, the target process will be suspended and can be examined. Notification that the internal data associated with a process query has been updated. Enables, for example, rebinding of breakpoints. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId. This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTM).

OnRecordedProcessQueryUpdated is invoked as part of event processing. See interface definition for more information.

[In] Provides facilities to record data from a recorded process. WorkList to append additional event processing work to. This work list will begin execution after all listeners have been notifiied. The event will not finish until after the work list fully executes. [In] Describes the event being processed.

IDkmRuntimeBreakpointConditionFailedNotification is implemented by components that want to listen for the RuntimeBreakpointConditionFailed event. IDkmRuntimeBreakpointConditionFailedNotification is invoked after all implementations of IDkmRuntimeBreakpointConditionFailedReceived. When this notification is called, the target process is stopped and implementers are able to either inspect the process or cause it to execute in a controlled manner (slip, func-eval). Provides a notification that a runtime breakpoint was hit, but a breakpoint condition encounters a runtime error. RuntimeBreakpointConditionFailed events can be suppressed by calling DkmEventDescriptorS.Suppress(). Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, RuntimeId, SourceId. This API was introduced in Visual Studio 16 Update 3 (DkmApiVersion.VS16Update3).

OnRuntimeBreakpointConditionFailed is invoked as part of event processing. See interface definition for more information.

[In] Low-level breakpoint object which is supported by debug monitors. [In] The thread of the stack frame of the target process. [In,Optional] The message to display to the user. [In] Failure code explaining why the IL-based breakpoint query failed to execute. [In] Describes the event being processed and provides the ability for a component to suppress this event.

IDkmRuntimeBreakpointConditionFailedReceived is implemented by components that want to listen for the RuntimeBreakpointConditionFailed event. IDkmRuntimeBreakpointConditionFailedReceived is invoked before IDkmRuntimeBreakpointConditionFailedNotification. From within this notification, it is not possible to cause the target process to execute (no func-eval, no slipping). Provides a notification that a runtime breakpoint was hit, but a breakpoint condition encounters a runtime error. RuntimeBreakpointConditionFailed events can be suppressed by calling DkmEventDescriptorS.Suppress(). Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, RuntimeId, SourceId. This API was introduced in Visual Studio 16 Update 3 (DkmApiVersion.VS16Update3).

OnRuntimeBreakpointConditionFailedReceived is invoked as part of event processing. See interface definition for more information.

IDkmRuntimeBreakpointHitWithErrorNotification is implemented by components that want to listen for the RuntimeBreakpointHitWithError event. IDkmRuntimeBreakpointHitWithErrorNotification is invoked after all implementations of IDkmRuntimeBreakpointHitWithErrorReceived. When this notification is called, the target process is stopped and implementers are able to either inspect the process or cause it to execute in a controlled manner (slip, func-eval). Provides a notification that a runtime breakpoint was hit, but processing resulted in a non-recoverable error. The process is now stopped and the breakpoint is now in an error state and will not be hit again. RuntimeBreakpointHitWithError events can be suppressed by calling DkmEventDescriptorS.Suppress(). Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, RuntimeId, SourceId. This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTM).

OnRuntimeBreakpointHitWithError is invoked as part of event processing. See interface definition for more information.

[In] Low-level breakpoint object which is supported by debug monitors. [In] DkmThread represents a thread running in the target process. [In] Contains true if the source runtime instance can determine that an exception is in flight on the thread which hit the breakpoint. Currently, only managed runtime instances ever set this. This is used to quickly determine if exception specific logic should apply without making another network round-trip. [In] Describes the severity of a message sent from a breakpoint manager back to the source component. This list is sorted in order of priority, as the UI will only display the most important warning. All warnings are ignored if the breakpoint is bound. [In] The error message to be reported. [In] Describes the event being processed and provides the ability for a component to suppress this event.

IDkmRuntimeBreakpointHitWithErrorReceived is implemented by components that want to listen for the RuntimeBreakpointHitWithError event. IDkmRuntimeBreakpointHitWithErrorReceived is invoked before IDkmRuntimeBreakpointHitWithErrorNotification. From within this notification, it is not possible to cause the target process to execute (no func-eval, no slipping). Provides a notification that a runtime breakpoint was hit, but processing resulted in a non-recoverable error. The process is now stopped and the breakpoint is now in an error state and will not be hit again. RuntimeBreakpointHitWithError events can be suppressed by calling DkmEventDescriptorS.Suppress(). Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, RuntimeId, SourceId. This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTM).

OnRuntimeBreakpointHitWithErrorReceived is invoked as part of event processing. See interface definition for more information.

IDkmRuntimeBreakpointNotification is implemented by components that want to listen for the RuntimeBreakpoint event. IDkmRuntimeBreakpointNotification is invoked after all implementations of IDkmRuntimeBreakpointReceived. When this notification is called, the target process is stopped and implementers are able to either inspect the process or cause it to execute in a controlled manner (slip, func-eval). Provides notification that a runtime breakpoint (DkmRuntimeBreakpoint) has been hit. Runtime breakpoints are the low-level breakpoint objects. Notification for the higher level breakpoints (DkmPendingBreakpoint/DkmBoundBreakpoint) is obtained through the BoundBreakpointHit event. RuntimeBreakpoint events can be suppressed by calling DkmEventDescriptorS.Suppress(). Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, RuntimeId, SourceId.

OnRuntimeBreakpoint is invoked as part of event processing. See interface definition for more information.

IDkmRuntimeBreakpointReceived is implemented by components that want to listen for the RuntimeBreakpoint event. IDkmRuntimeBreakpointReceived is invoked before IDkmRuntimeBreakpointNotification. From within this notification, it is not possible to cause the target process to execute (no func-eval, no slipping). Provides notification that a runtime breakpoint (DkmRuntimeBreakpoint) has been hit. Runtime breakpoints are the low-level breakpoint objects. Notification for the higher level breakpoints (DkmPendingBreakpoint/DkmBoundBreakpoint) is obtained through the BoundBreakpointHit event. RuntimeBreakpoint events can be suppressed by calling DkmEventDescriptorS.Suppress(). Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, RuntimeId, SourceId.

OnRuntimeBreakpointReceived is invoked as part of event processing. See interface definition for more information.

IDkmRuntimeDataBreakpointHitNotification is implemented by components that want to listen for the RuntimeDataBreakpointHit event. IDkmRuntimeDataBreakpointHitNotification is invoked after all implementations of IDkmRuntimeDataBreakpointHitReceived. When this notification is called, the target process is stopped and implementers are able to either inspect the process or cause it to execute in a controlled manner (slip, func-eval). Provides notification that a runtime data breakpoint breakpoint has been hit. RuntimeDataBreakpointHit events can be suppressed by calling DkmEventDescriptorS.Suppress(). Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, RuntimeId, SourceId. This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTM).

OnRuntimeDataBreakpointHit is invoked as part of event processing. See interface definition for more information.

[In] Low-level breakpoint object which is supported by debug monitors. [In] DkmThread represents a thread running in the target process. [In] Contains true if the source runtime instance can determine that an exception is in flight on the thread which hit the breakpoint. Currently, only managed runtime instances ever set this. This is used to quickly determine if exception specific logic should apply without making another network round-trip. [In] The additional message to show to the user. [In] Describes the event being processed and provides the ability for a component to suppress this event.

IDkmRuntimeDataBreakpointHitReceived is implemented by components that want to listen for the RuntimeDataBreakpointHit event. IDkmRuntimeDataBreakpointHitReceived is invoked before IDkmRuntimeDataBreakpointHitNotification. From within this notification, it is not possible to cause the target process to execute (no func-eval, no slipping). Provides notification that a runtime data breakpoint breakpoint has been hit. RuntimeDataBreakpointHit events can be suppressed by calling DkmEventDescriptorS.Suppress(). Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, RuntimeId, SourceId. This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTM).

OnRuntimeDataBreakpointHitReceived is invoked as part of event processing. See interface definition for more information.

[In] Low-level breakpoint object which is supported by debug monitors. [In] DkmThread represents a thread running in the target process. [In] Contains true if the source runtime instance can determine that an exception is in flight on the thread which hit the breakpoint. Currently, only managed runtime instances ever set this. This is used to quickly determine if exception specific logic should apply without making another network round-trip. [In] The additional message to show to the user. [In] Describes the event being processed and provides the ability for a component to suppress this event.

IDkmRuntimeInstanceLoadCompleteNotification is implemented by components that want to listen for the RuntimeInstanceLoadComplete event. When this notification fires, the target process will be suspended and can be examined. RuntimeInstanceLoadComplete is sent by the base debug monitor when launching or attaching to the process has completed. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, RuntimeId, TransportKind. This API was introduced in Visual Studio 12 Update 2 (DkmApiVersion.VS12Update2).

OnRuntimeInstanceLoadComplete is invoked as part of event processing. See interface definition for more information.

[In] The DkmRuntimeInstance class represents an execution environment which is loaded into a DkmProcess and which contains code to be debugged. WorkList to append additional event processing work to. This work list will begin execution after all listeners have been notifiied. The event will not finish until after the work list fully executes. [In] Describes the event being processed.

IDkmRuntimeInstanceLoadNotification is implemented by components that want to listen for the RuntimeInstanceLoad event. The target process may continue to run during this notification. RuntimeInstanceLoad is fired when a DkmRuntimeInstance object is created. This event can be used to detect that a particular type of code (ex: native) is now being debugged in this target process. In launch scenarios, the RuntimeInstanceLoad event will be fired before any code of the specified type has a chance to run in the target process. When debugging native code, this includes all code in the target process. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, RuntimeId, TransportKind.

OnRuntimeInstanceLoad is invoked as part of event processing. See interface definition for more information.

[In] The DkmRuntimeInstance class represents an execution environment which is loaded into a DkmProcess and which contains code to be debugged. [In] Describes the event being processed.

IDkmRuntimeInstanceUnloadNotification is implemented by components that want to listen for the RuntimeInstanceUnload event. The target process may continue to run during this notification. RuntimeInstanceUnload is fired when an execution environment unloads from the target process. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, RuntimeId, TransportKind.

OnRuntimeInstanceUnload is invoked as part of event processing. See interface definition for more information.

[In] The DkmRuntimeInstance class represents an execution environment which is loaded into a DkmProcess and which contains code to be debugged. [In] Describes the event being processed.

IDkmScriptDocumentContentInsertNotification is implemented by components that want to listen for the ScriptDocumentContentInsert event. The target process may continue to run during this notification. Notification that new content has been added to the target process. For aggregate documents (DkmScriptDocumentFlags.AggregateDocument is set), this is a new document section. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, RuntimeId, SymbolProviderId.

OnScriptDocumentContentInsert is invoked as part of event processing. See interface definition for more information.

[In] Represents a document which is executing in a script runtime environment. For example, the Microsoft JavaScript engine. [In] The text span of the inserted text. For aggregate documents (DkmScriptDocumentFlags.AggregateDocument is set), this must start on a new line, and at at the end of a line immediately before a new section would begin. [In] The new text content which is inserted into the document. [In] Describes the event being processed.

IDkmScriptDocumentContentRemoveNotification is implemented by components that want to listen for the ScriptDocumentContentRemove event. The target process may continue to run during this notification. Notification that content has been removed from the target process. For aggregate documents (DkmScriptDocumentFlags.AggregateDocument is set), this will correspond to a deleted text section. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, RuntimeId, SymbolProviderId.

OnScriptDocumentContentRemove is invoked as part of event processing. See interface definition for more information.

[In] Represents a document which is executing in a script runtime environment. For example, the Microsoft JavaScript engine. [In] The text span of the removed text. For aggregate documents (DkmScriptDocumentFlags.AggregateDocument is set), this must start at the begging of a line, and correspond to a previously added section. [In] Number of characters within the section to remove. [In] Describes the event being processed.

IDkmScriptDocumentTreeNodeCreateNotification is implemented by components that want to listen for the ScriptDocumentTreeNodeCreate event. When this notification fires, the target process will be suspended and can be examined. Notification when a new DkmScriptDocumentTreeNode object is created. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, RuntimeId.

OnScriptDocumentTreeNodeCreate is invoked as part of event processing. See interface definition for more information.

[In] Represents a node in the 'Script Documents' virtual tree within solution explorer. Nodes may either be a virtual container, or they can be a document. In the latter case, they will be a DkmScriptDocument. WorkList to append additional event processing work to. This work list will begin execution after all listeners have been notifiied. The event will not finish until after the work list fully executes. [In] Describes the event being processed.

IDkmScriptDocumentTreeNodeUnloadNotification is implemented by components that want to listen for the ScriptDocumentTreeNodeUnload event. The target process may continue to run during this notification. Notification that a DkmScriptDocumentTreeNode has been unloaded from the target process. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, RuntimeId.

OnScriptDocumentTreeNodeUnload is invoked as part of event processing. See interface definition for more information.

IDkmScriptSymbolsUpdatedNotification is implemented by components that want to listen for the ScriptSymbolsUpdated event. When this notification fires, the target process will be suspended and can be examined. Notification that symbol state for one or more script documents have been updated. This is used to rebind breakpoints in script-based modules. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, RuntimeId, TransportKind.

OnScriptSymbolsUpdated is invoked as part of event processing. See interface definition for more information.

[In] Represents a script-based execution environment executing in a target process. [In] Set of documents which have been updated. WorkList to append additional event processing work to. This work list will begin execution after all listeners have been notifiied. The event will not finish until after the work list fully executes. [In] Describes the event being processed.

IDkmTaskProviderCreateNotification is implemented by components that want to listen for the TaskProviderCreate event. The target process may continue to run during this notification. Indicates that a task provider object has been created. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, RuntimeId, TaskProviderId.

OnTaskProviderCreate is invoked as part of event processing. See interface definition for more information.

[In] Represents a task provider which is loaded into the target process. [In] Describes the event being processed.

IDkmThreadCreateNotification is implemented by components that want to listen for the ThreadCreate event. When this notification fires, the target process will be suspended and can be examined. ThreadCreate is fired when a new thread starts in the target process. ThreadCreate events can be suppressed. In this case the thread will be invisible to components above the level where the thread was suppressed. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, TransportKind.

OnThreadCreate is invoked as part of event processing. See interface definition for more information.

[In] DkmThread represents a thread running in the target process. WorkList to append additional event processing work to. This work list will begin execution after all listeners have been notifiied. The event will not finish until after the work list fully executes. [In] Describes the event being processed and provides the ability for a component to suppress this event.

IDkmThreadExitNotification is implemented by components that want to listen for the ThreadExit event. The target process may continue to run during this notification. ThreadExit is fired when a thread in the target process exits. It will not be fired if the target process exits while the thread is still running. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, TransportKind.

OnThreadExit is invoked as part of event processing. See interface definition for more information.

[In] DkmThread represents a thread running in the target process. [In] 32-bit value that the process returned on exit. This is the same value that would be reported from the kernel32!GetExitCodeThread. [In] Describes the event being processed.

IDkmThreadNameChangeNotification is implemented by components that want to listen for the ThreadNameChange event. When this notification fires, the target process will be suspended and can be examined. ThreadNameChange is fired when a thread name is changed in the target process. Currently, this is only fired when Managed thread change their name. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, TransportKind. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

OnThreadNameChange is invoked as part of event processing. See interface definition for more information.

IDkmTraceTimeContextSetNotification is implemented by components that want to listen for the TraceTimeContextSet event. When this notification fires, the target process will be suspended and can be examined. Sent by a debug monitor after the time context for a time travel debug process has been set. TraceTimeContextSet events can be suppressed by calling DkmEventDescriptorS.Suppress(). Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, TransportKind. This API was introduced in Visual Studio 16 Update 2 (DkmApiVersion.VS16Update2).

OnTraceTimeContextSet is invoked as part of event processing. See interface definition for more information.

[In] DkmProcess represents a target process which is being debugged. The debugger debugs processes, so this is the basic unit of debugging. A DkmProcess can represent a system process or a virtual process such as minidumps. [In] A point of time within a time travel trace. The internal representation is an implementation detail of the creator. [In] A point of time within a time travel trace. The internal representation is an implementation detail of the creator. [In] A point of time within a time travel trace. The internal representation is an implementation detail of the creator. [In] DkmThread represents a thread running in the target process. WorkList to append additional event processing work to. This work list will begin execution after all listeners have been notifiied. The event will not finish until after the work list fully executes. [In] Describes the event being processed and provides the ability for a component to suppress this event.

IDkmAfterSetNextStatementNotification implemented by components that wish to receive notification after a set next statement completed. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, RuntimeId, SymbolProviderId, TransportKind.

[In] DkmStackWalkFrame represents a frame on a call stack which has been walked, but may not have been formatted or filtered. Formatted frames are represented by DkmStackFrame instead. [In] Abstract representation of an executable code location (ex: EIP value). If resolved, an Instruction Address will be within a particular module instance. An Instruction Address is always within a particular Runtime Instance.

Interface to update components when 'IsGpuRaceHazardsAllowSameSettingEnabled' is enabled or disabled. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId.

Called when 'IsGpuRaceHazardsAllowSameSettingEnabled' is changed.

[In] Contains the session-wide debug settings. There is one instance of this object per engine Guid (ex: one instance for COMPlusOnlyEng2, one instance for COMPlusNativeEng).

Interface to update components when JustMyCode is enabled or disabled. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId.

Called when 'IsJustMyCodeEnabled' is changed.

[In] Contains the session-wide debug settings. There is one instance of this object per engine Guid (ex: one instance for COMPlusOnlyEng2, one instance for COMPlusNativeEng).

Interface to update components when native debugging is enabled or disabled for a particular process. Note that for Visual Studio 11, native debugging cannot be enabled/disabled on the fly, but future versions may support this functionality. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, TransportKind.

Called when 'IsNativeDebuggingEnabled' is changed.

Interface to update components when 'IsNativeExportsEnabled' is enabled or disabled. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId.

Called when 'IsNativeExportsEnabled' is changed.

[In] Contains the session-wide debug settings. There is one instance of this object per engine Guid (ex: one instance for COMPlusOnlyEng2, one instance for COMPlusNativeEng).

Interface to update components when native JustMyCode stepping is enabled or disabled. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId. This API was introduced in Visual Studio 15 Update 8 (DkmApiVersion.VS15Update8).

Called when 'IsNativeJustMyCodeSteppingEnabled' is changed.

[In] Contains the session-wide debug settings. There is one instance of this object per engine Guid (ex: one instance for COMPlusOnlyEng2, one instance for COMPlusNativeEng).

Interface to update components when loading native symbols out of process is enabled or disabled. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId. This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTMPreview).

Called when 'AllowOutOfProcessSymbolLoading' is changed.

[In] Contains the session-wide debug settings. There is one instance of this object per engine Guid (ex: one instance for COMPlusOnlyEng2, one instance for COMPlusNativeEng).

Interface to update components when RequireFullTrustForSourceServer is enabled or disabled. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId.

Called when 'RequireFullTrustForSourceServer' is changed.

[In] Contains the session-wide debug settings. There is one instance of this object per engine Guid (ex: one instance for COMPlusOnlyEng2, one instance for COMPlusNativeEng).

Interface to update components when 'IsStepOverPropertiesAndOperatorsEnabled' is enabled or disabled. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId.

Called when 'IsStepOverPropertiesAndOperatorsEnabled' is changed.

[In] Contains the session-wide debug settings. There is one instance of this object per engine Guid (ex: one instance for COMPlusOnlyEng2, one instance for COMPlusNativeEng).

Interface to update components when 'IsSuppressOptimizationsEnabled' is enabled or disabled. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId.

Called when 'IsSuppressOptimizationsEnabled' is changed.

[In] Contains the session-wide debug settings. There is one instance of this object per engine Guid (ex: one instance for COMPlusOnlyEng2, one instance for COMPlusNativeEng).

Interface to update components when symbol settings change. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId.

Called when the symbol path is changed.

[In] Contains the session-wide debug settings. There is one instance of this object per engine Guid (ex: one instance for COMPlusOnlyEng2, one instance for COMPlusNativeEng).

Interface to update components when trace settings are changed. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

Called when 'TraceSettings' is changed.

[In] Contains the session-wide debug settings. There is one instance of this object per engine Guid (ex: one instance for COMPlusOnlyEng2, one instance for COMPlusNativeEng).

Provides a mechanism for the Base Debug Monitor and Native Debug Monitor to obtain information about the stack frames that may require symbol support. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, TransportKind.

GetCurrentFrameInfo is used to obtain the frame base and return address for the current context of the thread. This takes into account Frame Pointer Omission and if the current instruction pointer is in a prolog, epilog etc... NOTE: In some cases this will get it wrong if the frame has Frame Pointer Omission and there are no symbols loaded.

[In] DkmThread represents a thread running in the target process. [Out] The return address of the frame. [Out] The frame base of the frame. [Out] The vframe of the current frame. Only valid on x86.

Provides a mechanism for walking native stack frames using information from symbol files. This mechanism is used to walk any stack frames which could not be resolved on the target computer. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, SymbolProviderId.

Initialize is invoked on each walker exactly once at the beginning of the walk process. This gives each walker a chance to initialize any state.

[In] DkmSymbolStackWalkContext allows the various symbol providers which walk the call stack to store private data which is associated with this call stack. [In] Registers to attempt to walk from. [In] Size of the stack range that the debugger will attempt to walk through.

UpdatePosition is invoked by the stack provider after another walker has walked one or more frames, and so this walker must be updated before invoking WalkNextFrame.

Walk the next stack frame from the call stack.

[In] DkmSymbolStackWalkContext allows the various symbol providers which walk the call stack to store private data which is associated with this call stack. [Out,Optional] NextRegisters indicates the registers of the next frame (the caller of 'FrameObject'). It is used to invoke UpdatePosition if the next frame is owned by a different symbol provider. A null NextRegisters value indicates that the returned frame is the last frame of the call stack, so the stack walk will end here. [Out,Optional] Created frame object for the current registers.

Implemented by callers of DkmRuntimeBreakpoint.SetCompiledConditionPending to provide compiled conditions when a breakpoint is hit. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, RuntimeId, SourceId.

Call back invoked from the breakpoint condition processor to the breakpoint manager (or other component which calls SetCompiledConditionPending) when the breakpoint condition needs to be re-compiled for a new instruction address.

[In] Low-level breakpoint object which is supported by debug monitors. [In] The instruction address to compile the condition against. [Out] Operator to use when evaluating the condition. [Out,Optional] The compiled condition to be used for the specified instruction address. This value is null in the case that the condition failed to compile. In this case, the condition processor should stop on the breakpoint.

Call back invoked from the breakpoint condition processor to the breakpoint manager when a breakpoint condition encounters a runtime error.

[In] Low-level breakpoint object which is supported by debug monitors. [In] The message to display to the user.

Call back invoked from the breakpoint condition processor to the breakpoint manager when a breakpoint condition encounters a runtime error.

[In] Low-level breakpoint object which is supported by debug monitors. [In] Failure code explaining why the IL-based breakpoint query failed to execute.

This interface is implemented by the Breakpoint Manager component to provide the default handling for breakpoints. Other components in the system may also implement this interface to remap the meaning of breakpoints for certain languages. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, CompilerVendorId, EngineId, LanguageId, SourceId.

[In] High level breakpoint object which is tied to a user-level construct (ex: source file, function name) which may map to zero or more code-level constructs (DkmBoundBreakpoint) and which may be tracked over time. WorkList which is currently being processed. This value can be used to check for cancelation or to append additional work. New work items will not begin executing until after this function returns. Routine to fire when the request is complete. This will be implicitly fired if the implementation returns failure from this interface method. The implementation must fire this method in all other scenarios.

Disable the pending breakpoint object so that it will no longer fire. If the pending breakpoint is already bound, any bound breakpoints will be implicitly disabled.

[In] High level breakpoint object which is tied to a user-level construct (ex: source file, function name) which may map to zero or more code-level constructs (DkmBoundBreakpoint) and which may be tracked over time. WorkList which is currently being processed. This value can be used to check for cancelation or to append additional work. New work items will not begin executing until after this function returns. Routine to fire when the request is complete. This will be implicitly fired if the implementation returns failure from this interface method. The implementation must fire this method in all other scenarios.

[In] High level breakpoint object which is tied to a user-level construct (ex: source file, function name) which may map to zero or more code-level constructs (DkmBoundBreakpoint) and which may be tracked over time. WorkList which is currently being processed. This value can be used to check for cancelation or to append additional work. New work items will not begin executing until after this function returns. [In,Optional] Condition to apply to this breakpoint. This value may be 'null' if the caller wishes to remove the condition. Routine to fire when the request is complete. This will be implicitly fired if the implementation returns failure from this interface method. The implementation must fire this method in all other scenarios.

Enables the bound breakpoint so that it can be hit. If the bound breakpoint is already enabled, this operation has no effect.

[In] Represents a breakpoint which has been bound (resolved) to a particular code instruction address or a particular data element. For example, in C++ templates one could create a DkmPendingBreakpoint for a source line. The breakpoint manager would resolve it to zero (ex: module not loaded), one (ex: template is only used on 'int') or many (ex: template is used with many template arguments) location. Each location would have a DkmBoundBreakpoint object. WorkList which is currently being processed. This value can be used to check for cancelation or to append additional work. New work items will not begin executing until after this function returns. Routine to fire when the request is complete. This will be implicitly fired if the implementation returns failure from this interface method. The implementation must fire this method in all other scenarios.

Disable the bound breakpoint so that it will no longer hit. If the bound breakpoint is already disabled, this operation has no effect.

Query to determine if the bound breakpoint is enabled.

Initialize or update or clear the condition on a breakpoint. If the same breakpoint has both a language-level condition, and a hit count condition, the language-level condition is applied first.

Modifies the value for a breakpoint hit count.

Interface implemented by breakpoint managers which wish to receive notification when files are updated in the IDE. Implementations of this interface are always called (no filtering is supported). To reduce memory impact, it is suggested that this interface be implemented in a small dll, or that the implementation is configured with 'CallOnlyWhenLoaded="true"'.

Provides notification that one or more files containing breakpoints have been updated.

[In] Object used to send file update notifications to breakpoint managers. WorkList which is currently being processed. This value can be used to check for cancelation or to append additional work. New work items will not begin executing until after this function returns.

Allows a component to add additional annotation to the call stack or remove physical frames from the call stack. For performance reasons, stack frame filters are invoked prior to evaluation by expression evaluators. One example stack frame filter is to hide external code in the call stack. Frame filters that add async stack walk contexts must have a priority of Normal or above. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, TaskProviderId.

Provides a filter with the next stack frame. A filter can simply pass this frame on through, it can suppress the frame by returning nothing, or it can provide its own set of annotated frames. The stack provider will ignore NotImplementedException (E_NOTIMPL). All other errors will truncate stack walk.

Implemented by components that wish to receive custom messages from another Concord component. This is interface is similar to IDkmCustomMessageForwardReceiver, except that this method requires that the caller be at a lower level in the component hierarchy than the component that receives the notification (ex: Base Debug Monitor -> AD7 AL). Implementers of this interface typically use a SourceId filter. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, SourceId, TransportKind.

Sends a message to a listening component which is higher in the hierarchy.

[In] Message structure used to pass information between custom debugger backend components and custom visual studio UI components (packages, add-ins, etc). [Out,Optional] Message sent back from the implementation.

Implemented by components that wish to receive custom messages from the IDE or from another Concord component. This is interface is similar to IDkmCustomMessageCallbackReceiver, except that this method requires that the caller be at a higher level in the component hierarchy than the component that receives the (ex: AD7 AL -> Base Debug Monitor). Implementers of this interface typically use a SourceId filter. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, SourceId, TransportKind.

Sends a message to a listening component which is lower in the hierarchy.

Allows a library that implements exception objects that maintain a captured stack trace to expose this stack trace to the debugger. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, ExceptionCategory, RuntimeId. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

Obtains the captured stack trace associated with the exception, if one is available.

IDkmLaunchResumeProcess is used to launch and resume a process. It is called from the debug monitor in F5, and from the transport in Ctrl-F5. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, TransportKind.

This API is remote-able version of the Win32 CreateProcess API. The implementation will merge the environment block, process command line redirection and launch the process. Unless the NoDebug flag is used, CreateProcess will use the DEBUG_PROCESS flag when creating the Win32 process.

[In] DkmProcessLaunchRequest is used to describe the process that debugger should launch. [In] Win32 process creation flags in addition to those found in the DkmProcessLaunchRequest.Win32Flags. This is often used to pass DEBUG_PROCESS (0x1), DEBUG_ONLY_THIS_PROCESS (0x2), or CREATE_SUSPENDED (0x4). [Out] DkmLaunchedProcessInfo is returned from APIs that launch a process.

This API is used to resume a process which was launched from CreateProcess with the LaunchSuspended flag set to true.

[In] DkmProcessLaunchRequest is used to describe the process that debugger should launch.

Extension to IDkmLaunchResumeProcess to support passing the created DkmProcess during resume. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, TransportKind. This API was introduced in Visual Studio 15 Update 3 (DkmApiVersion.VS15Update3).

This API is used to resume a process which was launched from CreateProcess with the LaunchSuspended flag set to true.

[In] DkmProcessLaunchRequest is used to describe the process that debugger should launch. [In] The process that should be resumed.

Provides the prefix text for a stack frame annotation. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: SourceId. This API was introduced in Visual Studio 15 Update 8 (DkmApiVersion.VS15Update8).

Gets formatted text associated with the annotation. This is prefixed to the frame name.

[In] A Guid / Value pair set by a frame filter or unwinder. Can be used to pass custom flags about the frame from one component to another. [In] The frame containing the annotation. [In] The options specifying the format of the frame. [Out,Optional] The annotation text.

IDkmBoundBreakpointHitNotification is implemented by components that want to listen for the BoundBreakpointHit event. IDkmBoundBreakpointHitNotification is invoked after all implementations of IDkmBoundBreakpointHitReceived. When this notification is called, the target process is stopped and implementers are able to either inspect the process or cause it to execute in a controlled manner (slip, func-eval). Provides notification that a bound breakpoint (DkmBoundBreakpoint) has been hit. Bound breakpoints are the high-level breakpoint objects. Notification for the low level breakpoints (DkmRuntimeBreakpoint) is obtained through the RuntimeBreakpoint event. BoundBreakpointHit events can be suppressed by calling DkmEventDescriptorS.Suppress(). Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, CompilerVendorId, EngineId, LanguageId, SourceId.

OnBoundBreakpointHit is invoked as part of event processing. See interface definition for more information.

[In] Represents a breakpoint which has been bound (resolved) to a particular code instruction address or a particular data element. For example, in C++ templates one could create a DkmPendingBreakpoint for a source line. The breakpoint manager would resolve it to zero (ex: module not loaded), one (ex: template is only used on 'int') or many (ex: template is used with many template arguments) location. Each location would have a DkmBoundBreakpoint object. [In] DkmThread represents a thread running in the target process. [In] Contains true if the source runtime instance can determine that an exception is in flight on the thread which hit the breakpoint. Currently, only managed runtime instances ever set this. This is used to quickly determine if exception specific logic should apply without making another network round-trip. [In] Describes the event being processed and provides the ability for a component to suppress this event.

IDkmBoundBreakpointHitReceived is implemented by components that want to listen for the BoundBreakpointHit event. IDkmBoundBreakpointHitReceived is invoked before IDkmBoundBreakpointHitNotification. From within this notification, it is not possible to cause the target process to execute (no func-eval, no slipping). Provides notification that a bound breakpoint (DkmBoundBreakpoint) has been hit. Bound breakpoints are the high-level breakpoint objects. Notification for the low level breakpoints (DkmRuntimeBreakpoint) is obtained through the RuntimeBreakpoint event. BoundBreakpointHit events can be suppressed by calling DkmEventDescriptorS.Suppress(). Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, CompilerVendorId, EngineId, LanguageId, SourceId.

OnBoundBreakpointHitReceived is invoked as part of event processing. See interface definition for more information.

[In] Represents a breakpoint which has been bound (resolved) to a particular code instruction address or a particular data element. For example, in C++ templates one could create a DkmPendingBreakpoint for a source line. The breakpoint manager would resolve it to zero (ex: module not loaded), one (ex: template is only used on 'int') or many (ex: template is used with many template arguments) location. Each location would have a DkmBoundBreakpoint object. [In] DkmThread represents a thread running in the target process. [In] Contains true if the source runtime instance can determine that an exception is in flight on the thread which hit the breakpoint. Currently, only managed runtime instances ever set this. This is used to quickly determine if exception specific logic should apply without making another network round-trip. [In] Describes the event being processed and provides the ability for a component to suppress this event.

IDkmBreakpointHitWithErrorNotification is implemented by components that want to listen for the BreakpointHitWithError event. IDkmBreakpointHitWithErrorNotification is invoked after all implementations of IDkmBreakpointHitWithErrorReceived. When this notification is called, the target process is stopped and implementers are able to either inspect the process or cause it to execute in a controlled manner (slip, func-eval). Provides a notification that a pending breakpoint was hit, but processing resulted in a non-recoverable error. The process is now stopped and the breakpoint is now in an error state and will not be hit again. BreakpointHitWithError events can be suppressed by calling DkmEventDescriptorS.Suppress(). Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, CompilerVendorId, EngineId, LanguageId, SourceId. This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTM).

OnBreakpointHitWithError is invoked as part of event processing. See interface definition for more information.

[In] High level breakpoint object which is tied to a user-level construct (ex: source file, function name) which may map to zero or more code-level constructs (DkmBoundBreakpoint) and which may be tracked over time. [In] DkmThread represents a thread running in the target process. [In] Contains true if the source runtime instance can determine that an exception is in flight on the thread which hit the breakpoint. Currently, only managed runtime instances ever set this. This is used to quickly determine if exception specific logic should apply without making another network round-trip. [In] Describes the severity of a message sent from a breakpoint manager back to the source component. This list is sorted in order of priority, as the UI will only display the most important warning. All warnings are ignored if the breakpoint is bound. [In] The error message to be reported. [In] Describes the event being processed and provides the ability for a component to suppress this event.

IDkmBreakpointHitWithErrorReceived is implemented by components that want to listen for the BreakpointHitWithError event. IDkmBreakpointHitWithErrorReceived is invoked before IDkmBreakpointHitWithErrorNotification. From within this notification, it is not possible to cause the target process to execute (no func-eval, no slipping). Provides a notification that a pending breakpoint was hit, but processing resulted in a non-recoverable error. The process is now stopped and the breakpoint is now in an error state and will not be hit again. BreakpointHitWithError events can be suppressed by calling DkmEventDescriptorS.Suppress(). Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, CompilerVendorId, EngineId, LanguageId, SourceId. This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTM).

OnBreakpointHitWithErrorReceived is invoked as part of event processing. See interface definition for more information.

[In] High level breakpoint object which is tied to a user-level construct (ex: source file, function name) which may map to zero or more code-level constructs (DkmBoundBreakpoint) and which may be tracked over time. [In] DkmThread represents a thread running in the target process. [In] Contains true if the source runtime instance can determine that an exception is in flight on the thread which hit the breakpoint. Currently, only managed runtime instances ever set this. This is used to quickly determine if exception specific logic should apply without making another network round-trip. [In] Describes the severity of a message sent from a breakpoint manager back to the source component. This list is sorted in order of priority, as the UI will only display the most important warning. All warnings are ignored if the breakpoint is bound. [In] The error message to be reported. [In] Describes the event being processed and provides the ability for a component to suppress this event.

This interface is implemented by components that add breakpoints to the breakpoint manager (such as the AD7 AL). This allows a component to be notified when the breakpoint manager binds a breakpoint or detects a breakpoint error or warning. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, CompilerVendorId, EngineId, LanguageId, SourceId.

Notification from the breakpoint manager when a breakpoint has been bound. In the case of user-set breakpoints, this notification will be sent to the AD7 AL, and the AD7 AL will fire a IDebugBreakpointBoundEvent2 to the Visual Studio Debugger UI.

[In] High level breakpoint object which is tied to a user-level construct (ex: source file, function name) which may map to zero or more code-level constructs (DkmBoundBreakpoint) and which may be tracked over time. [In] Represents a breakpoint which has been bound (resolved) to a particular code instruction address or a particular data element. For example, in C++ templates one could create a DkmPendingBreakpoint for a source line. The breakpoint manager would resolve it to zero (ex: module not loaded), one (ex: template is only used on 'int') or many (ex: template is used with many template arguments) location. Each location would have a DkmBoundBreakpoint object.

Notification from the breakpoint manager which indicates that the given breakpoint is being unbound.

[In] High level breakpoint object which is tied to a user-level construct (ex: source file, function name) which may map to zero or more code-level constructs (DkmBoundBreakpoint) and which may be tracked over time. [In] Represents a breakpoint which has been bound (resolved) to a particular code instruction address or a particular data element. For example, in C++ templates one could create a DkmPendingBreakpoint for a source line. The breakpoint manager would resolve it to zero (ex: module not loaded), one (ex: template is only used on 'int') or many (ex: template is used with many template arguments) location. Each location would have a DkmBoundBreakpoint object. [In] Describes the reason for a breakpoint to be unbound.

Notification from the breakpoint manager concerning the status of binding the breakpoint.

[In] High level breakpoint object which is tied to a user-level construct (ex: source file, function name) which may map to zero or more code-level constructs (DkmBoundBreakpoint) and which may be tracked over time. [In] Describes the severity of a message sent from a breakpoint manager back to the source component. This list is sorted in order of priority, as the UI will only display the most important warning. All warnings are ignored if the breakpoint is bound. [In] Message string to display to the user.

IDkmDataBreakpointHitNotification is implemented by components that want to listen for the DataBreakpointHit event. IDkmDataBreakpointHitNotification is invoked after all implementations of IDkmDataBreakpointHitReceived. When this notification is called, the target process is stopped and implementers are able to either inspect the process or cause it to execute in a controlled manner (slip, func-eval). Provides a notification that a pending breakpoint was hit, with extra data breakpoint information. The process is now stopped with additional information. DataBreakpointHit events can be suppressed by calling DkmEventDescriptorS.Suppress(). Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, CompilerVendorId, EngineId, LanguageId, SourceId. This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTM).

OnDataBreakpointHit is invoked as part of event processing. See interface definition for more information.

[In] Represents a breakpoint which has been bound (resolved) to a particular code instruction address or a particular data element. For example, in C++ templates one could create a DkmPendingBreakpoint for a source line. The breakpoint manager would resolve it to zero (ex: module not loaded), one (ex: template is only used on 'int') or many (ex: template is used with many template arguments) location. Each location would have a DkmBoundBreakpoint object. [In] DkmThread represents a thread running in the target process. [In] Contains true if the source runtime instance can determine that an exception is in flight on the thread which hit the breakpoint. Currently, only managed runtime instances ever set this. This is used to quickly determine if exception specific logic should apply without making another network round-trip. [In] The additional message to show to the user. [In] Describes the event being processed and provides the ability for a component to suppress this event.

IDkmDataBreakpointHitReceived is implemented by components that want to listen for the DataBreakpointHit event. IDkmDataBreakpointHitReceived is invoked before IDkmDataBreakpointHitNotification. From within this notification, it is not possible to cause the target process to execute (no func-eval, no slipping). Provides a notification that a pending breakpoint was hit, with extra data breakpoint information. The process is now stopped with additional information. DataBreakpointHit events can be suppressed by calling DkmEventDescriptorS.Suppress(). Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, CompilerVendorId, EngineId, LanguageId, SourceId. This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTM).

OnDataBreakpointHitReceived is invoked as part of event processing. See interface definition for more information.

[In] Represents a breakpoint which has been bound (resolved) to a particular code instruction address or a particular data element. For example, in C++ templates one could create a DkmPendingBreakpoint for a source line. The breakpoint manager would resolve it to zero (ex: module not loaded), one (ex: template is only used on 'int') or many (ex: template is used with many template arguments) location. Each location would have a DkmBoundBreakpoint object. [In] DkmThread represents a thread running in the target process. [In] Contains true if the source runtime instance can determine that an exception is in flight on the thread which hit the breakpoint. Currently, only managed runtime instances ever set this. This is used to quickly determine if exception specific logic should apply without making another network round-trip. [In] The additional message to show to the user. [In] Describes the event being processed and provides the ability for a component to suppress this event.

This interface is implemented by components that wish to add DkmPendingFileLineBreakpoint objects to the breakpoint manager. The breakpoint manager will query for the current location on the first bind and during an Edit-and-Continue apply. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, CompilerVendorId, EngineId, LanguageId, SourceId.

Returns the current location of a file/line breakpoint. In edit and continue scenarios, the location of the text marker may change within a debug session.

[In] Pending breakpoint which is requested to bind against code elements that point back to a text span within a source file. [Out] Source code position which corresponds to a code element. The could represent a location which has been extracted from a symbol (PDB) file, or it could be the location of a breakpoint in the IDE.

Returns the current text at the location of a file/line breakpoint.

[In] Pending breakpoint which is requested to bind against code elements that point back to a text span within a source file. [Out,Optional] The current source text.

Interface implemented by the Script DM to provide direct access to the target script runtime. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, RuntimeId, TransportKind.

Allows a caller to obtain a direct access to the IRemoteDebugApplication interface from the target process. This can be used to load dlls into the target application, or inspect the target application. Note that this should never be used for execution control, breakpoints, or evaluation.

[In] Represents a script-based execution environment executing in a target process. [Out] Debug application interface from the debugged process.

API which is called from break mode which tells the script runtime that execution should be aborted when resuming (BREAKRESUMEACTION_ABORT). This API requires an MSHTML v10+ target execution environment.

[In] Represents a script-based execution environment executing in a target process.

Interface to enumerate App Package information on the local or remote system. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: TransportKind.

Enumerates installed and launchable (App Packages with applications) App Packages.

Interface implemented on the target computer to handle evaluating breakpoint conditions and hit counts. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, RuntimeId, SourceId.

[In] Low-level breakpoint which is set on an instruction address. [In] Compiled query used to evaluate the condition. [In] Operator to use when evaluating the condition.

[In] Low-level breakpoint object which is supported by debug monitors.

Sets a breakpoint condition which is evaluated on the target computer. This is used for .NET languages.

[In] Low-level breakpoint object which is supported by debug monitors. [In] Conditions under which a breakpoint should fire. [Out,Optional] If the condition could not be parsed, this indicates the reason why. This value should be null if the compile succeeded.

Clear any compiled/evaluation condition associated with the specified DkmRuntimeBreakpoint. This method is implicitly called when the DkmRuntimeBreakpoint is closed.

[In] Low-level breakpoint object which is supported by debug monitors.

[In] Low-level breakpoint object which is supported by debug monitors. [In] Condition to apply to this breakpoint. [In] The initial value of the breakpoint's hit count. A value of -1/MAXDWORD indicates that the current hit count value should be preserved.

Clears the hit count condition on a breakpoint.

[In] Low-level breakpoint object which is supported by debug monitors. [In] Condition to apply to this breakpoint. [Out] Number of times that the breakpoint has been hit as of the time that the condition was removed.

Obtains the current hit count value for a DkmRuntimeBreakpoint which has a hit count condition. This function will fail if the DkmRuntimeBreakpoint does not currently have a hit count condition.

[In] Low-level breakpoint object which is supported by debug monitors. [Out] Number of times that the breakpoint has been hit.

Extension interface for GPU debugging, implemented on the target computer to handle evaluating breakpoint conditions. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, RuntimeId, SourceId.

[In] Low-level breakpoint which is set on an instruction address. [In] Compiled query used to evaluate the condition. [In] Operator to use when evaluating the condition.

Clear any condition associated with the specified DkmRuntimeInstructionBreakpoint.

[In] Low-level breakpoint which is set on an instruction address.

[In] Low-level breakpoint object which is supported by debug monitors. [In] The base debug monitor should re-send breakpoint event on this thread.

Interface implemented on the target computer to handle evaluating breakpoint conditions on all stopped threads and select the thread whose condition is true for GPU. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, RuntimeId, SourceId. This API was introduced in Visual Studio 11 Update 1 (DkmApiVersion.VS11FeaturePack1).

The base debug monitor asks the breakpoint condition processor to evaluate on all stopped threads, and selects the thread whose condition is true.

[In] Low-level breakpoint object which is supported by debug monitors. [In] The first stopped thread. [Out,Optional] The thread whose condition is true. The value is null in the case that no thread is found to have a true condition.

Interface to update name of the AppDomain. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, RuntimeId.

Called when 'Name' is changed.

[In] DkmClrAppDomain represents a CLR app domain inside a process which is being debugged.

IDkmClrDebugMonitorExceptionCaughtNotification is implemented by components that want to listen for the ClrDebugMonitorExceptionCaught event. When this notification fires, the target process will be suspended and can be examined. The 'ClrDebugMonitorExceptionCaught' event provides notification from the Managed Debug Monitor about a caught exception which occurred within the target process. This event is consumed by Diagnostic tools like IntelliTrace to be logged in their TraceDebugger.\n. ClrDebugMonitorExceptionCaught events can be suppressed by calling DkmEventDescriptorS.Suppress(). Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, RuntimeId. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

OnClrDebugMonitorExceptionCaught is invoked as part of event processing. See interface definition for more information.

[In] Provides information about an exception which was caught in the target process. This information includes details of the exception that was caught. WorkList to append additional event processing work to. This work list will begin execution after all listeners have been notifiied. The event will not finish until after the work list fully executes. [In] Describes the event being processed and provides the ability for a component to suppress this event.

Provide flow analysis helper operations for managed Edit and Continue. Implemented by the CLR Inspector, called from Managed EnC. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, RuntimeId, SymbolProviderId. This API was introduced in Visual Studio 16 Update 3 (DkmApiVersion.VS16Update3).

Internal helper method. Responsible for finding the list of eligible sequence points to be executed after the current address, similar to a step-over operation. It uses the latest metadata version for any of the module methods. Called from the Managed EnC after a break statement or an exception unwinding, for example.

[In] DkmClrInstructionAddress is used for addresses in managed code. [Out] List of IL offsets for each of the eligible sequence points. Empty if none is found.

Internal helper method. Responsible for finding all the leave instructions that target the address. Called from the Managed EnC when remapping exception unwinding, for example.

[In] DkmClrInstructionAddress is used for addresses in managed code. [In] IL code for the method of same version as the target address. This usually is the code before the latest change was made to that method. [Out] List of all the leave instruction offsets that target the address. Empty if none is found.

This interface allows managed code to remap the instruction pointer after edit and continue. Implemented by Managed EnC, called from ManagedDM. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, RuntimeId, SymbolProviderId, TransportKind. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

Remaps CLR instruction pointer after EnC sessions.

[In] 'DkmClrModuleInstance' is used for modules which are loaded into the Common Language Runtime. [In] Current thread. [In] Address prior to EnC update. [In] IL code of function prior to EnC. [In] Address that has the function token, version after the EnC update. Location info is not valid. [In] IL code of function after EnC. [Out] If TRUE NewILOffset has a valid value. [Out] If true then DM needs to check for any breakpoints at remapped offset. [Out] Updated instruction pointer after remapping.

Find an exception range affected by ENC.

[In] 'DkmClrModuleInstance' is used for modules which are loaded into the Common Language Runtime. [In] Instruction symbol for the current version of the method where we are attempting to resolve the breakpoint. [In] The version number for the older version of the method where we are trying to resolve the breakpoint in. [Out] IL offsets of the symbol in active exception ranges.

This interface provides Edit and Continue helpers to the client when tracking or applying updates. Implemented by the Managed EnC, called from the client. Implementations of this interface are always called (no filtering is supported). To reduce memory impact, it is suggested that this interface be implemented in a small dll, or that the implementation is configured with 'CallOnlyWhenLoaded="true"'. This API was introduced in Visual Studio 16 Update 3 (DkmApiVersion.VS16Update3).

[In] Represents a set of managed Edit and Continue updates.

Internal helper method for finding a new statement position for updating a document context. Implemented by the Managed EnC, called from ad7.

Internal methods used by the CLR Expression Evaluator to communicate between the monitor/IDE. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: CompilerVendorId, LanguageId. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

This method is used internally by the CLR Expression Evaluator.

Provides the ability to get the generic parameters for a stack frame. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, RuntimeId, SymbolProviderId, TransportKind. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

Gets the generic parameters for the current stack frame as a list of assembly qualified names.

Used internally to query type information about a stack frame for Null Reference Exception information. This interface is subject to change in future versions of Visual Studio. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, RuntimeId, SymbolProviderId, TransportKind. This API was introduced in Visual Studio 15 RTM (DkmApiVersion.VS15RTM).

GetFrameArgumentAndLocalTypes is called to get the types of all arguments and locals of the frame, ordered by their slot indices.

[In] DkmStackWalkFrame represents a frame on a call stack which has been walked, but may not have been formatted or filtered. Formatted frames are represented by DkmStackFrame instead. [Out,Optional] The type of the 'this' type for non-static methods. [Out] The types of the arguments ordered by argument index in metadata. [Out] The types of the locals ordered by slot index.

GetAllCodePathsInRange is called to get all managed code paths and return types that go through a CALL instruction in native, in the specific IL range.

[In] DkmStackWalkFrame represents a frame on a call stack which has been walked, but may not have been formatted or filtered. Formatted frames are represented by DkmStackFrame instead. [In] Specifies the query start IL offset, inclusively. [In] Specifies the query end IL offset, inclusively. [Out] DkmClrCodePath[] represents a code path in IL.

Allows execution of queries that have been compiled to Managed IL. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: EngineId, RuntimeId. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

Execute a compiled inspection query and returns the result as a list of formatted DkmEvaluationResults.

[In] Represents an evaluation query that has been compiled to managed IL code. WorkList which is currently being processed. This value can be used to check for cancelation or to append additional work. New work items will not begin executing until after this function returns. [In] The inspection context for this query. [In] The stack context to execute the query against. [In] The name of the expression used to create this inspection query. Routine to fire when the request is complete. This will be implicitly fired if the implementation returns failure from this interface method. The implementation must fire this method in all other scenarios.

Execute a compiled inspection query to get a set of local variable values as a list of formatted DkmEvaluationResults.

[In] Represents a query to populate local variable information using managed IL code. WorkList which is currently being processed. This value can be used to check for cancelation or to append additional work. New work items will not begin executing until after this function returns. [In] The inspection context for this query. [In] The stack context to execute the query against. [In] The index of the first local variable to get the value for. [In] The number of local variables to get the value for. Routine to fire when the request is complete. This will be implicitly fired if the implementation returns failure from this interface method. The implementation must fire this method in all other scenarios.

Gets the list of aliases that can currently be used in expressions.

[In] Represents a CLR instance running in a target process. [In,Optional] The current InspectionContext. If null, aliases that depend on the current thread or app domain will not be returned by this method. [Out] The list of alias that can currently be used in expressions.

Contains method to load the intrinsic methods assembly. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, RuntimeId, TransportKind. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

Get metadata for the "Intrinsic Methods Assembly". Intrinsic methods are special methods the debug engine understands when executing a CLR inspection query. Example: When evaluating "$exception" in the C# expression evaluator, the C# expression compiler will emit a call to GetException in the intrinsic methods assembly. Instead of executing the call normally, the debugger will instead simulate the method call and return the exception on the current thread.

[In] Represents a CLR instance running in a target process. [Out] The size of the metadata buffer. [Out] A pointer to the metadata buffer.

Methods to load metadata for modules that are not loaded in the debuggee process. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, RuntimeId. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

Get a pointer to the raw metadata bytes of the manifest module of the requested assembly that has not been loaded in the debuggee process. NOTE: This pointer value will become invalid if/when the actual module loads in the debuggee process or if the app domain is unloaded.

[In] DkmClrAppDomain represents a CLR app domain inside a process which is being debugged. [In] The fully qualified name of the assembly to load. [Out] The size of the metadata buffer. [Out] A pointer to the metadata buffer. CORDB_E_MISSING_METADATA indicates that the assembly was not found or could not be loaded.

Used internally to support DkmClrAppDomain.GetMetaDataBytesPtr. For performance reasons, use GetMetaDataBytesPtr instead of this method.

[In] DkmClrAppDomain represents a CLR app domain inside a process which is being debugged. [In] The fully qualified name of the assembly to load. [Out] The MVID of the module that was loaded. [Out] The metadata blob. CORDB_E_MISSING_METADATA indicates that the assembly was not found or could not be loaded.

Resolve an assembly by name and return the MVID of its manifest module.

[In] DkmClrAppDomain represents a CLR app domain inside a process which is being debugged. [In] The fully qualified name of the assembly to resolve. [Out] The MVID of the resolved assembly's manifest module. COR_E_FILENOTFOUND/System.IO.FileNotFoundException indicates that the assembly was not found or could not be loaded.

Interface implemented by the managed DM to obtain the metadata from a given module. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, RuntimeId, SymbolProviderId, TransportKind.

Obtains the CLR metadata from a given module. See IMetaDataImport documentation in MSDN for more information on metadata. NOTE: Callers must take great care when consuming this API from managed code. The IMetaDataImport implementation may hold a file handle to a debuggee file, and the file handle will only be closed when the COM reference count hits zero. So it must be manually released (Marshal.IsComObject + Marshal.ReleaseComObject) rather than waiting for the GC to detect that the object can be released. When testing, be sure that the debuggee file has at least 64KB of metadata, as the metadata reader will not keep the file locked for reading when dealing with small files.

[In] 'DkmClrModuleInstance' is used for modules which are loaded into the Common Language Runtime. [Out] The IMetaDataImport interface for this managed module instance. When consuming this API from managed code, the RCW which wraps the native implementation will have its reference count increased by 1 by this API. The caller should use Marshal.IsComObject + Marshal.ReleaseComObject to release this reference.

Added methods for accessing metadata that were added in VS14RTM. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, RuntimeId, SymbolProviderId, TransportKind. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

Get a pointer to the raw metadata bytes for the given module. NOTE: This pointer value will become invalid if/when the module is a) unloaded or b) modified. To detect these scenarios: a) Add a data item to the module instance or AppDomain. The pointer will be invalid after the OnClose method is called (when the module instance or AppDomain is unloaded). b) Implement IDkmClrModuleModifiedNotification.

[In] 'DkmClrModuleInstance' is used for modules which are loaded into the Common Language Runtime. [Out] The size of the metadata buffer. [Out] A pointer to the metadata buffer.

Added methods for accessing baseline (original) metadata. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, RuntimeId, SymbolProviderId, TransportKind. This API was introduced in Visual Studio 15 Update 5 (DkmApiVersion.VS15Update5).

Get a pointer to the original raw metadata bytes for the given module.

[In] 'DkmClrModuleInstance' is used for modules which are loaded into the Common Language Runtime. [Out] The size of the metadata buffer. [Out] A pointer to the metadata buffer.

Provides a method to get the signature token for a local variable signature given a method token. If the method has been modified via EnC, this method returns the latest blob token. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, RuntimeId, SymbolProviderId, TransportKind. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

Gets the signature token for a local variable signature given a method token.

[In] 'DkmClrModuleInstance' is used for modules which are loaded into the Common Language Runtime. [In] Token of the method to get the local variable signature for. [Out] The local variable signature blob token.

Obtains the DkmClrModuleInstance from an ICorDebugModule. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, RuntimeId, TransportKind.

Obtains the DkmClrModuleInstance from an ICorDebugModule.

[In] Represents a CLR instance running in a target process. [In] The CLR module to get the module instance for. [Out] The DkmClrModuleInstance that matches the provided ICorDebugModule.

Interface for resolving type ref token to type def and the associated assembly. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, RuntimeId, SymbolProviderId, TransportKind. This API was introduced in Visual Studio 15 Update 8 (DkmApiVersion.VS15Update8).

Resolve a token.

[In] 'DkmClrNcModuleInstance' is used for managed modules which are compiled to native code and embedded inside of a native module. Like DkmClrModuleInstance, these are 1:1 with an ICorDebugModule. [In] The type ref token. [Out] The name of the assembly containing the type. [Out] The type def token.

Stores object favorites information on the remote side and also computes the unique key used to indentify their parent types. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: EngineId, RuntimeId. This API was introduced in Visual Studio 16 Update 4 (DkmApiVersion.VS16Update4).

Gets the unique key used by object favorites to identify the type of this result.

[In] The formatted result of a successful evaluation, ready to be displayed in an expression evaluation window. [Out] The unique key used by object favorites to identify the type of this result.

Sets or updates items in the object favorites cached on the remote side for quick lookup by the result provider.

[In] Represents a CLR instance running in a target process. [In] The object favorites information to be set or replaced in the remote cache.

Provides result formatters with object favorites information which is cached on the remote side. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, RuntimeId, SymbolProviderId. This API was introduced in Visual Studio 16 Update 4 (DkmApiVersion.VS16Update4).

Gets the object favorites information for the type.

[In] Represents a managed type. [Out,Optional] The object favorites information for the type.

Internal methods for out-of-process stepping support. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, RuntimeId, TransportKind. This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTMPreview).

Internal helper method for finding candidate addresses for step in/over.

[In] Represents a CLR instance running in a target process. [In] The current stepper. [In] The beginning stack frame of the step. This frame may not be the top-most stack frame. [In] The stepping ranges to look for call instructions within. [Out] The result candidate addresses.

Methods to evaluate property on ICorDebugValueHandles. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, RuntimeId. This API was introduced in Visual Studio 15 RTM (DkmApiVersion.VS15RTM).

Evaluates a property on the given ICorDebugValue. The value's type must be loaded by the DkmClrAppDomain that this $Name$ is being called on.

[In] DkmClrAppDomain represents a CLR app domain inside a process which is being debugged. [In] The object to interpret a property on. This can be an ICorDebugHandleValue or an ICorDebugObjectValue. [In] The name of the property to interpret. [Out,Optional] The result of the property interpretation.

Methods to evaluate property on ICorDebugValueHandles. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, RuntimeId, SymbolProviderId, TransportKind. This API was introduced in Visual Studio 15 Update 3 (DkmApiVersion.VS15Update3).

Evaluates a property on the given ICorDebugValue. The value's type must be loaded by the DkmClrAppDomain of the DkmStackWalkFrame that this $Name$ is being called on.

[In] DkmStackWalkFrame represents a frame on a call stack which has been walked, but may not have been formatted or filtered. Formatted frames are represented by DkmStackFrame instead. [In] The object to interpret a property on. This can be an ICorDebugHandleValue or an ICorDebugObjectValue. [In] The name of the property to interpret. [Out,Optional] The result of the property interpretation.

Interface implemented by the managed DM to obtain information about the current runtime state of the process. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, RuntimeId, SymbolProviderId.

Obtains non user code status for this instruction address.

[In] DkmClrInstructionAddress is used for addresses in managed code. [Out] The non user code status for this instruction address.

Provides the map of how this method was compiled to native code.

[In] DkmClrInstructionAddress is used for addresses in managed code. [In,Optional] Stack frame where this address is from. This is necessary for CLR v2 support. This argument will be ignored for CLR v4. [Out] Structure to define the IL instruction mapping for one or more native instructions.

Obtains the bytes of the CLR metadata from a given module. These bytes can then be passed to IMetaDataDispenser::OpenScope to decode the metadata.

[In] 'DkmClrModuleInstance' is used for modules which are loaded into the Common Language Runtime. [Out] The raw metadata for this module.

Obtains the baseline bytes of the CLR metadata from a given module.

[In] 'DkmClrModuleInstance' is used for modules which are loaded into the Common Language Runtime. [Out] The original raw metadata for this module.

Interface implemented by the managed DM to provide expression evaluators and other components direct access to ICorDebug interfaces. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, RuntimeId.

Provides direct access to the ICorDebugAppDomain object, which expression evaluators or other components can use to inspect the app domain. The returned interface may ONLY be used to inspect the target process, and should NEVER be used to control execution (no stepping, no breakpoints, no continue, etc). Doing so is unsupported and will result in undefined behavior.

[In] DkmClrAppDomain represents a CLR app domain inside a process which is being debugged. [Out] ICorDebug interface representing an app domain inspection.

Provides direct access to the ICorDebugThread object, which expression evaluators or other components can use to inspect the app domain. The returned interface may ONLY be used to inspect the target process, and should NEVER be used to control execution (no stepping, no breakpoints, no continue, etc). Doing so is unsupported and will result in undefined behavior.

[In] Represents a CLR instance running in a target process. [In] DkmThread object that should be mapped to the CorDebug thread. [Out] ICorDebug interface representing an app domain inspection.

Provides direct access to the ICorDebugProcess object, which expression evaluators or other components can use for inspection. The returned interface may ONLY be used to inspect the target process, and should NEVER be used to control execution (no stepping, no breakpoints, no continue, etc). Doing so is unsupported and will result in undefined behavior.

[In] Represents a CLR instance running in a target process. [Out] ICorDebug interface representing a process.

Provides direct access to the ICorDebugModule object, which expression evaluators or other components can use to inspect the app domain. The returned interface may ONLY be used to inspect the target process, and should NEVER be used to control execution (no stepping, no breakpoints, no continue, etc). Doing so is unsupported and will result in undefined behavior.

[In] 'DkmClrModuleInstance' is used for modules which are loaded into the Common Language Runtime. [Out] ICorDebug interface representing an app domain inspection.

Provides direct access to the ICorDebugFunction object, which expression evaluators or other components can use to inspect the app domain. The returned interface may ONLY be used to inspect the target process, and should NEVER be used to control execution (no stepping, no breakpoints, no continue, etc). Doing so is unsupported and will result in undefined behavior.

[In] DkmClrInstructionAddress is used for addresses in managed code. [Out] ICorDebug interface representing an app domain inspection.

This API provides a partial implementation of ISymUnmanagedReader2 for a CLR module instance. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, RuntimeId, SymbolProviderId, TransportKind. This API was introduced in Visual Studio 15 RTM (DkmApiVersion.VS15RTM).

This API provides a partial ISymUnmanagedReader2 implementation for a CLR module.

[In] 'DkmClrModuleInstance' is used for modules which are loaded into the Common Language Runtime. [Out,Optional] The ISymUnmanagedReader for this module. If no symbols are available, this will return null.

This API allows an Expression Evaluator to obtain information contained within a CLR PDB File or CLR dynamic module symbol store. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: SymbolProviderId.

Returns the scopes within a method. There will always be at least one scope.

Returns the first method in the first document.

Returns the scopes within a method. There will always be at least one scope.

Gets a custom attribute based upon its name. Not to be confused with Metadata custom attributes, these attributes are held in the symbol store.

Gets the location of the instruction symbol in it's method.

[In] DkmClrInstructionSymbol represents an IL instruction that runs under the Common Language Runtime (CLR) in the target process. This object contains the method version number. So in Edit-and-Continue scenarios, the instruction symbol would be different for different versions of the method. This object does not contain information about generic binding parameters. So different generic instantiations of a method (ex: MyMethod<string> and MyMethod<int>) are represented by the same instruction symbol since the CLR represents them with a single method token. [Out] The location of the given instruction.

Gets the yield and resume points contained within the statement surrounding the given instruction symbol.

Gets the optional starting IL offset of an async method's generated catch handler.

Get the yield and resume information of the next await expression.

If the current method is an async method then return the kickoff method for this async method.

Enhancement to IDkmClrSymbolCallback to allow it to support ClrNc scenarios. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: RuntimeId, SymbolProviderId. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

Returns the scopes within a method. There will always be at least one scope.

Gets a custom attribute based upon its name. Not to be confused with Metadata custom attributes, these attributes are held in the symbol store.

Symbol provider callback enhancements added for Visual Studio 2019. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: RuntimeId, SymbolProviderId. This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTMPreview).

Gets the sequence points for a CLR method from the symbol file.

Provides APIs to expression evaluators to obtain the signature of local variables and constants. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: SymbolProviderId.

Provides the COR_SIGNATURE for a local constant.

[In] Represents a local constant defined within a method scope. These are defined with ISymUnmanagedWriter::DefineConstant or ISymUnmanagedWriter2::DefineConstant2. [Out] The COR_SIGNATURE for the constant, which defines the type of this constant.

Provides the COR_SIGNATURE for a local Variable.

[In] Represents a local variable defined within a method scope. These are defined with ISymUnmanagedWriter::DefineLocalVariable or ISymUnmanagedWriter2::DefineLocalVariable2. [Out] The COR_SIGNATURE for the Variable, which defines the type of this Variable.

Interface for resolving types from strings into method id's or type id's. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, RuntimeId, SymbolProviderId. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

Resolves a method name belonging to a given class into a DkmClrMethodId.

[In] Represents a managed type. [In] The name of the method. [In,Optional] Optional array of parameter types. [Out] A DkmClrMethodId describing the method.

Resolves a type name into a type. If the type is generic, the generic parameters will not be instantiated.

[In] 'DkmClrModuleInstance' is used for modules which are loaded into the Common Language Runtime. [In] The name of the type. [In,Optional] If the type is generic, specifies the generic parameters for the type. [Out] A DkmClrType describing the type.

Used internally to query ICorDebugType and size information from a DkmClrType. This interface is subject to change in future versions Visual Studio. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, RuntimeId, SymbolProviderId. This API was introduced in Visual Studio 15 RTM (DkmApiVersion.VS15RTM).

GetCorDebugType is called to get the underlying ICorDebugType.

[In] Represents a managed type. [Out] The underlying ICorDebugType.

GetRuntimeSize is called to get the runtime size of the type.

[In] Represents a managed type. [In] The stack frame, required to func-eval in order to compute the runtime size. [Out] The runtime size of a type.

CreateDkmClrType is used to instantiate a new DkmClrType from a COR_TYPEID.

Implemented by expression evaluators which support the C# EE's method of custom viewers (i.e. IPropertyProxyEESide). This interface is subject to change in future releases. Implementations of this interface are always called (no filtering is supported). To reduce memory impact, it is suggested that this interface be implemented in a small dll, or that the implementation is configured with 'CallOnlyWhenLoaded="true"'.

Not described (internal API).

[In] Concord wrapper around IPropertyProxyEESide. [Out,Optional] the result bytes.

Not described (internal API).

[In] Concord wrapper around IPropertyProxyEESide. [Out,Optional] Not described (internal API). [Out,Optional] Not described (internal API). [Out,Optional] Not described (internal API). [Out,Optional] class name. [Out] enum_ASSEMBLYLOCRESOLUTION enumeration. [Out] replacement ok.

Not described (internal API).

[In] Concord wrapper around IPropertyProxyEESide. [In] Not described (internal API). [Out,Optional] Not described (internal API).

Implements IPropertyProxyEESide::ResolveAssemblyReference().

[In] Concord wrapper around IPropertyProxyEESide. [In] Not described (internal API). [In] GETASSEMBLY flags. [Out,Optional] Not described (internal API). [Out,Optional] Not described (internal API). [Out,Optional] Not described (internal API). [Out] ASSEMBLYLOCRESOLUTION enum.

Not described (internal API).

[In] Concord wrapper around IPropertyProxyEESide. [Out,Optional] Not described (internal API).

Not described (internal API).

[In] Concord wrapper around IPropertyProxyEESide. [In] Not described (internal API). [Out,Optional] Not described (internal API).

Interface implemented to allow inspection of CLR values represented by DkmClrValues. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: SymbolProviderId. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

Gets attributes on the type that affect the way variables are displayed in the debugger windows.

[In] Represents a managed type. [Out] A list of attributes that apply to this type or its members.

Execute the ToString override on an object represented by the given DkmClrValue. If the value is of type object or does not override ToString, this method will return null. This method requires function evaluation to be enabled. If function evaluation is disabled by the user or for any other reason, this method will return null. This method will also return null if the function evaluation fails for any reason.

Gets the string to display in the debugger UI for a CLR value given a DebuggerDisplay attribute string.

Instantiate a proxy class for a DkmClrValue with an associated DebuggerTypeProxy attribute.

[In] A value resulting from a CLR inspection query. These values are used by a Result Formatter to generate DkmEvaluationResults. [In] The inspection context for this evaluation. [In] The type of the proxy to instantiate. The proxy type should have a constructor taking a single parameter. The debugger will pass the instance of the type being inspected to this constructor. [Out] A value representing the instantiated type proxy. E_INVALIDARG indicates that Type is an unconstructed generic type.

Instantiate the proxy class to use for iterating an IEnumerable value.

[In] A value resulting from a CLR inspection query. These values are used by a Result Formatter to generate DkmEvaluationResults. [In] The inspection context for this evaluation. [In] The interface type (IEnumerable or IEnumerable<T>) to construct the the results view proxy for. This is needed because a class may implement several different IEnumerable interfaces. [Out,Optional] A value representing the instantiated results view proxy. This method returns null in case of failure instantiating the results view proxy. COR_E_INVALIDOPERATION indicates that this method was called on a DkmClrValue that does not implement the requested interface or represents a null value. E_INVALIDARG indicates that EnumerableType is not an interface type.

Instantiate the proxy class to use for iterating the dynamic members of an IDynamicMetaObjectProvider value.

[In] A value resulting from a CLR inspection query. These values are used by a Result Formatter to generate DkmEvaluationResults. [In] The inspection context for this evaluation. [Out,Optional] A value representing the instantiated results view proxy. This method returns null in case of failure instantiating the dynamic view proxy. COR_E_INVALIDOPERATION indicates that this method was called on a DkmClrValue that does not implement the IDynamicMetaObjectProvider interface or represents a null value.

Gets the value of a field or property as a DkmClrValue.

[In] A value resulting from a CLR inspection query. These values are used by a Result Formatter to generate DkmEvaluationResults. [In] The name of the member to get the value for. [In] The type of member to get the value for. The value should match a value of System.Reflection.MemberTypes. This method currently only supports getting the value for Fields (4) or Properties (16). [In,Optional] The full name of the type containing the member to get the value for. If ParentTypeName value is null, this method will look for the member in the runtime type. [In] The inspection context for this evaluation. [Out] The DkmClrValue for the given member.

Get an array element. This method may only be used if the DkmClrValue represents an array value.

[In] A value resulting from a CLR inspection query. These values are used by a Result Formatter to generate DkmEvaluationResults. [In] The index or indices of the array element to get. [In] The inspection context for this evaluation. [Out] The element value.

Dereference this pointer value to get the underlying value. This method may only be used if the DkmClrValue represents a Pointer value.

Interface for data breakpoints failing after they have been bound. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, RuntimeId, SourceId. This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTM).

This method will be called when an breakpoint has been invalid and needs to inform the UI.

[In] Low-level breakpoint object which is supported by debug monitors. [In] Describes the severity of a message sent from a breakpoint manager back to the source component. This list is sorted in order of priority, as the UI will only display the most important warning. All warnings are ignored if the breakpoint is bound. [In] The error message to be reported.

Callback interface implemented by callers of DkmDeploymentCommand.Start to receive notification of events in the deployment command. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: SourceId, TransportKind.

Indication that the launched command has completed. After this is received, no further notifications will be sent.

[In] Object representing an arbitrary executable which is executed on the target computer. [In] 32-bit value which the processed returned on exit. This is the same value that would be reported from the kernel32!GetExitCodeProcess.

Indication that the target wrote to stdout. This is also used for StdErr if the DkmDeploymentCommandFlags.CombineStdErr flag is used.

[In] Object representing an arbitrary executable which is executed on the target computer. [In] Text written to stdout.

Indication that the target wrote to stderr. This will not be used if the DkmDeploymentCommandFlags.CombineStdErr flag is used. Note that the output from stderr and stdout is not synchronized, so if a program writes to stdout before stderr, a listener may still get the stderr output first (or vice versa).

[In] Object representing an arbitrary executable which is executed on the target computer. [In] Text written to stderr.

IDkmEntryPointNotification is implemented by components that want to listen for the EntryPoint event. IDkmEntryPointNotification is invoked after all implementations of IDkmEntryPointReceived. When this notification is called, the target process is stopped and implementers are able to either inspect the process or cause it to execute in a controlled manner (slip, func-eval). Fired from the breakpoint manager when the entry point breakpoint has been hit. EntryPoint events cannot be suppressed. To override the entry point, implement IDkmEntryPointQuery. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, TransportKind.

OnEntryPoint is invoked as part of event processing. See interface definition for more information.

[In] DkmProcess represents a target process which is being debugged. The debugger debugs processes, so this is the basic unit of debugging. A DkmProcess can represent a system process or a virtual process such as minidumps. [In] DkmThread represents a thread running in the target process. [In] Describes the event being processed.

IDkmEntryPointReceived is implemented by components that want to listen for the EntryPoint event. IDkmEntryPointReceived is invoked before IDkmEntryPointNotification. From within this notification, it is not possible to cause the target process to execute (no func-eval, no slipping). Fired from the breakpoint manager when the entry point breakpoint has been hit. EntryPoint events cannot be suppressed. To override the entry point, implement IDkmEntryPointQuery. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, TransportKind.

OnEntryPointReceived is invoked as part of event processing. See interface definition for more information.

[In] DkmProcess represents a target process which is being debugged. The debugger debugs processes, so this is the basic unit of debugging. A DkmProcess can represent a system process or a virtual process such as minidumps. [In] DkmThread represents a thread running in the target process. [In] Describes the event being processed.

Interface which allows a concord component to to analyze an exception and come up with an improved description of the problem. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, ExceptionCategory, RuntimeId, SourceId. This API was introduced in Visual Studio 14 Update 1 (DkmApiVersion.VS14Update1).

Tries to get a detailed information about the source of the problem.

[In] Provides information about an exception trigger which was satisfied (hit) by an exception coming from the target process. [Out,Optional] Result of the analysis.

Interface implemented by the exception manager component to allow exception triggers to be enabled or disabled. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, TransportKind.

Removes all the exception triggers which have been set with a particular SourceId. After this method returns, the exception triggers will no longer raise ExceptionTriggerHit events. Exception triggers are automatically cleared when the DkmProcess object is closed.

This is an updated version of IDkmExceptionManager, which was added for Visual Studio 14.0 to provide a means of removing exception triggers from the exception manager. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, TransportKind. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

Removes an exception trigger previously set. Note that the processing stage is ignored and does not need to match the value originally provided.

Optional internal interface which can be implemented to customize the environment of the GPU target process before it is started. From the debug monitor side, this API, or IDkmGPUEnvironmentFilter, can be implemented. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: EngineId.

Obtains any environment variables which the extension would like to add.

IDkmHeuristicStackWalker is invoked by the stack provider. It is invoked when attempting to walk through frames without symbols. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId.

[In] DkmStackWalkContext allows the various components which walk, filter, or examine call stacks to store private data which is associated with this call stack. [In] Registers to attempt to walk from. [In] RequestSize is the number of frames that the caller would like returned. The implementation of HeuristicWalkFrames may return fewer frames in the case that stack does not contain that many frames. [In] Stack address to stop the unwinding at. This value is UInt64.MaxValue if the no end stack pointer is present. [Out,Optional] NextRegisters indicates the registers of the next frame (the caller of 'FrameObject'). This will be null if the stack is complete, or if the EndStackPointer was reached. [Out] Returns true if the monitor reached the end of the stack. [Out] DkmStackWalkFrame[] represents a frame on a call stack which has been walked, but may not have been formatted or filtered. Formatted frames are represented by DkmStackFrame instead.

IDkmHiddenEntryPointNotification is implemented by components that want to listen for the HiddenEntryPoint event. IDkmHiddenEntryPointNotification is invoked after all implementations of IDkmHiddenEntryPointReceived. When this notification is called, the target process is stopped and implementers are able to either inspect the process or cause it to execute in a controlled manner (slip, func-eval). Fired from the breakpoint manager when the entry point breakpoint has been hit in hidden code. The actual EntryPoint is delayed until we leave hidden code, and might not even be fired if we're unable to find an appropriate opening. The HiddenEntryPoint will be fired in addition for any behind-the-scenes work necessary. HiddenEntryPoint events cannot be suppressed. To override the entry point, implement IDkmHiddenEntryPointQuery. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, TransportKind. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

OnHiddenEntryPoint is invoked as part of event processing. See interface definition for more information.

[In] DkmProcess represents a target process which is being debugged. The debugger debugs processes, so this is the basic unit of debugging. A DkmProcess can represent a system process or a virtual process such as minidumps. [In] DkmThread represents a thread running in the target process. [In] Describes the event being processed.

IDkmHiddenEntryPointReceived is implemented by components that want to listen for the HiddenEntryPoint event. IDkmHiddenEntryPointReceived is invoked before IDkmHiddenEntryPointNotification. From within this notification, it is not possible to cause the target process to execute (no func-eval, no slipping). Fired from the breakpoint manager when the entry point breakpoint has been hit in hidden code. The actual EntryPoint is delayed until we leave hidden code, and might not even be fired if we're unable to find an appropriate opening. The HiddenEntryPoint will be fired in addition for any behind-the-scenes work necessary. HiddenEntryPoint events cannot be suppressed. To override the entry point, implement IDkmHiddenEntryPointQuery. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, TransportKind. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

OnHiddenEntryPointReceived is invoked as part of event processing. See interface definition for more information.

[In] DkmProcess represents a target process which is being debugged. The debugger debugs processes, so this is the basic unit of debugging. A DkmProcess can represent a system process or a virtual process such as minidumps. [In] DkmThread represents a thread running in the target process. [In] Describes the event being processed.

Interface to provide IIS debugging facilities to the SDM. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: TransportKind.

Internal API to diagnose IIS start debugging failures.

Interface to provide URL->Work process resolution on the Visual Studio computer. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: TransportKind.

Internal API to determine the IIS processes which the debugger should automatically attach to.

[In] This represents a connection between the monitor and the IDE. It can either be a local connection if the monitor is running in the same process as the IDE, or it can be a remote connection. In the monitor process, there is only one connection. [In] URL that the debug verb was sent to. [In] Semi-colon delimitated string of addresses that URL's host name resolves to. These are only IPv4 addresses because IIS only supports filtering on IPv4 addresses. This resolution is always done on the VS computer to match the request from IE. [Out,Optional] Exception text for any caught exception. This may be present in the S_FALSE case. [Out] IIS worker processes to attach to.

Interface to provide URL->Worker process resolution for profiling scenarios. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: TransportKind. This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTMPreview).

Internal API to determine the IIS App pool for a given URL.

[In] This represents a connection between the monitor and the IDE. It can either be a local connection if the monitor is running in the same process as the IDE, or it can be a remote connection. In the monitor process, there is only one connection. [In] URL that the debug verb was sent to. [In] Semi-colon delimitated string of addresses that URL's host name resolves to. These are only IPv4 addresses because IIS only supports filtering on IPv4 addresses. This resolution is always done on the VS computer to match the request from IE. [Out] The architecture of the IIS application pool. [Out,Optional] Exception text for any caught exception. This may be present in the S_FALSE case. [Out,Optional] The name of the IIS application pool. This will be null on errors that have exception text.

Internal API to return the set of worker process process ids for a given app pool name.

Interface for interpreting IL. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, RuntimeId, SymbolProviderId, TransportKind. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

Simulates the execution of a method on an object by interpreting the method's MSIL code. The result of the method will be returned back to the caller. However, unlike a function evaluation, in which the method is actually running in the target, interpreting a method does not actually execute the method, but instead, merely simulates the behavior of the method. Because the method never actually executes, any side effects resulting from the method's execution are discarded after the interpretation of the method is complete, leaving the target process in an identical state to that from before the call.

[In] 'DkmClrModuleInstance' is used for modules which are loaded into the Common Language Runtime. [In] The method to be interpreted. This function does not support interpreting certain types of methods, including, but not limited to: - Methods that consume ref or out parameters - Methods whose implementation calls into native code via P/Invoke, COM interop, or some other means. [In,Optional] If the method belongs to a generic class, specifies the instantiations of the type's generic parameters. [In,Optional] If the method is generic, specifies the instantiations of the method's generic parameters. [In,Optional] If the method to be interpreted is non-static, specifies the non-null object instance that the method should be called on. If the method to be interpreted is a class constructor, this can be either null or non-null. A null this parameter on a class constructor will cause us to virtually create a new object and interpret the constructor. A non-null this parameter to a constructor will cause us to interpret the call to the constructor on the existing object. [In,Optional] Parameters to be passed into the function, excluding the 'this' parameter. This may be null if the function to be interpreted takes no parameters. If the function takes parameters, the length of this array must be equal to the number of parameters specified in the method signature. [In] The maximum number of total IL instructions that we are allowed to interpret. The IL interpretation will be aborted with an error code of E_ABORT if the actual number of instructions exceeds this limit. This limit prevents Visual Studio from hanging if the code being interpreted enters an infinite loop. [In] Additional options for the IL interpreter. [Out,Optional] If the method throws an unhandled exception, the type of the exception that got thrown. [Out,Optional] The return value of the method. This will be null if the method returns void or throws an exception.

Interface to provide process specific instruction addresses. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, TransportKind.

Resolves a CPU InstructionAddress to a DkmInstructionAddress.

[In] DkmProcess represents a target process which is being debugged. The debugger debugs processes, so this is the basic unit of debugging. A DkmProcess can represent a system process or a virtual process such as minidumps. WorkList which is currently being processed. This value can be used to check for cancelation or to append additional work. New work items will not begin executing until after this function returns. [In] Memory address where the native instruction is located. Routine to fire when the request is complete. This will be implicitly fired if the implementation returns failure from this interface method. The implementation must fire this method in all other scenarios.

Interface implemented by components that wish to receive notification when the base debug monitor performs a memory write to the instruction stream. This interface may only be implemented in the monitor process. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, TransportKind.

Method called by the base debug monitor to inform other components that the instruction memory of the target process was modified. Currently, this is only used for breakpoint insertion.

[In] DkmProcess represents a target process which is being debugged. The debugger debugs processes, so this is the basic unit of debugging. A DkmProcess can represent a system process or a virtual process such as minidumps. [In] The base address from which to write the target process's memory. [In] The original code bytes which were replaced in the target process.

[In] DkmProcess represents a target process which is being debugged. The debugger debugs processes, so this is the basic unit of debugging. A DkmProcess can represent a system process or a virtual process such as minidumps. [In] The base address from which to write the target process's memory. [In] The original code bytes which were restored in the target process.

Symbol provider for managed C++. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: RuntimeId, SymbolProviderId. This API was introduced in Visual Studio 14 Update 1 (DkmApiVersion.VS14Update1).

Returns symbol information concerning the innermost active scope of the location indicated by the given instruction symbol, which is assumed to have been compiled with managed C++.

Obtains the parameters to the managed C++ function represented by the given function symbol.

Obtains information to construct continuation frames of a managed task. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: EngineId, SymbolProviderId. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

[In] Provides a context for walking async return stacks and task creation stacks. WorkList which is currently being processed. This value can be used to check for cancelation or to append additional work. New work items will not begin executing until after this function returns. [In] The thread that the resultant frames should belong to. Routine to fire when the request is complete. This will be implicitly fired if the implementation returns failure from this interface method. The implementation must fire this method in all other scenarios.

[In] Provides a context for walking async return stacks and task creation stacks. WorkList which is currently being processed. This value can be used to check for cancelation or to append additional work. New work items will not begin executing until after this function returns. [In] The thread that the resultant frames should belong to. [In] The task object that we are retrieving continuation frames from. [In] The AppDomain of the Task object. Routine to fire when the request is complete. This will be implicitly fired if the implementation returns failure from this interface method. The implementation must fire this method in all other scenarios.

Returns the task handle that was used to create this frame.

[In] Contains information needed to construct a managed DkmStackWalkFrame. [Out] The task handle that matches this frame.

Interface provided by the managed debug monitor to continue the process for a managed function evaluation. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, RuntimeId, TransportKind.

Continue the process and wait for a func-eval to complete.

[In] Represents a CLR instance running in a target process. [In] The thread for which to do the func-eval. [In] The object. [In] Function evaluation flags. [In] The timeout. [In] The text being evaluated. Displayed in the call stack window if the function evaluation re-enters break mode. [Out] The result of doing the function evaluation. S_OK if all went well. Other possible values include S_EVAL_TIMEDOUT, S_EVAL_ABORTED, or E_PROCESS_DESTROYED.

Checks if the given thread is in a state in which the CLR supports managed func-evals.

[In] Represents a CLR instance running in a target process. [In] DkmThread represents a thread running in the target process. [Out] The result of doing the function evaluation. S_OK if all went well. Other possible values include E_EVAL_FUNCEVAL_IN_MINIDUMP or S_EVAL_BAD_THREAD_STATE.

Continue the process and wait for a func-eval to complete.

[In] Represents a CLR instance running in a target process. [In] The thread for which to do the func-eval. [In] The object. [In] Function evaluation flags. [In] The timeout. [In] The text being evaluated. Displayed in the call stack window if the function evaluation re-enters break mode. [In,Optional] The target method being evaluated if known. [Out] The result of doing the function evaluation. S_OK if all went well. Other possible values include S_EVAL_TIMEDOUT, S_EVAL_ABORTED, S_EVAL_RUDE_ABORTED or E_PROCESS_DESTROYED.

Interface implemented by sampler to obtain sampled managed heap. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: EngineId, RuntimeId. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

Initializes heap sampler.

[In] DkmManagedHeapSampler represents a sampler for objects in the managed heap. [In] The number of sampled objects to return. [In] Whether the sampler should calculate stats for only the live objects on the heap. E_MANAGED_HEAP_NOT_ENUMERABLE indicates that the managed heap is not a state that can be enumerated.

Walks the given number of objects on the heap.

[In] DkmManagedHeapSampler represents a sampler for objects in the managed heap. [In] Count of items requested. [Out] Count of items fetched.

Walks the given number of references on the heap.

[In] DkmManagedHeapSampler represents a sampler for objects in the managed heap. [In] Count of items requested. [Out] Count of items fetched.

Walks the given number of GC roots on the heap.

[In] DkmManagedHeapSampler represents a sampler for objects in the managed heap. [In] Count of items requested. [Out] Count of items fetched.

Returns the next requested portion of serialized object graph data.

[In] DkmManagedHeapSampler represents a sampler for objects in the managed heap. [In] Count of items requested. [Out] Sampled heap data.

Returns the heap type stats.

[In] DkmManagedHeapSampler represents a sampler for objects in the managed heap. [Out] Sampled heap type stats.

Returns roots from the sampled heap.

[In] DkmManagedHeapSampler represents a sampler for objects in the managed heap. [Out] Sampled heap roots.

Interface implemented by managed dm to allow walking the managed heap. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: EngineId, RuntimeId. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

Prepares enumerator for walking the objects in the heap, returns error if heap cannot be enumerated.

[In] DkmManagedHeapWalker represents an enumerator for managed heap. E_MANAGED_HEAP_NOT_ENUMERABLE indicates that the managed heap is not a state that can be enumerated.

Prepares enumeration for reporting references between objects in the heap, returns error if heap cannot be enumerated.

[In] DkmManagedHeapWalker represents an enumerator for managed heap. E_MANAGED_HEAP_NOT_ENUMERABLE indicates that the managed heap is not a state that can be enumerated.

Prepares enumeration for reporting roots in the heap, returns error if heap cannot be enumerated.

[In] DkmManagedHeapWalker represents an enumerator for managed heap. E_MANAGED_HEAP_NOT_ENUMERABLE indicates that the managed heap is not a state that can be enumerated.

Returns the next set of objects from the enumeration.

[In] DkmManagedHeapWalker represents an enumerator for managed heap. [In] Count of items requested. [Out] Array containing the managed heap object infos.

Returns the next set of elements from the enumeration.

[In] DkmManagedHeapWalker represents an enumerator for managed heap. [In] Count of items requested. [Out] Array containing the managed heap reference infos.

Returns the next set of roots from the enumeration.

[In] DkmManagedHeapWalker represents an enumerator for managed heap. [In] Count of items requested. [Out] Array containing the managed heap root infos.

Gets the type names for the given type ids.

[In] DkmManagedHeapWalker represents an enumerator for managed heap. [In] The list of managed type ids. [Out] The list of type names.

Gets the list of segments in the heap.

[In] DkmManagedHeapWalker represents an enumerator for managed heap. [Out] The list of heap segments.

Obtains managed return value information from ManagedDM for evaluation. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, RuntimeId. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

Evaluates and formats a given DkmRawReturnValue using solely the provided data.

[In] Provides a context for managed return value. [Out] Return value from CLR.

Used by ManagedDM to query code path info. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, RuntimeId, TransportKind. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

GetCodePathsInRange is called to get code paths in specific IL range.

[In] The DkmRuntimeInstance class represents an execution environment which is loaded into a DkmProcess and which contains code to be debugged. [In] The ICorDebugFrame to query for code paths. [In] Specifies the query start IL offset, inclusively. [In] Specifies the query end IL offset, inclusively. [Out] DkmSteppingCodePath[] represents a location that user can step to from current location.

Provides services to task providers and to Debug Monitors for getting managed task information. This is implemented by the Shim Managed EE. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, RuntimeId, TransportKind. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

Gets the metadata token for a CLR method.

[In] Represents a CLR instance running in a target process. [In] The fully qualified class name. [In] The method name. [In] The list of fully qualified arguments for the method. [Out] The metadata token or 0 if not found.

Get a DkmManagedTaskInfo from a stack frame parameter.

[In] Represents a CLR instance running in a target process. [In] The stack frame to get the task info from. [In] The index of the task argument. [Out] The DkmManagedTaskInfo for the task.

Get a DkmManagedTaskInfo array from a stack frame parameter.

[In] Represents a CLR instance running in a target process. [In] The stack frame to get the task info from. [In] The index of the task argument. [Out] The DkmManagedTaskInfo array for the tasks.

Get a DkmManagedTaskInfo from an ICorDebugHandleValue.

[In] Represents a CLR instance running in a target process. [In] The ICorDebugHandleValue for the task. [In] The AppDomain of the task. [Out] The DkmManagedTaskInfo for the task.

Provides services to task providers and to Debug Monitors for getting managed task information. This is implemented by the CLR Inspector. This interface is subject to change in future releases. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: EngineId, RuntimeId. This API was introduced in Visual Studio 15 Update 8 (DkmApiVersion.VS15Update8).

Get the location of the delegate from an ICorDebugHandleValue.

[In] Provides a context for walking async return stacks and task creation stacks. [In] The ICorDebugHandleValue for the task. [In] The thread that the frame should belong to. [In] The AppDomain of the task. [Out,Optional] The task's continuation delegate, as determined from the task object itself. This might be different from the delegate obtained through walking the logical stack, which might be more accurate.

Gets an ICorDebugHandleValue for an address of a managed object on the heap. The API will return E_NOTIMPL if heap inspection APIs are not supported by the CLR version.

[In] DkmClrAppDomain represents a CLR app domain inside a process which is being debugged. [In] The address of the object on the heap. [Out] The ICorDebugHandleValue for the object.

Gets the active tasks object addresses of the given thread using heap inspection and enumerating GC roots.

[In] DkmClrAppDomain represents a CLR app domain inside a process which is being debugged. [In] The thread. [Out] The active tasks for this thread.

Provides services to task providers and to Debug Monitors for getting managed task information. This is implemented by the CLR Inspector. This interface is subject to change in future releases. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, RuntimeId, TransportKind. This API was introduced in Visual Studio 16 Update 3 (DkmApiVersion.VS16Update3).

Get the task handle for an async frame.

[In] Represents a CLR instance running in a target process. [In] The async frame to retrieve task information for. [In] If true, create the Task if it doesn't already exist. [Out] The ICorDebugHandleValue for the associated task object of the async frame.

Exposes properties of a managed thread such as Managed Thread ID. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, TransportKind.

Get a managed thread's properties.

[In] DkmThread represents a thread running in the target process. [Out] The managed thread id of the thread.

IDkmMergedMonitorStackWalk is invoked by the stack provider. It will arbitrate between the various implementations of IDkmMonitorStackWalk to walk portions of the stack which should be walked inside the monitor (instead of walked inside the engine). Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId.

[In] DkmStackWalkContext allows the various components which walk, filter, or examine call stacks to store private data which is associated with this call stack. [In] RequestSizeHintIfCacheIsValid is a hint as to the number of frame that the caller needs. This value is treated as a hint because this API can return frames which are not yet walked, so this API may return more or less than the hint value. A request size hint of 0 means not to do any stack walking at all if the cache is valid. [In] RequestSizeHintIfCacheIsInvalid is a hint as to the number of frame that the caller needs. This value is treated as a hint because this API can return frames which are not yet walked, so this API may return more or less than the hint value. [In,Optional] Cached call stack hash, will not walk the stack if cache is still valid. This parameter is optional. If null, we will still compute the actual hash and do the stack walk, but will skip the comparing of the actual hash against the cached hash to suppress the stack walk. [Out] Returns true if the monitor reached the end of the stack. [Out,Optional] The actual hash of the call stack. This may be NULL for runtimes that don't support call stack hashing. [Out] The DkmStackWalkContext object that can used later to continue the walk. If the cache is valid, this is the original context. If the cache is invalid, this will be a new DkmStackWalkContext object. [Out] True if the cache was valid, false if not. [Out] Array of walked frames. For, unresolved frames, both InstructionAddress and Description will be null.

Return the top stack frame for a thread. This frame can come from a runtime instance, or a monitor unwinder. This can only be called from the server process. To obtain the top frame in the client process, use GetTopStackFrame.

[In] DkmThread represents a thread running in the target process. [In] The runtime instance of the frame. [Out] The top stack frame. E_NO_FRAME is returned if no native runtime is present and there are no frames on the stack.

IDkmMergedMonitorStackWalk164 is invoked by the stack provider. It will arbitrate between the various implementations of IDkmMonitorStackWalk to walk portions of the stack which should be walked inside the monitor (instead of walked inside the engine). Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId. This API was introduced in Visual Studio 16 Update 4 (DkmApiVersion.VS16Update4).

Version of RuntimeWalkNextFrames() that also checks if a cached copy of the call stack is still valid.

Obtains information about the minidump being debugged. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, TransportKind. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

Returns the path to the primary executable in the minidump being debugged.

When managed minidump debugging, determines whether metadata is available for a given module instance. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, RuntimeId, SymbolProviderId, TransportKind. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

Get metadata status.

[In] 'DkmClrModuleInstance' is used for modules which are loaded into the Common Language Runtime. [Out] Metadata status.

Provides decoding of export tables in Windows PE files. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, RuntimeId, SymbolProviderId.

[In] DkmNativeInstructionAddress is used for addresses that resolve to within a native module. This is used regardless as to if there are symbols for the module. [Out] Byte offset from the start of the export. [Out,Optional] Name of the export.

Finds the address of the specified named exported function (or data export).

[In] 'DkmNativeModuleInstance' is used for modules which contain CPU code and/or are loaded by the Win32 loader. [In] The export name to search for in the module's export table. [In] If true, the implementation will ignore any export which is in non-executable memory. [Out,Optional] If the export was found in the specified module, this will contain the target address. Note that this instruction address object may be in a different module than the searched module. This can happen if the export was forwarded and the destination module is already loaded. If the destination module is not loaded, the export will be ignored.

Provides additional decoding of export tables in Windows PE files. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, RuntimeId, SymbolProviderId, TransportKind. This API was introduced in Visual Studio 15 RTM (DkmApiVersion.VS15RTM).

Finds the address of the exported function (or data export) specified by the ordinal.

[In] 'DkmNativeModuleInstance' is used for modules which contain CPU code and/or are loaded by the Win32 loader. [In] The ordinal number to search for in the module's export table (includes the Ordinal Base). [In] If true, the implementation will ignore any export which is in non-executable memory. [Out,Optional] If the export was found in the specified module, this will contain the target address. Note that this instruction address object may be in a different module than the searched module. This can happen if the export was forwarded and the destination module is already loaded. If the destination module is not loaded, the export will be ignored.

Functions for querying the time travelling CLR runtime for data. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId. This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTM).

Queries for the times that the given method was JIT compiled.

[In] Provides facilities to record data from a recorded process. [In] The module that contains the CLR method that was JIT compiled. [In] The token of the method to query. [Out] All known method JIT instances across the full lifetime of the time travelling process.

Gets information about a method JIT instance. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId. This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTM).

Gets the maps from original IL to native code maps, if available.

[In] Describes the JIT compilation of a method at a point in time. Optionally offers Original IL to Native mapping and/or Original IL to Instrumented IL native mapping. [Out] The Original IL to Native map entries.

Interface implemented by the base DM services to provide a recorded process information without debugging it. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: TransportKind. This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTM).

Obtain information about a recorded file.

Get information about the computer where the recorded process ran.

[In] Basic information about a non-executable file that can be debugged. This non-executable file can be a recording of a running process, e.g. a time travel debug trace file. [Out] Object describing the system where the recorded process ran.

Get the lists of modules that loaded in the recorded process.

Get all the version number for all the CLR instances loaded into the recorded process.

[In] Basic information about a non-executable file that can be debugged. This non-executable file can be a recording of a running process, e.g. a time travel debug trace file. [Out] Version number for all the CLR instances loaded into the recorded process.

Functions for querying the time travelling runtime for data. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId. This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTM).

Get the snapshot record section events in the trace.

[In] Provides facilities to record data from a recorded process. [Out] The collection of the snapshot record section events.

Request the query to update itself.

[In] Provides facilities to record data from a recorded process. [Out] True if the query is outdated.

Request or force the query to update itself.

[In] Provides facilities to record data from a recorded process. [In] Whether to force update the query. [Out] True if the query is outdated.

Request to get all known recorded snapshots.

[In] Provides facilities to record data from a recorded process. [Out] The collection of the snapshot events.

Interface to provide a recorded process query. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, TransportKind. This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTM).

Gets the DkmRecordedProcessQuery for the given id in the process.

[In] DkmProcess represents a target process which is being debugged. The debugger debugs processes, so this is the basic unit of debugging. A DkmProcess can represent a system process or a virtual process such as minidumps. [In] The id of the DkmRecordedProcessQuery. [Out] Provides facilities to record data from a recorded process.

IDkmReturnValuesNotification is implemented by components that want to listen for the ReturnValues event. The target process may continue to run during this notification. The ReturnValues event is sent during a step, when one or more DkmRawReturnValues have been collected. The actual evaluation will be performed on the StepComplete event on the thread where the Return Values were recorded. ReturnValues events can be suppressed by calling DkmEventDescriptorS.Suppress(). Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, RuntimeId, SourceId.

OnReturnValues is invoked as part of event processing. See interface definition for more information.

[In] DkmStepper represents a request to step a thread. It facilitates shared object lifetime between the various runtime debug monitors that participate in stepping. [In,Optional] DkmRawReturnValues recorded. [In] If true, it is valid to use the current thread context to evaluate the last return value. This is true only in the case immediately after processing the return instruction, and so should only be set if raising this event immediately before, and on the same thread, as the StepComplete event. [In] Describes the event being processed and provides the ability for a component to suppress this event.

Interface implemented by the base DM services to provide a process listing, and provide basic information about running processes without attaching a debugger to the process. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: TransportKind.

Provides a listing of all the processes running on the target computer (including processes not being debugged).

[In] This represents a connection between the monitor and the IDE. It can either be a local connection if the monitor is running in the same process as the IDE, or it can be a remote connection. In the monitor process, there is only one connection. [In] If true, processes from all users should be included. [In] Flags indicating which properties of DkmRunningProcessInfo should be computed. [Out] Array of processes running on the target computer.

Obtain information about a process running on the target computer.

Called by the SDM prior to start debugging. It is used to obtain current information about the process, ensure that the process can be debugged, and to make any operating system configuration changes (ex: enabling enhanced error reporting) to improve debugging.

Terminates a process running on target computer which is not being debugged.

Provides information about the computer where the debug monitor is running.

[In] This represents a connection between the monitor and the IDE. It can either be a local connection if the monitor is running in the same process as the IDE, or it can be a remote connection. In the monitor process, there is only one connection. [In] If true and if the debug monitor is running under WOW64, this function will return information about the native subsystem rather than WOW. If the debug monitor is not running under WOW, this function is ignored. [Out] Object describing the system where the debugger is running.

Provides the version string for the CLR that the debugger expects a given executable to load. The return value is based on the content of the executable's PE header (if the exe is managed), the executable's config file, CLR environment variables, and loader policy in the registry. The return value may be incorrect, especially in the case of a native executable.

Deprecated. Use QueryExecutableArchitecture. Determines if the given executable file will execute within WOW64 (Windows On Windows), which is used to execute 32-bit processes on a 64-bit OS.

Returns the version of the CLR which is loaded in the monitor process.

Gets the architecture of the executable.

[In] This represents a connection between the monitor and the IDE. It can either be a local connection if the monitor is running in the same process as the IDE, or it can be a remote connection. In the monitor process, there is only one connection. [In] Path to the executable file. [Out] Example: PROCESSOR_ARCHITECTURE_INTEL (0), PROCESSOR_ARCHITECTURE_ARM (5), PROCESSOR_ARCHITECTURE_AMD64 (9), or PROCESSOR_ARCHITECTURE_ARM64 (12).

This interface is implemented by the breakpoint manager so it can receive notification that a runtime function resolution request has resolved into a new function. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, CompilerVendorId, EngineId, LanguageId.

Called by runtime function resolvers when a new resolution has been discovered for a DkmRuntimeFunctionResolutionRequest instance.

Called by runtime function resolvers when the resolver wishes to notify its client an error/warning occurred while attempting to resolve the breakpoint.

[In] DkmRuntimeFunctionResolutionRequest represents an expression to be parsed and evaluated by a runtime based expression evaluator and is bound to a particular process. Resolutions will send DkmModuleInstance::FunctionResolved events. [In] Describes the severity of a message sent from a breakpoint manager back to the source component. This list is sorted in order of priority, as the UI will only display the most important warning. All warnings are ignored if the breakpoint is bound. [In] Message string to display to the user.

This interface allows Concord components to compare two ICorDebugHandleValue objects' values by routing the calls to GetValue through the shim EE in order to have the proper LocalContext set up. Calling GetValue directly on a ICorDebugHandleValue object from Concord will result in an exception thrown from the VIL host. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, RuntimeId, TransportKind.

This method takes two ICorDebugHandleValues, calls GetValue on each, and compares the resulting values to see if they are equal. If necessary, it will set up a LocalContext for the VIL interpreter.

[In] Represents a CLR instance running in a target process. [In] The first ICorDebugHandleValue object. [In] The second ICorDebugHandleValue object. [Out] Set to true if the two given ICorDebugHandleValue objects have the same value, false otherwise.

Provides CLR values for managed hardware data bps. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, RuntimeId, SourceId. This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTM).

This method retrieves the address and size of field the DkmRuntimeClrDataBreakpoint is following.

[In] Low-level data breakpoint which is set using the hardware breakpoint registers of the CPU for managed values. [Out] The address of the data breakpoint. If not found, this will be set to 0. [Out] The size of the data breakpoint.

Interface to update components when the project item path is set for a script document. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, RuntimeId, SymbolProviderId.

Called when 'SourceProjectItem' is changed.

[In] Represents a document which is executing in a script runtime environment. For example, the Microsoft JavaScript engine.

IDkmScriptJmcStateChangeNotification is implemented by components that want to be notified when the JMC state changes for a script document. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, RuntimeId, SymbolProviderId. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

This method is called by the dispatcher when the JMC state of a script document changes.

[In] Represents a document which is executing in a script runtime environment. For example, the Microsoft JavaScript engine.

Internal interface implemented by VsDebugEng.ManImpl.45.dll to provide source server to source link command translation. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: CompilerVendorId, LanguageId, SymbolProviderId, TransportKind. This API was introduced in Visual Studio 16 Update 3 (DkmApiVersion.VS16Update3).

Called by a symbol provider to initialize the translator for the specified module.

Returns SourceLink information from the symbol file for the requested file path.

Provides the stack for view by the user. This stack has been filtered, annotated, and mixed together. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId.

[In] DkmStackContext objects are created by components that wish to request the stack from the stack provider. A component needs to close the context after they have completed the stack walk. To obtain the stack a component should create this object and then call GetNextFrames. WorkList which is currently being processed. This value can be used to check for cancelation or to append additional work. New work items will not begin executing until after this function returns. [In] RequestSize is the number of frames that the caller would like returned. The implementation of GetNextFrames may return fewer frames in the case that stack does not contain that many frames. Negative values, or request to read more than MaxFrames (currently 5,000) will be capped to MaxFrames. Routine to fire when the request is complete. This will be implicitly fired if the implementation returns failure from this interface method. The implementation must fire this method in all other scenarios.

Format a DkmStackWalkFrame into a DkmStackFrame. Formatting a frame is one step of what the stack provider does during GetNextFrames. This method can be used to format a frame in a different way than was originally performed by the stack provider in GetNextFrames.

[In] DkmStackWalkFrame represents a frame on a call stack which has been walked, but may not have been formatted or filtered. Formatted frames are represented by DkmStackFrame instead. [In] DkmInspectionSession allows the various components which inspect data to store private data which is associated with a group of evaluations. [In] Collection of settings that affect how the stack provider formats a DkmStackFrame. [Out] DkmStackFrame represents a frame on the call stack after filtering and translation.

Returns the top call stack frame for a thread. This value is normally cached after the first stack walk and cleared on continue. This is only callable above the stack provider in the client process. To obtain the top frame in the server process, call GetTopStackWalkFrame.

[In] DkmThread represents a thread running in the target process. [Out] DkmStackWalkFrame represents a frame on a call stack which has been walked, but may not have been formatted or filtered. Formatted frames are represented by DkmStackFrame instead.

IDkmStepCompleteNotification is implemented by components that want to listen for the StepComplete event. IDkmStepCompleteNotification is invoked after all implementations of IDkmStepCompleteReceived. When this notification is called, the target process is stopped and implementers are able to either inspect the process or cause it to execute in a controlled manner (slip, func-eval). Sent by a runtime monitor when a step has completed successfully. Note that the step might actually finish on a different thread than it was started on. StepComplete events can be suppressed by calling DkmEventDescriptorS.Suppress(). Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, RuntimeId, SourceId.

OnStepComplete is invoked as part of event processing. See interface definition for more information.

[In] DkmStepper represents a request to step a thread. It facilitates shared object lifetime between the various runtime debug monitors that participate in stepping. [In] The thread the step actually finished on. Normally, this is the same as the thread in DkmStepper, but in some scenarios, it could be different. [In] Contains true if the source runtime instance can determine that an exception is in flight on the stepping thread. Currently, only managed runtime instances ever set this. This is used to quickly determine if exception specific logic should apply without making another network round-trip. [In] Describes the event being processed and provides the ability for a component to suppress this event.

IDkmStepCompleteReceived is implemented by components that want to listen for the StepComplete event. IDkmStepCompleteReceived is invoked before IDkmStepCompleteNotification. From within this notification, it is not possible to cause the target process to execute (no func-eval, no slipping). Sent by a runtime monitor when a step has completed successfully. Note that the step might actually finish on a different thread than it was started on. StepComplete events can be suppressed by calling DkmEventDescriptorS.Suppress(). Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, RuntimeId, SourceId.

OnStepCompleteReceived is invoked as part of event processing. See interface definition for more information.

Interface of the stepping manager. This component is implemented by Microsoft and it provides stepping arbitration between the various debug monitors active in the process. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId.

Called by the stopping event manager before a step operation actually begins The stopping event manager will notify all runtime instances so they can setup any necessary state before the the stopping event manager starts blocking function evaluations.

[In] DkmStepper represents a request to step a thread. It facilitates shared object lifetime between the various runtime debug monitors that participate in stepping.

Used to initialize a stepper object so that the step will be performed when execution is next resumed. This method is implemented by the stepping manager by finding an appropriate runtime debug monitor, and asking this runtime debug monitor to setup a step. This method should only be called once for a given stepper object.

Allows a stepper to be cancelled after creation by the controlling runtime instance. The calling runtime instance must match the current controlling runtime instance. This is generally used in cross thread stepping scenarios where the original stepper may be reactivated. The stepping manager will close the stepper and not send step complete.

[In] DkmStepper represents a request to step a thread. It facilitates shared object lifetime between the various runtime debug monitors that participate in stepping. [In] The calling runtime instance that wishes to take control of the step.

Called by the stopping manager prior to resuming execution in order to clear all steppers from a given thread. The stepping manager will call StopStep on the controlling runtime instance and then close the stepper objects.

[In] DkmThread represents a thread running in the target process.

Allows runtime monitors to obtain information from the stepping manager. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, RuntimeId, SourceId.

Returns the runtime instance currently in-control of this DkmStepper.

[In] DkmStepper represents a request to step a thread. It facilitates shared object lifetime between the various runtime debug monitors that participate in stepping. [Out] The runtime instance currently in control of this stepper.

StepControlRequested is called when a non-controlling runtime instance detects that the thread has hit a transition into its runtime. The stepping manager will forward the call to the current controlling runtime instance. If the current controlling runtime instance can stop stepping, it should set Granted to true. Actual control is not given until the requesting runtime calls DkmStepper.TakeStepControl. This two part process allows callers to request control of multiple steppers at the same time.

[In] DkmStepper represents a request to step a thread. It facilitates shared object lifetime between the various runtime debug monitors that participate in stepping. [In] DkmStepArbitrationReason the reason step arbitration is occurring. [In] The calling runtime instance that wishes to take control of the step. [Out] The the controlling runtime can stop the step and give control to the caller, then it should set this to true.

TakeStepControl is called when a non-controlling runtime instance detects that the thread has hit a transition into its runtime. The stepping manager will forward the call to the current controlling runtime instance. The runtime instance requesting control should first call StepControlRequested on all steppers it wants control of. If they all set Granted to true, the runtime instance should then call this method on each stepper it is taking control of.

[In] DkmStepper represents a request to step a thread. It facilitates shared object lifetime between the various runtime debug monitors that participate in stepping. [In] Set to true by the caller if it would like the current controlling runtime instance to leave guards in place to stop the step if necessary. For instance, this can be used to leave guard breakpoints after a call instruction so another runtime can step back out if the target of the call doesn't have source. However, any stepping state that affects the immediate step, such as trap flags, should be removed by the controlling runtime instance. [In] DkmStepArbitrationReason the reason step arbitration is occurring. [In] The calling runtime instance that wishes to take control of the step.

Called by a runtime monitor when a step has left the confines of what the runtime monitor understands or a potential transition into another runtime has been encountered during a step. The stepping manager will initiate stepping arbitration to give each runtime monitor a chance to inspect the process and determine which runtime should complete the step. The runtimes are called in priority order. After this process is complete, the stepping manager will call AfterSteppingArbitration on the monitor that requested arbitration so it can respond to the new controlling monitor if one was found, or finish the step if one was not found.

Called by a runtime monitor when a step is continuing on a different thread. The stepping manager will create a new DkmStepper to be used on the new thread and initiate stepping arbitration to determine which runtime should complete the step just as OnStepArbitration does. The new stepper uses the same step kind and step unit as the original stepper. A new starting instruction address must be given and is set as the stepper's starting address. The original stepper remains alive and when the new stepper completes the stepping manager will suppress the event and notify the original stepper of the completion.

[In] DkmStepper represents a request to step a thread. It facilitates shared object lifetime between the various runtime debug monitors that participate in stepping. [In] DkmStepArbitrationReason the reason step arbitration is occurring. [In] The runtime instance requesting arbitration. [In] The thread on which to create the new stepper. [In] Starting address of the new stepper. [Out,Optional] The new stepper.

Extends the information runtime monitors can obtain from the stepping manager. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, RuntimeId, SourceId. This API was introduced in Visual Studio 11 Update 1 (DkmApiVersion.VS11FeaturePack1).

[In] DkmStepper represents a request to step a thread. It facilitates shared object lifetime between the various runtime debug monitors that participate in stepping. [In] If true, the exception in flight flag is set. If false, it is cleared.

[In] DkmStepper represents a request to step a thread. It facilitates shared object lifetime between the various runtime debug monitors that participate in stepping. [Out] If true, the exception in flight flag is set. If false, it is cleared.

Interface implemented by the Minidump BDM in order to query for Stowed Exception information. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, TransportKind. This API was introduced in Visual Studio 12 Update 3 (DkmApiVersion.VS12Update3).

Get the stowed exceptions from a dump.

Get the native stowed exception from a dump. This will return S_FALSE if there is no native stowed exception.

[In] DkmProcess represents a target process which is being debugged. The debugger debugs processes, so this is the basic unit of debugging. A DkmProcess can represent a system process or a virtual process such as minidumps. [Out,Optional] The native stowed exception from the dump, or NULL if there is no native stowed exception.

Get the managed stowed exception from a dump. This will return S_FALSE if there is no managed stowed exception.

[In] DkmProcess represents a target process which is being debugged. The debugger debugs processes, so this is the basic unit of debugging. A DkmProcess can represent a system process or a virtual process such as minidumps. [Out,Optional] The managed stowed exception from the dump, or NULL if there is no managed stowed exception.

Provides the location of a thread, as visible in the threads window, or threads drop down in the debug location toolbar. This is implemented by the Microsoft stack provider component. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, TransportKind.

Provides the location of a thread, as visible in the threads window, or threads drop down in the debug location toolbar.

[In] DkmThread represents a thread running in the target process. WorkList which is currently being processed. This value can be used to check for cancelation or to append additional work. New work items will not begin executing until after this function returns. Routine to fire when the request is complete. This will be implicitly fired if the implementation returns failure from this interface method. The implementation must fire this method in all other scenarios.

Returns the stack base and limit of a thread. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, TransportKind.

Retrieves the stack limit/stack base of the given thread. Note that its possible for this value to change over time, for example, in the case of fibers.

[In] DkmThread represents a thread running in the target process. [Out] The limit/base address for the memory containing a thread's stack. E_INVALID_MEMORY_ADDRESS indicates that the address containing the TEB structure could not be read from the target process. This may be returned for minidumps without heap.

This interface is implemented by debug monitors that allow time travelling. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, TransportKind. This API was introduced in Visual Studio 15 Update 8 (DkmApiVersion.VS15Update8).

Called to find out what time relative to the current process time a value from a memory read is resolved from.

[In] DkmProcess represents a target process which is being debugged. The debugger debugs processes, so this is the basic unit of debugging. A DkmProcess can represent a system process or a virtual process such as minidumps. [In] The base address of a memory read. [In] The size of the memory read. [Out] The read flags representing the lowest confidence memory read across the given address range.

Gets a value indicating whether the process is running in the forward or reverse direction. This method is only implemented for time travelling processes.

Sets the processes execution direction. The direction can be forward or reverse. This method is only implemented for time travelling processes.

Set the process at the time context.

[In] DkmProcess represents a target process which is being debugged. The debugger debugs processes, so this is the basic unit of debugging. A DkmProcess can represent a system process or a virtual process such as minidumps. [In] The position where the replay starts. [In,Optional] The beginning of the replay range. NULL means the beginning of the file. [In,Optional] The end of the replay range. NULL means the end of the file.

Provides the ability to read and write from Win32 TLS slots within the target process. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, TransportKind.

Retrieves the value in the debuggee thread's thread local storage (TLS) slot for the specified TLS index. Each thread of a process has its own slot for each TLS index.

[In] DkmThread represents a thread running in the target process. [In] The TLS index that was allocated when the target process called the TlsAlloc function. [Out] The pointer-sized value which was stored in the thread's TLS slot. If the target thread is 32-bit, the upper 32-bits of this value will be zero.

Stores a value in the debuggee thread's thread local storage (TLS) slot for the specified TLS index. Each thread of a process has its own slot for each TLS index.

[In] DkmThread represents a thread running in the target process. [In] The TLS index that was allocated when the target process called the TlsAlloc function. [In] The pointer-sized value to store in the thread's TLS slot. If the target thread is 32-bit, the upper 32-bits of this value will be ignored.

Interface implemented by the AD7AL as a gateway to services provided by the rest of Visual Studio. Implementations of this interface are always called (no filtering is supported). To reduce memory impact, it is suggested that this interface be implemented in a small dll, or that the implementation is configured with 'CallOnlyWhenLoaded="true"'.

Displays a message to the user inside the Visual Studio debugger IDE. This function does not block waiting for the user to dismiss the error message.

[In] Contains information about a message that is to be displayed to the user.

Displays a message to the user inside the Visual Studio debugger IDE. This function waits for the Visual Studio IDE to complete processing this message. This method may not be called from code that runs as part of UI event processing. Doing so will cause a deadlock. This method requires DkmUserMessage.Process to be non-null.

[In] Contains information about a message that is to be displayed to the user. [Out] Win32 'ID' code from displaying the message box (ex: IDYES). These codes are defined in winuser.h from the Windows SDK.

Returns the enumeration of DkmCodeViewCompilerId values. This enumeration may then be used by a symbol provider to map the information within a code view record to the DkmCompilerId structure.

[In] Contains the session-wide debug settings. There is one instance of this object per engine Guid (ex: one instance for COMPlusOnlyEng2, one instance for COMPlusNativeEng). [Out] DkmCodeViewCompilerId[] is used to translate information that is within the S_COMPILE* code view records into a DkmCompilerId. This allows the debugger to load an appropriate expression evaluator for a stack frame. Symbol providers may obtain this collection through DkmEngineSettings. Expression evaluators may add additional entries to this collection by having their setup add sub key(s) to the '%VSRegistryRoot%\Debugger\CodeView Compilers' registry key.

Sends a custom message to a Visual Studio package. This can be used, for example, to drive a custom UI or make a custom UI visible by enabling a command context (IVsMonitorSelection.SetCmdUIContext). For local 32-bit debugging, the custom message parameters (DkmCustomMessage.Parameter1/2), may contain any value (ex: object/IUnknown, string, etc), however, values are transferred between threads without marshalling, so in cases where this will not work, the sender is responsible for converting the parameter into a form which can be used from the VS service (ex: calling ole32!CoMarshalInterThreadInterfaceInStream). For remote debugging, and 64-bit debugging, the custom message parameters are marshalled across machines, and so the restrictions describe in the DkmCustomMessage.Parameter1 documentation applies.

[In] Message structure used to pass information between custom debugger backend components and custom visual studio UI components (packages, add-ins, etc). [In] Visual Studio service that this event should be sent to. A VS package must register this service id. The service class must implement the IVsCustomDebuggerEventHandler110 interface. Services can be registered in the registry ($RootKey$\Services\{VsService}), or through the VS shell IProfferService interface. Registry keys may be set through .pkgdef files. If the service should be called even if it is not already loaded, then the registry approach should be used. If the service should only be called if it has already been started, then IProfferService should be used. [In] True if SendToPackage should block waiting for the package to finish processing this message. Note that before Visual Studio 2015, when true, DkmCustomMessage.Process must be non-null. This requirement was dropped in Visual Studio 2015.

Reads language-specific from the registry. The settings are stored under HKLM\Software\Microsoft\VisualStudio\15.0\AD7Metrics\ExpressionEvaluator\[Languag Guid]\[Vendor Guid].

[In] Describes a programming language. [Out] Pairing between the name of a setting and its value.

Get the user document visual studio folder path.

Queries the language service (IVsLanguageDebugInfoScript) to obtain script block information from the associated project item of the specified script document.

[In] Represents a document which is executing in a script runtime environment. For example, the Microsoft JavaScript engine. [Out] Set of script blocks returned from the language service.

Interface implemented by the AD7AL as a gateway to services provided by the rest of Visual Studio. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, TransportKind. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

[In] Contains information about a message that is to be displayed to the user. WorkList which is currently being processed. This value can be used to check for cancelation or to append additional work. New work items will not begin executing until after this function returns. Routine to fire when the request is complete. This will be implicitly fired if the implementation returns failure from this interface method. The implementation must fire this method in all other scenarios.

Used to disassemble instructions in the debuggee address space. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, TransportKind.

Disassemble an address range in the debuggee process.

[In] DkmProcess represents a target process which is being debugged. The debugger debugs processes, so this is the basic unit of debugging. A DkmProcess can represent a system process or a virtual process such as minidumps. [In] The address where disassembly should start. [In] The number of instructions to disassemble. [Out] The results of disassembling the address range.

[In] DkmProcess represents a target process which is being debugged. The debugger debugs processes, so this is the basic unit of debugging. A DkmProcess can represent a system process or a virtual process such as minidumps. [In] The address of the current instruction where the offset should begin. [In] The number of instructions relative to StartAddress to find the desired address. This value can be negative. [Out] The address of the instruction InstructionOffset instructions from StartAddress.

A method that calculates and returns the effective addresses for the requested address. The effective address is the calculated address that an instruction operand represents. For instance, on x86, an instruction may be of the form dwordptr [esp-12]. The effective address of this operand will be the result of subtracting 12 from esp. The number of operands and effective addresses are architecture specific.

[In] DkmStackFrame represents a frame on the call stack after filtering and translation. [In] The address for which to obtain the effective addresses. [Out] The collection of effective addresses for this instruction if any.

Used to disassemble instructions in the debuggee address space with respect to a specific runtime. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, RuntimeId, TransportKind. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

Disassemble an address range in the debuggee runtime.

[In] The DkmRuntimeInstance class represents an execution environment which is loaded into a DkmProcess and which contains code to be debugged. [In] The address where disassembly should start. [In] The number of instructions to disassemble. [Out] The results of disassembling the address range.

[In] The DkmRuntimeInstance class represents an execution environment which is loaded into a DkmProcess and which contains code to be debugged. [In] The address of the current instruction where the offset should begin. [In] The number of instructions relative to StartAddress to find the desired address. This value can be negative. [Out] The address of the instruction InstructionOffset instructions from StartAddress.

Interface for querying the GPU debugging breakpoint behavior. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, TransportKind.

Get the breakpoint behavior of the process.

Provides the compute kernel hierarchy, i.e., the thread group, compute vector and compute thread for view by the user. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, TransportKind.

Obtain the warp size of the hardware or emulator.

[In] DkmGPUComputeKernel represents a GPU compute kernel running in the target process. [Out] Width of the hardware.

Obtain the active thread groups from the compute kernel.

[In] DkmGPUComputeKernel represents a GPU compute kernel running in the target process. [Out] List of global Thread group id of all active thread groups. [Out] Number of active thread groups in the compute kernel.

Get the dimension of the thread block.

[In] DkmGPUComputeKernel represents a GPU compute kernel running in the target process. [Out] Thread group dimensions. [Out] Number of Thread block dimensions.

Get the dimension of the thread block.

[In] DkmGPUComputeKernel represents a GPU compute kernel running in the target process. [Out] Grid Dimensions. [Out] Number of Grid dimensions.

Get the dimension of the thread block.

[In] DkmGPUComputeThread represents a compute thread running in the GPU target process. [Out] Thread group dimensions. [Out] Number of Thread block dimensions.

Get the dimension of the thread block.

[In] DkmGPUComputeThread represents a compute thread running in the GPU target process. [Out] Grid dimensions. [Out] Number of Grid dimensions.

Get the name of compute kernel.

[In] DkmGPUComputeKernel represents a GPU compute kernel running in the target process. [Out] Name of the ComputeKernel that is launched.

Get properties of the compute kernel.

[In] DkmGPUComputeKernel represents a GPU compute kernel running in the target process. [Out] List of Compute kernel properties. [Out] Number of properties in the compute kernel.

Get the dimension of the thread block.

[In] DkmGPUComputeThread represents a compute thread running in the GPU target process. [Out] Thread group dimensions. [Out] Number of Thread block dimensions.

Get the dimension of the thread block.

[In] DkmGPUComputeThread represents a compute thread running in the GPU target process. [Out] Grid dimensions. [Out] Number of Grid dimensions.

Runs the select query on thread info objects.

[In] DkmGPUComputeKernel represents a GPU compute kernel running in the target process. [In] From clause specification for selection (can be empty to select from all available threads). [In] Where clause specification for selection. [Out] The result set of compute thread info objects.

Runs the group by query on thread info objects.

[In] DkmGPUComputeKernel represents a GPU compute kernel running in the target process. [In] Flags specifying on which columns the group by is run. [In] From clause specification for selection (can be empty to select from all available threads). [In] Where clause specification for group by. [Out] The result set of compute thread info objects.

Get all threads that hit breakpoint.

[In] DkmGPUComputeKernel represents a GPU compute kernel running in the target process. [Out] The result set of compute thread ids that hit breakpoint.

Gets the DkmGPUComputeThread object for a given thread ID.

[In] DkmGPUComputeKernel represents a GPU compute kernel running in the target process. [In] ID of the thread to return. [Out] Thread object that matches the given thread ID.

Update flagged state of compute threads.

[In] DkmGPUComputeKernel represents a GPU compute kernel running in the target process. [In] Where clause specification for update. [In] The value to update with.

Update frozen state of compute threads.

[In] DkmGPUComputeKernel represents a GPU compute kernel running in the target process. [In] Where clause specification for update. [In] The value to update with.

Get the dimension of the thread block.

[In] DkmGPUComputeKernel represents a GPU compute kernel running in the target process. [Out] Thread group dimensions. [Out] Thread group dimensions. [Out] Number of Thread block dimensions. [Out] Model Type.

Used to query raw disassembly in the GPU debuggee byte code. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, RuntimeId, SymbolProviderId, TransportKind.

Obtain the disassembly of the address range in the debuggee module instance.

Returns the disassembly size in the debuggee module instance.

Returns the address of the next instruction relative to a starting address.

Implemented by base debug monitors to provide access to the memory of the target GPU process. Base debug monitors are responsible for performing the memory I/O. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, TransportKind.

Read the memory of the target GPU process. The method is on DkmGPUComputeThread because it may read thread local memory, group shared memory or global memory.

[In] DkmGPUComputeThread represents a compute thread running in the GPU target process. [In] The address from which to read the target GPU process's memory. [In] The instruction pointer where to resolve address to register location. [In] Flags controlling the behavior of DkmProcess.ReadMemory and DkmProcess.ReadMemoryString. [In,Out] A buffer that receives the contents from the address space of the target process. On failure, the content of this buffer is unspecified. [Out] Indicates the number of bytes read from the target GPU process. If DkmReadMemoryFlags.AllowPartialRead is clear, on success this value will always be exactly equal to the input size. If DkmReadMemoryFlags.AllowPartialRead is specified, on success, this value will be greater than zero.

Writes memory to the target GPU process. The method is on DkmGPUComputeThread because it may write thread local memory, group shared memory or global memory.

[In] DkmGPUComputeThread represents a compute thread running in the GPU target process. [In] The base address from which to write the target GPU process's memory. [In] The instruction pointer where to resolve address to register location. [In] Data to be written in the address space of the specified GPU process.

Checks if a tag for a buffer has been forwarded for this kernel execution.

[In] DkmGPUComputeThread represents a compute thread running in the GPU target process. [In] The C++ AMP pointer tag. [Out] The forwarded tag value.

Validate the specified GPU memory address.

[In] DkmGPUComputeThread represents a compute thread running in the GPU target process. [In] The address to validate. [Out] True if the specified address is a valid GPU memory address, false otherwise.

Implemented by base debug monitors to provide access to the registers of the GPU compute thread. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, TransportKind.

Obtain the list of all register descriptions from the GPU compute thread.

[In] DkmGPUComputeThread represents a compute thread running in the GPU target process. [Out] The list of all register descriptions from the GPU compute thread.

Set the value of a register in the GPU compute thread.

[In] DkmGPUComputeThread represents a compute thread running in the GPU target process. [In] The description of a register from the GPU compute thread. [In] The value bytes of a register to be written in the GPU compute thread.

IDkmGPUSetMemoryAccessWarningOperation is used to configure GPU memory access warnings on the debugged GPU device. It is implemented by base debug monitors which support reporting GPU Memory Access Exceptions. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, TransportKind.

Enables / disables a particular GPU memory access warning.

Disables all active GPU memory access warnings.

Callback interface which is implemented by GPU symbol providers to provide information from the symbol store to base debug monitors. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: SymbolProviderId.

Translate accelerator pointer tag into HLSL register attributes.

This method returns address information to the GPU debug monitor.

[In] DkmInstructionSymbol represents a method in the target process. [In,Optional] Abstract representation of an executable code location (ex: EIP value). If resolved, an Instruction Address will be within a particular module instance. An Instruction Address is always within a particular Runtime Instance. [In] The next instruction address which is used to determine inline function call. [Out,Optional] The address type information.

This method returns compiler flags of the given GPU module.

Queries the symbol provider to determine the ranges of instructions which do not correspond to any user source statements and are used by the base debug monitor to always step through during stepping.

[In] DkmInstructionSymbol represents a method in the target process. [Out] Array of no source ranges to always step through. This array will be empty if there are no no-source ranges for the given instruction.

This API is used to read information about a symbol for DPC++. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: CompilerVendorId, LanguageId, SymbolProviderId, TransportKind.

Translate accelerator pointer tag into HLSL register attributes using relative virtual address.

Verify if the accelerator pointer tag is valid.

Gets a C++ AMP address for a register.

Sets a C++ AMP address for a register.

Gets a C++ AMP address for a register.

GetInstructionOffsetForRva is used by components to query symbol provider to perform instruction offset and RVA translation for DPC++.

Allows remote components to obtain source position information for DPC++ when the symbol provider is on the VS machine. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: RuntimeId, SymbolProviderId.

[In] DkmInstructionSymbol represents a method in the target process. [In,Optional] A reference object describing the current inspection session. Common usage is for symbol providers to cache lookups using its data container. [Out,Optional] Source code position which corresponds to a code element. The could represent a location which has been extracted from a symbol (PDB) file, or it could be the location of a breakpoint in the IDE.

Interface implemented by GPU base debug monitors to enable temporary instruction breakpoints in stepping. The temporary instruction breakpoints are passed to ContinueDebugEvent. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, SourceId.

Enable temporary breakpoint in stepping on a thread. This is similar to single step except one or more instructions are advanced. When breakpoint is hit, step complete event is sent.

[In] DkmSingleStepRequest represents a request to single step a thread. [In] The instruction offset of temporary breakpoints to set.

Clear temporary breakpoint in stepping on a thread.

[In] DkmSingleStepRequest represents a request to single step a thread.

Interface implemented by base debug monitors which read symbols from debuggee's memory at runtime. This interface would be implemented by base debug monitors to deal with symbol formats which are generated or loaded at runtime in the debuggee's memory. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, RuntimeId, SymbolProviderId, TransportKind.

This method is invoked by symbol handlers to read symbols for DkmModuleInstances whose symbols reside in debuggee's memory.

Implemented by components which create DkmScriptDocument objects in order to provide document content and notifications when the content changes. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, RuntimeId, SymbolProviderId.

Provides the current content of the specified document object.

[In] Represents a document which is executing in a script runtime environment. For example, the Microsoft JavaScript engine. [In] If true, the script document provider should raise events when the content of this document changes. Passing true is equivalent to calling SetRaiseContentEvents(true). If false, the RaiseContentEvent state remains the same. [Out] For aggregate documents (DkmScriptDocumentFlags.AggregateDocument is set), this is the 1-based line numbers for where the section dividers should be drawn. For standard documents, an empty array is returned. [Out] The current content of this document.

Enables or disables raising events when the content of the document is changed. By default, documents do not generate content events. So this method should be called by any component that wishes to receive content events. The script document manager maintains a count of the number of calls to enable content events, and will raise events whenever this count is greater than 0. Callers should take care to ensure that SetRaiseContentEvents(false) is called ONLY after a successful call to SetRaiseContentEvents(true). Content events are automatically disabled when the document is unloaded.

[In] Represents a document which is executing in a script runtime environment. For example, the Microsoft JavaScript engine. [In] If true, content events should be enabled for this document. If false, the count of content event listeners is decremented. When the count reaches zero, no further events will be sent.

API implemented by the script local agent to match script documents against breakpoint requests. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, RuntimeId, SymbolProviderId.

This method is called when a script document is created or when the project item path is set to try and bind breakpoints against the given script document.

[In] Represents a document which is executing in a script runtime environment. For example, the Microsoft JavaScript engine. [In] Identifies a source file and provides the information which a symbol handler could use to search a symbol file (PDB) for information on this source file. [Out,Optional] If the given script document matches the given source file id, this returns a DkmResolvedDocument for the match. Otherwise, null is returned.

Implemented by components which create DkmScriptDocument objects, and use them as the basis of symbol resolution. This interface doesn't need to be implemented by script document system which leave DkmResolvedDocument.ScriptDocument as null. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, RuntimeId, SymbolProviderId.

[In] Represents a document which is executing in a script runtime environment. For example, the Microsoft JavaScript engine. [In] If true, symbol events should be enabled for this document. If false, the count of symbol event listeners is decremented. When the count reaches zero, no further events will be sent.

Walk async call stack and task creation stacks. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: EngineId, RuntimeId, SymbolProviderId, TaskProviderId. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

Gets the logged creation stack of this task.

Gets the async call stack of this thread.

Interface implemented by the task provider component to obtain information about tasks. This interface is subject to change in future versions of Visual Studio. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, TaskProviderId.

Enumerates the current set of tasks running in the target process.

[In] Represents a task provider which is loaded into the target process. [In] TODO. [In] Count of tasks requested. [Out] Number of scheduled tasks. [Out] Array contained the found tasks. [Out] TODO.

TODO.

[In] Represents a task provider which is loaded into the target process. [Out] TODO.

Returns children tasks.

[In] Represents either a managed TPL task or a native Concurrency Runtime task. [Out] TODO.

Returns task properties.

[In] Represents either a managed TPL task or a native Concurrency Runtime task. [In] TODO. [In] TODO. [Out] TODO.

Optional interface implemented by task providers to receive a notification when task providers are first requested for a particular process. This interface is subject to change in future versions of Visual Studio. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, TransportKind.

Invoked by the AD7 AL to provide a notification when task providers are first requested from the UI for a particular process. This allows implementations to delay initialization to when the task UI if first shown.

Interface implemented by task provider components to provide the set of synchronization objects owned by a task. This interface is subject to change in future versions of Visual Studio. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, TaskProviderId.

TODO.

[In] Represents either a managed TPL task or a native Concurrency Runtime task. [Out] TODO.

Interface implemented by edit and continue engine to support status query service. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: RuntimeId, SymbolProviderId. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

Check if the address is in stale code or not.

[In] DkmInstructionSymbol represents a method in the target process. [In] The owning module instance of the checking address. [In] Specify if this address belongs to leaf frame or not. [Out] True if address is in stale code, False otherwise.

Interface used to gather performance data from the debuggee. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: BaseDebugMonitorId, EngineId, TransportKind. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

[In] DkmProcess represents a target process which is being debugged. The debugger debugs processes, so this is the basic unit of debugging. A DkmProcess can represent a system process or a virtual process such as minidumps. WorkList which is currently being processed. This value can be used to check for cancelation or to append additional work. New work items will not begin executing until after this function returns. Routine to fire when the request is complete. This will be implicitly fired if the implementation returns failure from this interface method. The implementation must fire this method in all other scenarios.

Agent operations relating to production diagnostics. The agent will be launched with STDIN and STDOUT redirected. A client can write to STDIN by sending a UTF8 string through the SendMessage method. When the process writes to STDOUT, DkmCustomMessage::SendToVsService is invoked with the source id set to DkmProductionAgent::UniqueId and the UTF8 encoded contents in param1. Implementations of this interface are always called (no filtering is supported). To reduce memory impact, it is suggested that this interface be implemented in a small dll, or that the implementation is configured with 'CallOnlyWhenLoaded="true"'. This API was introduced in Visual Studio 15 Update 2 (DkmApiVersion.VS15Update2).

Send a message to a production agent.

[In] DkmProductionAgent represents an agent process launched using the StartAgent method of DkmProductionConnection. [In] The message to send to the agent encoded as a UTF8 string.

Operations relating to production diagnostics. Implementations of this interface may restrict when they are called using a filter defined in their component configuration. The following properties may be used: TransportKind. This API was introduced in Visual Studio 15 Update 2 (DkmApiVersion.VS15Update2).

Start an agent process with input and output redirected.

[In] This represents a connection between the monitor and the IDE with the purpose of transporting messages related to the production scenario. [In] The path of the agent executable. The path will have environment variables expanded. [In] The command line parameters to pass to the agent. [In] The Guid of the VS service to send the contents of writes to stdout to. [Out] The DkmProductionAgent instance that represents this agent.

Enumeration code of the various versions of this API.

Visual Studio 11 Release to Manufacturing (RTM) version

Visual Studio 11 Update 1

Visual Studio 11 Update 2

Visual Studio 12 Release to Manufacturing (RTM) version

Visual Studio 12 Update 2

Visual Studio 12 Update 3

Visual Studio 14 Release to Manufacturing (RTM) version

Visual Studio 14 Windows 10 Tools 1.1

Visual Studio 14 Update 1

Visual Studio 14 Update 2

Visual Studio 14 Update 3

Visual Studio 14 Update 3 Micro Update

Visual Studio 15 Release to Manufacturing (RTM) version

Visual Studio 15 Update 1

Visual Studio 15 Update 2

Visual Studio 15 Update 3

Visual Studio 15 Update 4

Visual Studio 15 Update 5

Visual Studio 15 Update 6

Visual Studio 15 Update 7

Visual Studio 15 Update 8

Visual Studio 15 Update 9

Visual Studio 16 RTM (Release to Manufacturing) preview version

Visual Studio 16 Release to Manufacturing (RTM) version

Visual Studio 16 Update 1

Visual Studio 16 Update 2

Visual Studio 16 Update 3

Visual Studio 16 Update 4

Indicates the type of async-break that occurred.

An active thread was found inside the target process and the debugger used it to break.

The target process appears to be deadlocked and was frozen to emulate break mode.

The caller of AsyncBreak requested an immediate break. The target process is frozen to emulate break mode.

DkmBaseDebugMonitorId identifies the base debug monitor used to inspect and control the debugged process. For example, DkmBaseDebugMonitorId.WindowsProcess is used for processes debugged by the Win32 debugging API and DkmBaseDebugMonitorId.DumpFile is used for minidumps.

DkmProcess is backed by a live Microsoft Windows process.

DkmProcess is debugged using ONLY the ICorDebug API (the process is not being debugging through the Win32 debugging API). This value is used when debugging with the ICorDebug v2 pipeline. Scenarios include debugging a Win32 process running the v2 CLR and debugging a managed process running on a Windows CE device.

DkmProcess is back by a minidump or crashdump file.

DkmProcess is backed by a live Microsoft Windows ActiveScript process.

DkmProcess is backed by a live Microsoft Windows D3D process that runs GPU code on GPU hardware or reference rasterizer.

DkmProcess is a live win32 process being debugged with the legacy in-process CLR interop model. Both managed and native code can be debugged.

Managed/native interop dump debugging.

DkmProcess is backed by a snapshot of a win32 process. Such a debuggee can be inspected but all execution control operations are blocked including stepping and func-eval. This is necessary because the process is not fully initialized and cannot run code.

DkmProcess is backed by a time travel trace file.

DkmProcess is backed by a time travel trace file with interop debugging enabled.

Specifies the type of User Interface that is driving an instance of the engine. This API was introduced in Visual Studio 15 RTM (DkmApiVersion.VS15RTM).

No client UI has been specified.

The Visual Studio IDE.

The Visual Studio Code Editor.

The Xamarin Studio IDE.

Message structure used to pass information between custom debugger backend components and custom visual studio UI components (packages, add-ins, etc).

[Optional] Transport connection used to send the message.

[Optional] DkmProcess represents a target process which is being debugged. The debugger debugs processes, so this is the basic unit of debugging. A DkmProcess can represent a system process or a virtual process such as minidumps.

Identifies the source of an object. SourceIds are used to enable filtering in scenarios when multiple components may be creating instances of a class. For example, source ids can be used to determine if a breakpoint comes from the AD7 AL (ex: user breakpoint, or other breakpoint visible at the SDM level) instead of a breakpoint which may be created by another component (for example an internal breakpoint used for stepping).

Identifies the type of custom event being sent. Partners are free to define any set of values.

[Optional] Specifies additional message-specific information. Note that if this message may need to travel over remoting boundaries, it is important to restrict the type of this parameter to something which can be marshalled: strings, primitives (ex: int), and arrays of primitives (ex: byte array).

[Optional] If non-null, this specifies the worker process connection that the message should be sent through. This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTMPreview).

Create a new DkmCustomMessage object instance.

[In,Optional] Transport connection used to send the message. [In,Optional] DkmProcess represents a target process which is being debugged. The debugger debugs processes, so this is the basic unit of debugging. A DkmProcess can represent a system process or a virtual process such as minidumps. [In] Identifies the source of an object. SourceIds are used to enable filtering in scenarios when multiple components may be creating instances of a class. For example, source ids can be used to determine if a breakpoint comes from the AD7 AL (ex: user breakpoint, or other breakpoint visible at the SDM level) instead of a breakpoint which may be created by another component (for example an internal breakpoint used for stepping). [In] Identifies the type of custom event being sent. Partners are free to define any set of values. [In,Optional] Specifies additional message-specific information. Note that if this message may need to travel over remoting boundaries, it is important to restrict the type of this parameter to something which can be marshalled: strings, primitives (ex: int), and arrays of primitives (ex: byte array). [In,Optional] Specifies additional message-specific information. Note that if this message may need to travel over remoting boundaries, it is important to restrict the type of this parameter to something which can be marshalled: strings, primitives (ex: int), and arrays of primitives (ex: byte array). [Out] Result of this method call.

Create a new DkmCustomMessage object instance. This API was introduced in Visual Studio 15 RTM (DkmApiVersion.VS15RTM).

Create a new DkmCustomMessage object instance. This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTMPreview).

Raises a CustomStop event to a VS service which is expecting it. Note that there are restrictions on the type for parameters to this custom message. See DkmCustomMessage.SendToVsService for more information.

[In] DkmThread represents a thread running in the target process. [In] Visual Studio service that this event should be sent to. A VS package must register this service id (ex: Software\Microsoft\VisualStudio\$(ver)\Services\{VsService}) and this package must implement the IVsCustomDebuggerStoppingEventHandler110 interface.

Sends a message to a listening component which is higher in the hierarchy.

[Out,Optional] Message sent back from the implementation.

Sends a message to a listening component which is lower in the hierarchy.

[Out,Optional] Message sent back from the implementation.

Sends a message to a listening component which is lower in the hierarchy. This method will append a new work item to the specified work list, and return once the work item has been appended. The actual processing of the work item is asynchronous. The caller will be notified that the request is complete through the completion routine.

WorkList to append the new work item to. Routine to fire when the request is complete. If the request is successfully appended to the work list, this will always fire (including when the operation is canceled). This will never fire if appending the work item fails.

[In] Visual Studio service that this event should be sent to. A VS package must register this service id. The service class must implement the IVsCustomDebuggerEventHandler110 interface. Services can be registered in the registry ($RootKey$\Services\{VsService}), or through the VS shell IProfferService interface. Registry keys may be set through .pkgdef files. If the service should be called even if it is not already loaded, then the registry approach should be used. If the service should only be called if it has already been started, then IProfferService should be used. [In] True if SendToPackage should block waiting for the package to finish processing this message. Note that before Visual Studio 2015, when true, DkmCustomMessage.Process must be non-null. This requirement was dropped in Visual Studio 2015.

Obtain a pointer to the native object used to call into native. This method is invoked from IXapiMarshalableElement<IntPtr>.ManagedToNative or from a derived classes's implementation of this function.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Action to be taken if the data item is already in the container.

Add the data item only if there is no other data item with the same id.

Always add the data item. If the data item is already present then overwrite it with the new value.

Internal flags indicating the current state of a dispatcher object.

No flags are currently set

Object has been fully initialized and has not been closed

Object has been unloaded

Critical Section has been initialized

Object is hidden from components which are above the creation level.

Object is hidden from components which are below the creation level.

Reference object has been marshalled into its associated connection

Result of an asynchronous DkmUserMessage.DisplayPrompt call.

Creates a new result structure to hold the error from a failed call to DkmUserMessage.DisplayPrompt.

[In] exception object containing the error

HRESULT code returned from the caller. This will be DkmExceptionCode.COR_E_OPERATIONCANCELED (0x8013153B) if the operation was canceled before processing was complete.

Win32 'ID' code from displaying the message box (ex: IDYES). These codes are defined in winuser.h from the Windows SDK. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

Creates a new result structure to hold the output from a successful call to DkmUserMessage.DisplayPrompt.

[In] Win32 'ID' code from displaying the message box (ex: IDYES). These codes are defined in winuser.h from the Windows SDK.

Type of dump to save.

Save a basic minidump. Global memory, heap memory, and modules are not included.

Save a full minidump. Global memory, heap memory, and modules are included.

Flags that indicate immutable traits of this engine settings.

No process debug flags are set.

This flag should no longer be read, instead use DkmDebugLaunchSettings.IsNativeCodeSupported(). This flag may still be written and indicates that this engine id supports native code debugging.

Engine will use Just My Code when enabled from the IDE.

These are the 'standard' engine GUID values. It is expected that this list will grow over time, so where possible, it is recommended to query for a setting instead of comparing the EngineId.

Native-only debugging engine Guid.

Debug engine for debugging all code within a Win32 process.

Debug engine for debugging CLR code within the desktop CLR v2.0. For example, a VB application. When debugging in this mode, native debugging is not possible.

Debug engine for debugging CLR code within CLR v4. When debugging in this mode, native debugging is not possible.

Debug engine for debugging only user CLR code inside the Microsoft SQL Server process.

Debug engine used for Silverlight debugging.

Debug engine used for .NET Compact Framework v1 debugging.

Debug engine used for .NET Compact Framework v2 debugging.

Debug engine used for debugging Silverlight apps on Apple computers.

Debug engine used for active script debugging (ex: script in Microsoft Internet Explorer).

Debug engine used for Core CLR debugging in Silverlight and XNA apps on Windows Phone.

Debug engine used for Concord interop CLR v2. This GUID is used within Concord and is not known above the AD7 layer.

Debug engine used for Concord interop CLR v4. This GUID is used within Concord and is not known above the AD7 layer.

Debug an application running under the native-compiled .NET Framework.

Engine for debugging snapshots.

Contains the session-wide debug settings. There is one instance of this object per engine Guid (ex: one instance for COMPlusOnlyEng2, one instance for COMPlusNativeEng).

These are the 'standard' engine GUID values. It is expected that this list will grow over time, so where possible, it is recommended to query for a setting instead of comparing the EngineId.

Flags that indicate immutable traits of this engine settings.

Indicates which version of the CLR debugging services (mscordbi.dll or other implementation of the ICorDebug API) should be used when debugging this process.

Collection of all programming languages supported while debugging this process.

List of supported values for IMAGE_DEBUG_DIRECTORY.Type.

Specifies whether FEQA is enabled for this engine for this debug session.

List of executables for whom FEQA isn't enabled even if FEQA DLLs are loaded.

Enables stepping over 'await' statements and stepping out of async methods. This is on by default.

List of PDB name patterns used to determine if PDB will be loaded on remote side.

Base debug monitor used by this engine. This value may be Guid.Empty (GUID_NULL) if the engine may use various base debug monitors depending on the process being debugged.

The maximum number of frames supported in the call stack window. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

Enables Edit and Continue. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

True if the debugger should validate the digital signatures of CLR debugging libraries before loading them. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

[Optional] List of registry tweaks in the Visual Studio registry that components may use to customize their behavior. Registry tweaks are read from the key [Visual Studio Registry Root]\Debugger\Engine at the start of each debug session. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

Used to indicate whether to create a dump of the debuggee when a func eval is aborted or rude aborted. This API was introduced in Visual Studio 15 Update 4 (DkmApiVersion.VS15Update4).

If data breakpoints descriptors should be treated as strings. This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTM).

When true, the debugger will enable JustMyCode features (stepping, call stack, and exception filtering).

A collection of DkmStrings representing the symbol search paths and cache path.

When true, the debugger will suppress Just-In-Time compiler optimizations for newly-loaded modules.

When true, the debugger will step over properties and operators when a step in is done.

When true, the debugger will will attempt to use the export tables from Win32 PE files to resolve addresses.

When true, the debugger will ignore GPU race hazards that didn't change the previous data.

When true, the debugger will require assemblies to be fully trusted before executing source server commands from an assembly. The concept of fully trusted only applies to CLR assemblies.

[Optional] Trace settings for WPF output. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

When true, the debugger will enable Just My Code stepping for native (when the module is compiled with the /JMC switch). This API was introduced in Visual Studio 15 Update 8 (DkmApiVersion.VS15Update8).

When true, the debugger will load native symbols in a separate process. This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTMPreview).

When true (the default state), the CLR inspector will attempt to interpret simple properties/methods in some cases rather than using func-eval. More complicated methods will still be evaluated using func-eval. This API was introduced in Visual Studio 16 Update 2 (DkmApiVersion.VS16Update2).

Find a DkmEngineSettings object. If no object with the given input key is present, FindSettings will fail.

[In] Search key used to find the element. [Out,Optional] Result of the search.

GetSettings enumerates all the created DkmEngineSettings objects.

[Out] Array containing the enumerated elements.

Find a DkmProcess element within this DkmEngineSettings. If no element with the given input key is present, FindProcess will fail.

[In] Search key used to find the element. [Out,Optional] Result of the search.

GetProcesses enumerates the DkmProcess elements of this DkmEngineSettings object.

[Out] Array containing the enumerated elements.

Returns the DkmLanguage object which matches the given compiler id. If the language is unknown (not registered with the engine), then this method will return the default language object.

[In] LanguageId/VendorId search key. Both values may be Guid.Empty to obtain the default language. Otherwise the vendor id must be non-zero or the default language object will be returned. [Out] Describes a programming language.

Returns the enumeration of DkmCodeViewCompilerId values. This enumeration may then be used by a symbol provider to map the information within a code view record to the DkmCompilerId structure.

[Out] DkmCodeViewCompilerId[] is used to translate information that is within the S_COMPILE* code view records into a DkmCompilerId. This allows the debugger to load an appropriate expression evaluator for a stack frame. Symbol providers may obtain this collection through DkmEngineSettings. Expression evaluators may add additional entries to this collection by having their setup add sub key(s) to the '%VSRegistryRoot%\Debugger\CodeView Compilers' registry key.

Get the user document visual studio folder path.

[Out] Returns the user document visual studio path.

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Enumeration of all events which are currently defined in this API.

Flags to indicate what type of logging to perform on a func eval abort. This API was introduced in Visual Studio 15 Update 4 (DkmApiVersion.VS15Update4).

No logging on func eval abort.

Create a full dump when a func eval is aborted.

Create a full dump when a func eval is rude-aborted.

Create a minidump when a func eval is aborted.

Create a minidump when a func eval is rude-aborted.

Indicates if there is a function evaluation occurring in the target process and if stopping events are allowed for this evaluation.

No function evaluation is currently in progress.

A function evaluation is currently in progress. No stopping events are permitted on the queried thread, so stopping events will be suppressed after the 'received' phase of stopping event processing. This value is used when (1) the function evaluation was started without the DkmFuncEvalFlags.AllowStoppingEvents flag -or- (2) the queried thread is not the evaluating thread and DkmFuncEvalFlags.RunAllThreads was not used.

A function evaluation is currently in progress. Stopping events are permitted on the queried thread, so if the queried thread hits a breakpoint, the debugger may enter nested break state.

Result of an asynchronous DkmInstructionAddress.GetCurrentCPUAddress call.

Creates a new result structure to hold the error from a failed call to DkmInstructionAddress.GetCurrentCPUAddress.

[In] exception object containing the error

HRESULT code returned from the caller. This will be DkmExceptionCode.COR_E_OPERATIONCANCELED (0x8013153B) if the operation was canceled before processing was complete.

An array of the current CPU Instruction Addresses that map to this DkmInstructionAddress.

Creates a new result structure to hold the output from a successful call to DkmInstructionAddress.GetCurrentCPUAddress.

[In] An array of the current CPU Instruction Addresses that map to this DkmInstructionAddress.

Marshal a native struct to managed

Pointer to native struct. Managed object.

Obtain a pointer to the native object used to call into native.

Outgoing managed->native call Native object

Validate the fields of this structure

Struct that holds the field path (ex: "myArgument.StructField")

Result of an asynchronous DkmProcess.GetInstructionAddress call.

Creates a new result structure to hold the error from a failed call to DkmProcess.GetInstructionAddress.

[In] exception object containing the error

HRESULT code returned from the caller. This will be DkmExceptionCode.COR_E_OPERATIONCANCELED (0x8013153B) if the operation was canceled before processing was complete.

True if this address is the first address in the line's range. False otherwise.

Creates a new result structure to hold the output from a successful call to DkmProcess.GetInstructionAddress.

Marshal a native struct to managed

Pointer to native struct. Managed object.

Obtain a pointer to the native object used to call into native.

Outgoing managed->native call Native object

Validate the fields of this structure

Struct that holds the field path (ex: "myArgument.StructField")

Result of an asynchronous DkmProcess.GetInstructionAddress call.

Creates a new result structure to hold the error from a failed call to DkmProcess.GetInstructionAddress.

[In] exception object containing the error

HRESULT code returned from the caller. This will be DkmExceptionCode.COR_E_OPERATIONCANCELED (0x8013153B) if the operation was canceled before processing was complete.

The address of the instruction InstructionOffset instructions from StartAddress.

Creates a new result structure to hold the output from a successful call to DkmProcess.GetInstructionAddress.

[In] The address of the instruction InstructionOffset instructions from StartAddress.

Marshal a native struct to managed

Pointer to native struct. Managed object.

Obtain a pointer to the native object used to call into native.

Outgoing managed->native call Native object

Validate the fields of this structure

Struct that holds the field path (ex: "myArgument.StructField")

Abstract representation of an executable code location (ex: EIP value). If resolved, an Instruction Address will be within a particular module instance. An Instruction Address is always within a particular Runtime Instance. Derived classes: DkmClrInstructionAddress, DkmClrNcInstructionAddress, DkmCustomInstructionAddress, DkmNativeInstructionAddress, DkmScriptInstructionAddress, DkmUnknownInstructionAddress

CPUInstruction provides the address that the CPU will execute. This is always provided for native instructions. It may be provided for CLR or custom addresses depending on how the address object was created.

The address of where the CPU instruction is located in the target process.

Initialize a new CPUInstruction value.

[In] The address of where the CPU instruction is located in the target process.

DkmInstructionAddress is an abstract base class. This enum indicates which derived class this object is an instance of.

Object is an instance of 'DkmNativeInstructionAddress'.

Object is an instance of 'DkmClrInstructionAddress'.

Object is an instance of 'DkmScriptInstructionAddress'.

Object is an instance of 'DkmCustomInstructionAddress'.

Object is an instance of 'DkmUnknownInstructionAddress'.

[Optional] CPUInstructionPart provides the address that the CPU will execute. This is always provided for native instructions. It may be provided for CLR or custom addresses depending on how the address object was created.

DkmInstructionAddress is an abstract base class. This enum indicates which derived class this object is an instance of.

The DkmRuntimeInstance class represents an execution environment which is loaded into a DkmProcess and which contains code to be debugged.

[Optional] The module containing this address. Addresses without a module cannot have symbols (even for custom addresses). CLR addresses will always have a module. Native addresses will not have a module if either the CPU jumped to an invalid address (ex: NULL), or if the CPU is executing dynamically-emitted code.

DkmProcess represents a target process which is being debugged. The debugger debugs processes, so this is the basic unit of debugging. A DkmProcess can represent a system process or a virtual process such as minidumps.

Convert a DkmInstructionAddress into a DkmInstructionSymbol. If the DkmInstructionAddress is not in a DkmModule then GetSymbol will return null (S_FALSE in native code).

[Out,Optional] DkmInstructionSymbol represents a method in the target process.

Compares two instruction addresses and returns a value indicating whether one is less than, equal to, or greater than the other. The addresses must be from the same module.

[In] An address to compare with this address. [Out] A 32-bit signed integer that indicates the relative order of the objects being compared. The return value has the following meanings: Less than zero: This instance is less than 'other'. Zero: This instance is equal to 'other'. Greater than zero: This instance is greater than 'other'.

Compares two instruction addresses and determines if they are within the same function. Location constraint: API must be called from an IDE component (component level > 100,000).

[In] An address to compare with this address. [Out] True if the two addresses are from the same function.

Resolves a DkmInstructionAddress to a CPU InstructionAddress. This is the reverse mapping of ResolveCPUInstructionAddress. This API is currently only supported by CLR DkmRuntimeInstance objects. Location constraint: This API should generally be called on the client, but it can be called on the server for translating CLR addresses (but not native-compiled).

[Out] An array of the current CPU Instruction Addresses that map to this DkmInstructionAddress.

Resolves a DkmInstructionAddress to a CPU InstructionAddress. This is the reverse mapping of ResolveCPUInstructionAddress. This API is currently only supported by CLR DkmRuntimeInstance objects. This method will append a new work item to the specified work list, and return once the work item has been appended. The actual processing of the work item is asynchronous. The caller will be notified that the request is complete through the completion routine. Location constraint: This API should generally be called on the client, but it can be called on the server for translating CLR addresses (but not native-compiled).

Determines if a given instruction address is user code or not. This method will append a new work item to the specified work list, and return once the work item has been appended. The actual processing of the work item is asynchronous. The caller will be notified that the request is complete through the completion routine. Location constraint: Note: with Visual Studio 2017 Update 8, the CallDirection of the API was made 'Bidirectional' from 'Normal' and can now be called from any component. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Pairing between the name of a setting and its value.

The name of the setting.

The value of the setting. This can be either a DWORD or a string.

Create a new DkmLanguageRegistrySetting object instance.

[In] The name of the setting. [In] The value of the setting. This can be either a DWORD or a string. [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Enumeration describing the time that a memory read resolves to with respect to the current process time. This API was introduced in Visual Studio 15 Update 8 (DkmApiVersion.VS15Update8).

Default value. Represents 'Now' on the current thread.

Describes a value read from a time in the past.

Describes a value read from a time in the future.

Describes a memory range that has gaps in reachable memory across the lifespan of the process.

Flags which indicate traits of a DkmModuleInstance.

No module flags are set.

Module is backed by a file. Note that this is set even in cases where the module could not be resolved (dll is missing, binary could not be found while examining a minidump, etc).

Module is backed by a file and the debug monitor was able to open this file.

Neither the module's file or memory content could be found. Debugging will be impaired.

Module was relocated because it could not load at its preferred base address.

Optimization status for the module could be detected and the module was determined to be optimized.

Optimization status for the module could be detected and the module was determined to be unoptimized.

The module can be edited during debugging. For .NET modules this implies that the CORDEBUG_JIT_ENABLE_ENC is set.

The Module Instance class represent a code bundle (ex: dll or exe) which is loaded into a particular process at a particular location. Module Instance objects are 1:1 with the execution environment's notion of a code bundle. For example, in native code, Module Instance objects are 1:1 with base address. Derived classes: DkmClrModuleInstance, DkmClrNcModuleInstance, DkmCustomModuleInstance, DkmNativeModuleInstance, DkmClrNcContainerModuleInstance

'MinidumpInfo' is used to convey additional information about modules in a DkmProcess for a minidump.

Path where the module was loaded on the computer where the dump was taken.

Initialize a new MinidumpInfo value.

[In] Path where the module was loaded on the computer where the dump was taken.

DkmModuleInstance is an abstract base class. This enum indicates which derived class this object is an instance of.

Object is an instance of 'DkmNativeModuleInstance'.

Object is an instance of 'DkmClrModuleInstance'.

Object is an instance of 'DkmCustomModuleInstance'.

Object is an instance of 'DkmClrNcContainerModuleInstance'.

[Optional] 'MinidumpInfoPart' is used to convey additional information about modules in a DkmProcess for a minidump.

DkmModuleInstance is an abstract base class. This enum indicates which derived class this object is an instance of.

Uniquely identifies the DkmModuleInstance object.

Short representation of the module name. For file-based modules, this is the file name and extension (ex: kernel32.dll).

Fully qualified module name. For file-based modules, this is the full path to the module (ex: c:\windows\system32\kernel32.dll.

Date/Time of when the loaded module was built. This value is obtained from the IMAGE_NT_HEADERS of the loaded module. The unit of measurement is a FILETIME value, which is a 64-bit value representing the number of 100-nanosecond intervals since January 1, 1601 (UTC).

The DkmRuntimeInstance class represents an execution environment which is loaded into a DkmProcess and which contains code to be debugged.

[Optional] File version information.

[Optional] Contains information needed to locate symbols for this module. On Win32, this information is contained within the IMAGE_DEBUG_DIRECTORY.

Flags which indicate traits of a DkmModuleInstance.

Enumeration that indicates how a module is laid out in memory.

[Optional] The starting memory address of where the module loaded. This value will be zero if the module did not load in a contiguous block of memory.

The integer count of the number of module instances that have loaded up to and including this module. Each runtime instance keeps track of its own load order count.

[Optional] The number of bytes in the module's memory region. This value will be zero if the module did not load in a contiguous block of memory.

String description of the context under which this module has been loaded. ex: 'Win32' or 'CLR v2.0.50727: Default Domain'.

This represents a connection between the monitor and the IDE. It can either be a local connection if the monitor is running in the same process as the IDE, or it can be a remote connection. In the monitor process, there is only one connection.

Indicates if this module instance has been disabled. Disabled modules are largely ignored by the debugger. For native modules, the address range of the disabled module is treated as if it is unmapped. For CLR modules, any frames from these modules is hidden from the call stack.

[Optional] The symbol handler's representation of a module (DkmModule) which is associated with this module instance. This value is initially null, and is assigned if and when symbols are associated with this module instance.

Updates the disabled status on a module. This method may only be called from a ModuleInstanceLoad event. When disabling a module, it is common to also suppress the module load event.

[In] Indicates if this module instance has been disabled. Disabled modules are largely ignored by the debugger. For native modules, the address range of the disabled module is treated as if it is unmapped. For CLR modules, any frames from these modules is hidden from the call stack.

Obtain the disassembly of the address range in the debuggee module instance.

[In] The address where disassembly should start. [In] The number of instructions to disassemble. [In] True if this is forward disassembling, otherwise this is reverse disassembling. [Out] True if the disassembly has reached the end of byte code, false otherwise. [Out] The results of disassembly read from the debuggee byte code.

Returns the disassembly size in the debuggee module instance.

[Out] The disassembly size.

Returns the address of the next instruction relative to a starting address.

[In] The address of the current instruction. [Out] The address of the next instruction from StartAddress.

This method is invoked by base debug monitors in response to a call to IDkmModuleSymbolsLoaded.RaiseSymbolsLoadedEvent. This method must be invoked from the event thread, or from the request thread as part of a reload. Base debug monitors should synchronously switch to the event thread, pause the target process, and invoke OnSymbolsLoaded. Location constraint: API must be called from a Monitor component (component level < 100,000).

This method is invoked by a symbol provider to associate a DkmModule with a DkmModuleInstance and to trigger a ModuleSymbolsLoaded event. It may be called only once for a DkmModuleInstance object. Calling this API will both establish the DkmModule<->DkmModuleInstance association, as well as cause a ModuleSymbolsLoaded event to be raised.

[In] The DkmModule that is associated with the DkmModuleInstance. [In] True if symbols are being reloaded for an existing module, False if this is happening as part of module load processing.

Runtime instances call this method to mark a module as a boundary module. When stepping, runtimes should check if the step has hit a boundary module and start stepping arbitration if they have. Note that some runtimes may not be able to honor this request. The dispatcher will keep a count of the number of times this has been called. Only when a matching number of calls to ClearTransitionModuleFlag have been made will the module no longer be considered a transition module. Location constraint: API must be called from a Monitor component (component level < 100,000).

Runtime instances call this method to mark a module as a boundary module. When stepping, runtimes should check if the step has hit a boundary module and start stepping arbitration if they have. Note that some runtimes may not be able to honor this request. The dispatcher will keep a count of the number of times FlagAsTransitionModule has been called. Only when a matching number of calls to ClearTransitionModuleFlag will the module no longer be considered a transition module. Location constraint: API must be called from a Monitor component (component level < 100,000).

Returns true if any runtime instance has flagged this module as a transition module. Location constraint: API must be called from a Monitor component (component level < 100,000).

[Out] Boolean return value. True if the module is a transition module. False otherwise.

Attempt to load a binary that previously failed to load using updated symbol paths. Location constraint: API must be called from an IDE component (component level > 100,000).

Called to initiate loading of symbols for DkmModuleInstances whose symbols were not found when the module loaded. Location constraint: API must be called from an IDE component (component level > 100,000).

Obtain a localized a string description of the current symbol status. Location constraint: API must be called from an IDE component (component level > 100,000).

[In] This value will be true for creating the initial load output message, and false for obtaining the output window text. [Out] Localized status string (ex: 'Symbols Loaded', 'No symbols loaded', etc.).

[Out] String containing information about the symbol search. The typical format is 'location1:result1\r\nlocation2:result2...'.

This method is invoked by symbol handlers to read symbols for DkmModuleInstances whose symbols reside in debuggee's memory.

[Out,Optional] The symbol buffer that is read from debuggee's memory at runtime.

Raise a ModuleSymbolsUpdated event. Components which implement the event sink interface will receive the event notification. Control will return once all components have been notified.

Raise a BinaryLoaded event. Components which implement the event sink interface will receive the event notification. Control will return once all components have been notified. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

[In] The full path, relative to the computer running Visual Studio to open the minidump, of the matching binary we were able to find.

Determines if a module is considered user code. Location constraint: This method can be called from an IDE component. Starting in Visual Studio 2013 Update 2, it is also possible to call this from a monitor component for managed code. From Visual Studio 2017 Update 8, the CallDirection of the API was made 'Bidirectional' from 'Normal' and can now be called from any component, AsyncCaller was set to 'true' and the CallerLocationConstraint was set to 'None' from 'NoMarshalling'. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

[Out] True if some or all of the module is user code. False if the entire module is nonuser code.

Determines if a module is considered user code. This method will append a new work item to the specified work list, and return once the work item has been appended. The actual processing of the work item is asynchronous. The caller will be notified that the request is complete through the completion routine. Location constraint: This method can be called from an IDE component. Starting in Visual Studio 2013 Update 2, it is also possible to call this from a monitor component for managed code. From Visual Studio 2017 Update 8, the CallDirection of the API was made 'Bidirectional' from 'Normal' and can now be called from any component, AsyncCaller was set to 'true' and the CallerLocationConstraint was set to 'None' from 'NoMarshalling'. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

Raise a BinaryReloadOpportunity event. Components which implement the event sink interface will receive the event notification. Control will return once all components have been notified. Location constraint: API must be called from a Monitor component (component level < 100,000). This API was introduced in Visual Studio 12 Update 2 (DkmApiVersion.VS12Update2).

This method allows a component to determine if module load event for a module was suppressed. This API was introduced in Visual Studio 12 Update 3 (DkmApiVersion.VS12Update3).

[Out] Returns true if module load event was suppressed.

This method is called when a module changes due to EnC or dynamically emitted code. Location constraint: API must be called from a Monitor component (component level < 100,000). This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Result of an asynchronous DkmModuleInstance.IsUserCode call.

Creates a new result structure to hold the error from a failed call to DkmModuleInstance.IsUserCode.

[In] exception object containing the error

HRESULT code returned from the caller. This will be DkmExceptionCode.COR_E_OPERATIONCANCELED (0x8013153B) if the operation was canceled before processing was complete.

True if some or all of the module is user code. False if the entire module is nonuser code. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

Creates a new result structure to hold the output from a successful call to DkmModuleInstance.IsUserCode.

[In] True if some or all of the module is user code. False if the entire module is nonuser code.

Enumeration that indicates how a module is laid out in memory.

The memory layout of this module is unknown or not defined. This is used for CLR dynamic modules.

Dll is loaded using the 'in memory' layout for a PE. This is the result from LoadLibrary or CreateFileMapping(..SEC_IMAGE...).

Dll is loaded using the disk layout for a PE. This is the result of a PE file being directly blitted into a memory buffer using ReadFile.

File version information.

[Optional] 'FileVersion' field from the variable-sized version data (ex: '6.0.6000.16386 (vista_rtm.061101-2205)').

[Optional] 'CompanyName' field from the variable-sized version data (ex: 'Microsoft Corporation').

Most significant 32-bits of the file version (e.g. 0x00030010 = 3.10).

Least significant 32 bits of the file's binary version number (e.g. 0x00000031 = 0.31).

Most significant 32 bits of the binary version number of the product with which this file was distributed (e.g. 0x00030010 = 3.10).

Least significant 32 bits of the binary version number of the product with which this file was distributed (e.g. 0x00000031 = 0.31).

VS_FF_* flags from winver.h of the Platform SDK.

Create a new DkmModuleVersion object instance.

[In,Optional] 'FileVersion' field from the variable-sized version data (ex: '6.0.6000.16386 (vista_rtm.061101-2205)'). [In,Optional] 'CompanyName' field from the variable-sized version data (ex: 'Microsoft Corporation'). [In] Most significant 32-bits of the file version (e.g. 0x00030010 = 3.10). [In] Least significant 32 bits of the file's binary version number (e.g. 0x00000031 = 0.31). [In] Most significant 32 bits of the binary version number of the product with which this file was distributed (e.g. 0x00030010 = 3.10). [In] Least significant 32 bits of the binary version number of the product with which this file was distributed (e.g. 0x00000031 = 0.31). [In] VS_FF_* flags from winver.h of the Platform SDK. [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Process execution counters collection. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

Number of performance watch start/stop iterations. If this number is high then performance data is not reliable. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

System time (in milliseconds) consumed by debuggee process during debugger step. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

User time (in milliseconds) consumed by debuggee process during debugger step. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

Kernel time (in milliseconds) consumed by debuggee process during debugger step. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

System time (in milliseconds) considered to be the runtime overhead during debugger step. SystemTime value does not contain this overhead. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

System time (in milliseconds) considered to be the OS overhead during debugger step. SystemTime value does not contain this overhead. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

System time (in milliseconds) considered to be the total overhead during debugger step. SystemTime value does not contain this overhead. Runtime overhead + OS overhead value might be greater than TotalOverhead if they are overlapping. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

Id based on the QPC time to co-relate debugger events in the Concord and package. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

Create a new DkmPerformanceCounters object instance. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

[In] Number of performance watch start/stop iterations. If this number is high then performance data is not reliable. [In] System time (in milliseconds) consumed by debuggee process during debugger step. [In] User time (in milliseconds) consumed by debuggee process during debugger step. [In] Kernel time (in milliseconds) consumed by debuggee process during debugger step. [In] System time (in milliseconds) considered to be the runtime overhead during debugger step. SystemTime value does not contain this overhead. [In] System time (in milliseconds) considered to be the OS overhead during debugger step. SystemTime value does not contain this overhead. [In] System time (in milliseconds) considered to be the total overhead during debugger step. SystemTime value does not contain this overhead. Runtime overhead + OS overhead value might be greater than TotalOverhead if they are overlapping. [In] Id based on the QPC time to co-relate debugger events in the Concord and package. [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Result of an asynchronous DkmProcess.QueryPerformanceCounters call.

Creates a new result structure to hold the error from a failed call to DkmProcess.QueryPerformanceCounters.

[In] exception object containing the error

HRESULT code returned from the caller. This will be DkmExceptionCode.COR_E_OPERATIONCANCELED (0x8013153B) if the operation was canceled before processing was complete.

Collected performance counters. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

Creates a new result structure to hold the output from a successful call to DkmProcess.QueryPerformanceCounters.

[In] Collected performance counters.

Marshal a native struct to managed

Pointer to native struct. Managed object.

Obtain a pointer to the native object used to call into native.

Outgoing managed->native call Native object

Validate the fields of this structure

Struct that holds the field path (ex: "myArgument.StructField")

Information relevant to a running process. For example, this Part will NOT be present for minidumps.

Process Id (PID) assigned by the operating system. As the same process id may be used by multiple computers, and as process ids may be recycled, it is recommended to use 'UniqueId' for identity purposes.

64-bit date time value indicating when the process was started. The start time along with the id and the machine where the process was started can uniquely identify a process.

Initialize a new Live value.

[In] Process Id (PID) assigned by the operating system. As the same process id may be used by multiple computers, and as process ids may be recycled, it is recommended to use 'UniqueId' for identity purposes. [In] 64-bit date time value indicating when the process was started. The start time along with the id and the machine where the process was started can uniquely identify a process.

[Optional] Information relevant to a running process. For example, this Part will NOT be present for minidumps.

Full path to the starting executable of the process.

Guid which uniquely identifies this process object. This Guid value is the same as the Guid exposed at the SDM layer (IDebugProcess2::GetProcessId) and at the automation layer.

StartMethod describes how the debug engine started debugging this process.

Contains the session-wide debug settings. There is one instance of this object per engine Guid (ex: one instance for COMPlusOnlyEng2, one instance for COMPlusNativeEng).

Settings supplied during a start debugging operation from a project system or other caller of LaunchDebugTargets (or various other start debugging APIs).

Contains information about the computer system that this process is running under. If this process is running under WOW (32-bit emulation on a 64-bit OS) this information will be for the 32-bit subsystem rather than the 64-bit subsystem.

True if the process belongs to a Windows Store app package or Windows Phone app package. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

When true, the debugger will attempt to debug native code - it will stop on native exceptions, load symbols, display native frames on the call stack, bind and hit breakpoints, and leave native threads stopped while in break state.

Find a DkmProcess object. If no object with the given input key is present, FindProcess will fail.

[In] Search key used to find the element. [Out,Optional] Result of the search.

GetProcesses enumerates all the created DkmProcess objects.

[Out] Array containing the enumerated elements.

Creates a new process object. This method is called from the base debug monitor on the event thread as part of the processing of IDkmStartDebuggingOperations.AttachToProcess or IDkmStartDebuggingOperations.ResumeDebuggedProcess. This method will send a ProcessCreate event. Location constraint: API must be called from a Monitor component (component level < 100,000).

[In] This represents a connection between the monitor and the IDE. It can either be a local connection if the monitor is running in the same process as the IDE, or it can be a remote connection. In the monitor process, there is only one connection. [In] Full path to the starting executable of the process. [In] Guid which uniquely identifies this process object. This Guid value is the same as the Guid exposed at the SDM layer (IDebugProcess2::GetProcessId) and at the automation layer. [In] StartMethod describes how the debug engine started debugging this process. [In] Contains the session-wide debug settings. There is one instance of this object per engine Guid (ex: one instance for COMPlusOnlyEng2, one instance for COMPlusNativeEng). [In] Settings supplied during a start debugging operation from a project system or other caller of LaunchDebugTargets (or various other start debugging APIs). [In] Contains information about the computer system that this process is running under. If this process is running under WOW (32-bit emulation on a 64-bit OS) this information will be for the 32-bit subsystem rather than the 64-bit subsystem. [In] DkmBaseDebugMonitorId identifies the base debug monitor used to inspect and control the debugged process. For example, DkmBaseDebugMonitorId.WindowsProcess is used for processes debugged by the Win32 debugging API and DkmBaseDebugMonitorId.DumpFile is used for minidumps. [In] When true, the debugger will attempt to debug native code - it will stop on native exceptions, load symbols, display native frames on the call stack, bind and hit breakpoints, and leave native threads stopped while in break state. [In,Optional] Information relevant to a running process. For example, this Part will NOT be present for minidumps. [In,Optional] Data object to add to the new DkmProcess instance. Pass 'null' in the case that the caller doesn't need to add a data item. [Out] Result of this method call.

[In] This represents a connection between the monitor and the IDE. It can either be a local connection if the monitor is running in the same process as the IDE, or it can be a remote connection. In the monitor process, there is only one connection. [In] Full path to the starting executable of the process. [In] Guid which uniquely identifies this process object. This Guid value is the same as the Guid exposed at the SDM layer (IDebugProcess2::GetProcessId) and at the automation layer. [In] StartMethod describes how the debug engine started debugging this process. [In] Contains the session-wide debug settings. There is one instance of this object per engine Guid (ex: one instance for COMPlusOnlyEng2, one instance for COMPlusNativeEng). [In] Settings supplied during a start debugging operation from a project system or other caller of LaunchDebugTargets (or various other start debugging APIs). [In] Contains information about the computer system that this process is running under. If this process is running under WOW (32-bit emulation on a 64-bit OS) this information will be for the 32-bit subsystem rather than the 64-bit subsystem. [In] DkmBaseDebugMonitorId identifies the base debug monitor used to inspect and control the debugged process. For example, DkmBaseDebugMonitorId.WindowsProcess is used for processes debugged by the Win32 debugging API and DkmBaseDebugMonitorId.DumpFile is used for minidumps. [In] True if the process belongs to a Windows Store app package or Windows Phone app package. [In] When true, the debugger will attempt to debug native code - it will stop on native exceptions, load symbols, display native frames on the call stack, bind and hit breakpoints, and leave native threads stopped while in break state. [In,Optional] Information relevant to a running process. For example, this Part will NOT be present for minidumps. [In,Optional] Data object to add to the new DkmProcess instance. Pass 'null' in the case that the caller doesn't need to add a data item. [Out] Result of this method call.

GetThreads enumerates the DkmThread elements of this DkmProcess object.

[Out] Array containing the enumerated elements.

Find a DkmThread element within this DkmProcess. If no element with the given input key is present, FindSystemThread will fail. If an object is found, it will always contain the 'System' Part.

[In] Search key used to find the element. [Out,Optional] Result of the search.

Raise a AsyncBreakComplete event. Components which implement the event sink interface will receive the event notification. This method will enqueue the event and control will immediately return to the caller.

[In] Indicates the type of async-break that occurred. [In] DkmThread represents a thread running in the target process.

GetPendingBreakpoints enumerates the DkmPendingBreakpoint elements of this DkmProcess object.

[Out] Array containing the enumerated elements.

Find a DkmRuntimeInstance element within this DkmProcess. If no element with the given input key is present, FindRuntimeInstance will fail.

[In] Search key used to find the element. [Out,Optional] Result of the search.

GetRuntimeInstances enumerates the DkmRuntimeInstance elements of this DkmProcess object.

[Out] Array containing the enumerated elements.

GetComputeKernels enumerates the DkmGPUComputeKernel elements of this DkmProcess object.

[Out] Array containing the enumerated elements.

GetRuntimeFunctionResolutionRequests enumerates the DkmRuntimeFunctionResolutionRequest elements of this DkmProcess object.

[Out] Array containing the enumerated elements.

Raise a EntryPoint event. Components which implement the event sink interface will receive the event notification. This method will enqueue the event and control will immediately return to the caller.

[In] DkmThread represents a thread running in the target process.

Resolves a CPU instruction to a native module, and returns a DkmNativeInstructionAddress to represent this CPU instruction. If the instruction pointer is not within a module, a DkmUnknownInstructionAddress object is returned instead.

[In] Memory address where the native instruction is located. [Out] Abstract representation of an executable code location (ex: EIP value). If resolved, an Instruction Address will be within a particular module instance. An Instruction Address is always within a particular Runtime Instance.

Resolves a virtual address to a native module. If the virtual address is not within a module, null is returned (S_FALSE return code in native). Disabled modules will not be returned.

[In] Memory address to use as a search key. [Out,Optional] 'DkmNativeModuleInstance' is used for modules which contain CPU code and/or are loaded by the Win32 loader.

Resolves a virtual address to a native module. If the virtual address is not within a module, null is returned (S_FALSE return code in native).

[In] Memory address to use as a search key. [In] When true, the search will include module instances that have 'IsDisabled' set to 'true'. [Out,Optional] 'DkmNativeModuleInstance' is used for modules which contain CPU code and/or are loaded by the Win32 loader.

This method will tell the debug monitors to asynchronously break execution of the debuggee process. An AsyncBreakComplete event is sent after the operation is complete.

[In] If this is set to true, implementers should immediately enter break rather than trying to find a thread inside the process that is executing code.

[In] The original path to the exe stored in the minidump. [In] The path to the dump file. [In] The original path to the binary stored in the minidump. [In] The time date stamp of the binary in the time_t format. [In] The size of the image. [Out,Optional] The path on the local disk of the local (or downloaded) binary.

Disassemble an address range in the debuggee process. Location constraint: API must be called from an IDE component (component level > 100,000).

[In] The address where disassembly should start. [In] The number of instructions to disassemble. [Out] The results of disassembling the address range.

Returns the address of the kth instruction relative to a starting address. For constant length instruction sets, this is simple arithmetic. For variable length instruction sets, reverse-disassembly is required to obtain this address. Location constraint: API must be called from an IDE component (component level > 100,000).

[In] The address of the current instruction where the offset should begin. [In] The number of instructions relative to StartAddress to find the desired address. This value can be negative. [Out] The address of the instruction InstructionOffset instructions from StartAddress.

Returns the address of the kth instruction relative to a starting address. For constant length instruction sets, this is simple arithmetic. For variable length instruction sets, reverse-disassembly is required to obtain this address. This method will append a new work item to the specified work list, and return once the work item has been appended. The actual processing of the work item is asynchronous. The caller will be notified that the request is complete through the completion routine. Location constraint: API must be called from an IDE component (component level > 100,000).

WorkList to append the new work item to. [In] The address of the current instruction where the offset should begin. [In] The number of instructions relative to StartAddress to find the desired address. This value can be negative. Routine to fire when the request is complete. If the request is successfully appended to the work list, this will always fire (including when the operation is canceled). This will never fire if appending the work item fails.

This method will write out a memory dump of the process to the path specified.

[In] The type of dump to write. Either minidump or full-memory minidump. [In] The full path to where the minidump should be saved. In remote scenarios, this path is relative to the remote machine. [In,Optional] The thread to use for the minidump if there is no current exception.

Adds an exception trigger so that ExceptionTriggerHit events will be sent when the exception trigger has been met. If there is already an exception triggered defined for this {SourceId, DkmExceptionTrigger} tuple then the existing trigger will be modified with the new settings. For example, if a component defines a trigger to stop when an access violation exception is thrown and later sets a trigger to fire when any Win32 exception goes unhandled, then the access violation trigger will be removed. This method will append a new work item to the specified work list, and return once the work item has been appended. The actual processing of the work item is asynchronous. The caller will be notified that the request is complete through the completion routine.

WorkList to append the new work item to. [In] Identifies the source of an object. SourceIds are used to enable filtering in scenarios when multiple components may be creating instances of a class. For example, source ids can be used to determine if a breakpoint comes from the AD7 AL (ex: user breakpoint, or other breakpoint visible at the SDM level) instead of a breakpoint which may be created by another component (for example an internal breakpoint used for stepping). [In] Describes an exception or collection of exceptions which a component wants to break on. When a higher level components wants to be notified about certain exceptions, it should create one or more exception triggers, and then enable these triggers (DkmProcess.EnableExceptionTriggers). After this, when the exception occurs, a ExceptionTriggerHit exception will be fired whenever this trigger is met. Routine to fire when the request is complete. If the request is successfully appended to the work list, this will always fire (including when the operation is canceled). This will never fire if appending the work item fails.

The method will return the contents of the IMAGE_RUNTIME_FUNCTION_ENTRY for an address if possible. For searching static entries, callers should call the equivalent method on DkmNativeModuleInstance.

[In] The virtual address for which to find a function table entry for. [Out] The base address for the runtime function table entry. [Out,Optional] The runtime function table entry for this address if found.

Get the breakpoint behavior of the process.

[Out] The breakpoint behavior of the process.

Enables / disables a particular GPU memory access warning.

[In] Warning code to set. [In] True to set the warning, false to clear it.

Disables all active GPU memory access warnings.

Resolves a CPU InstructionAddress to a DkmInstructionAddress. This method will append a new work item to the specified work list, and return once the work item has been appended. The actual processing of the work item is asynchronous. The caller will be notified that the request is complete through the completion routine. Location constraint: API must be called from an IDE component (component level > 100,000).

WorkList to append the new work item to. [In] Memory address where the native instruction is located. Routine to fire when the request is complete. If the request is successfully appended to the work list, this will always fire (including when the operation is canceled). This will never fire if appending the work item fails.

Method called by the base debug monitor to inform other components that the instruction memory of the target process was modified. Currently, this is only used for breakpoint insertion. Location constraint: API must be called from a Monitor component (component level < 100,000).

[In] The base address from which to write the target process's memory. [In] The original code bytes which were replaced in the target process.

Method called by the base debug monitor to inform other components that the instruction memory of the target process was restored to its original state. Currently, this is only used for breakpoint removal. Location constraint: API must be called from a Monitor component (component level < 100,000).

[In] The base address from which to write the target process's memory. [In] The original code bytes which were restored in the target process.

Read the memory of the target process.

[In] The base address from which to read the target process's memory. [In] Flags controlling the behavior of DkmProcess.ReadMemory and DkmProcess.ReadMemoryString. [In,Out] A buffer that receives the contents from the address space of the target process. On failure, the content of this buffer is unspecified. [In] The number of bytes to be read from the process. In scenarios where the call is marshalled to the remote debugger from the IDE, this must be less than 25 MBs. [Out] Indicates the number of bytes read from the target process. If DkmReadMemoryFlags.AllowPartialRead is clear, on success this value will always be exactly equal to the input size. If DkmReadMemoryFlags.AllowPartialRead is specified, on success, this value will be greater than zero. E_INVALID_MEMORY_ADDRESS indicates that the address is not valid. See 'DkmReadMemoryFlags.AllowPartialRead' documentation for more information.

Read the memory of the target process.

[In] The base address from which to read the target process's memory. [In] Flags controlling the behavior of DkmProcess.ReadMemory and DkmProcess.ReadMemoryString. [In,Out] A buffer that receives the contents from the address space of the target process. On failure, the content of this buffer is unspecified. [Out] Indicates the number of bytes read from the target process. If DkmReadMemoryFlags.AllowPartialRead is clear, on success this value will always be exactly equal to the input size. If DkmReadMemoryFlags.AllowPartialRead is specified, on success, this value will be greater than zero. E_INVALID_MEMORY_ADDRESS indicates that the address is not valid. See 'DkmReadMemoryFlags.AllowPartialRead' documentation for more information.

Reads a null-terminated string from the target process process's memory. This can be used to read an ANSI or Unicode (UTF-8, UTF-16 or UTF-32) strings.

[In] The base address from which to read the target process's memory. [In] Flags controlling the behavior of DkmProcess.ReadMemory and DkmProcess.ReadMemoryString. [In] Number of bytes in each character. This should be set to 1 (ANSI/UTF-8), 2 (UTF-16) or 4 (UTF-32). [In] The maximum number of characters to read from the target process. When DkmReadMemoryFlags.AllowPartialRead is false, the request will fail if a null terminator isn't found within this range. This value should be reasonable. The Microsoft implementation will fail any request for more than 25 MBs of string memory. [Out] The value of the string which was read from the target process. If DkmReadMemoryFlags.AllowPartialRead is clear, this memory will always include the null termination character. If DkmReadMemoryFlags.AllowPartialRead is specified, this buffer will not contain the null termination character if the read was truncated. E_INVALID_MEMORY_ADDRESS indicates that the address is not valid. See 'DkmReadMemoryFlags.AllowPartialRead' documentation for more information. E_STRING_TOO_LONG indicates that the string could not be read within the specified maximum number of characters.

[In] The base address from which to write the target process's memory. [In] Data to be written in the address space of the specified process.

Obtains the number of active handles in the process.

[Out] The number of handles in the debuggee process.

Obtains the number of clock cycles that the debuggee has been running since ResetRunningTime() was last called.

[Out] The time the debuggee has been running.

Sets the running time counter to the specified value.

[In] The value to set the clock to.

Provides access to the DkmRuntimeInstance which is for the naive code within a process. There is exactly one DkmRuntimeInstance for a process.

[Out] Represents the native code executing in a target process.

This method is called to tell the monitor to detach from the target process. This will trigger a ProcessExit event to be sent on the event thread.

This method is called to tell the monitor to terminate the target process. This will trigger a ProcessExit event to be sent on the event thread.

[In] The exit code to be used by the process and threads terminated as a result of this call. Use the GetExitCodeProcess function to retrieve a process's exit value. Use the GetExitCodeThread function to retrieve a thread's exit value.

StoppingEventProcessingBegin is called by the base debug monitor on the event thread. It notifies the Dispatcher that the target process is stopped and may have reached a stopping event. For example, the Win32 base debug monitor calls this whenever it receives an EXCEPTION_DEBUG_EVENT from the operating system. This method updates the internal state of the DkmProcess object so that stopping events are allowed to be sent.

[In] Normally, the dispatcher will reject (return E_TARGET_ALREADY_STOPPED) attempts to send additional stopping events after the target process has received its initial batch of stopping events (StoppingEventProcessingContinue has been called). By passing 'true' for this argument, the base debug monitor causes these events to be queued rather than rejected. This is used by the Win32 debug monitor when it fully drains the Win32 debugging event queue prior to the start of a function evaluation.

StoppingEventProcessingContinue is called by the base debug monitor on the event thread. This method is called after all stopping events within the current batch have been issued (ex: called DkmRuntimeBreakpoint.OnHit). This method will notify components which have implemented a stopping event notification interface and will call into the execution manager to slip the process to a safe point. The base debug monitor must call StoppingEventProcessingContinue after any successful call to StoppingEventProcessingBegin. the base debug monitor after it has issued all stopping events. A base debug monitor should expect to be reentrantly called while it is in this method.

[Out] Status code returned to the base debug monitor to indicate the next action to take in stopping event processing.

AbortingFuncEvalExecution is called by the runtime debug monitor when aborting a function evaluation. AbortingFuncEvalExecution will update the internal state of the DkmProcess object so the stopping event manager will allow two stopping events through: a function evaluation complete breakpoint or an async break.

[In] Flags impacting how function evaluation requests are performed.

This method allows a component to determined if the process is considered stopped by the Dispatcher. This method does not need to be called from within an interface method which requires the target process to be stopped, but it may be helpful during operations which may be called from run mode.

[Out] Returns true if the process is considered stopped. This will return true on request threads after the debugger has sent a stopping event (ex: breakpoint hit) to the IDE and before the process has been resumed. It will return true on event threads if a pausing event (ex: module load) or stopping event (ex: breakpoint hit) is being processed.

Provides the list of active system threads in the process. Threads which are not system threads (DkmThread::System is null) or have been unloaded, will not be present in this collection.

[Out] Returned array of system threads.

[In] Address within the target process where the memory should be committed or reserved. This value is typically zero, in which case the system chooses an address. [In] The size of the region of memory to allocate, in bytes. The system will automatically round up to the next page boundary. [In] Indicates the type of allocation to perform. This is typically MEM_COMMIT | MEM_RESERVE (0x3000) which reserves and commits an allocation in one step. [In] The memory protection for the region of pages to be allocated. If the pages are being committed, you can specify any one of the memory protection constants (ex: PAGE_READWRITE, PAGE_EXECUTE). [Out] Base address of the allocated region of pages.

Releases and/or decommits a region of memory within the virtual address space of the target process. For additional information, see the VirtualFree Win32 API in MSDN.

[In] Address within the target process where the memory should be freed. [In] Number of bytes to decommit. To release a region of memory, this value must be zero. [In] Indicates the type of free operation to perform. This is typically MEM_RELEASE (0x8000), which releases the specified region of pages. After the operation, the pages are in the free state. MEM_DECOMMIT (0x4000) can be used instead to decommit the pages without releasing them.

[In] The base address from which to read the target process's memory. [In,Out] A buffer that receives the contents from the address space of the target process. On failure, the content of this buffer is unspecified. [In] The number of bytes to be read from the process. In scenarios where the call is marshalled to the remote debugger from the IDE, this must be less than 25 MBs. E_INVALID_MEMORY_ADDRESS indicates that one or more bytes of the request could not be read.

[In] The base address from which to write the target process's memory. [In] Data to be written in the address space of the specified process.

This method is called by the process's base debug monitor to raise a LoadComplete event. LoadComplete is issued after DkmModuleInstance objects have been created for the initial set of modules in the process, and generally the initial set of threads have also been created. The load complete event may be deferred by a runtime debug monitor using DkmLoadCompleteEventDeferral.Add, in which case this method will immediately complete. Otherwise, this method will send the event to all components which implement the event sync interface. Control will return once all components have been notified. This method may only be called by the component which created the object.

ProcessExit is sent by the dispatcher when DkmProcess::Unload is invoked by the monitor. This method may only be called by the component which created the object.

[In] 32-bit value which the processed returned on exit. This is the same value that would be reported from the kernel32!GetExitCodeProcess.

Returns the path to the primary executable in the minidump being debugged. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

[Out] Path to the debuggee's primary executable file.

Returns true if once all the initial module loads/thread creates have been sent for all the runtimes present when we started debugging the process. Note that this definition may be different from the Win32 Debug API definition of load complete since other runtime instances may need additional time to load. This API was introduced in Visual Studio 12 Update 2 (DkmApiVersion.VS12Update2).

[Out] True if the process has reached load complete.

Get the stowed exceptions from a dump. This API was introduced in Visual Studio 12 Update 3 (DkmApiVersion.VS12Update3).

[Out] An array of stowed exception records contained in the dump.

Get the native stowed exception from a dump. This will return S_FALSE if there is no native stowed exception. This API was introduced in Visual Studio 12 Update 3 (DkmApiVersion.VS12Update3).

[Out,Optional] The native stowed exception from the dump, or NULL if there is no native stowed exception.

Get the managed stowed exception from a dump. This will return S_FALSE if there is no managed stowed exception. This API was introduced in Visual Studio 12 Update 3 (DkmApiVersion.VS12Update3).

[Out,Optional] The managed stowed exception from the dump, or NULL if there is no managed stowed exception.

Raise a HiddenEntryPoint event. Components which implement the event sink interface will receive the event notification. This method will enqueue the event and control will immediately return to the caller. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

[In] DkmThread represents a thread running in the target process.

Handler which is notified before the target process is terminated or detached. Location constraint: API must be called from an IDE component (component level > 100,000). This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

Called by a component to indicate that detach is not allowed on the process. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

[In] HRESULT indicating why detach is not available. This should be a failed HRESULT value (value less than zero).

Removes an exception trigger previously set. Note that the processing stage is ignored and does not need to match the value originally provided. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

Removes an exception trigger previously set. Note that the processing stage is ignored and does not need to match the value originally provided. This method will append a new work item to the specified work list, and return once the work item has been appended. The actual processing of the work item is asynchronous. The caller will be notified that the request is complete through the completion routine. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

Asynchronous Method to obtain the timing data from the IDkmPerformanceMeasurementDispatcherService gathered from events emitted by the runtimes in the process. This is called asynchronously because obtaining the debugger overhead can be very expensive. This method will append a new work item to the specified work list, and return once the work item has been appended. The actual processing of the work item is asynchronous. The caller will be notified that the request is complete through the completion routine. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

Find a DkmProcessSnapshot element within this DkmProcess. If no element with the given input key is present, FindProcessSnapshot will fail. This API was introduced in Visual Studio 15 Update 3 (DkmApiVersion.VS15Update3).

[In] Search key used to find the element. [Out,Optional] Result of the search.

GetProcessSnapshots enumerates the DkmProcessSnapshot elements of this DkmProcess object. This API was introduced in Visual Studio 15 Update 3 (DkmApiVersion.VS15Update3).

[Out] Array containing the enumerated elements.

Take a snapshot of the debuggee. Location constraint: Server. This API was introduced in Visual Studio 15 Update 3 (DkmApiVersion.VS15Update3).

[In] The timestamp of the debug event for which the snapshot is taken. Typically, it's obtained via QueryPerformanceCounter when the debug event occurs. [In,Optional] The thread that the stopping event occurs in. [Out] The new snapshot that's created. Indicates that we cannot take snapshot of the DkmProcess. Indicates that there is no enough memory for a new snapshot.

Get the source snapshot object for the debugged process. The debugged process must represent snapshots. This API was introduced in Visual Studio 15 Update 3 (DkmApiVersion.VS15Update3).

[Out] The object that represents the snapshot. Indicates that the DkmProcess doesn't represent snapshots. Indicates that the snapshot information is missing even though DkmProcess flags indicate that there is one.

Remove the process snapshots for this process. This API was introduced in Visual Studio 15 Update 3 (DkmApiVersion.VS15Update3).

Remove the process snapshots for this process. This API was introduced in Visual Studio 15 Update 5 (DkmApiVersion.VS15Update5).

[In] The id for the snapshot to be removed.

This method can be called from a monitor component to wait for any non-stopping with pause event handling, as well as any IDkmProcessContinueNotification processing that is currently happening to finish. Among other things, this can be helpful when attempting to abort func-evals by making sure that the target process has an opportunity to run. Note that this method doesn't provide any guarantee that there will not immediately be more pausing events, so code shouldn't assume that after returning from this API no stopping event processing is happening. Location constraint: API must be called from a Monitor component (component level < 100,000). This API was introduced in Visual Studio 15 Update 6 (DkmApiVersion.VS15Update6).

[In] Timeout in milliseconds to wait. -1 (INFINITE in C++) to wait forever. [Out] True if this method succeeded and if it needed to wait for event processing to finish before returning.

Handler which is notified after a process snapshot is taken for the given process. This API was introduced in Visual Studio 15 Update 6 (DkmApiVersion.VS15Update6).

[In] The process snapshot object that's added.

Handler which is notified after a process snapshot is removed from the given process. This API was introduced in Visual Studio 15 Update 6 (DkmApiVersion.VS15Update6).

[In] The process snapshot object that's removed.

Called to find out what time relative to the current process time a value from a memory read is resolved from. This API was introduced in Visual Studio 15 Update 8 (DkmApiVersion.VS15Update8).

[In] The base address of a memory read. [In] The size of the memory read. [Out] The read flags representing the lowest confidence memory read across the given address range.

Gets a value indicating whether the process is running in the forward or reverse direction. This method is only implemented for time travelling processes. This API was introduced in Visual Studio 15 Update 8 (DkmApiVersion.VS15Update8).

[Out] The current execution direction.

Sets the processes execution direction. The direction can be forward or reverse. This method is only implemented for time travelling processes. This API was introduced in Visual Studio 15 Update 8 (DkmApiVersion.VS15Update8).

[In] The requested execution direction.

Gets the time context representing the ending position of the trace. This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTMPreview).

[Out] The time context representing the ending position of the trace.

Raise a TraceTimeContextSet event. Components which implement the event sink interface will receive the event notification. Control will return once all components have been notified. This method may only be called by the component which created the object. This API was introduced in Visual Studio 16 Update 2 (DkmApiVersion.VS16Update2).

[In] A point of time within a time travel trace. The internal representation is an implementation detail of the creator. [In] A point of time within a time travel trace. The internal representation is an implementation detail of the creator. [In] A point of time within a time travel trace. The internal representation is an implementation detail of the creator. [In] DkmThread represents a thread running in the target process.

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Indicates the direction the process is executing in. This API was introduced in Visual Studio 15 Update 8 (DkmApiVersion.VS15Update8).

Process is executing in the forward direction.

Process is executing in reverse.

Stores a QPC timestamp for a process stop/resume event. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

QPC time for this event. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

Create a new DkmProcessExecutionCounters object instance. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

[In] QPC time for this event. [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

DkmProcessSnapshot represents a snapshot that's captured about a running process. This API was introduced in Visual Studio 15 Update 3 (DkmApiVersion.VS15Update3).

An increasing number to identify the snapshot within a process. This API was introduced in Visual Studio 15 Update 3 (DkmApiVersion.VS15Update3).

Process Id assigned to the Snapshot by the operating system. This API was introduced in Visual Studio 15 Update 3 (DkmApiVersion.VS15Update3).

The process that this snapshot is associate with. This API was introduced in Visual Studio 15 Update 3 (DkmApiVersion.VS15Update3).

The timestamp of the debug event for which the snapshot is taken. Typically, it's obtained via QueryPerformanceCounter when the debug event occurs. This API was introduced in Visual Studio 15 Update 3 (DkmApiVersion.VS15Update3).

The id of the stopping thread. It usually is used to set the UI when we attach to a snapshot. This API was introduced in Visual Studio 15 Update 3 (DkmApiVersion.VS15Update3).

Creates a new process snapshot object. This method is called from the base debug monitor on the event thread as part of processing of TakeSnapshot. Location constraint: API must be called from a Monitor component (component level < 100,000). This API was introduced in Visual Studio 15 Update 3 (DkmApiVersion.VS15Update3).

[In] An increasing number to identify the snapshot within a process. [In] Process Id assigned to the Snapshot by the operating system. [In] The process that this snapshot is associate with. [In] The timestamp of the debug event for which the snapshot is taken. Typically, it's obtained via QueryPerformanceCounter when the debug event occurs. [In] The id of the stopping thread. It usually is used to set the UI when we attach to a snapshot. [In,Optional] Data object to add to the new DkmProcessSnapshot instance. Pass 'null' in the case that the caller doesn't need to add a data item. [Out] Result of this method call.

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Flags controlling the behavior of DkmProcess.ReadMemory and DkmProcess.ReadMemoryString.

Indicates that the caller wants the default behavior for ReadMemory.

Indicates that the caller wants the read operation to succeed if only part of the memory read succeeded. If this is set, an E_INVALID_MEMORY_ADDRESS error will only be raised if 'Address' is invalid. If this flag is clear, a E_INVALID_MEMORY_ADDRESS error will be raised if any portion of the requested memory was unreadable.

Indicates that the read should only succeed if the memory pages in question have one of the the execute flags set (PAGE_EXECUTE, PAGE_EXECUTE_READONLY, etc.). If combined with AllowPartialRead, this will return all memory between the starting address and the end of the executable region. If no executable code is found, the read fails with E_INVALID_MEMORY_PROTECT.

Indicates that the read is a GPU C++ AMP pointer and that the high bits should be read from the tag memory.

A key/value pair read from the registry. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

The name of the registry value that specifies this tweak. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

The value of this tweak in the registry. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

Create a new DkmRegistryTweak object instance. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

[In] The name of the registry value that specifies this tweak. [In] The value of this tweak in the registry. [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Result of an asynchronous DkmRuntimeInstance.ResolveCPUInstructionAddress call.

Creates a new result structure to hold the error from a failed call to DkmRuntimeInstance.ResolveCPUInstructionAddress.

[In] exception object containing the error

HRESULT code returned from the caller. This will be DkmExceptionCode.COR_E_OPERATIONCANCELED (0x8013153B) if the operation was canceled before processing was complete.

True if this address is the first address in the line's range. False otherwise.

Creates a new result structure to hold the output from a successful call to DkmRuntimeInstance.ResolveCPUInstructionAddress.

Marshal a native struct to managed

Pointer to native struct. Managed object.

Obtain a pointer to the native object used to call into native.

Outgoing managed->native call Native object

Validate the fields of this structure

Struct that holds the field path (ex: "myArgument.StructField")

Enumeration of runtime capabilities. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

No capabilities specified.

Allow stack caching for when this runtime has a stack frame at the top of the stack.

Prevent detaching the debugger. Detach will be disabled if any of the runtime instances have this capability set.

Indicates that the runtime supports the Just-My-Code feature.

Indicates that the runtime does not allow stopping in non-user code. This is currently used to disable breakpoints in non-user code for runtimes with this capability. When stack frames for runtimes with this capability set are at the top of the stack, any non-user frames will be collapsed to [External Code]. This capability flag should only be set when SupportJustMyCode is also set.

If the managed runtime supports heap inspection.

The Runtime Id identifies the execution environment for a particular piece of code. Runtime Ids are used by the dispatcher to decide which monitor to dispatch to. Note that the ordering of the runtime ID Guids is somewhat significant as this dictates which runtime gets the first shot during arbitration. Thus, if one wants to declare a new runtime instance which is built on the CLR, the runtime id should be less than DkmRuntimeId.Clr.

Identifies native code. Since all code executed by the CPU is native, this is the default runtime and any code address unclaimed by other runtimes will be treated as native.

Identifies code running under the CLR runtime.

Identifies code running under the GPU D3D runtime.

Identifies code running under Microsoft ActiveScript based runtimes.

Identifies code running under Microsoft ActiveScript based runtimes that can interop with other debug code types.

Identifies code running under the native-compiled CLR.

Identifies code running under the GPU Interop D3D runtime.

The DkmRuntimeInstance class represents an execution environment which is loaded into a DkmProcess and which contains code to be debugged. Derived classes: DkmClrRuntimeInstance, DkmClrNcRuntimeInstance, DkmCustomRuntimeInstance, DkmNativeRuntimeInstance, DkmScriptRuntimeInstance

DkmRuntimeInstance is an abstract base class. This enum indicates which derived class this object is an instance of.

Object is an instance of 'DkmNativeRuntimeInstance'.

Object is an instance of 'DkmClrRuntimeInstance'.

Object is an instance of 'DkmScriptRuntimeInstance'.

Object is an instance of 'DkmCustomRuntimeInstance'.

DkmRuntimeInstance is an abstract base class. This enum indicates which derived class this object is an instance of.

Identifies a DkmRuntimeInstance object within a process.

Enumeration of runtime capabilities. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

[Optional] For runtimes that are implemented on top of another runtime, this can optionally be used to indicant the logical parent. This can then be used to request services from the parent when the child runtime doesn't implement the service. This is currently used only for obtaining the top stack frame to evaluate a conditional breakpoint when the child runtime doesn't walk stacks itself. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

GetScriptDocumentTreeNodes enumerates the DkmScriptDocumentTreeNode elements of this DkmRuntimeInstance object.

[Out] Array containing the enumerated elements.

GetModuleInstances enumerates the DkmModuleInstance elements of this DkmRuntimeInstance object.

[Out] Array containing the enumerated elements.

GetTaskProviders enumerates the DkmTaskProvider elements of this DkmRuntimeInstance object.

[Out] Array containing the enumerated elements.

[In] Memory address where the native instruction is located. [Out] True if this address is the first address in the line's range. False otherwise. [Out] Abstract representation of an executable code location (ex: EIP value). If resolved, an Instruction Address will be within a particular module instance. An Instruction Address is always within a particular Runtime Instance.

Resolves a CPU InstructionAddress to a runtime-specific DkmInstructionAddress object. This API is currently only supported by CLR DkmRuntimeInstance objects, and the CLR runtime instance can currently only find instruction addresses which are in a method that is currently on the call stack of one of the threads in the target process. This method will append a new work item to the specified work list, and return once the work item has been appended. The actual processing of the work item is asynchronous. The caller will be notified that the request is complete through the completion routine. Location constraint: This API should generally be called on the client, but it can be called on the server for translating CLR addresses (but not native-compiled).

This method returns all modules that match the specified name.

[In] Name of the module to search for. This string may or may not contain the file extension (ex: 'kernel32' or 'kernel32.dll'). [Out] Returns any modules that match the specified search key. Only currently loaded dlls will be returned. Modules are returned in load-order.

Sets the value of the register in the thread's context. Sub registers that are made up of larger registers are supported.

[In] The stack frame the register is being set in. For most runtime instances, this is used to verify the stack frame is the top of the stack and stop the write if it isn't. [In] The CV constant of the register to set. [In] The value to set the register to. The size of the byte array must match the width of the register being set.

BeforeEnableNewStepper is called by the stepping manager before a new stepper is enabled. This gives runtimes the ability to do any initialization that might be required such as performing pre-step function evaluations. Location constraint: API must be called from a Monitor component (component level < 100,000).

[In] DkmStepper represents a request to step a thread. It facilitates shared object lifetime between the various runtime debug monitors that participate in stepping.

[In] DkmStepper represents a request to step a thread. It facilitates shared object lifetime between the various runtime debug monitors that participate in stepping. [In] DkmStepArbitrationReason the reason step arbitration is occurring. [Out] If the runtime instance wants control of the step, it should set this to true. It should be set to false to not take control.

Step is called by the stepping manager after it determines this monitor is the correct monitor to perform the step. Location constraint: API must be called from a Monitor component (component level < 100,000).

StopStep is called by the stepping manager when the process is being continued to clear out any remaining stepping state for a stepper. Location constraint: API must be called from a Monitor component (component level < 100,000).

[In] DkmStepper represents a request to step a thread. It facilitates shared object lifetime between the various runtime debug monitors that participate in stepping.

[In] DkmStepper represents a request to step a thread. It facilitates shared object lifetime between the various runtime debug monitors that participate in stepping. [In] DkmStepArbitrationReason the reason step arbitration is occurring. [In,Optional] The DkmRuntimeInstance class represents an execution environment which is loaded into a DkmProcess and which contains code to be debugged.

OnNewControllingRuntimeInstance is called by the stepping manager on all non-controlling runtime instances after step arbitration has selected a new controlling runtime instance. Location constraint: API must be called from a Monitor component (component level < 100,000).

[In] DkmStepper represents a request to step a thread. It facilitates shared object lifetime between the various runtime debug monitors that participate in stepping. [In] DkmStepArbitrationReason the reason step arbitration is occurring. [In] The DkmRuntimeInstance class represents an execution environment which is loaded into a DkmProcess and which contains code to be debugged.

[In] DkmStepper represents a request to step a thread. It facilitates shared object lifetime between the various runtime debug monitors that participate in stepping. [In] DkmStepArbitrationReason the reason step arbitration is occurring. [In] The calling runtime instance that wishes to take control of the step. [Out] The controlling runtime can stop the step and give control to the caller, then it should set this to true.

NotifyStepComplete is called by the stepping manager on all non-controlling runtime instances when a step is complete. Location constraint: API must be called from a Monitor component (component level < 100,000).

[In] DkmStepper represents a request to step a thread. It facilitates shared object lifetime between the various runtime debug monitors that participate in stepping.

Gets the Display Properties of the Thread including the Display Name and Thread Category. This method will append a new work item to the specified work list, and return once the work item has been appended. The actual processing of the work item is asynchronous. The caller will be notified that the request is complete through the completion routine. Location constraint: API must be called from an IDE component (component level > 100,000).

WorkList to append the new work item to. [In] The Thread. Routine to fire when the request is complete. If the request is successfully appended to the work list, this will always fire (including when the operation is canceled). This will never fire if appending the work item fails.

Compute the name of a thread.

[In] The Thread. [Out,Optional] The Thread Name.

Compute the name of a thread. This method will append a new work item to the specified work list, and return once the work item has been appended. The actual processing of the work item is asynchronous. The caller will be notified that the request is complete through the completion routine.

RuntimeInstanceUnload is sent by the dispatcher when DkmRuntimeInstance::Unload is invoked by the monitor. This method may only be called by the component which created the object.

GetManagedHeapSamplers enumerates the DkmManagedHeapSampler elements of this DkmRuntimeInstance object. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

[Out] Array containing the enumerated elements.

GetManagedHeapWalkers enumerates the DkmManagedHeapWalker elements of this DkmRuntimeInstance object. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

[Out] Array containing the enumerated elements.

GetCodePathsInRange is called to get code paths in specific IL range. Location constraint: It should only be called on server side. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

[In] The ICorDebugFrame to query for code paths. [In] Specifies the query start IL offset, inclusively. [In] Specifies the query end IL offset, inclusively. [Out] DkmSteppingCodePath[] represents a location that user can step to from current location.

Disassemble an address range in the debuggee runtime. Location constraint: API must be called from an IDE component (component level > 100,000). This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

[In] The address where disassembly should start. [In] The number of instructions to disassemble. [Out] The results of disassembling the address range.

Returns the address of the kth instruction relative to a starting address. For constant length instruction sets, this is simple arithmetic. For variable length instruction sets, reverse-disassembly is required to obtain this address. Location constraint: API must be called from an IDE component (component level > 100,000). This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

This method is called by a debug monitor to raise a RuntimeInstanceLoadComplete event. RuntimeInstanceLoadComplete is currently only sent for the native runtime instance, though this may change in the future. The event is issued after DkmModuleInstance objects have been created for the initial set of modules in the runtime instance. This method may only be called by the component which created the object. This API was introduced in Visual Studio 12 Update 2 (DkmApiVersion.VS12Update2).

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Identifies a DkmRuntimeInstance object within a process.

Compare two elements of the DkmRuntimeInstanceId structure.

Value to comare against this instance. 'true' if the two elements are equal.

Compare two elements of the DkmRuntimeInstanceId sructure.

Left side of the comparison Right side of the comparison

Compare two elements of the DkmRuntimeInstanceId sructure.

Left side of the comparison Right side of the comparison

Compare two elements of the DkmRuntimeInstanceId sructure.

Left side of the comparison Right side of the comparison

Compare two elements of the DkmRuntimeInstanceId sructure.

Left side of the comparison Right side of the comparison

Compare two elements of the DkmRuntimeInstanceId sructure.

Left side of the comparison Right side of the comparison

Compare two elements of the DkmRuntimeInstanceId sructure.

Left side of the comparison Right side of the comparison

Indicates which type of runtime instance this is (ex: native code, CLR, etc).

Used along with the 'RuntimeType' to uniquely identify a particular runtime instance within a given DkmProcess. If the 'RuntimeType' only supports a single runtime instance per process (ex: DkmRuntimeId.Native), this value is typically zero. For DkmRuntimeId.Clr, this value is the base address of the CLR dll.

Initialize a new DkmRuntimeInstanceId value.

[In] Indicates which type of runtime instance this is (ex: native code, CLR, etc). [In] Used along with the 'RuntimeType' to uniquely identify a particular runtime instance within a given DkmProcess. If the 'RuntimeType' only supports a single runtime instance per process (ex: DkmRuntimeId.Native), this value is typically zero. For DkmRuntimeId.Clr, this value is the base address of the CLR dll.

Result of an asynchronous DkmCustomMessage.SendLower call.

Creates a new result structure to hold the error from a failed call to DkmCustomMessage.SendLower.

[In] exception object containing the error

HRESULT code returned from the caller. This will be DkmExceptionCode.COR_E_OPERATIONCANCELED (0x8013153B) if the operation was canceled before processing was complete.

[Optional] Message sent back from the implementation.

Creates a new result structure to hold the output from a successful call to DkmCustomMessage.SendLower.

[In,Optional] Message sent back from the implementation.

Marshal a native struct to managed

Pointer to native struct. Managed object.

Obtain a pointer to the native object used to call into native.

Outgoing managed->native call Native object

Validate the fields of this structure

Struct that holds the field path (ex: "myArgument.StructField")

Object was created in response to a breakpoint request from the IDE.

Object was created for a source-level breakpoint by the Microsoft breakpoint manager.

Filtered events sent to the Native DM filter on this Source ID.

DkmExceptionTrigger was created in response to exception settings from the IDE.

DkmExceptionTrigger was created in response to the 'Break when exceptions cross AppDomain or managed/native boundaries (Managed only)' debugger option.

DkmStepper created in response to a step request from the IDE.

SymbolsUpdate event generated by Managed DM.

DkmStepper created by Managed DM.

Filtered events sent to the GPU Debug Monitor filter on this Source ID.

Object was created at the AD7 layer to execute a command.

DkmStepper created by the Stepping Manager.

Object created for local CPP EE.

Object created for server CPP EE.

Enables a custom data breakpoint created by the Breakpoint Manager to be handled separately from normal source level breakpoints.

Status code returned to the base debug monitor to indicate the next action to take in stopping event processing.

The base debug monitor should resume execution of the target processes normally. If an exception event was raised, standard exception processing (ex: handler search, stack unwinding) should continue in the target process unless DkmExceptionInformation.SquashProcessing() was successfully called. This status value is returned when the base debug monitor didn't issue any stopping events, or when all stopping events were suppressed.

The base debug monitor should resume execution of non-suspended threads in the target process. Standard exception processing on suspended thread should be held up so that the decision as to if it should be allowed to continue normally or be squashed may be made at a later time. This status value is used when one or more threads are not at a safe point, so the target process must be slipped. The target process is expected to hit one or more stopping events (breakpoint or exception) in order to indicate that a safe point has been reached. The base debug monitor may also choose to eventually time out and proceed without reaching a safe point. The timeout value is specified in DkmEngineSettings.SlipTimeout.

The base debug monitor should resume execution of non-suspended threads in the target process. Standard exception processing on suspended thread should be held up so that the decision as to if it should be allowed to continue normally or be squashed may be made at a later time. After resuming execution, the base debug monitor should immediately call StoppingEventProcessingContinue again. This status value is used when all threads are in the target process are at a safe point, but one or more threads in the target process should run free while in break mode. This is used when managed-only debugging certain host applications.

Stopping event processing has completed and a stopping event has been sent to the IDE. Execution of the target process should stay halted until the IDE resumes execution.

This value is returned if StoppingEventProcessingBegin was called with ForceQueueMode set to true.

DkmThread represents a thread running in the target process. Derived classes: DkmGPUComputeThread, DkmVirtualThread

Describes traits of the thread which are relevant to a full Win32 thread. Currently, this value is required, and all threads will have a 'System' block. In the future, this value may be NULL if the DkmThread represents something other than a full Win32 thread.

Thread Id (TID) assigned by the operating system. While running, this uniquely identifies the thread within a particular DkmProcess.

Initialize a new System value.

[In] Thread Id (TID) assigned by the operating system. While running, this uniquely identifies the thread within a particular DkmProcess.

[Optional] Describes traits of the thread which are relevant to a full Win32 thread. Currently, this value is required, and all threads will have a 'System' block. In the future, this value may be NULL if the DkmThread represents something other than a full Win32 thread.

Guid which uniquely identifies this thread object.

If available, this is the Win32 start address of this thread (value passed to the CreateThread API). The value will not always be available, for example, it is generally not available in scenarios where the thread was started after the debugger attached, or in minidumps.

Address within the target process, where the Win32 thread environment block is stored. See documentation on the TEB structure in MSDN for more information.

True if this is the main thread of this process. The main thread is the first thread to start.

Contains information about the computer system that this thread is running under. If this thread is running under WOW (32-bit emulation on a 64-bit OS) this information will be for the 32-bit subsystem rather than the 64-bit subsystem.

DkmThread is called by a debug monitor to create a new DkmThread instance. DkmThread objects for system threads are created by the base debug monitor. This method must be called on the event thread. This method will send a ThreadCreate event. Location constraint: API must be called from a Monitor component (component level < 100,000).

[In] DkmProcess represents a target process which is being debugged. The debugger debugs processes, so this is the basic unit of debugging. A DkmProcess can represent a system process or a virtual process such as minidumps. [In] If available, this is the Win32 start address of this thread (value passed to the CreateThread API). The value will not always be available, for example, it is generally not available in scenarios where the thread was started after the debugger attached, or in minidumps. [In] Address within the target process, where the Win32 thread environment block is stored. See documentation on the TEB structure in MSDN for more information. [In] True if this is the main thread of this process. The main thread is the first thread to start. [In,Optional] Describes traits of the thread which are relevant to a full Win32 thread. Currently, this value is required, and all threads will have a 'System' block. In the future, this value may be NULL if the DkmThread represents something other than a full Win32 thread. [In,Optional] Data object to add to the new DkmThread instance. Pass 'null' in the case that the caller doesn't need to add a data item. [Out] Result of this method call.

GetSteppers enumerates the DkmStepper elements of this DkmThread object.

[Out] Array containing the enumerated elements.

Raise a EmbeddedBreakpointHit event. Components which implement the event sink interface will receive the event notification. This method will enqueue the event and control will immediately return to the caller.

[In,Optional] The address where the embedded breakpoint was hit. [In] If true, the UI will display an exception hit dialog for a breakpoint exception. If false, UI will simply break and the DkmInstructionAddress is not used.

[In] Flags impacting how function evaluation requests are performed.

[In] Win32 exception code to raise. Currently, this must be EXCEPTION_BREAKPOINT or EXCEPTION_SINGLE_STEP.

Gets the extended registers from the thread context.

[Out] An array of extended registers.

Sets the value of the extended register in the thread's context.

[In] The CV constant of the register to set. For AVX, this can be any of the YMM register enumeration codes. The caller is expected to set the full YMM register (including the portions which are aliased on XMM registers). [In] The value to set the register to. The size of the byte array must match the width of the register being set.

Convert an array of DkmUnwoundRegisters into an instance of DkmFrameRegisters containing a sorted DkmReadOnlyCollection of DkmUnwoundRegisters.

[In] The unwound register collection to use as the source of the collection. [In] The vframe for this register set. This is only used on x86. [Out] DkmFrameRegisters represents the registers of a stack frame.

Get a managed thread's properties.

[Out] The managed thread id of the thread.

Get a managed thread's properties. This method will append a new work item to the specified work list, and return once the work item has been appended. The actual processing of the work item is asynchronous. The caller will be notified that the request is complete through the completion routine.

[In] The runtime instance of the frame. [Out] The top stack frame. E_NO_FRAME is returned if no native runtime is present and there are no frames on the stack.

[Out] The return address of the frame. [Out] The frame base of the frame. [Out] The vframe of the current frame. Only valid on x86.

[Out] DkmStackWalkFrame represents a frame on a call stack which has been walked, but may not have been formatted or filtered. Formatted frames are represented by DkmStackFrame instead.

Returns a DkmFrameRegisters object containing the thread's current register values.

[In] An array of cvconst/value pairs to add to the collection of register values coming from the context. This is generally used to add the vframe pseudo-register on x86. [Out] DkmFrameRegisters represents the registers of a stack frame.

Creates a DkmFrameRegisters object from the supplied byte array containing a Win32 CONTEXT structure.

[In] Win32 CONTEXT to obtain the registers for. [In] An array of cvconst/value pairs to add to the collection of register values coming from the context. This is generally used to add the vframe pseudo-register on x86. [In] An array of extended registers. [Out] DkmFrameRegisters represents the registers of a stack frame.

OnContinueExecution is called by the base debug monitor on the event thread. This method is called as part of the implementation of IDkmContinueExecution.ContinueExecution, which is what is used by the IDE to continue the target process. This method is used by the Dispatcher to either dispatch stopping events which could not be processed earlier, or to update the internal state of the DkmProcess object to indicate that the target process is now running. Before marking the process as running, the Dispatcher will send a Continue event. A base debug monitor should expect to be reentrantly called while it is in this method.

[Out] True if the base debug monitor should resume execution of the target process.

OnBeginFuncEvalExecution is called by the base debug monitor on the event thread. This method is called as part of the implementation of IDkmBaseFuncEvalService.BeginFuncEvalExecution, which is called to resume the process for a function evaluation. OnBeginFuncEvalExecution will update the internal state of the DkmProcess object to indicate that a function evaluation is in progress. This will also send a FuncEvalStarting event and it will mark the process as running, so that no operations which require a stopped process will be allowed.

[In] Flags impacting how function evaluation requests are performed. [Out] True if the base debug monitor should resume execution of the target process. This will be true unless both DkmFuncEvalFlags.AllowStoppingEvents and DkmFuncEvalFlags.RunAllThreads are set -and- there are events waiting to be processed.

EndFuncEvalExecution is called by the runtime debug monitor on the event thread to exit function evaluation mode. EndFuncEvalExecution will update the internal state of the DkmProcess object to indicate that the function evaluation has ended. This will also send a FuncEvalEnded event and it will mark the process as stopped. This method may be called (1) while processing a 'received' stopping event notification -or- (2) while processing a non-stopping event such as thread exit, -or- (3) while the target is still stopped, for example if the function evaluation setup failed.

[In] Flags impacting how function evaluation requests are performed.

Indicates if the given thread has a stopping event in the queue. This information is used by the execution manager to decide if a thread may be slipped.

[In] If true, the dispatcher will ignore async break events when searching for stopping events. [Out] True if the thread has a queued stopping event.

GetCurrentFuncEvalMode may be called by components as part of event processing to determine if function evaluation is enabled. This function may only be called as part of event processing.

[Out] Indicates if there is a function evaluation occurring in the target process and if stopping events are allowed for this evaluation.

Update the context (register values) of a thread.

[In] A CONTEXT structure that contains the context to be set in the specified thread. The value of the ContextFlags member of this structure specifies which portions of a thread's context to set. Some values in the CONTEXT structure that cannot be specified are silently set to the correct value. This includes bits in the CPU status register that specify the privileged processor mode, global enabling bits in the debugging register, and other states that must be controlled by the operating system.

Obtain the current context (register values) of a thread.

[In] Win32 flags indicating which portion of the CONTEXT object to obtain (ex: CONTEXT_FULL, CONTEXT_CONTROL, CONTEXT_INTEGER). [In,Out] A Win32 CONTEXT structure that contains the context of the specified thread. The value of the ContextFlags member of this structure specifies which portions of a thread's context to obtained. [In] Size of the context structure to read in bytes. This must exactly match the size required to read the context.

Obtain the current context (register values) of a thread.

Provides the location of a thread, as visible in the threads window, or threads drop down in the debug location toolbar. This method will append a new work item to the specified work list, and return once the work item has been appended. The actual processing of the work item is asynchronous. The caller will be notified that the request is complete through the completion routine. Location constraint: API must be called from an IDE component (component level > 100,000).

Retrieves the stack limit/stack base of the given thread. Note that its possible for this value to change over time, for example, in the case of fibers.

[Out] The limit/base address for the memory containing a thread's stack. E_INVALID_MEMORY_ADDRESS indicates that the address containing the TEB structure could not be read from the target process. This may be returned for minidumps without heap.

Suspend this thread.

[In] Pass true if this suspension should be hidden in calls to GetSuspensionCount. This is useful for internal suspensions that should not be reported to the user such as thread slippage suspensions. [Out,Optional] The previous number of suspensions for this thread minus the ones internal to the debugger.

Resume this thread.

Return the current suspension count of this thread.

[In] Pass true to return the true suspension count for the thread. Return false to only see the suspensions that occurred in the debuggee process or the one's that passed true for InternalSuspension to Suspend. [Out] The suspension count of thread. The internal thread suspension count is subtracted from this value if ShowInternal is false.

Return the current suspension count of this thread. This method will append a new work item to the specified work list, and return once the work item has been appended. The actual processing of the work item is asynchronous. The caller will be notified that the request is complete through the completion routine.

WorkList to append the new work item to. [In] Pass true to return the true suspension count for the thread. Return false to only see the suspensions that occurred in the debuggee process or the one's that passed true for InternalSuspension to Suspend. Routine to fire when the request is complete. If the request is successfully appended to the work list, this will always fire (including when the operation is canceled). This will never fire if appending the work item fails.

Return the total number of suspensions caused by the debugger (i.e. calls to DkmThread::Suspend without a call to DkmThread::Resume). This excludes any suspensions external to the debugger.

[Out] The total number of suspensions caused by the debugger (i.e. calls to DkmThread::Suspend without a call to DkmThread::Resume). This excludes any suspensions external to the debugger.

Retrieves the value in the debuggee thread's thread local storage (TLS) slot for the specified TLS index. Each thread of a process has its own slot for each TLS index.

[In] The TLS index that was allocated when the target process called the TlsAlloc function. [Out] The pointer-sized value which was stored in the thread's TLS slot. If the target thread is 32-bit, the upper 32-bits of this value will be zero.

Stores a value in the debuggee thread's thread local storage (TLS) slot for the specified TLS index. Each thread of a process has its own slot for each TLS index.

[In] The TLS index that was allocated when the target process called the TlsAlloc function. [In] The pointer-sized value to store in the thread's TLS slot. If the target thread is 32-bit, the upper 32-bits of this value will be ignored.

Get a thread's dynamic properties.

[Out] The priority of the thread. The values returned correspond directly to the values defined for kernel32!GetThreadPriority. [Out] The affinity mask of the thread. The values returned correspond directly to the values defined for kernel32!SetThreadAffinityMask.

Get a thread's dynamic properties. This method will append a new work item to the specified work list, and return once the work item has been appended. The actual processing of the work item is asynchronous. The caller will be notified that the request is complete through the completion routine.

Get volatile flags about a thread. For instance, return if a thread is a user-mode scheduled thread.

[Out] Volatile flags that apply to a thread. These values are expected to change over time and should not be cached by callers.

Get volatile flags about a thread. For instance, return if a thread is a user-mode scheduled thread. This method will append a new work item to the specified work list, and return once the work item has been appended. The actual processing of the work item is asynchronous. The caller will be notified that the request is complete through the completion routine.

Raise a InterceptExceptionCompleted event. Components which implement the event sink interface will receive the event notification. This method will enqueue the event and control will immediately return to the caller.

[In] Cookie that was handed out when intercept exception request came in.

ThreadExit is sent by the dispatcher when DkmThread::Unload is invoked by the monitor. This method may only be called by the component which created the object.

[In] 32-bit value that the process returned on exit. This is the same value that would be reported from the kernel32!GetExitCodeThread.

GetThreadCurrentWinRtErrorInfo is used to get the address of the current IErrorInfo object for this thread. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

[Out,Optional] Address of the current IErrorInfo object on this thread.

ThreadNameChange is sent by the dispatcher when DkmThread::NameChange is invoked by the monitor. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

A point of time within a time travel trace. The internal representation is an implementation detail of the creator. This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTMPreview).

Implementation defined data that uniquely identifies this time context. This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTMPreview).

The process this time context applies to. This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTMPreview).

An approximation of this position relative to the beginning of the trace. In some cases the amount of trace time can change so the approximation cannot be assumed to be constant relative to the end point. This is used for display purposes only and shouldn't be used as an exact position in the trace. This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTMPreview).

Create a new DkmTraceTimeContext object instance. This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTMPreview).

[In] Implementation defined data that uniquely identifies this time context. [In] The process this time context applies to. [In] An approximation of this position relative to the beginning of the trace. In some cases the amount of trace time can change so the approximation cannot be assumed to be constant relative to the end point. This is used for display purposes only and shouldn't be used as an exact position in the trace. [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Represents an address which could not be resolved to a module.

Create a new DkmUnknownInstructionAddress object instance.

[In] The DkmRuntimeInstance class represents an execution environment which is loaded into a DkmProcess and which contains code to be debugged. [In,Optional] CPUInstruction provides the address that the CPU will execute. This is always provided for native instructions. It may be provided for CLR or custom addresses depending on how the address object was created. [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Contains information about a message that is to be displayed to the user.

Connection used to send the message to the debugger. This will value is usually obtained from DkmProcess.Connection unless the message needs to be sent before the DkmProcess is created.

[Optional] Process that this message is in reference to.

Indicates where a DkmUserMessage should be output within the debugger IDE.

Text to display inside the message box or inside the output window. If an error code is provided, '%1' will be replaced with the text for the error message. For example: 'Unable to stand on my head. %1'.

Win32 message box flags from winuser.h (ex: MB_OK). These flags are ignored if OutputKind is not set to 'MessageBox'.

Error code to display a message for. This value should be S_OK (0) if the message is not for an error.

An optional timestamp value. Typically, obtained via QueryPerformanceCounter when the object is created. Note that if the object is created on the local side of the remoting layer, no timestamp will be available. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

Create a new DkmUserMessage object instance.

[In] Connection used to send the message to the debugger. This will value is usually obtained from DkmProcess.Connection unless the message needs to be sent before the DkmProcess is created. [In,Optional] Process that this message is in reference to. [In] Indicates where a DkmUserMessage should be output within the debugger IDE. [In] Text to display inside the message box or inside the output window. If an error code is provided, '%1' will be replaced with the text for the error message. For example: 'Unable to stand on my head. %1'. [In] Win32 message box flags from winuser.h (ex: MB_OK). These flags are ignored if OutputKind is not set to 'MessageBox'. [In] Error code to display a message for. This value should be S_OK (0) if the message is not for an error. [Out] Result of this method call.

Create a new DkmUserMessage object instance. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

Displays a message to the user inside the Visual Studio debugger IDE. This function does not block waiting for the user to dismiss the error message.

[Out] Win32 'ID' code from displaying the message box (ex: IDYES). These codes are defined in winuser.h from the Windows SDK.

Displays a message to the user inside the Visual Studio debugger IDE. This method is the Async implementation. Once it is executed the completion routine will be called with the DkmProcess and the user response (Yes/No). This method requires DkmUserMessage.Process to be non-null. This method will append a new work item to the specified work list, and return once the work item has been appended. The actual processing of the work item is asynchronous. The caller will be notified that the request is complete through the completion routine. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Indicates where a DkmUserMessage should be output within the debugger IDE.

Message should be displayed in the output window. It will always appear and cannot be filtered by the user.

Message should be displayed in the output window. If the user has chosen to hide exception message, the message will not be displayed. Typically, messages of this kind inform the user that an exception has occurred in the debuggee.

Message should be displayed in the output window. If the user has chosen to hide program output, the message will not be displayed. Typically, messages of this kind are sent from the debuggee using API's such as OutputDebugString() or System.Diagnostics.Debugger.WriteLine().

Message should be displayed in a message box.

Message displayed in message box prompts to enable/disable JustMyCode.

Step filtering-related message. Will go to output window, unless the user chooses to turn off step-filtering messages.

Message box informing user that we stepped over a property or operator. UI layer will handle the logic of suppressing the dialog if it was already shown before.

Message is displayed in a message box and the debugger UI will attempt a detach/terminate to stop debugging this process. If the FatalError is being generated from a debug event, the component sending the fatal error may want to suspend the threads of the process so that it doesn't execute further until debugging stops.

This message kind is used when the user aborts an operation that is required in order to debug. Like a FatalError message, the debugger UI the debugger UI will attempt a detach/terminate to stop debugging this process when the event is received.

Message is displayed when a user is using the new debugger (Concord) and has hit a breakpoint in a language that not supported.

Warning message from the debugger which will always be sent to the output window.

DkmVirtualThread represents a thread that does not physically exist in the debugged process. This API was introduced in Visual Studio 16 Update 2 (DkmApiVersion.VS16Update2).

Create a new DkmVirtualThread object instance. Location constraint: API must be called from a Monitor component (component level < 100,000). This API was introduced in Visual Studio 16 Update 2 (DkmApiVersion.VS16Update2).

[In] DkmProcess represents a target process which is being debugged. The debugger debugs processes, so this is the basic unit of debugging. A DkmProcess can represent a system process or a virtual process such as minidumps. [In,Optional] Describes traits of the thread which are relevant to a full Win32 thread. Currently, this value is required, and all threads will have a 'System' block. In the future, this value may be NULL if the DkmThread represents something other than a full Win32 thread. [In,Optional] Data object to add to the new DkmVirtualThread instance. Pass 'null' in the case that the caller doesn't need to add a data item. [Out] Result of this method call.

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Represents an operation which is happening on the debugger backend, and which may be slow, so the user should be informed if it winds up taking longer the specified delay. This API was introduced in Visual Studio 15 RTM (DkmApiVersion.VS15RTM).

Guid which uniquely identifies this operation. This API was introduced in Visual Studio 15 RTM (DkmApiVersion.VS15RTM).

Description of the operation to show to the user. This API was introduced in Visual Studio 15 RTM (DkmApiVersion.VS15RTM).

Flags for a DkmWaitUIOperation. This API was introduced in Visual Studio 15 RTM (DkmApiVersion.VS15RTM).

Closes a DkmWaitUIOperation object instance. This will shutdown the wait UI if it is open. Code that calls DkmWaitUIOperation.Create should always call this method to indicate the operation is done. This method may only be called by the component which created the object. This API was introduced in Visual Studio 15 RTM (DkmApiVersion.VS15RTM).

Creates a new DkmWaitUIOperation object. Call 'OnStart' to indicate that the operation has actually started. The caller is responsible for closing the created object after they are done. This API was introduced in Visual Studio 15 RTM (DkmApiVersion.VS15RTM).

Indicates that the operation has begun. UI will pop up from the IDE if it is still in progress after the delay has expired. The implementation of this method is async and this function will immediately return. The caller make sure to Close the DkmWaitUIOperation to indicate that the operation is complete. This method may only be called by the component which created the object. This API was introduced in Visual Studio 15 RTM (DkmApiVersion.VS15RTM).

[In] Number of milliseconds to delay before putting up the wait UI.

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Flags for a DkmWaitUIOperation. This API was introduced in Visual Studio 15 RTM (DkmApiVersion.VS15RTM).

No flags are set.

If set, the wait dialog should provide a cancellation button if it this is part of an outer operation which is cancellable. Currently the only such operations are expression evaluation.

Dispatcher object which represents a child node of a visualized expression. Each node returned from GetChildren / GetItems should be an instance of this object..

The result of evaluating this visualized child. The expression evaluator reserves the right to override this instance so do not rely on storing data items in the DkmEvaluationResult instance. Use the DkmVisualizedExpression instance as a data container instead.

The Parent of this visualized child.

The index of this child in the parent object's child collection. The expression evaluator will use this when processing the full name of a child item. The full name is used when the user clicks on an item and says Add To Watch or when the user types something in the watch window directly. If the visualizer does not provide a full name, then callback to the expression evaluator to construct a default expand expression The value of the index field will be used to obtain the correct expand expression.

Create a new DkmChildVisualizedExpression object instance.

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Enum that describes the location of the visualizer assembly. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

Location unknown.

The ...\Documents\...\Visual Studio X\Visualizers directory.

The ...\Common7\Packages\Debugger\Visualizers directory.

Present on an assembly loaded by the debuggee.

Represents a collection of favorite properties and/or fields on a type as well as auto generated display strings. This API was introduced in Visual Studio 16 Update 4 (DkmApiVersion.VS16Update4).

A string representing the type which is targeted by this info. This API was introduced in Visual Studio 16 Update 4 (DkmApiVersion.VS16Update4).

[Optional] The display string for the target type, this is created and updated automatically by the IDkmClrObjectFavoritesCache when favorites are added or removed. This value is optional when sent to IDkmClrObjectFavoritesCache.UpdateFavorites(). It should always be present in values returned from IDkmClrObjectFavoritesCacheCallback.GetFavorites(). This API was introduced in Visual Studio 16 Update 4 (DkmApiVersion.VS16Update4).

[Optional] The simple display string for the target type which does not include field names. This value is optional when sent to IDkmClrObjectFavoritesCache.UpdateFavorites(). It should always be present in values returned from IDkmClrObjectFavoritesCacheCallback.GetFavorites(). This API was introduced in Visual Studio 16 Update 4 (DkmApiVersion.VS16Update4).

The properties and/or fields which are favorites on the target type. This API was introduced in Visual Studio 16 Update 4 (DkmApiVersion.VS16Update4).

Create a new DkmClrObjectFavoritesInfo object instance. This API was introduced in Visual Studio 16 Update 4 (DkmApiVersion.VS16Update4).

[In] A string representing the type which is targeted by this info. [In,Optional] The display string for the target type, this is created and updated automatically by the IDkmClrObjectFavoritesCache when favorites are added or removed. This value is optional when sent to IDkmClrObjectFavoritesCache.UpdateFavorites(). It should always be present in values returned from IDkmClrObjectFavoritesCacheCallback.GetFavorites(). [In,Optional] The simple display string for the target type which does not include field names. This value is optional when sent to IDkmClrObjectFavoritesCache.UpdateFavorites(). It should always be present in values returned from IDkmClrObjectFavoritesCacheCallback.GetFavorites(). [In] The properties and/or fields which are favorites on the target type. [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Flags which indicate attributes of a CLR value. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

No value flags set.

Indicates that the evaluation did not succeed and has returned an error message.

Indicates that the value exists only in the debugger and is not backed by a real value in the process being debugged.

Indicates that the evaluation returned a void value.

Result of an asynchronous DkmLanguageExpression.CompileDisplayAttributeInternal call.

Creates a new result structure to hold the error from a failed call to DkmLanguageExpression.CompileDisplayAttributeInternal.

[In] exception object containing the error

HRESULT code returned from the caller. This will be DkmExceptionCode.COR_E_OPERATIONCANCELED (0x8013153B) if the operation was canceled before processing was complete.

[Optional] Indicates any error compiling the expression. If the code compiles successfully, this value should be null. In error cases, this value indicates the reason for the compile error and the caller should return S_OK. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

[Optional] The compiled display attribute. If Result is null, and Error is not null, there was a compile error. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

Creates a new result structure to hold the output from a successful call to DkmLanguageExpression.CompileDisplayAttributeInternal.

[In,Optional] Indicates any error compiling the expression. If the code compiles successfully, this value should be null. In error cases, this value indicates the reason for the compile error and the caller should return S_OK. [In,Optional] The compiled display attribute. If Result is null, and Error is not null, there was a compile error.

Marshal a native struct to managed

Pointer to native struct. Managed object.

Obtain a pointer to the native object used to call into native.

Outgoing managed->native call Native object

Validate the fields of this structure

Struct that holds the field path (ex: "myArgument.StructField")

An inspection query compiled to a custom format. The RuntimeType indicates the format of the query.

Body of the query.

Create a new DkmCompiledCustomInspectionQuery object instance.

Create a new DkmCompiledCustomInspectionQuery object instance. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

[In] The DkmRuntimeInstance class represents an execution environment which is loaded into a DkmProcess and which contains code to be debugged. [In] Indicates the type of inspection query. This is used to select a component to process the query. [In,Optional] Custom Data to associate with this inspection query. It will persist as long as the query has the potential to execute. [In] The language of the expression evaluator that created this query. [In] Body of the query. [Out] Result of this method call.

Create a new DkmCompiledCustomInspectionQuery object instance. This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTMPreview).

[In] The DkmRuntimeInstance class represents an execution environment which is loaded into a DkmProcess and which contains code to be debugged. [In] Indicates the type of inspection query. This is used to select a component to process the query. [In,Optional] Custom Data to associate with this inspection query. It will persist as long as the query has the potential to execute. [In] The language of the expression evaluator that created this query. [In,Optional] If non-null, the worker process where the inspection query was created. [In] Body of the query. [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Represents a query which is produced by an expression evaluator or similar component and set to the target computer to obtain information about the dynamic state of the program (ex: the current value of a register). Consumers of inspection queries should call Close() once it is known that the inspection query will no longer execute. Derived classes: DkmCompiledCustomInspectionQuery, DkmCompiledILInspectionQuery, DkmCompiledClrInspectionQuery, DkmCompiledClrLocalsQuery

DkmCompiledInspectionQuery is an abstract base class. This enum indicates which derived class this object is an instance of.

Object is an instance of 'DkmCompiledILInspectionQuery'.

Object is an instance of 'DkmCompiledCustomInspectionQuery'.

Object is an instance of 'DkmCompiledClrInspectionQuery'.

Object is an instance of 'DkmCompiledClrLocalsQuery'.

DkmCompiledInspectionQuery is an abstract base class. This enum indicates which derived class this object is an instance of.

The DkmRuntimeInstance class represents an execution environment which is loaded into a DkmProcess and which contains code to be debugged.

Indicates the type of inspection query. This is used to select a component to process the query.

[Optional] Custom Data to associate with this inspection query. It will persist as long as the query has the potential to execute. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

The language of the expression evaluator that created this query. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

[Optional] If non-null, the worker process where the inspection query was created. This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTMPreview).

Executes a compiled inspection query and returns any results.

[In,Optional] Optional array of parameter values to pass to the IL stream. [In] The stack frame context we are evaluating on. [In] This is the timeout to be used for potentially slow operations such as a function evaluation. This value is in milliseconds. [In] Flags impacting how function evaluation requests are performed. [Out] If an expected error occurs evaluating the DkmIL, indicates the reason for the failure. [Out] Results of the evaluations. Each ILEvaluationResult object contains an index that indicates which DkmILInstruction in the instructions parameter this result came from. NOTE: some instructions will not return a result.

Executes a compiled inspection query and returns any results. This method will append a new work item to the specified work list, and return once the work item has been appended. The actual processing of the work item is asynchronous. The caller will be notified that the request is complete through the completion routine.

WorkList to append the new work item to. [In,Optional] Optional array of parameter values to pass to the IL stream. [In] The stack frame context we are evaluating on. [In] This is the timeout to be used for potentially slow operations such as a function evaluation. This value is in milliseconds. [In] Flags impacting how function evaluation requests are performed. Routine to fire when the request is complete. If the request is successfully appended to the work list, this will always fire (including when the operation is canceled). This will never fire if appending the work item fails.

Closes this compiled inspection query. This should be called at the point in which the query will no longer execute. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

Resolves a DkmILFailureReason into an error message. This is used to produce the error message for a condition breakpoint. Location constraint: API must be called from an IDE component (component level > 100,000). This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

[In] Error code returned from execution of the IL stream. [Out] Human-readable error message describing the error.

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Indicates the type of inspection query. This is used to select a component to process the query.

Query is a DkmCompiledILInspectionQuery object.

Query is a DkmCompiledClrInspectionQuery.

Represents the results of parsing one or more visualization files. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

The language for which this visualization data applies to. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

The inspection session which owns the lifetime of this object. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

Guid which uniquely identifies this inspection session. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

[Optional] This represents a transport connection used for symbol processing, or other memory intensive activities. This worker process may be remote or local. This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTMPreview).

Closes a DkmCompiledVisualizationData object instance. This will release any resources associated with this object across all components. This includes resources across computer or managed/native marshalling boundaries. DkmCompiledVisualizationData objects are automatically closed when their associated DkmInspectionSession object is closed. This method may only be called by the component which created the object. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

Create a new DkmCompiledVisualizationData object instance. The caller is responsible for closing the created object after they are done. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

[In] The language for which this visualization data applies to. [In] The inspection session which owns the lifetime of this object. [In,Optional] Data object to add to the new DkmCompiledVisualizationData instance. Pass 'null' in the case that the caller doesn't need to add a data item. [Out] Result of this method call.

[In] The language for which this visualization data applies to. [In] The inspection session which owns the lifetime of this object. [In,Optional] This represents a transport connection used for symbol processing, or other memory intensive activities. This worker process may be remote or local. [In,Optional] Data object to add to the new DkmCompiledVisualizationData instance. Pass 'null' in the case that the caller doesn't need to add a data item. [Out] Result of this method call.

Compiles object visualization data from a human-readable form into a DkmCompiledVisualizationData object. Location constraint: API must be called from an IDE component (component level > 100,000). This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

[In] List of full paths, on to the Visual Studio computer, that describe information to be used for object visualization. For C++, each item in the array should be the full path to a .natvis file you wish to use when formatting the results of the expression.

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Specifies the relative priority of context-specific visualization data, relative to the default visualization data. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

Indicates that context-specific visualization data will not be used.

Indicates that context-specific visualization data will be used only as a fallback when regular visualization data is not available.

Indicates that context-specific visualization data will be prioritized ahead of default visualization data and that default visualization data will only be used as a fallback when context-specific data is not available for the object being visualized.

Indicates that context-specific visualization data will be used exclusively and that default visualization data will not be used at all.

Identifies the compiler (language and vendor) that a method comes from. This is used to select an expression evaluator.

Compare two elements of the DkmCompilerId structure.

Value to comare against this instance. 'true' if the two elements are equal.

Compare two elements of the DkmCompilerId sructure.

Left side of the comparison Right side of the comparison

Compare two elements of the DkmCompilerId sructure.

Left side of the comparison Right side of the comparison

Compare two elements of the DkmCompilerId sructure.

Left side of the comparison Right side of the comparison

Compare two elements of the DkmCompilerId sructure.

Left side of the comparison Right side of the comparison

Compare two elements of the DkmCompilerId sructure.

Left side of the comparison Right side of the comparison

Compare two elements of the DkmCompilerId sructure.

Left side of the comparison Right side of the comparison

Vendor for the compiler. In some contexts this may be Guid.Empty to indicate that the vendor is unknown.

Language that the code was written in. In some contexts, this may be Guid.Empty to indicate that the language is unknown.

Initialize a new DkmCompilerId value.

[In] Vendor for the compiler. In some contexts this may be Guid.Empty to indicate that the vendor is unknown. [In] Language that the code was written in. In some contexts, this may be Guid.Empty to indicate that the language is unknown.

Data container used to hold custom data about an object that does not directly support data containers. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

Unique id of this data container. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

Closes a DkmCustomDataContainer object instance. This will release any resources associated with this object across all components. This includes resources across computer or managed/native marshalling boundaries. DkmCustomDataContainer objects are automatically closed when their associated DkmProcess object is closed. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

Create a new DkmCustomDataContainer object instance. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

[In] DkmProcess represents a target process which is being debugged. The debugger debugs processes, so this is the basic unit of debugging. A DkmProcess can represent a system process or a virtual process such as minidumps. [In,Optional] Data object to add to the new DkmCustomDataContainer instance. Pass 'null' in the case that the caller doesn't need to add a data item. [Out] Result of this method call.

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

DkmCustomRawReturnValue carries sufficient context that can be used to partially reconstruct and visualize a function-call's return value in a custom runtime environment.

Custom raw return value.

Create a new DkmCustomRawReturnValue object instance.

[In] IP address within the symbol that was returned called and from. Note that there's no guarantee where in the function this address will be. [In] Custom raw return value. [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Contains information about a custom UI visualizer which can be displayed for an evaluation result.

Unique id for this viewer.

The text that will appear in the drop-down menu.

[Optional] The description of the custom viewer.

The name of the EE metric under which viewer CLSID is stored.

[Optional] The full name of the UI-side class of the Custom Managed Visualizer. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

[Optional] The full name of the UI-side visualizer assembly. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

The location of the UI-side visualizer assembly. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

[Optional] The full name of the the debuggee-side class of the Custom Managed Visualizer. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

[Optional] The full name of the debuggee-side visualizer assembly. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

Create a new DkmCustomUIVisualizerInfo object instance.

Create a new DkmCustomUIVisualizerInfo object instance. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

[In] Unique id for this viewer. [In] The text that will appear in the drop-down menu. [In,Optional] The description of the custom viewer. [In] The name of the EE metric under which viewer CLSID is stored. [In,Optional] The full name of the UI-side class of the Custom Managed Visualizer. [In,Optional] The full name of the UI-side visualizer assembly. [In] The location of the UI-side visualizer assembly. [In,Optional] The full name of the the debuggee-side class of the Custom Managed Visualizer. [In,Optional] The full name of the debuggee-side visualizer assembly. [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Represents an address in data. Derived classes: DkmGPUDataAddress

The DkmRuntimeInstance class represents an execution environment which is loaded into a DkmProcess and which contains code to be debugged.

Data address.

[Optional] Set when the data address is an instruction address.

Create a new DkmDataAddress object instance.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

DkmDataBreakpointInfo has the necessary data for creating a data breakpoint for a property. This API was introduced in Visual Studio 15 Update 8 (DkmApiVersion.VS15Update8).

[Optional] Identifier of an expression, which is the address or an reference for that property. This identifier will be used when creating a new data breakpoint.

Size of the data.

Initialize a new DkmDataBreakpointInfo value. This API was introduced in Visual Studio 15 Update 8 (DkmApiVersion.VS15Update8).

[In,Optional] Identifier of an expression, which is the address or an reference for that property. This identifier will be used when creating a new data breakpoint. [In] Size of the data.

Marshal a native struct to managed

Pointer to native struct. Managed object.

Obtain a pointer to the native object used to call into native.

Outgoing managed->native call Native object

Validate the fields of this structure

Struct that holds the field path (ex: "myArgument.StructField")

Result of an asynchronous DkmInspectionContext.EvaluateExpression call.

Creates a new result structure to hold the error from a failed call to DkmInspectionContext.EvaluateExpression.

[In] exception object containing the error

Object containing the result of the evaluation. This object must be closed by the caller when the caller is done with the object.

Creates a new result structure to hold the output from a successful call to DkmInspectionContext.EvaluateExpression.

[In] Object containing the result of the evaluation. This object must be closed by the caller when the caller is done with the object.

Marshal a native struct to managed

Pointer to native struct. Managed object.

Obtain a pointer to the native object used to call into native.

Outgoing managed->native call Native object

Validate the fields of this structure

Struct that holds the field path (ex: "myArgument.StructField")

Result of an asynchronous DkmInspectionContext.EvaluateReturnValue call.

Creates a new result structure to hold the error from a failed call to DkmInspectionContext.EvaluateReturnValue.

[In] exception object containing the error

[Optional] Object containing the result of the evaluation. This object must be closed by the caller when the caller is done with the object. If not present, the function had no return value.

Creates a new result structure to hold the output from a successful call to DkmInspectionContext.EvaluateReturnValue.

[In,Optional] Object containing the result of the evaluation. This object must be closed by the caller when the caller is done with the object. If not present, the function had no return value.

Marshal a native struct to managed

Pointer to native struct. Managed object.

Obtain a pointer to the native object used to call into native.

Outgoing managed->native call Native object

Validate the fields of this structure

Struct that holds the field path (ex: "myArgument.StructField")

Result of an asynchronous DkmInspectionContext.EvaluateReturnValue2 call.

Creates a new result structure to hold the error from a failed call to DkmInspectionContext.EvaluateReturnValue2.

[In] exception object containing the error

[Optional] Object containing the result of the evaluation. This object must be closed by the caller when the caller is done with the object. If not present, the function had no return value. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

Creates a new result structure to hold the output from a successful call to DkmInspectionContext.EvaluateReturnValue2.

[In,Optional] Object containing the result of the evaluation. This object must be closed by the caller when the caller is done with the object. If not present, the function had no return value.

Marshal a native struct to managed

Pointer to native struct. Managed object.

Obtain a pointer to the native object used to call into native.

Outgoing managed->native call Native object

Validate the fields of this structure

Struct that holds the field path (ex: "myArgument.StructField")

Result of an asynchronous DkmEvaluationResultEnumContext.GetItems call.

Creates a new result structure to hold the error from a failed call to DkmEvaluationResultEnumContext.GetItems.

[In] exception object containing the error

HRESULT code returned from the caller. This will be DkmExceptionCode.COR_E_OPERATIONCANCELED (0x8013153B) if the operation was canceled before processing was complete.

The DkmEvaluationResult items to return. Each item must be closed by the caller when the caller is done.

Creates a new result structure to hold the output from a successful call to DkmEvaluationResultEnumContext.GetItems.

[In] The DkmEvaluationResult items to return. Each item must be closed by the caller when the caller is done.

Marshal a native struct to managed

Pointer to native struct. Managed object.

Obtain a pointer to the native object used to call into native.

Outgoing managed->native call Native object

Validate the fields of this structure

Struct that holds the field path (ex: "myArgument.StructField")

Flags which effect how an input expression should be parsed, compiled or displayed.

Input expression should be treated with the default semantics.

The text is an expression (not a statement).

The text might contain function name/parameter signatures, and the expression is to be parsed [and later evaluated] as an address.

The expression evaluator should not evaluate expressions which have side effects, such as assignment statements. The debugger UI will use this flag when the expression needs to be treated with care, such as in data tips. It is up to the expression evaluator to decide what is considered a side effect for their language.

Expression evaluators should not attempt a func-eval. If a component mistakenly issues a func-eval with this flag set then the func-eval will not be honored.

The expression evaluation is happening in the context of design-time expression evaluation (DTEE). In this scenario, the user enters text in the immediate window in design mode.

Allow the variables to be declared as part of the expression.

Force evaluation to occur now. Somebody is requesting it (like the user). Since this flag only impacts the display of the expression, it may be varied between compile and display.

Display the type members as is without the aid of a native visualizer.

If the runtime in question supports interpreted func-evaluation, this flag means to perform real func-evaluations rather than interpreting any function calls in the process.

Expression evaluators should hide non-public members.

Expression evaluators should call ToString method if flag is not present.

Indicates that the expression evaluator should not calculate the Value or EditableValue properties of the returned DkmEvaluationResult. This flag is used as a performance optimization in situations where the value and editable value are not used and do not need to be computed. When this flag is set, the resultant evaluation result, if successful, will have the empty string for its value and editable value.

Indicates that when C++ debugging and natvis is used to visualize an object, that the [Raw View] node should be omitted. This flag may be used as a performance optimization in situations where it is not needed.

Formatter should display the result as a string without quotation marks.

The result should be displayed in Dynamic View.

Only the members that contain the query result should be displayed.

The value will not not be expanded. If calculating whether a value can be expanded is expensive, this flag indicates that determining the expandability is not required.

Enables additional side effects when a value is explicitly refreshed that may have been suppressed during the initial evaluation.

Expansions containing favorites should be filtered to only those items.

Auto generated display strings for expansions with favorites should not include field names.

The formatted result of an evaluation, ready to be displayed in an expression evaluation window. Derived classes: DkmSuccessEvaluationResult, DkmFailedEvaluationResult, DkmIntermediateEvaluationResult

DkmEvaluationResult is an abstract base class. This enum indicates which derived class this object is an instance of.

Object is an instance of 'DkmSuccessEvaluationResult'.

Object is an instance of 'DkmFailedEvaluationResult'.

Object is an instance of 'DkmIntermediateEvaluationResult'.

DkmEvaluationResult is an abstract base class. This enum indicates which derived class this object is an instance of.

Inspection context used to create this evaluation result.

The stack frame this expression result was created on.

The name of the expression this result applies to.

[Optional] The full name of the expression this result applies to. This value is used to allow child elements to be added to the watch window (Add Watch from the context menu), and to refresh parts of the evaluation tree. As an example of how FullName differs from name, the name of the 0th element of an array in C++ is '[0]' while the full name would by 'myArrayVariable[0]'. For Visual Studio 14 and later it's possible to calculate the full name later if needed. To do this, the expression evaluator should create the DkmEvaluationResult with a null full name and implement IDkmFullNameProvider. Concord will then call IDkmFullNameProvider.CalculateFullName to get the full name when needed in the UI.

Guid which uniquely identifies this evaluation result.

Language used to perform inspections.

The InspectionSession allows the various components which examine data in the target process to store private data with the same lifetime. Inspection sessions are closed when the user attempts to continue the process.

Indicates which runtime monitor will be used to perform this evaluation.

Closes the evaluation result object to release the resources associated with it. This method must be invoked by the component which initiated the enumeration (ex: called DkmInspectionContext.EvaluateExpression, DkmEvaluationResultEnumContext.GetItems, etc). DkmEvaluationResult objects are automatically closed when their associated DkmInspectionSession object is closed.

Gets an enumeration context used to obtain the children of this evaluation result. This is used in all expression evaluation windows. This method will append a new work item to the specified work list, and return once the work item has been appended. The actual processing of the work item is asynchronous. The caller will be notified that the request is complete through the completion routine. Location constraint: IDE components may call this method regardless of what type of code is being debugged. This method is also currently supported for debug monitor components, when debugging code running under the CLR; however this functionality may be removed in a future version.

WorkList to append the new work item to. [In] The initial number of children that the caller would like returned. This value can be zero if no children will be initially returned. This value may be larger than the number of children that this expression has, in which case all children should be returned. Very large or negative values should not be used as arrays can have extremely large sizes which would cause out-of-memory if all elements were requested. [In] The inspection context to use for computing the children. This may differ from the original inspection context with respect to settings, such as radix, evaluation flags, or timeout. Routine to fire when the request is complete. If the request is successfully appended to the work list, this will always fire (including when the operation is canceled). This will never fire if appending the work item fails.

Modifies the value of the given evaluation result (assumed to be non-read-only) to match the given string. This is used after the user edits a value in any of the evaluation windows. Location constraint: IDE components may call this method regardless of what type of code is being debugged. This method is also currently supported for debug monitor components, when debugging code running under the CLR; however this functionality may be removed in a future version.

[In] Textual representation of value to assign to the evaluation result. [In] If a function evaluation is needed to assign the value, specifies the timeout to use. [Out,Optional] If the operation failed, this indicates the reason why. This value should be null if the operation succeeded. In native code, an S_OK return value is used when returning error text.

This method is used for evaluation results that include DkmEvaluationResultFlags.RawString to obtain the the underlying string, with no enclosing quotes or escape sequences. This is method is invoked to display one of the various string visualizers in an expression evaluation window (click the magnifying glass icon). Location constraint: IDE components may call this method regardless of what type of code is being debugged. This method is also currently supported for debug monitor components, when debugging code running under the CLR; however this functionality may be removed in a future version.

[Out,Optional] The underlying string value.

Creates an object id for this particular expression. Location constraint: IDE components may call this method regardless of what type of code is being debugged. This method is also currently supported for debug monitor components, when debugging code running under the CLR; however this functionality may be removed in a future version.

Destroys an object id for this particular expression. Location constraint: IDE components may call this method regardless of what type of code is being debugged. This method is also currently supported for debug monitor components, when debugging code running under the CLR; however this functionality may be removed in a future version.

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Specifies the access control level (public, private, etc) of the represented field/method/property. This is principally used by the debugger UI to select icons in the watch and other expression evaluation windows.

Not applicable (the result of the expression is not a field of a class).

Indicates that the result of the expression is a public field.

Indicates that the result of the expression is a private field.

Indicates that the result of the expression is a protected field.

Indicates that the result of the expression is a final field.

Indicates that the result of the expression is an internal field.

The category (ex: Data, Method, etc) of the underlying value represented by this evaluation result. This is principally used by the debugger UI to select icons in the watch and other expression evaluation windows.

Indicates that the evaluation result does not belong to a category listed in this enumeration.

Indicates that the evaluation result represents data.

Indicates that the evaluation result represents a method.

Indicates that the evaluation result represents a event.

Indicates that the evaluation result represents a property.

Indicates that the evaluation result represents a class.

Indicates that the evaluation result represents an interface.

Node in the evaluation result tree to access fields/properties/etc of a base class.

Node in the evaluation result tree to access fields/properties/etc of an inner class.

Node in the evaluation result tree to access fields/properties/etc of the most derived class.

Context object used to enumerate child members of an evaluation result, or to enumerate local variables from a stack frame. This is logically similar to an enumerator, except that access to elements is index-based rather than sequential.

The number of items (DkmEvaluationResults) which can be obtained through this DkmEvaluationResultEnumContext.

The stack frame this expression result was created on.

Inspection context used to create this enumeration context.

Guid which uniquely identifies this enumeration context.

Language used to perform inspections.

Indicates which runtime monitor will be used to perform this evaluation.

Closes the enum context object to release the resources associated with it. This method must be invoked by the component which initiated the enumeration (ex: called DkmEvaluationResult.GetChildren or DkmInspectionContext.GetFrameLocals). DkmEvaluationResultEnumContext objects are automatically closed when their associated DkmInspectionSession object is closed.

Create a new DkmEvaluationResultEnumContext object instance.

[In] The number of items (DkmEvaluationResults) which can be obtained through this DkmEvaluationResultEnumContext. [In] The stack frame this expression result was created on. [In] Inspection context used to create this enumeration context. [In,Optional] Data object to add to the new DkmEvaluationResultEnumContext instance. Pass 'null' in the case that the caller doesn't need to add a data item. [Out] Result of this method call.

Obtain DkmEvaluationResult items from this enumeration context. This is used to obtain local variables of a stack frame or child members from an evaluation result. This method will append a new work item to the specified work list, and return once the work item has been appended. The actual processing of the work item is asynchronous. The caller will be notified that the request is complete through the completion routine. Location constraint: IDE components may call this method regardless of what type of code is being debugged. This method is also currently supported for debug monitor components, when debugging code running under the CLR; however this functionality may be removed in a future version.

WorkList to append the new work item to. [In] The zero-based index of the first item to obtain. [In] The number of items to try and return. This value may be larger than the total number of remaining items, in which case all remaining items should be returned. Very large or negative values should not be used as arrays can have extremely large sizes which would cause out-of-memory if all elements were requested. Routine to fire when the request is complete. If the request is successfully appended to the work list, this will always fire (including when the operation is canceled). This will never fire if appending the work item fails.

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Flags which indicate attributes of an expression evaluation result.

No attribute flags are set.

Indicates that the evaluation caused a side effect.

Indicates that the result of this evaluation has children which can be accessed through IDkmLanguageExpressionEvaluator.GetChildrenEnumContext.

Indicates that the result of the evaluation is a Boolean value.

If the Boolean flag is set, indicates that the result of the evaluation is "true", as opposed to "false".

Indicates that the result of the expression represents a conceptual string that can be displayed in the string viewer. The EE should be prepared to provide the raw string via IDkmLanguageExpressionEvaluator::GetUnderlyingString().

Indicates that the result of the expression evaluation is an address that can be navigated to in the memory window.

Indicates that the result of the expression evaluation is read-only. If false, the user will be allowed to modify the value.

Indicates that the IL interpreter was used to get the result of the expression evaluation.

Indicates that the expression contains side effects that were discarded by the IL interpreter. To flush the side effects, the user should re-evaluate the expression with real func-evals turned on.

Indicates that the expression has an object id associated with it.

Indicates that the expression can have an object id assigned to it.

Indicates that the expression was rejected because it has a cross thread dependency.

Indicates that the value is invalid.

Indicates that the object being inspected has a visualizer associated with it. Currently, this flag is only implemented for C++ and is set whenever the result of the evaluation has a natvis entry associated with it.

Indicates that the Evaluation Results was marked as an Error but has an expandable object. An example of this is the VB EE results that is an Exception object.

Indicates that the function or property being evaluated threw an exception. Not all expression evaluators set this flag.

Indicates that this value is the return value of a function that was called during the last step.

Indicates that the type of the value is a built-in type.

Indicates that the UI will provide a refresh button that the user can click on to repeat the evaluation. The retry will happen with DkmEvaluationFlags::EvaluateNow set.

Indicates that the formatting of this object requires additional side effects that have been suppressed; the user can redo the evaluation with these additional side effects by clicking the refresh button.

For time-travelling processes, indicates that memory had to be read from the 'future' relative to the current process time in order to evaluate an expression.

For time-travelling processes, indicates that memory had to be read from the 'past' relative to the current process time in order to evaluate an expression.

For time-travelling processes, indicates that there was a gap (unknown to the process) in memory used in order to evaluate an expression.

Indicates that the result of the expression has an address which is currently being tracked by a data breakpoint.

This evaluation result is an item which can be added as a favorite of its parent type.

This evaluation result is an item which has been added as a favorite of its parent type.

This evaluation result is an item whose current expansion contains at least one favorite item.

If the evaluation result supports replacing the object for managed custom visualizers.

If the result of an expression evaluation is data, indicates where the data is stored. This is principally used by the debugger UI to select icons in the watch and other expression evaluation windows.

Indicates that the evaluation result does not have a storage type.

Indicates that the evaluation result represents a global variable.

Indicates that the evaluation result represents a static variable.

Indicates that the evaluation result represents a register.

Type modifier flags (ex: const). These are principally used by the debugger UI to select icons in the watch and other expression evaluation windows.

None.

Indicates that the represented method/property is virtual.

Indicates that the represented value is a constant.

Indicates that the represented method/class is synchronized.

Indicates that the represented field is volatile.

Result of an asynchronous DkmCompiledInspectionQuery.Execute call.

Creates a new result structure to hold the error from a failed call to DkmCompiledInspectionQuery.Execute.

[In] exception object containing the error

HRESULT code returned from the caller. This will be DkmExceptionCode.COR_E_OPERATIONCANCELED (0x8013153B) if the operation was canceled before processing was complete.

Results of the evaluations. Each ILEvaluationResult object contains an index that indicates which DkmILInstruction in the instructions parameter this result came from. NOTE: some instructions will not return a result.

If an expected error occurs evaluating the DkmIL, indicates the reason for the failure.

Creates a new result structure to hold the output from a successful call to DkmCompiledInspectionQuery.Execute.

[In] Results of the evaluations. Each ILEvaluationResult object contains an index that indicates which DkmILInstruction in the instructions parameter this result came from. NOTE: some instructions will not return a result. [In] If an expected error occurs evaluating the DkmIL, indicates the reason for the failure.

Marshal a native struct to managed

Pointer to native struct. Managed object.

Obtain a pointer to the native object used to call into native.

Outgoing managed->native call Native object

Validate the fields of this structure

Struct that holds the field path (ex: "myArgument.StructField")

Base class for all expression value homes. Derived classes: DkmFakeValueHome, DkmPointerValueHome

DkmExpressionValueHome is an abstract base class. This enum indicates which derived class this object is an instance of.

Object is an instance of 'DkmPointerValueHome'.

Object is an instance of 'DkmFakeValueHome'.

DkmExpressionValueHome is an abstract base class. This enum indicates which derived class this object is an instance of.

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

The formatted result of a failed evaluation, ready to be displayed in an expression evaluation window.

Specifies the error message to display to the user.

Flags which indicate attributes of an expression evaluation result.

[Optional] A string that describes the type of the value. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

Create a new DkmFailedEvaluationResult object instance.

Create a new DkmFailedEvaluationResult object instance. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

Create a new DkmFailedEvaluationResult object instance. This API was introduced in Visual Studio 14 Update 2 (DkmApiVersion.VS14Update2).

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

An instance of DkmExpressionValueHome that does not represent anything real. Normally used to represent values that do not actually exist in the debuggee.

Deprecated. Do not use.

Create a new DkmFakeValueHome object instance.

[In] Deprecated. Do not use. [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Represents a logical top level item in the 'Locals' window, whose value is obtaining using IDkmFramePseudoLocalProvider. Currently this is only used for optimized locals while .NET Debugging. This API was introduced in Visual Studio 15 Update 8 (DkmApiVersion.VS15Update8).

The Guid pair used to identify this PseudoLocal. This API was introduced in Visual Studio 15 Update 8 (DkmApiVersion.VS15Update8).

The name of the PseudoLocal. This API was introduced in Visual Studio 15 Update 8 (DkmApiVersion.VS15Update8).

The DkmRuntimeInstance class represents an execution environment which is loaded into a DkmProcess and which contains code to be debugged. This API was introduced in Visual Studio 15 Update 8 (DkmApiVersion.VS15Update8).

Create a new DkmFramePseudoLocal object instance. This API was introduced in Visual Studio 15 Update 8 (DkmApiVersion.VS15Update8).

[In] The Guid pair used to identify this PseudoLocal. [In] The name of the PseudoLocal. [In] The DkmRuntimeInstance class represents an execution environment which is loaded into a DkmProcess and which contains code to be debugged. [Out] Result of this method call.

Gets the evaluation result for the pseudo local to be included among the frame locals. This method will append a new work item to the specified work list, and return once the work item has been appended. The actual processing of the work item is asynchronous. The caller will be notified that the request is complete through the completion routine. This API was introduced in Visual Studio 15 Update 8 (DkmApiVersion.VS15Update8).

WorkList to append the new work item to. [In] The current inspection context. [In] The current frame. Routine to fire when the request is complete. If the request is successfully appended to the work list, this will always fire (including when the operation is canceled). This will never fire if appending the work item fails.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Flags impacting how function evaluation requests are performed.

The function evaluation will continue past stopping events (ex: breakpoints will be skipped) and will execute on a single thread (all other threads will be left suspended).

Indicates that stopping events should be processed normally during the function evaluation. This option is used for function evaluation requests from the immediate window. When this flag is missing, most stopping events are immediately suppressed. This flag should only be enabled by the AD7 AL.

All threads should run during the function evaluation. If this flag is missing, all threads other than the evaluating thread are suspended during the evaluation. A component may use this flag in conjunction with the thread suspension API in order to suspend a subset of the threads in the application. This flag may not be used with function evaluation requests from the event thread.

Result of an asynchronous DkmEvaluationResult.GetChildren call.

Creates a new result structure to hold the error from a failed call to DkmEvaluationResult.GetChildren.

[In] exception object containing the error

HRESULT code returned from the caller. This will be DkmExceptionCode.COR_E_OPERATIONCANCELED (0x8013153B) if the operation was canceled before processing was complete.

The initial children to return. Each child must be closed by the caller when the caller is done.

Context object used to enumerate the children, including the children already returned via the InitialChildren parameter. This object must be closed by the caller of this API when enumeration is complete.

Creates a new result structure to hold the output from a successful call to DkmEvaluationResult.GetChildren.

[In] The initial children to return. Each child must be closed by the caller when the caller is done. [In] Context object used to enumerate the children, including the children already returned via the InitialChildren parameter. This object must be closed by the caller of this API when enumeration is complete.

Marshal a native struct to managed

Pointer to native struct. Managed object.

Obtain a pointer to the native object used to call into native.

Outgoing managed->native call Native object

Validate the fields of this structure

Struct that holds the field path (ex: "myArgument.StructField")

Result of an asynchronous DkmSuccessEvaluationResult.GetDataBreakpointDisplayName call.

Creates a new result structure to hold the error from a failed call to DkmSuccessEvaluationResult.GetDataBreakpointDisplayName.

[In] exception object containing the error

HRESULT code returned from the caller. This will be DkmExceptionCode.COR_E_OPERATIONCANCELED (0x8013153B) if the operation was canceled before processing was complete.

The data breakpoint display name. This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTM).

Creates a new result structure to hold the output from a successful call to DkmSuccessEvaluationResult.GetDataBreakpointDisplayName.

[In] The data breakpoint display name.

Marshal a native struct to managed

Pointer to native struct. Managed object.

Obtain a pointer to the native object used to call into native.

Outgoing managed->native call Native object

Validate the fields of this structure

Struct that holds the field path (ex: "myArgument.StructField")

Result of an asynchronous DkmSuccessEvaluationResult.GetDataBreakpointInfo call.

Creates a new result structure to hold the error from a failed call to DkmSuccessEvaluationResult.GetDataBreakpointInfo.

[In] exception object containing the error

HRESULT code returned from the caller. This will be DkmExceptionCode.COR_E_OPERATIONCANCELED (0x8013153B) if the operation was canceled before processing was complete.

The data breakpoint information. This API was introduced in Visual Studio 15 Update 8 (DkmApiVersion.VS15Update8).

[Optional] If the operation failed, this indicates the reason why. This value should be null if the operation succeeded. This API was introduced in Visual Studio 15 Update 8 (DkmApiVersion.VS15Update8).

Creates a new result structure to hold the output from a successful call to DkmSuccessEvaluationResult.GetDataBreakpointInfo.

[In] The data breakpoint information. [In,Optional] If the operation failed, this indicates the reason why. This value should be null if the operation succeeded.

Marshal a native struct to managed

Pointer to native struct. Managed object.

Obtain a pointer to the native object used to call into native.

Outgoing managed->native call Native object

Validate the fields of this structure

Struct that holds the field path (ex: "myArgument.StructField")

Result of an asynchronous DkmInspectionContext.GetFrameArguments call.

Creates a new result structure to hold the error from a failed call to DkmInspectionContext.GetFrameArguments.

[In] exception object containing the error

HRESULT code returned from the caller. This will be DkmExceptionCode.COR_E_OPERATIONCANCELED (0x8013153B) if the operation was canceled before processing was complete.

DkmEvaluationResult for each argument. Each DkmEvaluationResult must be closed by the caller when done with the object.

Creates a new result structure to hold the output from a successful call to DkmInspectionContext.GetFrameArguments.

[In] DkmEvaluationResult for each argument. Each DkmEvaluationResult must be closed by the caller when done with the object.

Marshal a native struct to managed

Pointer to native struct. Managed object.

Obtain a pointer to the native object used to call into native.

Outgoing managed->native call Native object

Validate the fields of this structure

Struct that holds the field path (ex: "myArgument.StructField")

Result of an asynchronous DkmInspectionContext.GetFrameLocals call.

Creates a new result structure to hold the error from a failed call to DkmInspectionContext.GetFrameLocals.

[In] exception object containing the error

HRESULT code returned from the caller. This will be DkmExceptionCode.COR_E_OPERATIONCANCELED (0x8013153B) if the operation was canceled before processing was complete.

Creates a new result structure to hold the output from a successful call to DkmInspectionContext.GetFrameLocals.

Marshal a native struct to managed

Pointer to native struct. Managed object.

Obtain a pointer to the native object used to call into native.

Outgoing managed->native call Native object

Validate the fields of this structure

Struct that holds the field path (ex: "myArgument.StructField")

Result of an asynchronous DkmInspectionContext.GetFrameName call.

Creates a new result structure to hold the error from a failed call to DkmInspectionContext.GetFrameName.

[In] exception object containing the error

HRESULT code returned from the caller. This will be DkmExceptionCode.COR_E_OPERATIONCANCELED (0x8013153B) if the operation was canceled before processing was complete.

Language's representation of the name of this frame.

Creates a new result structure to hold the output from a successful call to DkmInspectionContext.GetFrameName.

[In] Language's representation of the name of this frame.

Marshal a native struct to managed

Pointer to native struct. Managed object.

Obtain a pointer to the native object used to call into native.

Outgoing managed->native call Native object

Validate the fields of this structure

Struct that holds the field path (ex: "myArgument.StructField")

Result of an asynchronous DkmInspectionContext.GetFrameReturnType call.

Creates a new result structure to hold the error from a failed call to DkmInspectionContext.GetFrameReturnType.

[In] exception object containing the error

HRESULT code returned from the caller. This will be DkmExceptionCode.COR_E_OPERATIONCANCELED (0x8013153B) if the operation was canceled before processing was complete.

[Optional] Language's representation of the return type for this frame.

Creates a new result structure to hold the output from a successful call to DkmInspectionContext.GetFrameReturnType.

[In,Optional] Language's representation of the return type for this frame.

Marshal a native struct to managed

Pointer to native struct. Managed object.

Obtain a pointer to the native object used to call into native.

Outgoing managed->native call Native object

Validate the fields of this structure

Struct that holds the field path (ex: "myArgument.StructField")

Result of an asynchronous DkmLanguage.GetLanguageSettings call.

Creates a new result structure to hold the error from a failed call to DkmLanguage.GetLanguageSettings.

[In] exception object containing the error

HRESULT code returned from the caller. This will be DkmExceptionCode.COR_E_OPERATIONCANCELED (0x8013153B) if the operation was canceled before processing was complete.

Pairing between the name of a setting and its value.

Creates a new result structure to hold the output from a successful call to DkmLanguage.GetLanguageSettings.

[In] Pairing between the name of a setting and its value.

Marshal a native struct to managed

Pointer to native struct. Managed object.

Obtain a pointer to the native object used to call into native.

Outgoing managed->native call Native object

Validate the fields of this structure

Struct that holds the field path (ex: "myArgument.StructField")

Result of an asynchronous DkmLanguageInstructionAddress.GetMethodName call.

Creates a new result structure to hold the error from a failed call to DkmLanguageInstructionAddress.GetMethodName.

[In] exception object containing the error

HRESULT code returned from the caller. This will be DkmExceptionCode.COR_E_OPERATIONCANCELED (0x8013153B) if the operation was canceled before processing was complete.

Language's representation of the name of this method.

Creates a new result structure to hold the output from a successful call to DkmLanguageInstructionAddress.GetMethodName.

[In] Language's representation of the name of this method.

Marshal a native struct to managed

Pointer to native struct. Managed object.

Obtain a pointer to the native object used to call into native.

Outgoing managed->native call Native object

Validate the fields of this structure

Struct that holds the field path (ex: "myArgument.StructField")

Context to use for IL evaluation.

Optional section that describes an alternate thread to use for evaluation.

Global-to-kernel thread ID to use for evaluation.

Initialize a new ThreadOverride value.

[In] Global-to-kernel thread ID to use for evaluation.

[Optional] Optional section that describes an alternate thread to use for evaluation.

[Optional] Stack frame to use for evaluation. The specific thread to use may be overridden using the optional ThreadOverride part. A stack frame is required for accessing registers, invoking functions, or accessing thread-local storage, or for any query that is executing on a GPU runtime instance. A stack frame is not required when executing a query on a native runtime instance that only reads or writes memory.

[Optional] Custom data to associate with this DkmILContext. This is used to convey information associated with a particular execution of a DkmCompiledInspectionQuery. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

Create a new DkmILContext object instance.

[In,Optional] Stack frame to use for evaluation. The specific thread to use may be overridden using the optional ThreadOverride part. A stack frame is required for accessing registers, invoking functions, or accessing thread-local storage, or for any query that is executing on a GPU runtime instance. A stack frame is not required when executing a query on a native runtime instance that only reads or writes memory. [In,Optional] Optional section that describes an alternate thread to use for evaluation. [Out] Result of this method call.

Create a new DkmILContext object instance. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

[In,Optional] Stack frame to use for evaluation. The specific thread to use may be overridden using the optional ThreadOverride part. A stack frame is required for accessing registers, invoking functions, or accessing thread-local storage, or for any query that is executing on a GPU runtime instance. A stack frame is not required when executing a query on a native runtime instance that only reads or writes memory. [In,Optional] Custom data to associate with this DkmILContext. This is used to convey information associated with a particular execution of a DkmCompiledInspectionQuery. [In,Optional] Optional section that describes an alternate thread to use for evaluation. [Out] Result of this method call.

Closes this compiled inspection query. This should be called after executing the query, when data associated with the context is no longer needed. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Options and target context to use while performing the inspection operation.

Indicates which runtime monitor will be used to perform this evaluation.

The thread being examined.

This is the timeout to be used for potentially slow operations such as a function evaluation. This value is in milliseconds.

Flags which effect how an input expression should be parsed, compiled or displayed.

Flags impacting how function evaluation requests are performed.

The radix to use when formatting integer data. Currently supported values are '16' and '10'.

Language used to perform inspections.

[Optional] Deprecated - do not use. Instead, components should use the ReturnValues property as the list of all return values and set $ReturnValue to represent the last return value item in the list.

[Optional] Specifies an optional list of full paths to visualization files to use, in addition to the default files from the users profile directory and the Visual Studio installation directory. Precedence between conflicting visualizers in these paths, relative to the standard paths are resolved according to the information specified in 'AdditionalVisualizationDataPriority'. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

If AdditionalVisualizationData is specified, specifies the priority of such data, relative to the default search locations. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

[Optional] Raw representation of values for $ReturnValue1, $ReturnValue2, etc. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

[Optional] If non-null, this specifies a connection to a worker process where symbols for this inspection operation are processed. This will be null if symbols are loaded in the IDE process, or if they are loaded in the remote debugger (DkmModule.Connection is non-null). This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTMPreview).

Create a new DkmInspectionContext object instance.

[In] The InspectionSession allows the various components which examine data in the target process to store private data with the same lifetime. Inspection sessions are closed when the user attempts to continue the process. [In] Indicates which runtime monitor will be used to perform this evaluation. [In] The thread being examined. [In] This is the timeout to be used for potentially slow operations such as a function evaluation. This value is in milliseconds. [In] Flags which effect how an input expression should be parsed, compiled or displayed. [In] Flags impacting how function evaluation requests are performed. [In] The radix to use when formatting integer data. Currently supported values are '16' and '10'. [In] Language used to perform inspections. [In,Optional] Deprecated - do not use. Instead, components should use the ReturnValues property as the list of all return values and set $ReturnValue to represent the last return value item in the list. [Out] Result of this method call.

Create a new DkmInspectionContext object instance. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

Create a new DkmInspectionContext object instance. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

Create a new DkmInspectionContext object instance. This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTMPreview).

Bind the input expression and evaluate it. Then format the resulting value for display in the debugger. This is used for data tips, the watch windows, the immediate window, etc. This method will append a new work item to the specified work list, and return once the work item has been appended. The actual processing of the work item is asynchronous. The caller will be notified that the request is complete through the completion routine. Location constraint: API must be called from an IDE component (component level > 100,000).

WorkList to append the new work item to. [In] The compute threads to use when executing the query. [In] Stack frame to match on compute threads. [In] Expression to evaluate. Routine to fire when the request is complete. If the request is successfully appended to the work list, this will always fire (including when the operation is canceled). This will never fire if appending the work item fails.

Bind the input expression and evaluate it. Then format the resulting value for display in the debugger. This is used for data tips, the watch windows, the immediate window, etc. This method will append a new work item to the specified work list, and return once the work item has been appended. The actual processing of the work item is asynchronous. The caller will be notified that the request is complete through the completion routine. Location constraint: IDE components may call this method regardless of what type of code is being debugged. This method is also currently supported for debug monitor components, when debugging code running under the CLR; however this functionality may be removed in a future version.

WorkList to append the new work item to. [In] DkmLanguageExpression represents an expression to be parsed and evaluated by an expression evaluator. [In] Stack frame to evaluate the expression in. Routine to fire when the request is complete. If the request is successfully appended to the work list, this will always fire (including when the operation is canceled). This will never fire if appending the work item fails.

Gets an enumeration context used to obtain the local variables of this stack frame. This is used in computing the locals window. This method will append a new work item to the specified work list, and return once the work item has been appended. The actual processing of the work item is asynchronous. The caller will be notified that the request is complete through the completion routine. Location constraint: IDE components may call this method regardless of what type of code is being debugged. This method is also currently supported for debug monitor components, when debugging code running under the CLR; however this functionality may be removed in a future version.

WorkList to append the new work item to. [In] Stack frame to evaluate the expression in. Routine to fire when the request is complete. If the request is successfully appended to the work list, this will always fire (including when the operation is canceled). This will never fire if appending the work item fails.

Provides information on the arguments of a stack frame. This is currently only exposed through the VS automation model (EnvDTE.StackFrame.Arguments). This method will append a new work item to the specified work list, and return once the work item has been appended. The actual processing of the work item is asynchronous. The caller will be notified that the request is complete through the completion routine. Location constraint: IDE components may call this method regardless of what type of code is being debugged. This method is also currently supported for debug monitor components, when debugging code running under the CLR; however this functionality may be removed in a future version.

WorkList to append the new work item to. [In] Walked frames which the evaluator is requested to describe. Routine to fire when the request is complete. If the request is successfully appended to the work list, this will always fire (including when the operation is canceled). This will never fire if appending the work item fails.

Provides a text representation for a stack frame. This is used when building the formatted call stack. This method will append a new work item to the specified work list, and return once the work item has been appended. The actual processing of the work item is asynchronous. The caller will be notified that the request is complete through the completion routine. Location constraint: IDE components may call this method regardless of what type of code is being debugged. This method is also currently supported for debug monitor components, when debugging code running under the CLR; however this functionality may be removed in a future version.

WorkList to append the new work item to. [In] Walked frames which the evaluator is requested to describe. [In] Flags to indicate what information about the arguments should be included in the frame name. Routine to fire when the request is complete. If the request is successfully appended to the work list, this will always fire (including when the operation is canceled). This will never fire if appending the work item fails.

Provides a text representation of the return type for one or more stack frame. This is currently only exposed through the VS automation model (EnvDTE.StackFrame.ReturnType). This method will append a new work item to the specified work list, and return once the work item has been appended. The actual processing of the work item is asynchronous. The caller will be notified that the request is complete through the completion routine. Location constraint: API must be called from an IDE component (component level > 100,000).

Evaluates and formats a given DkmRawReturnValue using solely the provided data. This method will append a new work item to the specified work list, and return once the work item has been appended. The actual processing of the work item is asynchronous. The caller will be notified that the request is complete through the completion routine. Location constraint: API must be called from an IDE component (component level > 100,000).

WorkList to append the new work item to. [In] Stack frame that provides the context of in which to evaluate the expression. [In] Return value target and cached context. Routine to fire when the request is complete. If the request is successfully appended to the work list, this will always fire (including when the operation is canceled). This will never fire if appending the work item fails.

Get a DkmCompiledClrLocalsQuery to allow viewing of local variables. Location constraint: API must be called from an IDE component (component level > 100,000). This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

[In] The code context to use for getting local variables. [In] If set to true, get a query for arguments only. [Out] The local variables query.

Gets the type name string to display in the UI for the given DkmClrType. This method will always return a value and is used in variable inspection windows. Location constraint: API must be called from a Monitor component (component level < 100,000). This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

[In] The type to get the name for. [In,Optional] The optional information provided by the expression compiler for identifying compiler intrinsic type information. [In,Optional] The optional format specifier(s) to use when formatting this result. [Out] The type name string.

Get the type name in a form valid in the language, if valid syntax. This method is for constructing valid full names with the ability to escape/return null if there is not a valid syntax. Location constraint: API must be called from a Monitor component (component level < 100,000). This API was introduced in Visual Studio 15 RTM (DkmApiVersion.VS15RTM).

[In] The type to get the name for. [In,Optional] The information provided by the expression compiler for identifying compiler intrinsic type information. [Out,Optional] The type name if the name can be represented as valid syntax.

Get an array index expression. Location constraint: API must be called from a Monitor component (component level < 100,000). This API was introduced in Visual Studio 15 RTM (DkmApiVersion.VS15RTM).

[In] Arguments to array expression. [Out] The array index expression.

Get a cast expression, if valid syntax. Location constraint: API must be called from a Monitor component (component level < 100,000). This API was introduced in Visual Studio 15 RTM (DkmApiVersion.VS15RTM).

[In] Expression being cast. [In] The type to get a cast expression for. [In,Optional] The information provided by the expression compiler for identifying compiler intrinsic type information. [In] Options for the cast expression to avoid parse errors or other results. [Out,Optional] The cast expression or null if the type name would be invalid syntax.

Get an object creation expression, if valid syntax. Location constraint: API must be called from a Monitor component (component level < 100,000). This API was introduced in Visual Studio 15 RTM (DkmApiVersion.VS15RTM).

[In] The type to get an object expression for. [In,Optional] The information provided by the expression compiler for identifying compiler intrinsic type information. [In] Arguments to constructor call. [Out,Optional] The object creation expression or null if the type name would be invalid syntax.

Get the identifier in a form valid in the language. Location constraint: API must be called from a Monitor component (component level < 100,000). This API was introduced in Visual Studio 15 RTM (DkmApiVersion.VS15RTM).

[In] String to test if valid identifier in the EE language. [Out,Optional] The identifier in the form valid in the given language or null if it cannot be represented as a valid identifier.

Get a member access expression, if it can be represented as valid syntax. Location constraint: API must be called from a Monitor component (component level < 100,000). This API was introduced in Visual Studio 15 RTM (DkmApiVersion.VS15RTM).

[In] The expression being dotted into. [In,Optional] The declaring type. This is required if either RequiresExplicitCast or IsStatic is true. [In,Optional] The information provided by the expression compiler for identifying compiler intrinsic type information (for the declaring type). [In] The name of the type member. [In] True if the expression must be explicitly cast to dot into the member. [In] True if the member is static. [Out,Optional] The member access expression or null if the expression cannot be represented as valid syntax.

Returns true if the expression may require parentheses when used as a sub-expression in the language. Location constraint: API must be called from a Monitor component (component level < 100,000). This API was introduced in Visual Studio 15 RTM (DkmApiVersion.VS15RTM).

[In] The string representing the expression to check. [Out] Whether the expression may require parentheses.

Splits the string into the expression and format specifier parts. Location constraint: API must be called from a Monitor component (component level < 100,000). This API was introduced in Visual Studio 15 RTM (DkmApiVersion.VS15RTM).

[In] The expression being split to expression and format specifier parts. [Out] The format specifier(s) to use when formatting this result. [Out] The expression without format specifiers.

Get the language specific expression for this/Me. Location constraint: API must be called from a Monitor component (component level < 100,000). This API was introduced in Visual Studio 15 RTM (DkmApiVersion.VS15RTM).

[Out] The language specific expression for this/Me.

Get the language specific expression for null (keyword). Location constraint: API must be called from a Monitor component (component level < 100,000). This API was introduced in Visual Studio 15 RTM (DkmApiVersion.VS15RTM).

[Out] The language specific expression for null (keyword).

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

DkmInspectionSession allows the various components which inspect data to store private data which is associated with a group of evaluations.

Guid which uniquely identifies this inspection session.

Closes a DkmInspectionSession object instance. This will release any resources associated with this object across all components. This includes resources across computer or managed/native marshalling boundaries. DkmInspectionSession objects are automatically closed when their associated DkmProcess object is closed. This method may only be called by the component which created the object.

Create a new DkmInspectionSession object instance. The caller is responsible for closing the created object after they are done.

[In] DkmProcess represents a target process which is being debugged. The debugger debugs processes, so this is the basic unit of debugging. A DkmProcess can represent a system process or a virtual process such as minidumps. [In,Optional] Data object to add to the new DkmInspectionSession instance. Pass 'null' in the case that the caller doesn't need to add a data item. [Out] Result of this method call.

Find a DkmRawReturnValueContainer element within this DkmInspectionSession. If no element with the given input key is present, FindReturnValueContainer will fail. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

[In] Search key used to find the element. [Out,Optional] Result of the search.

GetReturnValueContainers enumerates the DkmRawReturnValueContainer elements of this DkmInspectionSession object. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

[Out] Array containing the enumerated elements.

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

The formatted result of an evaluation that must be re-evaluated by a different Expression Evaluator. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

Expression that should be evaluated by a different Expression Evaluator than the one that generated the DkmIntermediateResult. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

The language of Expression. This is different from DkmEvaluationResult->Language(), which specifies the language of the initial evaluation. IntermediateLanguage specifies the language of the re-evaluation. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

The runtime of the Expression Evaluator that would consume the intermediate result and produce a final result. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

Category of the evaluation result. This overrides the DkmEvaluationResultCategory of the final evaluation result. Use DkmEvaluationResultCategory::Other to defer to that of the final evaluation result. This API was introduced in Visual Studio 14 Update 1 (DkmApiVersion.VS14Update1).

Access level of the evaluation result. This overrides the DkmEvaluationResultAccessType of the final evaluation result. Use DkmEvaluationResultAccessType::None to defer to that of the final evaluation result. This API was introduced in Visual Studio 15 RTM (DkmApiVersion.VS15RTM).

storage type of the evaluation result. This overrides the DkmEvaluationResultStorageType of the final evaluation result. Use DkmEvaluationResultStorageType::None to defer to that of the final evaluation result. This API was introduced in Visual Studio 15 RTM (DkmApiVersion.VS15RTM).

type modifier flags of the evaluation result. This overrides the DkmEvaluationResultTypeModifierFlags of the final evaluation result. Use DkmEvaluationResultTypeModifierFlags::None to defer to that of the final evaluation result. This API was introduced in Visual Studio 15 RTM (DkmApiVersion.VS15RTM).

Create a new DkmIntermediateEvaluationResult object instance. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

Create a new DkmIntermediateEvaluationResult object instance. This API was introduced in Visual Studio 14 Update 1 (DkmApiVersion.VS14Update1).

Create a new DkmIntermediateEvaluationResult object instance. This API was introduced in Visual Studio 15 RTM (DkmApiVersion.VS15RTM).

[In] Inspection context used to create this evaluation result. [In] The stack frame this expression result was created on. [In] The name of the expression this result applies to. [In,Optional] The full name of the expression this result applies to. This value is used to allow child elements to be added to the watch window (Add Watch from the context menu), and to refresh parts of the evaluation tree. As an example of how FullName differs from name, the name of the 0th element of an array in C++ is '[0]' while the full name would by 'myArrayVariable[0]'. For Visual Studio 14 and later it's possible to calculate the full name later if needed. To do this, the expression evaluator should create the DkmEvaluationResult with a null full name and implement IDkmFullNameProvider. Concord will then call IDkmFullNameProvider.CalculateFullName to get the full name when needed in the UI. [In] Expression that should be evaluated by a different Expression Evaluator than the one that generated the DkmIntermediateResult. [In] The language of Expression. This is different from DkmEvaluationResult->Language(), which specifies the language of the initial evaluation. IntermediateLanguage specifies the language of the re-evaluation. [In] The runtime of the Expression Evaluator that would consume the intermediate result and produce a final result. [In] Category of the evaluation result. This overrides the DkmEvaluationResultCategory of the final evaluation result. Use DkmEvaluationResultCategory::Other to defer to that of the final evaluation result. [In] Access level of the evaluation result. This overrides the DkmEvaluationResultAccessType of the final evaluation result. Use DkmEvaluationResultAccessType::None to defer to that of the final evaluation result. [In] storage type of the evaluation result. This overrides the DkmEvaluationResultStorageType of the final evaluation result. Use DkmEvaluationResultStorageType::None to defer to that of the final evaluation result. [In] type modifier flags of the evaluation result. This overrides the DkmEvaluationResultTypeModifierFlags of the final evaluation result. Use DkmEvaluationResultTypeModifierFlags::None to defer to that of the final evaluation result. [In,Optional] Data object to add to the new DkmIntermediateEvaluationResult instance. Pass 'null' in the case that the caller doesn't need to add a data item. [Out] Result of this method call.

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Describes a programming language.

Name of the programming language (ex: C++). This string will appear in the call stack window.

LanguageId/VendorId pair for this DkmLanguage object. For the default language, both of these values will be Guid.Empty. For all other languages, both of these values are non-zero.

Create a new DkmLanguage object instance.

[In] Name of the programming language (ex: C++). This string will appear in the call stack window. [In] LanguageId/VendorId pair for this DkmLanguage object. For the default language, both of these values will be Guid.Empty. For all other languages, both of these values are non-zero. [Out] Result of this method call.

Reads language-specific from the registry. The settings are stored under HKLM\Software\Microsoft\VisualStudio\15.0\AD7Metrics\ExpressionEvaluator\[Languag Guid]\[Vendor Guid].

[Out] Pairing between the name of a setting and its value.

Reads language-specific from the registry. The settings are stored under HKLM\Software\Microsoft\VisualStudio\15.0\AD7Metrics\ExpressionEvaluator\[Languag Guid]\[Vendor Guid]. This method will append a new work item to the specified work list, and return once the work item has been appended. The actual processing of the work item is asynchronous. The caller will be notified that the request is complete through the completion routine.

Reads a file path as a metric of the given name for the expression evaluator of the given language. Then, reads the entire contents of the file, on the Visual Studio computer, and returns the contents as a string. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

[In] The name of the metric that contains the full path to the file. [Out] The contents of the file that was referenced by the metric.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

DkmLanguageExpression represents an expression to be parsed and evaluated by an expression evaluator.

Describes a programming language.

Flags which effect how the condition text should be compiled by the expression evaluator. During evaluation, the caller must ensure that the DkmEvaluationFlags set on the InspectionContext agree with this value -- that is that they may only differ by the last set of flags which are only relevant to the display of values.

Source text of the parsed expression.

Guid which uniquely identifies this expression object.

Closes a DkmLanguageExpression object instance. This will release any resources associated with this object across all components. This includes resources across computer or managed/native marshalling boundaries. This method may only be called by the component which created the object.

Creates a new DkmLanguageExpression object. This can be evaluated with DkmInspectionContext.EvaluateExpression. The caller is responsible for closing the created object after they are done.

[In] Describes a programming language. [In] Flags which effect how the condition text should be compiled by the expression evaluator. During evaluation, the caller must ensure that the DkmEvaluationFlags set on the InspectionContext agree with this value -- that is that they may only differ by the last set of flags which are only relevant to the display of values. [In] Source text of the parsed expression. [In,Optional] Data object to add to the new DkmLanguageExpression instance. Pass 'null' in the case that the caller doesn't need to add a data item. [Out] Result of this method call.

Compile the expression into MSIL code that can be executed by the CLR or debugger to evaluate the expression. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

[In] The code context to use for compiling the expression. [In,Optional] The inspection context for this evaluation. This value is null if there is no current evaluation context. An example of a time when there is no evaluation context is when compiling conditional breakpoints. [Out,Optional] Indicates any error compiling the expression. If the code compiles successfully, this value should be null. It should also be null for cases where the language or expression is not supported and the debug engine needs to fall back to the default implementation. In error cases, this value indicates the reason for the compile error and the caller should return S_OK. [Out,Optional] The compiled expression. If Result is null, and Error is not null, there was a compile error. If both are null, compilation of the expression is not supported and the debug engine needs to use the legacy expression evaluator.

Compile the given expression and generate code to assign the value of the expression to an L-Value. Location constraint: API must be called from an IDE component (component level > 100,000). This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

[In] The code context to use for compiling the expression. [In] The L-value of the assignment. This is the result of a previous evaluation. [Out,Optional] Indicates any error compiling the expression or the reason the assignment is invalid. If the compiler can generate code for the assignment, this value should be null. In error cases, this value indicates the reason for the compile error and the caller should return S_OK. [Out,Optional] The compiled assignment operation. If Result is null, and Error is not null, there was a compile error.

Compile the given DebuggerDisplayAttribute string. The resulting IL should return a string. For debugger display, there is no code context. Instead the compiler must do its binding based on a type token. Location constraint: API must be called from an IDE component (component level > 100,000). This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

[In] The module instance containing the type the DebuggerDisplayAttribute applies to. [In] The metadata token of the type the DebuggerDisplayAttribute applies to. [Out,Optional] Indicates any error compiling the expression. If the code compiles successfully, this value should be null. In error cases, this value indicates the reason for the compile error and the caller should return S_OK. [Out,Optional] The compiled display attribute. If Result is null, and Error is not null, there was a compile error.

This method is used internally by the CLR Expression Evaluator. Location constraint: API must be called from a Monitor component (component level < 100,000). This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

This method is used internally by the CLR Expression Evaluator. This method will append a new work item to the specified work list, and return once the work item has been appended. The actual processing of the work item is asynchronous. The caller will be notified that the request is complete through the completion routine. Location constraint: API must be called from a Monitor component (component level < 100,000). This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

WorkList to append the new work item to. [In] The module instance containing the type the DebuggerDisplayAttribute applies to. [In] The metadata token of the type the DebuggerDisplayAttribute applies to. Routine to fire when the request is complete. If the request is successfully appended to the work list, this will always fire (including when the operation is canceled). This will never fire if appending the work item fails.

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Unique id for a programming language. These values must also be registered under $(RegRoot)\AD7Metric\ExpressionEvaluator and returned from symbol providers (through GetCompilerId) and language services (through IVsLanguageDebugInfo.GetLanguageID).

Visual Basic.

JScript (ECMA Script).

C++.

T-SQL.

Script.

C#.

Fortran.

Cobol.

Pascal.

Java.

MSIL Assembly.

Language used for causality function breakpoints (ASMX).

Language used for specifying MVID/METHOD_TOKEN. This is used for Indigo. Example: '{6AF7F59F-ED82-4f76-95BE-6BB908DBDC69}/06000001'.

Client side (targeting IE) script.

HLSL.

Objective-C.

Objective-C++.

Pairing between an instruction address and the language that should be used to decode it.

Describes a programming language.

The DkmRuntimeInstance class represents an execution environment which is loaded into a DkmProcess and which contains code to be debugged.

Create a new DkmLanguageInstructionAddress object instance.

[In] Describes a programming language. [In] Abstract representation of an executable code location (ex: EIP value). If resolved, an Instruction Address will be within a particular module instance. An Instruction Address is always within a particular Runtime Instance. [Out] Result of this method call.

This method is obsolete and should not be used. Location constraint: API must be called from an IDE component (component level > 100,000).

[In] Not used. [Out,Optional] Not used.

[In] Breakpoint condition to compile. [Out,Optional] If the compilation failed, this indicates the reason why. This value should be null if the compile succeeded. If the compile does fail, S_FALSE is returned (native code only). [Out,Optional] The result of the compilation. This is null in the case that the compilation failed. In this case, ErrorText should indicate the reason for the failure.

Provides a text representation for a method symbol. This is used when describing an address in the UI, for example the 'Function' column in the breakpoints window.

[In] Flags to indicate what information about the arguments should be included in the method name. As parameter values cannot be obtained without a stack frame and a stack frame is not available here, the "Values" flag will never be present. [Out] Language's representation of the name of this method.

Provides a text representation for a method symbol. This is used when describing an address in the UI, for example the 'Function' column in the breakpoints window. This method will append a new work item to the specified work list, and return once the work item has been appended. The actual processing of the work item is asynchronous. The caller will be notified that the request is complete through the completion routine.

WorkList to append the new work item to. [In] Flags to indicate what information about the arguments should be included in the method name. As parameter values cannot be obtained without a stack frame and a stack frame is not available here, the "Values" flag will never be present. Routine to fire when the request is complete. If the request is successfully appended to the work list, this will always fire (including when the operation is canceled). This will never fire if appending the work item fails.

Called during a Step-Into to determine special behavior for a particular function. Location constraint: API must be called from an IDE component (component level > 100,000).

[Out] Flags which describe how to proceed with a Step-Into action.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

DkmNativeRawReturnValue carries sufficient context that can be used to partially reconstruct and visualize a function-call's return value within the context of Native stepping.

Set of platform dependent registers that may hold the return value.

The result of copying some (platform dependent) number of bytes at the address referenced by the (platform dependent) return-value register. May be used to provide visualizations for pointer return values.

Create a new DkmNativeRawReturnValue object instance.

[In] IP address within the symbol that was returned called and from. Note that there's no guarantee where in the function this address will be. [In] Set of platform dependent registers that may hold the return value. [In] The result of copying some (platform dependent) number of bytes at the address referenced by the (platform dependent) return-value register. May be used to provide visualizations for pointer return values. [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Set of platform dependent registers that may hold the return value of a function call.

The code-view register ID constant.

The value of the register. The size of the register in bytes can be found by the length of this array.

Create a new DkmNativeReturnValueRegister object instance.

[In] The code-view register ID constant. [In] The value of the register. The size of the register in bytes can be found by the length of this array. [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

An instance of DkmExpressionValueHome that defines a linear address in the debuggee. The expression evaluator addin should format the object pointed to by this address.

A straight linear address in the debuggee process.

Create a new DkmPointerValueHome object instance.

[In] A straight linear address in the debuggee process. [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

DkmRawManagedReturnValue carries method-call's return value within the context of managed stepping. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

Context information wraps method's return value. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

Create a new DkmRawManagedReturnValue object instance. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

[In] IP address within the symbol that was returned called and from. Note that there's no guarantee where in the function this address will be. [In] Context information wraps method's return value. [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

DkmRawReturnValue carries sufficient context that can be used to partially reconstruct and visualize a function-call's return value. Derived classes: DkmCustomRawReturnValue, DkmNativeRawReturnValue, DkmRawManagedReturnValue

DkmRawReturnValue is an abstract base class. This enum indicates which derived class this object is an instance of.

Object is an instance of 'DkmNativeRawReturnValue'.

Object is an instance of 'DkmCustomRawReturnValue'.

Object is an instance of 'DkmRawManagedReturnValue'.

DkmRawReturnValue is an abstract base class. This enum indicates which derived class this object is an instance of.

IP address within the symbol that was returned called and from. Note that there's no guarantee where in the function this address will be.

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Reference object that can be used to attach data items to a DkmRawReturnValue. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

The inspection session that owns this frame data object. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

Unique identifier of this return value. The first return value is zero, then one, etc. Return value id's are unique only within a particular DkmInspectionSession. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

The DkmRawReturnValue object that this container refers to. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

Create a new DkmRawReturnValueContainer object instance. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

[In] The inspection session that owns this frame data object. [In] Unique identifier of this return value. The first return value is zero, then one, etc. Return value id's are unique only within a particular DkmInspectionSession. [In] The DkmRawReturnValue object that this container refers to. [In,Optional] Data object to add to the new DkmRawReturnValueContainer instance. Pass 'null' in the case that the caller doesn't need to add a data item. [Out] Result of this method call.

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Dispatcher object which represents a top-level visualized expression. An instance is created by the expression evaluator when it determines a type should be visualized.

[Optional] The module that contains the type symbol.

The name of the expression up to the root node. Addins can choose to use this name or construct their own.

The full name of the expression up to the root node. Addins can choose to use this full name or construct their own. However, if the addin uses a different full name, it must be parsed by the expression evaluator.

Flags the expression evaluator passes to the visualizer addin describing the value in question. For instance, this will include if the object is a pointer or if it is a reference.

Deprecated: no longer used.

[Optional] The type of the object being inspected. This is often the same type that is being referred to by the natvis entry that triggered the addin. However, it can also be a pointer or reference to the type, or even a base or derived class of the type. The addin should make no assumptions about what is in this string and should not attempt to parse it to obtain information about the object. Most addins should pass this string along through, as is to the 'Type' property of the evaluation result they create. However, an addin may choose to add additional annotations to the 'Type' string before returning it back. Except for a hint of what to put in the 'Type' field of the result, this string is irrelevant to the visualization of the object. Regardless of whether the original object is a pointer, reference, base type, or derived type, the supplied DkmExpressionValueHome will always identify the location of the object itself, never a pointer or reference to the object. An empty type string may be passed in here if the type of the evaluation result does not matter for the scenario in which the visualizer is being invoked. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

Create a new DkmRootVisualizedExpression object instance.

Create a new DkmRootVisualizedExpression object instance. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

[In] Options and target context to use while performing the inspection operation. [In] Guid which ties together the addin and the expressions that call that addin. The addin should use the Guid provided in the native visualizer file as a filter. [In] Guid which ties together the expression evaluator that created this object and the object itself. Generally used by expression evaluators to filter their implementation of IDkmCustomVisualizerCallback to only DkmVisualizedExpression they created. [In] Stack frame the expression is being evaluated in expression in. [In,Optional] The location at which the value is stored, which can be modified to edit the value. This should be null for read-only values, such as integer constants. [In,Optional] The module that contains the type symbol. [In] The name of the expression up to the root node. Addins can choose to use this name or construct their own. [In] The full name of the expression up to the root node. Addins can choose to use this full name or construct their own. However, if the addin uses a different full name, it must be parsed by the expression evaluator. [In] Flags the expression evaluator passes to the visualizer addin describing the value in question. For instance, this will include if the object is a pointer or if it is a reference. [In] Deprecated: no longer used. [In,Optional] The type of the object being inspected. This is often the same type that is being referred to by the natvis entry that triggered the addin. However, it can also be a pointer or reference to the type, or even a base or derived class of the type. The addin should make no assumptions about what is in this string and should not attempt to parse it to obtain information about the object. Most addins should pass this string along through, as is to the 'Type' property of the evaluation result they create. However, an addin may choose to add additional annotations to the 'Type' string before returning it back. Except for a hint of what to put in the 'Type' field of the result, this string is irrelevant to the visualization of the object. Regardless of whether the original object is a pointer, reference, base type, or derived type, the supplied DkmExpressionValueHome will always identify the location of the object itself, never a pointer or reference to the object. An empty type string may be passed in here if the type of the evaluation result does not matter for the scenario in which the visualizer is being invoked. [In,Optional] Data object to add to the new DkmRootVisualizedExpression instance. Pass 'null' in the case that the caller doesn't need to add a data item. [Out] Result of this method call.

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Flags the expression evaluator passes to the visualizer addin describing the value in question. For instance, this will include if the object is a pointer or if it is a reference.

No flags set.

Deprecated; no longer used.

The formatted result of a successful evaluation, ready to be displayed in an expression evaluation window.

Flags which indicate attributes of an expression evaluation result.

[Optional] String that describes the value.

[Optional] If the value is writable, specifies the default string to be used when you double-click on the value to edit it. The EE should be able to parse and evaluate this string and get back the current evaluation result. If the value is read-only, the editable value is ignored and should be null.

[Optional] A string that describes the type of the value.

The category (ex: Data, Method, etc) of this evaluation result.

The access control level (public, private, etc) of the evaluation result.

The storage type (ex: static) of the evaluation result.

Type modifier flags (ex: const) of the evaluation result.

[Optional] If the result is an address (i.e. the address flag is set in Flags), specifies the location of the backing value. This is used when the evaluation result is used as the input to the memory window or disassembly window. If it is an instruction address then it must have the CPUInstruction address set.

[Optional] A list of custom viewers for this object.

[Optional] If available, a list of external modules, not including the current module, that are used for the inspection of the object. Loading symbols for as many modules in this list as possible will enhance the display of the object.

[Optional] When DkmEvaluationResultFlags::CanEvaluateNow is set, specifies the text to display as a tooltip when the user hovers over the refresh button. If this value is null, a default message will be used. This API was introduced in Visual Studio 15 RTM (DkmApiVersion.VS15RTM).

Create a new DkmSuccessEvaluationResult object instance.

[In] Inspection context used to create this evaluation result. [In] The stack frame this expression result was created on. [In] The name of the expression this result applies to. [In,Optional] The full name of the expression this result applies to. This value is used to allow child elements to be added to the watch window (Add Watch from the context menu), and to refresh parts of the evaluation tree. As an example of how FullName differs from name, the name of the 0th element of an array in C++ is '[0]' while the full name would by 'myArrayVariable[0]'. For Visual Studio 14 and later it's possible to calculate the full name later if needed. To do this, the expression evaluator should create the DkmEvaluationResult with a null full name and implement IDkmFullNameProvider. Concord will then call IDkmFullNameProvider.CalculateFullName to get the full name when needed in the UI. [In] Flags which indicate attributes of an expression evaluation result. [In,Optional] String that describes the value. [In,Optional] If the value is writable, specifies the default string to be used when you double-click on the value to edit it. The EE should be able to parse and evaluate this string and get back the current evaluation result. If the value is read-only, the editable value is ignored and should be null. [In,Optional] A string that describes the type of the value. [In] The category (ex: Data, Method, etc) of this evaluation result. [In] The access control level (public, private, etc) of the evaluation result. [In] The storage type (ex: static) of the evaluation result. [In] Type modifier flags (ex: const) of the evaluation result. [In,Optional] If the result is an address (i.e. the address flag is set in Flags), specifies the location of the backing value. This is used when the evaluation result is used as the input to the memory window or disassembly window. If it is an instruction address then it must have the CPUInstruction address set. [In,Optional] A list of custom viewers for this object. [In,Optional] If available, a list of external modules, not including the current module, that are used for the inspection of the object. Loading symbols for as many modules in this list as possible will enhance the display of the object. [In,Optional] Data object to add to the new DkmSuccessEvaluationResult instance. Pass 'null' in the case that the caller doesn't need to add a data item. [Out] Result of this method call.

Create a new DkmSuccessEvaluationResult object instance. This API was introduced in Visual Studio 15 RTM (DkmApiVersion.VS15RTM).

[In] Inspection context used to create this evaluation result. [In] The stack frame this expression result was created on. [In] The name of the expression this result applies to. [In,Optional] The full name of the expression this result applies to. This value is used to allow child elements to be added to the watch window (Add Watch from the context menu), and to refresh parts of the evaluation tree. As an example of how FullName differs from name, the name of the 0th element of an array in C++ is '[0]' while the full name would by 'myArrayVariable[0]'. For Visual Studio 14 and later it's possible to calculate the full name later if needed. To do this, the expression evaluator should create the DkmEvaluationResult with a null full name and implement IDkmFullNameProvider. Concord will then call IDkmFullNameProvider.CalculateFullName to get the full name when needed in the UI. [In] Flags which indicate attributes of an expression evaluation result. [In,Optional] String that describes the value. [In,Optional] If the value is writable, specifies the default string to be used when you double-click on the value to edit it. The EE should be able to parse and evaluate this string and get back the current evaluation result. If the value is read-only, the editable value is ignored and should be null. [In,Optional] A string that describes the type of the value. [In] The category (ex: Data, Method, etc) of this evaluation result. [In] The access control level (public, private, etc) of the evaluation result. [In] The storage type (ex: static) of the evaluation result. [In] Type modifier flags (ex: const) of the evaluation result. [In,Optional] If the result is an address (i.e. the address flag is set in Flags), specifies the location of the backing value. This is used when the evaluation result is used as the input to the memory window or disassembly window. If it is an instruction address then it must have the CPUInstruction address set. [In,Optional] A list of custom viewers for this object. [In,Optional] If available, a list of external modules, not including the current module, that are used for the inspection of the object. Loading symbols for as many modules in this list as possible will enhance the display of the object. [In,Optional] When DkmEvaluationResultFlags::CanEvaluateNow is set, specifies the text to display as a tooltip when the user hovers over the refresh button. If this value is null, a default message will be used. [In,Optional] Data object to add to the new DkmSuccessEvaluationResult instance. Pass 'null' in the case that the caller doesn't need to add a data item. [Out] Result of this method call.

Instantiates the debuggee-side Custom Visualizer type in the debuggee process. Location constraint: API must be called from an IDE component (component level > 100,000). This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

[In] The index of the selected visualizer. [Out,Optional] The type of the exception thrown, if any. [Out,Optional] The stack trace of the exception thrown, if any. [Out,Optional] The exception message, if any.

Releases the debuggee-side Custom Visualizer type in the debuggee process. Location constraint: API must be called from an IDE component (component level > 100,000). This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

[Out] If the handle was successfully removed, return true. If no handle, return false.

Resolves an assembly name to the path of the assembly or to its raw bytes. Location constraint: API must be called from an IDE component (component level > 100,000). This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

[In] The fully qualified name of the assembly to resolve. [Out,Optional] The path of the resolved assembly for local debugging. [Out,Optional] The byte array of the resolved assembly for remote debugging.

Executes the debuggee-side Custom Visualizer type's GetData(...) method. Location constraint: API must be called from an IDE component (component level > 100,000). This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

[Out,Optional] The type of the exception thrown, if any. [Out,Optional] The stack trace of the exception thrown, if any. [Out,Optional] The exception message, if any. [Out,Optional] The raw bytes of the GetData(...) method marshalled as a byte array.

Executes the debuggee-side Custom Visualizer type's TransferData(...) method. Location constraint: API must be called from an IDE component (component level > 100,000). This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

[In] The data to transfer to the debuggee-side Visualizer class. [Out,Optional] The type of the exception thrown, if any. [Out,Optional] The stack trace of the exception thrown, if any. [Out,Optional] The exception message, if any. [Out,Optional] The raw bytes of the result of the TransferData(...) method marshalled as a byte array.

Executes the debuggee-side Custom Visualizer type's CreateReplacementObject(...) method, and writes the result to the visualized object handle. Location constraint: API must be called from an IDE component (component level > 100,000). This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

Gets the underlying DkmClrValue from a DkmSuccessEvaluationResult, if it exists. Location constraint: API must be called from a Monitor component (component level < 100,000). This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

[Out,Optional] The DkmClrValue, if it exists.

Returns the data breakpoint information related to the evaluation result, if valid. Location constraint: API must be called from an IDE component (component level > 100,000). This API was introduced in Visual Studio 15 Update 8 (DkmApiVersion.VS15Update8).

[Out,Optional] If the operation failed, this indicates the reason why. This value should be null if the operation succeeded. [Out] The data breakpoint information.

Returns the data breakpoint information related to the evaluation result, if valid. This method will append a new work item to the specified work list, and return once the work item has been appended. The actual processing of the work item is asynchronous. The caller will be notified that the request is complete through the completion routine. Location constraint: API must be called from an IDE component (component level > 100,000). This API was introduced in Visual Studio 15 Update 8 (DkmApiVersion.VS15Update8).

Gets the data breakpoint display name for the evaluation result. Location constraint: API must be called from an IDE component (component level > 100,000). This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTM).

[Out] The data breakpoint display name.

Gets the data breakpoint display name for the evaluation result. This method will append a new work item to the specified work list, and return once the work item has been appended. The actual processing of the work item is asynchronous. The caller will be notified that the request is complete through the completion routine. Location constraint: API must be called from an IDE component (component level > 100,000). This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTM).

Adds the specified child to the collection of favorites items on the type of this result. Location constraint: API must be called from an IDE component (component level > 100,000). This API was introduced in Visual Studio 16 Update 4 (DkmApiVersion.VS16Update4).

[In] The child item to be added.

Removes the specified child from the collection of favorite items on the type of this result. Location constraint: API must be called from an IDE component (component level > 100,000). This API was introduced in Visual Studio 16 Update 4 (DkmApiVersion.VS16Update4).

[In] The child item to be removed.

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Obtains the DkmSuccessEvaluationResult object which backs the IDebugProperty3 object. This API will only function correctly from the main thread of Visual Studio.

AD7 IDebugProperty3 object DkmSuccessEvaluationResult which backs the AD7 object.

Flags that indicate what information is requested for a variable.

No flags are set.

Provide information about the types of variables.

Types names should be provided as an alias rather than in their full form. For example, return 'std::map<int,int>' instead of 'std::map<int,int,std::less<int>,std::allocator<std::pair<int const ,int> > >'. This flag is only valid when paired with the 'Types' flag.

Provide information about the names of variables.

Provide full names of the variables.

Provide information about the values of variables. This flag is set for GetFrameName() when the user has toggled the option "Show Parameter Values". This flag is never set for calls to GetMethodName().

If specified, the expression evaluator will simplify template types to create a shorter frame name. Currently this is only supported by the C++ EE.

Guid value which, along with the DkmLanguageId, can identify the compiler/interpreter used to compile/interpret the target code. The vendor id is used along with the language id to select expression evaluators. This value is used as many compilers may exist for the same programming language. But even though the compilers may all use the same programming language, they will generally not be able to use the same expression evaluator.

Indicates that the compiler/interpreter was produced by Microsoft.

Dispatcher object used for custom visualization through a concord EE addin. Derived classes: DkmChildVisualizedExpression, DkmRootVisualizedExpression

DkmVisualizedExpression is an abstract base class. This enum indicates which derived class this object is an instance of.

Object is an instance of 'DkmRootVisualizedExpression'.

Object is an instance of 'DkmChildVisualizedExpression'.

DkmVisualizedExpression is an abstract base class. This enum indicates which derived class this object is an instance of.

Options and target context to use while performing the inspection operation.

Guid which uniquely identifies this instance.

Guid which ties together the addin and the expressions that call that addin. The addin should use the Guid provided in the native visualizer file as a filter.

Guid which ties together the expression evaluator that created this object and the object itself. Generally used by expression evaluators to filter their implementation of IDkmCustomVisualizerCallback to only DkmVisualizedExpression they created.

Stack frame the expression is being evaluated in expression in.

[Optional] The location at which the value is stored, which can be modified to edit the value. This should be null for read-only values, such as integer constants.

Indicates which runtime monitor will be used to perform this evaluation.

Closes a DkmVisualizedExpression object instance. This will release any resources associated with this object across all components. This includes resources across computer or managed/native marshalling boundaries. DkmVisualizedExpression objects are automatically closed when their associated DkmInspectionSession object is closed.

Evaluate a visualized expression returning a DkmEvaluationResult for it. Location constraint: API must be called from an IDE component (component level > 100,000).

[Out,Optional] Object containing the result of the evaluation. This object must be closed by the caller when the caller is done with the object. The expression evaluator reserves the right to override this instance so do not rely on storing data items in the DkmEvaluationResult instance. Use the DkmVisualizedExpression instance as a data container instead.

[Out] Return true to use default expansion, false otherwise. [Out,Optional] The instance of DkmEvaluationResult returned from a call to one of the methods of IDkmCustomVisualizerCallback. The expression evaluator can only control DkmEvaluationResults it understands.

Gets an enumeration context used to obtain the children of this evaluation result. This is used in all expression evaluation windows. Location constraint: API must be called from an IDE component (component level > 100,000).

[In] The initial number of children that the caller would like returned. This value can be zero if no children will be initially returned. This value may be larger than the number of children that this expression has, in which case all children should be returned. Very large or negative values should not be used as arrays can have extremely large sizes which would cause out-of-memory if all elements were requested. [In] The inspection context to use for computing the children. This may differ from the original inspection context with respect to settings, such as radix, evaluation flags, or timeout. [Out] The initial children to return. [Out] Context object used to enumerate the children. This object must be closed by the caller of this API when enumeration is complete.

Called to obtain items from a instance of DkmEvaluationResultEnumContext created by an earlier call to GetChildren. Location constraint: API must be called from an IDE component (component level > 100,000).

[In] The enum context to use for this call. This instance will have been returned from a previous call to DkmVisualizedExpression. [In] The zero-based index of the first item to obtain. [In] The number of items to try and return. This value may be larger than the total number of remaining items, in which case all remaining items should be returned. Very large or negative values should not be used as arrays can have extremely large sizes which would cause out-of-memory if all elements were requested. [Out] The DkmChildVisualizedExpression items to return.

[Out,Optional] The underlying string value.

[In] The GUID of the TypeSymbolInterface interface requested from the caller. For the Microsoft native C++ expression evaluator, this should be IID_IDiaSymbol. [Out] The symbol interface of the type that was used to evaluate the expression.

[In] The inspection context to use for this evaluation. [In] The expression the visualizer addin to would like the expression evaluator to evaluate. [In] Stack frame to evaluate the expression in. [Out] Object containing the result of the evaluation. E_PROCESS_DESTROYED indicates that the process exited while attempting to evaluate.

[In] The index of child for which this full name is created. Ignored in the case of a root item. [Out] The returned full name string.

[In] The evaluation result returned from the expression evaluator for this expression. The expression evaluator can only control the expansion of evaluations it understands. [In] The initial number of children that the caller would like returned. This value can be zero if no children will be initially returned. This value may be larger than the number of children that this expression has, in which case all children should be returned. Very large or negative values should not be used as arrays can have extremely large sizes which would cause out-of-memory if all elements were requested. [In] The inspection context to use for computing the children. This may differ from the original inspection context with respect to settings, such as radix, evaluation flags, or timeout. [Out] The initial children to return. Each child must be closed by the caller when the caller is done. [Out] Context object used to enumerate the children. This object must be closed by the caller of this API when enumeration is complete.

[In] Context object used to enumerate the children. [In] The zero-based index of the first item to obtain. [In] The number of items to try and return. This value may be larger than the total number of remaining items, in which case all remaining items should be returned. Very large or negative values should not be used as arrays can have extremely large sizes which would cause out-of-memory if all elements were requested. [Out] The DkmEvaluationResult items to return. Each item must be closed by the caller when the caller is done.

Modifies the value of the given evaluation result (assumed to be non-read-only) to match the given string. This is used after the user edits a value in any of the evaluation windows.

[In] The evaluation result returned from the expression evaluator for this expression. The expression evaluator can only control evaluations it understands. [In] Textual representation of value to assign to the evaluation result. [In] If a function evaluation is needed to assign the value, specifies the timeout to use. [Out,Optional] If the operation failed, this indicates the reason why. This value should be null if the operation succeeded. In native code, an S_OK return value is used when returning error text.

[In] The evaluation result returned from the expression evaluator for this expression. The expression evaluator can only control evaluations it understands. [Out,Optional] The underlying string value.

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Flags that may be set as a result of compiling an expression to be evaluated. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

No result flags set.

Indicates that the compiler detects the possibility of side effects if this expression is evaluated. This means the expression is an assignment, method call, or other expression likely to change the state of the debuggee. Although property getters and indexers have the potential to cause side effects, these should be assumed to not have side effects.

Indicates that the result of the expression will be read-only.

Indicates that the return type of compiled expression is boolean.

A custom type info is an object passed between an IDkmClrExpressionCompiler and an IDkmClrResultProvider, this can be used by the result provider to decode a compiler-specific type that does not have an underlying CLR type. A result provider should always check the PayloadTypeId for a compiler it recognizes before attempting to decode the included payload. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

This Guid is used to identify the type of the payload. This allows result providers to ignore ClrCustomTypeInfos from different compilers. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

Data payload that contains compiler-specific custom information to be used by a result provider to decode the given type. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

[Optional] Optional type modifiers (modopt) present in the field, method, or property signature from which this value was obtained. This API was introduced in Visual Studio 14 Update 2 (DkmApiVersion.VS14Update2).

[Optional] Required type modifiers (modreq) present in the field, method, or property signature from which this value was obtained. This API was introduced in Visual Studio 14 Update 2 (DkmApiVersion.VS14Update2).

Create a new DkmClrCustomTypeInfo object instance. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

Create a new DkmClrCustomTypeInfo object instance. This API was introduced in Visual Studio 14 Update 2 (DkmApiVersion.VS14Update2).

[In] This Guid is used to identify the type of the payload. This allows result providers to ignore ClrCustomTypeInfos from different compilers. [In] Data payload that contains compiler-specific custom information to be used by a result provider to decode the given type. [In,Optional] Optional type modifiers (modopt) present in the field, method, or property signature from which this value was obtained. [In,Optional] Required type modifiers (modreq) present in the field, method, or property signature from which this value was obtained. [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Represents a DebuggerBrowsable attribute on a field or property and determines if and how a member is displayed in the debugger variable windows. See msdn documentation for DebuggerBrowsableAttribute. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

The display state for the attribute. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

Create a new DkmClrDebuggerBrowsableAttribute object instance. Location constraint: API must be called from a Monitor component (component level < 100,000). This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

[In] The type this attribute applies to. [In,Optional] The member this attribute applies to if applicable. [In] The display state for the attribute. [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

The state values a DebuggerBrowsable attribute can have. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

Indicates that the member is not displayed in the debugger variable windows.

Indicates that the member is displayed but not expanded by default.

Indicates that the member itself is not shown, but its constituent objects are displayed if it is an array or collection.

Represents a DebuggerDisplay attribute on a type, enum, field, property, or delegate. See msdn documentation for DebuggerDisplayAttribute. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

[Optional] The simple name (not full name) of the originating assembly for this attribute. This value is null if the attribute did not come from the debuggee process. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

[Optional] The public key token of the originating assembly. This value is null if the originating assembly is not signed or the attribute did not come from the debuggee process. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

[Optional] The value to display in the debugger variable windows. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

[Optional] The name to display in the debugger variable windows. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

[Optional] The type name to display in the debugger variable windows. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

Create a new DkmClrDebuggerDisplayAttribute object instance. Location constraint: API must be called from a Monitor component (component level < 100,000). This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

[In] The type this attribute applies to. [In,Optional] The member this attribute applies to if applicable. [In,Optional] The simple name (not full name) of the originating assembly for this attribute. This value is null if the attribute did not come from the debuggee process. [In,Optional] The public key token of the originating assembly. This value is null if the originating assembly is not signed or the attribute did not come from the debuggee process. [In,Optional] The value to display in the debugger variable windows. [In,Optional] The name to display in the debugger variable windows. [In,Optional] The type name to display in the debugger variable windows. [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Represents a DebuggerTypeProxy attribute on a type and specifies a display proxy for a type. See msdn documentation for DebuggerTypeProxyAttribute. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

The proxy type. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

Create a new DkmClrDebuggerTypeProxyAttribute object instance. Location constraint: API must be called from a Monitor component (component level < 100,000). This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

[In] The type this attribute applies to. [In,Optional] The member this attribute applies to if applicable. [In] The proxy type. [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Represents a DebuggerVisualizer attribute on a type and specifies the IDE-side and debuggee-side visualizer type names, and its description. See msdn documentation for DebuggerVisualizerAttribute. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

The full name of the UI-side type of the Custom Managed Visualizer. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

The full name of the assembly containing the UI-side type. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

The location of the UI-side assembly. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

The full name of the debuggee-side type of the Custom Managed Visualizer. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

The full name of the assembly containing the debuggee-side type. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

The visualizer description. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

Create a new DkmClrDebuggerVisualizerAttribute object instance. Location constraint: API must be called from a Monitor component (component level < 100,000). This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

[In] The type this attribute applies to. [In,Optional] The member this attribute applies to if applicable. [In] The full name of the UI-side type of the Custom Managed Visualizer. [In] The full name of the assembly containing the UI-side type. [In] The location of the UI-side assembly. [In] The full name of the debuggee-side type of the Custom Managed Visualizer. [In] The full name of the assembly containing the debuggee-side type. [In] The visualizer description. [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

An attribute that affects the way the debugger displays the evaluation results for a type. Example attributes are DebuggerDisplay and DebuggerTypeProxy. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM). Derived classes: DkmClrDebuggerBrowsableAttribute, DkmClrDebuggerDisplayAttribute, DkmClrDebuggerTypeProxyAttribute, DkmClrDebuggerVisualizerAttribute

DkmClrEvalAttribute is an abstract base class. This enum indicates which derived class this object is an instance of.

Object is an instance of 'DkmClrDebuggerBrowsableAttribute'.

Object is an instance of 'DkmClrDebuggerDisplayAttribute'.

Object is an instance of 'DkmClrDebuggerTypeProxyAttribute'.

Object is an instance of 'DkmClrDebuggerVisualizerAttribute'.

DkmClrEvalAttribute is an abstract base class. This enum indicates which derived class this object is an instance of.

The type this attribute applies to. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

[Optional] The member this attribute applies to if applicable. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

The module the type resides in. If the type resides in a synthetic assembly, this value will be a real module in the same AppDomain. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM). This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Information about a local variable and how to inspect it. Currently local variable info includes the user visible name of the variable and the method on the inspection query to execute to get its value. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

The user-visible name of the variable. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

The full name of the variable. This is the expression evaluated if the variable is added to the Watch window. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

The name of the method to execute to get the value of this variable. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

[Optional] Flags, provided by the compiler, describing the local variable. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

[Optional] What category this variable belongs to, this controls the glyph displayed in the evaluation windows. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

[Optional] The optional information provided to the result formatter for identifying compiler intrinsic type information. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

Create a new DkmClrLocalVariableInfo object instance. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

[In] The user-visible name of the variable. [In] The full name of the variable. This is the expression evaluated if the variable is added to the Watch window. [In] The name of the method to execute to get the value of this variable. [In,Optional] Flags, provided by the compiler, describing the local variable. [In,Optional] What category this variable belongs to, this controls the glyph displayed in the evaluation windows. [In,Optional] The optional information provided to the result formatter for identifying compiler intrinsic type information. [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

A value resulting from a CLR inspection query. These values are used by a Result Formatter to generate DkmEvaluationResults. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

The language being used. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

[Optional] The runtime type of this node. System.String, for example. This value is null when the value is invalid AND the type cannot be determined. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

The category (ex: Data, Method, etc) of this evaluation result. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

The access control level (public, private, etc) of the evaluation result. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

The storage type (ex: static) of the evaluation result. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

Type modifier flags (ex: const) of the evaluation result. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

True if the value is a null (or if there is no value). This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

[Optional] The value of this node if the DkmClrValue is a value that can be represented in the debugger process. If the DkmClrValue is of a complex type, this value will be null. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

The stack frame used as the inspection frame of the interpreted expression. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

Flags describing of the result of the evaluation that created this DkmClrValue. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

Flags describing this value. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

An interface pointer to the native COM object if this value is an RCW. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

[Optional] The alias for this value. If the object has not been assigned an alias, this value will be null. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

[Optional] The dimensions of the the array. This value is only valid if this DkmClrValue is an array value. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

[Optional] The lower bounds of the the array. This value is only valid if this DkmClrValue is an array value. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

Guid which uniquely identifies this interpreted result. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

Closes the CLR value to release resources associated with it. This method must be invoked by the object that requested the evaluation query (ex: called DkmCompiledClrInspectionQuery.Execute). DkmClrValue objects are automatically closed when their associated DkmInspectionSession object is closed. Location constraint: API must be called from a Monitor component (component level < 100,000). This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

Create a new DkmClrValue object instance. Location constraint: API must be called from a Monitor component (component level < 100,000). This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

[In] The InspectionSession allows the various components which examine data in the target process to store private data with the same lifetime. Inspection sessions are closed when the user attempts to continue the process. [In] The language being used. [In,Optional] The runtime type of this node. System.String, for example. This value is null when the value is invalid AND the type cannot be determined. [In] The category (ex: Data, Method, etc) of this evaluation result. [In] The access control level (public, private, etc) of the evaluation result. [In] The storage type (ex: static) of the evaluation result. [In] Type modifier flags (ex: const) of the evaluation result. [In] True if the value is a null (or if there is no value). [In,Optional] The value of this node if the DkmClrValue is a value that can be represented in the debugger process. If the DkmClrValue is of a complex type, this value will be null. [In] The stack frame used as the inspection frame of the interpreted expression. [In] Flags describing of the result of the evaluation that created this DkmClrValue. [In] Flags describing this value. [In] An interface pointer to the native COM object if this value is an RCW. [In,Optional] If the result is an address (i.e. the address flag is set in Flags), specifies the location of the backing value. This is used when the evaluation result is used as the input to the memory window or disassembly window. If it is an instruction address then it must have the CPUInstruction address set. [In,Optional] The alias for this value. If the object has not been assigned an alias, this value will be null. [In,Optional] The dimensions of the the array. This value is only valid if this DkmClrValue is an array value. [In,Optional] The lower bounds of the the array. This value is only valid if this DkmClrValue is an array value. [In,Optional] Data object to add to the new DkmClrValue instance. Pass 'null' in the case that the caller doesn't need to add a data item. [Out] Result of this method call.

Get the value string to display in the UI for the given DkmClrValue. Location constraint: API must be called from a Monitor component (component level < 100,000). This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

[In] The inspection context for this evaluation. [In,Optional] The optional format specifier(s) to use when formatting this result. [Out] The value string.

Determines if this value has an underlying string representation. If this method returns true, the user can use string visualizers to view this value in the debugger. GetUnderlyingString should return the underlying string representation. Location constraint: API must be called from a Monitor component (component level < 100,000). This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

[In] The inspection context for this evaluation. [Out] True if this value has and underlying string representation.

Get the underlying string representation of the value. Location constraint: API must be called from a Monitor component (component level < 100,000). This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

[In] The inspection context for this evaluation. [Out] The underlying string representation.

Format a DkmClrValue and return a DkmEvaluationResult. This method will append a new work item to the specified work list, and return once the work item has been appended. The actual processing of the work item is asynchronous. The caller will be notified that the request is complete through the completion routine. Location constraint: API must be called from a Monitor component (component level < 100,000). This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

WorkList to append the new work item to. [In,Optional] The declared type if it is different from the runtime type. [In,Optional] The optional information provided by the expression compiler for identifying compiler intrinsic type information. [In] The inspection context for this evaluation. [In,Optional] The optional format specifier(s) to use when formatting this result. [In] The name of this result. This value is typically the expression being evaluated. [In,Optional] The full name of this result. This is the expression added to the Watch window if the user selects "Add to Watch". Routine to fire when the request is complete. If the request is successfully appended to the work list, this will always fire (including when the operation is canceled). This will never fire if appending the work item fails.

[In] The inspection context for this evaluation. [Out,Optional] The result of calling ToString on the object represented by this DkmClrValue.

Gets the string to display in the debugger UI for a CLR value given a DebuggerDisplay attribute string. This method will append a new work item to the specified work list, and return once the work item has been appended. The actual processing of the work item is asynchronous. The caller will be notified that the request is complete through the completion routine. Location constraint: API must be called from a Monitor component (component level < 100,000). This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

WorkList to append the new work item to. [In] The inspection context for this evaluation. [In] The type to use when evaluating debugger display attributes. [In] The format string to be evaluated by the debugger. For example "Count = {Count}". Routine to fire when the request is complete. If the request is successfully appended to the work list, this will always fire (including when the operation is canceled). This will never fire if appending the work item fails.

Instantiate a proxy class for a DkmClrValue with an associated DebuggerTypeProxy attribute. Location constraint: API must be called from a Monitor component (component level < 100,000). This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

[In] The inspection context for this evaluation. [In] The type of the proxy to instantiate. The proxy type should have a constructor taking a single parameter. The debugger will pass the instance of the type being inspected to this constructor. [Out] A value representing the instantiated type proxy. E_INVALIDARG indicates that Type is an unconstructed generic type.

Instantiate the proxy class to use for iterating an IEnumerable value. Location constraint: API must be called from a Monitor component (component level < 100,000). This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

[In] The inspection context for this evaluation. [In] The interface type (IEnumerable or IEnumerable<T>) to construct the the results view proxy for. This is needed because a class may implement several different IEnumerable interfaces. [Out,Optional] A value representing the instantiated results view proxy. This method returns null in case of failure instantiating the results view proxy. COR_E_INVALIDOPERATION indicates that this method was called on a DkmClrValue that does not implement the requested interface or represents a null value. E_INVALIDARG indicates that EnumerableType is not an interface type.

Instantiate the proxy class to use for iterating the dynamic members of an IDynamicMetaObjectProvider value. Location constraint: API must be called from a Monitor component (component level < 100,000). This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

[In] The inspection context for this evaluation. [Out,Optional] A value representing the instantiated results view proxy. This method returns null in case of failure instantiating the dynamic view proxy. COR_E_INVALIDOPERATION indicates that this method was called on a DkmClrValue that does not implement the IDynamicMetaObjectProvider interface or represents a null value.

Gets the value of a field or property as a DkmClrValue. Location constraint: API must be called from a Monitor component (component level < 100,000). This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

[In] The name of the member to get the value for. [In] The type of member to get the value for. The value should match a value of System.Reflection.MemberTypes. This method currently only supports getting the value for Fields (4) or Properties (16). [In,Optional] The full name of the type containing the member to get the value for. If ParentTypeName value is null, this method will look for the member in the runtime type. [In] The inspection context for this evaluation. [Out] The DkmClrValue for the given member.

Get an array element. This method may only be used if the DkmClrValue represents an array value. Location constraint: API must be called from a Monitor component (component level < 100,000). This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

[In] The index or indices of the array element to get. [In] The inspection context for this evaluation. [Out] The element value.

Dereference this pointer value to get the underlying value. This method may only be used if the DkmClrValue represents a Pointer value. Location constraint: API must be called from a Monitor component (component level < 100,000). This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

[In] The inspection context for this evaluation. [Out] The dereferenced value.

[In,Optional] The information provided by the expression compiler for identifying compiler intrinsic type information. [In] The inspection context for this evaluation. [In,Optional] The optional format specifier(s) to use when formatting this result. [Out] The value string.

Get the editable value string to display in the UI for the given DkmClrValue. Location constraint: API must be called from a Monitor component (component level < 100,000). This API was introduced in Visual Studio 15 RTM (DkmApiVersion.VS15RTM).

[In] The inspection context for this evaluation. [In,Optional] The information provided by the expression compiler for identifying compiler intrinsic type information. [Out] The editable value string.

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Represents an evaluation query that has been compiled to managed IL code. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

Binary of the query assembly. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

The fully qualified name of the type containing the query method. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

The name of the query method. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

[Optional] The format specifier(s) to use when formatting the result of this query. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

[Optional] Flags, provided by the compiler, describing the inspection query. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

[Optional] What category this variable belongs to, this controls the glyph displayed in the evaluation windows. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

[Optional] The access control level (public, private, etc) of the evaluation result. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

[Optional] The storage type (ex: static) of the evaluation result. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

[Optional] Type modifier flags (ex: const) of the evaluation result. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

[Optional] The optional information provided to the result formatter for identifying compiler intrinsic type information. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

Guid which uniquely identifies this query. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

Create a new DkmCompiledClrInspectionQuery object instance. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

[In] The DkmRuntimeInstance class represents an execution environment which is loaded into a DkmProcess and which contains code to be debugged. [In,Optional] Custom Data to associate with this inspection query. It will persist as long as the query has the potential to execute. [In] The language of the expression evaluator that created this query. [In] Binary of the query assembly. [In] The fully qualified name of the type containing the query method. [In] The name of the query method. [In,Optional] The format specifier(s) to use when formatting the result of this query. [In,Optional] Flags, provided by the compiler, describing the inspection query. [In,Optional] What category this variable belongs to, this controls the glyph displayed in the evaluation windows. [In,Optional] The access control level (public, private, etc) of the evaluation result. [In,Optional] The storage type (ex: static) of the evaluation result. [In,Optional] Type modifier flags (ex: const) of the evaluation result. [In,Optional] The optional information provided to the result formatter for identifying compiler intrinsic type information. [Out] Result of this method call.

Create a new DkmCompiledClrInspectionQuery object instance. This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTMPreview).

[In] The DkmRuntimeInstance class represents an execution environment which is loaded into a DkmProcess and which contains code to be debugged. [In,Optional] Custom Data to associate with this inspection query. It will persist as long as the query has the potential to execute. [In] The language of the expression evaluator that created this query. [In,Optional] If non-null, the worker process where the inspection query was created. [In] Binary of the query assembly. [In] The fully qualified name of the type containing the query method. [In] The name of the query method. [In,Optional] The format specifier(s) to use when formatting the result of this query. [In,Optional] Flags, provided by the compiler, describing the inspection query. [In,Optional] What category this variable belongs to, this controls the glyph displayed in the evaluation windows. [In,Optional] The access control level (public, private, etc) of the evaluation result. [In,Optional] The storage type (ex: static) of the evaluation result. [In,Optional] Type modifier flags (ex: const) of the evaluation result. [In,Optional] The optional information provided to the result formatter for identifying compiler intrinsic type information. [Out] Result of this method call.

Execute a compiled inspection query and returns the result as a list of formatted DkmEvaluationResults. This method will append a new work item to the specified work list, and return once the work item has been appended. The actual processing of the work item is asynchronous. The caller will be notified that the request is complete through the completion routine. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

WorkList to append the new work item to. [In] The inspection context for this query. [In] The stack context to execute the query against. [In] The name of the expression used to create this inspection query. Routine to fire when the request is complete. If the request is successfully appended to the work list, this will always fire (including when the operation is canceled). This will never fire if appending the work item fails.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Represents a query to populate local variable information using managed IL code. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

Binary of the query assembly. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

The fully qualified name of the type containing the query method. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

The collection of local variable names and method names on the query type to get the values. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

Guid which uniquely identifies this query. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

Create a new DkmCompiledClrLocalsQuery object instance. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

Create a new DkmCompiledClrLocalsQuery object instance. This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTMPreview).

Execute a compiled inspection query to get a set of local variable values as a list of formatted DkmEvaluationResults. This method will append a new work item to the specified work list, and return once the work item has been appended. The actual processing of the work item is asynchronous. The caller will be notified that the request is complete through the completion routine. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

WorkList to append the new work item to. [In] The inspection context for this query. [In] The stack context to execute the query against. [In] The index of the first local variable to get the value for. [In] The number of local variables to get the value for. Routine to fire when the request is complete. If the request is successfully appended to the work list, this will always fire (including when the operation is canceled). This will never fire if appending the work item fails.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Result of an asynchronous DkmClrValue.EvaluateDebuggerDisplayString call.

Creates a new result structure to hold the error from a failed call to DkmClrValue.EvaluateDebuggerDisplayString.

[In] exception object containing the error

HRESULT code returned from the caller. This will be DkmExceptionCode.COR_E_OPERATIONCANCELED (0x8013153B) if the operation was canceled before processing was complete.

The formatted value to display in the debugger UI. For example "Count = 5". This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

Creates a new result structure to hold the output from a successful call to DkmClrValue.EvaluateDebuggerDisplayString.

[In] The formatted value to display in the debugger UI. For example "Count = 5".

Marshal a native struct to managed

Pointer to native struct. Managed object.

Obtain a pointer to the native object used to call into native.

Outgoing managed->native call Native object

Validate the fields of this structure

Struct that holds the field path (ex: "myArgument.StructField")

Result of an asynchronous DkmClrValue.GetResult call.

Creates a new result structure to hold the error from a failed call to DkmClrValue.GetResult.

[In] exception object containing the error

HRESULT code returned from the caller. This will be DkmExceptionCode.COR_E_OPERATIONCANCELED (0x8013153B) if the operation was canceled before processing was complete.

The formatted DkmEvaluationResult. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

Creates a new result structure to hold the output from a successful call to DkmClrValue.GetResult.

[In] The formatted DkmEvaluationResult.

Marshal a native struct to managed

Pointer to native struct. Managed object.

Obtain a pointer to the native object used to call into native.

Outgoing managed->native call Native object

Validate the fields of this structure

Struct that holds the field path (ex: "myArgument.StructField")

Result of an asynchronous DkmCompiledClrInspectionQuery.Execute call.

Creates a new result structure to hold the error from a failed call to DkmCompiledClrInspectionQuery.Execute.

[In] exception object containing the error

HRESULT code returned from the caller. This will be DkmExceptionCode.COR_E_OPERATIONCANCELED (0x8013153B) if the operation was canceled before processing was complete.

The formatted result of the inspection query. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

Creates a new result structure to hold the output from a successful call to DkmCompiledClrInspectionQuery.Execute.

[In] The formatted result of the inspection query.

Marshal a native struct to managed

Pointer to native struct. Managed object.

Obtain a pointer to the native object used to call into native.

Outgoing managed->native call Native object

Validate the fields of this structure

Struct that holds the field path (ex: "myArgument.StructField")

Result of an asynchronous DkmCompiledClrLocalsQuery.GetLocalValues call.

Creates a new result structure to hold the error from a failed call to DkmCompiledClrLocalsQuery.GetLocalValues.

[In] exception object containing the error

HRESULT code returned from the caller. This will be DkmExceptionCode.COR_E_OPERATIONCANCELED (0x8013153B) if the operation was canceled before processing was complete.

The list formatted local variable evaluation results. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

Creates a new result structure to hold the output from a successful call to DkmCompiledClrLocalsQuery.GetLocalValues.

[In] The list formatted local variable evaluation results.

Marshal a native struct to managed

Pointer to native struct. Managed object.

Obtain a pointer to the native object used to call into native.

Outgoing managed->native call Native object

Validate the fields of this structure

Struct that holds the field path (ex: "myArgument.StructField")

An inspection query compiled to one or more DkmIL instructions.

Body of the query.

Create a new DkmCompiledILInspectionQuery object instance.

[In] The DkmRuntimeInstance class represents an execution environment which is loaded into a DkmProcess and which contains code to be debugged. [In] Body of the query. [Out] Result of this method call.

Create a new DkmCompiledILInspectionQuery object instance. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

Create a new DkmCompiledILInspectionQuery object instance. This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTMPreview).

Executes a compiled inspection query and returns any results.

[In] The stack frame context we are evaluating on. [In] The compute threads to use when executing the query. [In,Optional] Parameters to pass to each thread. The collection should be empty if unused, or have exactly as many members as the Threads parameter. [Out] Results of the evaluations.

WorkList to append the new work item to. [In] The stack frame context we are evaluating on. [In] The compute threads to use when executing the query. [In,Optional] Parameters to pass to each thread. The collection should be empty if unused, or have exactly as many members as the Threads parameter. Routine to fire when the request is complete. If the request is successfully appended to the work list, this will always fire (including when the operation is canceled). This will never fire if appending the work item fails.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Pops two values off the evaluation stack, adds them, and pushes the sum onto the evaluation stack. Both operands popped off the stack must be the size indicated by DkmPrimitiveObjectType. The resultant value will have the same size as the operands. In the event of overflow, the result will be truncated.

The type of addition to perform (e.g. integer vs. floating-point).

Create a new DkmILAdd object instance.

[In] The type of addition to perform (e.g. integer vs. floating-point). [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

A request to translate a C++ AMP pointer tag if its buffer has been forwarded. Pops the 32-bit tag off the stack, pushes the new 32-bit tag on the stack. Usually a no-op.

Create a new DkmILAmpAdjustBufferTag object instance.

[Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Begins a try block. If an error occurs within the execution of the try block, control will jump to an appropriate catch block to allow the IL to recover from the error. Exception handling in native IL works as follows: An exception in native IL means that some operation, such as a register read or memory read failed. Each exception is identified by a 32-bit exception code that describes the problem. Exception code values are defined according to the DkmILFailureReason enumeration, and additional user-defined values may also be used to handle exception-conditions that are specific to an intrinsic function (e.g. attempt to take the log of 0). By default, when an exception occurs, the IL processing will stop immediately, causing DkmCompiledInspectionQuery::ExecuteQuery() to fail, returning the exception code as an out parameter. To handle the exception with IL, the IL should execute a DkmILBeginTry instruction to enter a guarded exception-handling state. The IL processing will remain in this state until a DkmILEndTryBlock instruction is executed. A DkmILBeginTryBlock instruction specifies what to do if an exception occurs within the block. The block's exception handling logic is defined by a collection of DkmILCatchBlock objects. Each catch block defines the exception code that the catch block will catch, as well as the offset into the instruction stream where the catch block is located at. Thus, when an exception occurs, we will do the following: 1) Check if we are inside a try block: No: Abort the IL operation and cause DkmCompiledInspectionQuery::ExecuteQuery() to fail. Yes: 2) Examine the list of DkmILCatchBlock objects associated with the try block in sequential order, looking for a catch block that catches the exception code. (If more than one catch block works, we use the first match and ignore the other matches). If we find a match: - Clear the state that says we're in a try block (so any exceptions from the catch handler will go unhandled unless a new try block gets set up) - Remove all values from the IL stack that got pushed after we entered the try block. Local variables, saved return values, and IL stack values that were already pushed before the try block began are retained. (It is illegal to pop a value off the stack inside a try block that got pushed outside the try block). - Push the exception code on the stack as a 32-bit value - Transfer control to the offset of the catch handler and continue the IL If we don't find a match: - The exception is unhandled. Abort the IL operation and cause DkmCompiledInspectionQuery::ExecuteQuery() to fail. If during the execution of the inspection query, we detect that the work list has been canceled, we will promptly abort the IL processing. The IL will not have a chance to handle this. In general, exception handling is allowed when an inspection fails, or an arithmetic error occurs (e.g. division by zero), however, on error conditions that can only arise through invalid IL (e.g. attempt to pop from empty stack), we do not guarantee that exception handling of such errors will be supported. If an exception occurs that we do not support handling, the IL processing will simply abort.

Ordered list of catch blocks to handle exceptions occurring within the try block.

Create a new DkmILBeginTry object instance.

[In] Ordered list of catch blocks to handle exceptions occurring within the try block. [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Pops two integer values off of the evaluation stack. Performs a bitwise and on the two values, and pushes the result onto the stack. The two values popped from the stack must be the same size.

The type of operands to expect (e.g. 32-bit or 64-bit). Floating-point modes are not allowed.

Create a new DkmILBitAnd object instance.

[In] The type of operands to expect (e.g. 32-bit or 64-bit). Floating-point modes are not allowed. [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Reads the value of a bit field from memory. The address of the bit field is popped off the stack.

The bit position to read from. Must be between 0 and 63.

Number of bits to read. Must be between 1 and 64.

The type of object to read. Must be an integer and must be at least as large, in bits, as NumBits.

Create a new DkmILBitFieldRead object instance.

[In] The bit position to read from. Must be between 0 and 63. [In] Number of bits to read. Must be between 1 and 64. [In] The type of object to read. Must be an integer and must be at least as large, in bits, as NumBits. [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Pops a value off the IL stack. Then, reads a bit-field directly off that value. This is different from DkmILBitFieldRead in that the value popped from the stack directly contains the value to read the bits from, rather than a memory address.

Offset within the state of the value where the bit-field begins.

The bit position to read from. Must be between 0 and 63.

Number of bits to read. Must be between 1 and 64.

The type of object to read. Must be an integer and must be at least as large, in bits, as NumBits.

Create a new DkmILBitFieldReadFromBytes object instance.

[In] Offset within the state of the value where the bit-field begins. [In] The bit position to read from. Must be between 0 and 63. [In] Number of bits to read. Must be between 1 and 64. [In] The type of object to read. Must be an integer and must be at least as large, in bits, as NumBits. [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Pops a value off the stack. Then, pops a memory address off the stack. Then, modifies the value of the bit field at that memory address, at the given offset and size, to match the value that was just popped off the stack.

The bit position to write to. Must be between 0 and 63.

Number of bits to write. Must be between 1 and 64.

Create a new DkmILBitFieldWrite object instance.

[In] The bit position to write to. Must be between 0 and 63. [In] Number of bits to write. Must be between 1 and 64. [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Pops a value off the IL stack. Then pops a second value off the IL stack. The first value to be popped (second to be pushed) will be treated as an object that contains a bit field described herein. The second value to be popped (first to be pushed) will be the value of the bit field that will be inserted into the first value. The result of the modification is then pushed onto the IL stack.

Offset within the state of the value where the bit-field begins.

The bit position to write to. Must be between 0 and 63.

Number of bits to write. Must be between 1 and 64.

Create a new DkmILBitFieldWriteToBytes object instance.

[In] Offset within the state of the value where the bit-field begins. [In] The bit position to write to. Must be between 0 and 63. [In] Number of bits to write. Must be between 1 and 64. [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Pops an integer value off of the evaluation stack. Inverts all the bits and pushes the result onto the stack.

The type of operands to expect (e.g. 32-bit or 64-bit). Floating-point modes are not allowed.

Create a new DkmILBitNot object instance.

[In] The type of operands to expect (e.g. 32-bit or 64-bit). Floating-point modes are not allowed. [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Pops two integer values off of the evaluation stack. Performs a bitwise or on the two values, and pushes the result onto the stack. The two values popped from the stack must be the same size.

The type of operands to expect (e.g. 32-bit or 64-bit). Floating-point modes are not allowed.

Create a new DkmILBitOr object instance.

[In] The type of operands to expect (e.g. 32-bit or 64-bit). Floating-point modes are not allowed. [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Pops two integer values off of the evaluation stack. Shifts the first value left by the second value and pushes the result onto the evaluation stack. The first operand must be the size indicated by by DkmPrimitiveObjectType. The second operand must be 32-bit.

The type of operands to expect (e.g. 32-bit or 64-bit). Floating-point modes are not allowed.

Create a new DkmILBitShiftLeft object instance.

[In] The type of operands to expect (e.g. 32-bit or 64-bit). Floating-point modes are not allowed. [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Pops two integer values off of the evaluation stack. Shifts the first value right by the second value and pushes the result onto the evaluation stack. The first operand must be the size indicated by by DkmPrimitiveObjectType. The second operand must be 32-bit.

The type of operands to expect (e.g. 32-bit or 64-bit). Floating-point modes are not allowed. Also, specifies whether the operation is signed or unsigned. An unsigned mode means the upper-bit will be filled with a zero; a signed mode means the upper-bit will be preserved.

Create a new DkmILBitShiftRight object instance.

[In] The type of operands to expect (e.g. 32-bit or 64-bit). Floating-point modes are not allowed. Also, specifies whether the operation is signed or unsigned. An unsigned mode means the upper-bit will be filled with a zero; a signed mode means the upper-bit will be preserved. [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Pops two integer values off of the evaluation stack. Performs a bitwise exclusive-or on the two values, and pushes the result onto the stack. The two values popped from the stack must be the same size.

The type of operands to expect (e.g. 32-bit or 64-bit). Floating-point modes are not allowed.

Create a new DkmILBitXor object instance.

[In] The type of operands to expect (e.g. 32-bit or 64-bit). Floating-point modes are not allowed. [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Describes the calling convention for a function evaluation on x86. Ignored for other architectures.

The x86 stdcall calling convention.

The x86 cdecl calling convention.

The x86 thiscall calling convention.

The x86 fastcall calling convention.

An IL catch block, which can be used to recover from errors while executing IL.

The type of error to catch, "None" to catch all errors.

The index of the IL instruction to jump to when the catch block executes.

Create a new DkmILCatchBlock object instance.

[In] The type of error to catch, "None" to catch all errors. [In] The index of the IL instruction to jump to when the catch block executes. [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Checks if the timeout limit on the IL stream has been exceeded. If so, throws an IL exception with failure code 'Aborted'. This exception may be handled in a catch block, so immediate termination of the IL is not guaranteed. Otherwise, this instruction simply returns. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

Create a new DkmILCheckTimeout object instance. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

[Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Pops two values off of the evaluation stack. If the two values are equal (same size, all the bytes have the same value), pushes a 32-bit 1 onto the stack. Otherwise, pushes a 32-bit 0 onto the stack.

The type of comparison to perform (e.g. integer vs. floating-point).

Create a new DkmILCompareEqual object instance.

[In] The type of comparison to perform (e.g. integer vs. floating-point). [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Pops two values off the evaluation stack and performs a numerical comparison of the values, using the arithmetic mode specified. If the first operand is greater than the second operand, pushes a 32-bit value of 1 on the stack; otherwise, pushes a 32-bit value of 0 on the stack.

The type of comparison to perform (e.g. integer vs. floating-point).

Create a new DkmILCompareGreaterThan object instance.

[In] The type of comparison to perform (e.g. integer vs. floating-point). [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Pops two values off the evaluation stack and performs a numerical comparison of the values, using the arithmetic mode specified. If the first operand is greater than or equal to the second operand, pushes a 32-bit value of 1 on the stack; otherwise, pushes a 32-bit value of 0 on the stack.

The type of comparison to perform (e.g. integer vs. floating-point).

Create a new DkmILCompareGreaterThanOrEqual object instance.

[In] The type of comparison to perform (e.g. integer vs. floating-point). [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Pops two values off the evaluation stack and performs a numerical comparison of the values, using the arithmetic mode specified. If the first operand is less than the second operand, pushes a 32-bit value of 1 on the stack; otherwise, pushes a 32-bit value of 0 on the stack.

The type of comparison to perform (e.g. integer vs. floating-point).

Create a new DkmILCompareLessThan object instance.

[In] The type of comparison to perform (e.g. integer vs. floating-point). [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

The type of comparison to perform (e.g. integer vs. floating-point).

Create a new DkmILCompareLessThanOrEqual object instance.

[In] The type of comparison to perform (e.g. integer vs. floating-point). [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Pops two values off of the evaluation stack. If the two values are not equal (same size, all the bytes don't have the same value), pushes a 32-bit 1 onto the stack. Otherwise, pushes a 32-bit 0 onto the stack.

The type of comparison to perform (e.g. integer vs. floating-point).

Create a new DkmILCompareNotEqual object instance.

[In] The type of comparison to perform (e.g. integer vs. floating-point). [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Pops a value off the evaluation stack and converts it from one type to another.

The expected type of the object to be popped from the stack. The actual object popped from the stack must have a size that matches this type.

The type that you want to convert the value to. This is the type of the object that will be pushed onto the stack.

Create a new DkmILConvert object instance.

[In] The expected type of the object to be popped from the stack. The actual object popped from the stack must have a size that matches this type. [In] The type that you want to convert the value to. This is the type of the object that will be pushed onto the stack. [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Pops two values off the evaluation stack, divides them, and pushes the result onto the evaluation stack. Both operands popped off the stack must be the size indicated by DkmPrimitiveObjectType. The first value popped from the stack will be divided by the second value popped, so to evaluate "a / b", you would push a, then push b, then divide. The resultant value will have the same size as the operands. In the event of overflow, the result will be truncated.

The type of subtraction to perform (e.g. integer vs. floating-point).

Create a new DkmILDivide object instance.

[In] The type of subtraction to perform (e.g. integer vs. floating-point). [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Make a duplicate copy of the value on the top of the DkmIL stack and push this copy on top of the stack. If the result of a DkmDuplicateTop gets returned, the GUID associated with the result will be the GUID of the original instruction, not the GUID of the DkmDuplicateTop.

Create a new DkmILDuplicateTop object instance.

[Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Ends a try block. After this, all exceptions will go unhandled unless a new DkmILBeginTry instruction is executed.

Create a new DkmILEndTry object instance.

[Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

DkmILEvaluationResult represents the result of evaluating one DkmILInstruction.

UniqueId of the DkmILInstruction object that originally pushed the returned value onto the evaluation stack.

The results of evaluating the DkmILInstruction. Empty for pseudo-addresses.

If true, indicates that the IL result is a pseudo-address, rather than an actual value. The ResultBytes property of a pseudo-address will be the bytes of the local variable that the pseudo-address refers to, excluding any bytes prior to the offset of the pseudo-address. The ResultBytes property of a pseudo-address will be empty if the backing local variable does not exist, is another pseudo-address, or is capturing fewer bytes than the byte offset of the current pseudo-address. For details on pseudo-addresses, see the DkmILPushLocalVariablePseudoAddress function. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

[Optional] If IsPseudoAddress is true, specifies the contents of the backing data for the pseudo-address. This will be NULL if the backing local variable does not exist, is another pseudo-address, or contains fewer bytes than the offset of the pseudo-address. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

If this evaluation result represents the pseudo-address of somewhere within a register (pushed onto the stack with a DkmILPushRegisterPseudoAddress instruction), returns the register that backs the result. If no backing register exists, the return value is 0 (CV_REG_NONE). This API was introduced in Visual Studio 15 RTM (DkmApiVersion.VS15RTM).

If this evaluation result represents the pseudo-address of somewhere within a register (pushed onto the stack with a DkmILPushRegisterPseudoAddress instruction), returns the byte offset within the register that this pseudo-address represents. If no backing register exists, the return value is zero. This property is valid only if BackingRegisterId() returns a nonzero value. This API was introduced in Visual Studio 15 RTM (DkmApiVersion.VS15RTM).

Create a new DkmILEvaluationResult object instance.

Create a new DkmILEvaluationResult object instance. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

Create a new DkmILEvaluationResult object instance. This API was introduced in Visual Studio 15 RTM (DkmApiVersion.VS15RTM).

[In] UniqueId of the DkmILInstruction object that originally pushed the returned value onto the evaluation stack. [In] The results of evaluating the DkmILInstruction. Empty for pseudo-addresses. [In] If true, indicates that the IL result is a pseudo-address, rather than an actual value. The ResultBytes property of a pseudo-address will be the bytes of the local variable that the pseudo-address refers to, excluding any bytes prior to the offset of the pseudo-address. The ResultBytes property of a pseudo-address will be empty if the backing local variable does not exist, is another pseudo-address, or is capturing fewer bytes than the byte offset of the current pseudo-address. For details on pseudo-addresses, see the DkmILPushLocalVariablePseudoAddress function. [In,Optional] If IsPseudoAddress is true, specifies the contents of the backing data for the pseudo-address. This will be NULL if the backing local variable does not exist, is another pseudo-address, or contains fewer bytes than the offset of the pseudo-address. [In] If this evaluation result represents the pseudo-address of somewhere within a register (pushed onto the stack with a DkmILPushRegisterPseudoAddress instruction), returns the register that backs the result. If no backing register exists, the return value is 0 (CV_REG_NONE). [In] If this evaluation result represents the pseudo-address of somewhere within a register (pushed onto the stack with a DkmILPushRegisterPseudoAddress instruction), returns the byte offset within the register that this pseudo-address represents. If no backing register exists, the return value is zero. This property is valid only if BackingRegisterId() returns a nonzero value. [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Pops the arguments off the IL stack in reverse order. Then, pops the address of the function off the eval stack. Next, executes the function in the debuggee process. (Prior to execution, the IL stream should push the function address first, then the arguments in forwards order). The return value for the function is copied to the IL Stack as a byte array.

The number of arguments to pass to the intrinsic function. These arguments are popped off the IL stack.

The size of the return value in bytes. This dictates how the return address is found on some architectures. For instance, on x86, a 4 byte or less return value is returned in EAX. An 8 byte return value is returned in EDX:EAX, and for anything larger, a pointer is returned in EAX to an object on the heap, or for by value returns, to an object on the stack after the stack is cleaned up.

The calling convention of the function to be executed. Ignored on non-x86 processors that only have a single calling convention.

Flags affecting how a function evaluation should occur.

Flags affecting arguments to a function evaluation. There will be one argument flag for each argument.

Used for the arm calling convention where a complex type containing all elements the same size are returned enregistered. This is only used if the EnregisteredComplexReturn flag in DkmILFunctionEvaluationFlags is set. This value should return the size of each element in the complex type. FloatingPointReturn is used to determine if the return value is in the in the integer registers of the floating point registers. The IL Interpreter will copy these values onto the stack and return a pointer to that location as if they were not enregistered.

Create a new DkmILExecuteFunction object instance.

[In] The number of arguments to pass to the intrinsic function. These arguments are popped off the IL stack. [In] The size of the return value in bytes. This dictates how the return address is found on some architectures. For instance, on x86, a 4 byte or less return value is returned in EAX. An 8 byte return value is returned in EDX:EAX, and for anything larger, a pointer is returned in EAX to an object on the heap, or for by value returns, to an object on the stack after the stack is cleaned up. [In] The calling convention of the function to be executed. Ignored on non-x86 processors that only have a single calling convention. [In] Flags affecting how a function evaluation should occur. [In] Flags affecting arguments to a function evaluation. There will be one argument flag for each argument. [In] Used for the arm calling convention where a complex type containing all elements the same size are returned enregistered. This is only used if the EnregisteredComplexReturn flag in DkmILFunctionEvaluationFlags is set. This value should return the size of each element in the complex type. FloatingPointReturn is used to determine if the return value is in the in the integer registers of the floating point registers. The IL Interpreter will copy these values onto the stack and return a pointer to that location as if they were not enregistered. [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Pops the arguments off the IL stack in reverse order (prior to the DkmILExecuteIntrinsic instruction, arguments should be pushed on the stack in order). Then, executes an EE-defined operation that makes use of these values. Then, pushes the result back onto the IL stack.

The language associated with the intrinsic function.

A unique identifier for the intrinsic function within the language.

The number of arguments to pass to the intrinsic function. These arguments are popped off the IL stack.

[Optional] Optional collection of subroutines that the intrinsic function can call into.

[Optional] If non-null, the worker process where the inspection query was created. This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTMPreview).

Create a new DkmILExecuteIntrinsic object instance.

Create a new DkmILExecuteIntrinsic object instance. This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTMPreview).

Executes an intrinsic function. Location constraint: API must be called from a Monitor component (component level < 100,000).

[In] The stack frame context we are evaluating on. [In] The arguments supplied to the intrinsic function. [In,Optional] Optional array of IL-based subroutines that the intrinsic function may choose to invoke during its operation. [Out] If an error occurs, specifies the reason for the error. To indicate an error code whose meaning is specific to the particular intrinsic function being executed, return a value less than zero. [Out] The results of the evaluation to be pushed onto the IL stack (in order).

Executes an intrinsic function. Location constraint: API must be called from a Monitor component (component level < 100,000). This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

[In] The stack frame context we are evaluating on. [In] Currently executing instruction query that this intrinsic function belongs to. [In] The arguments supplied to the intrinsic function. [In,Optional] Optional array of IL-based subroutines that the intrinsic function may choose to invoke during its operation. [Out] If an error occurs, specifies the reason for the error. To indicate an error code whose meaning is specific to the particular intrinsic function being executed, return a value less than zero. [Out] The results of the evaluation to be pushed onto the IL stack (in order).

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Pops a value off the IL stack and extracts a subset of the bytes of that value, pushing the result back onto the IL stack. If the entire region of bytes to extract doesn't fall within the bounds of the value popped from the stack, an IL exception of code ByteExtractionOutOfBounds will be thrown.

The offset of the first byte to extract.

The number of bytes to extract.

Create a new DkmILExtractBytes object instance.

[In] The offset of the first byte to extract. [In] The number of bytes to extract. [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Pops a length, offset, and blob of bytes from the IL stack (in that order). Extracts the portion of the blob of bytes at the given offset of the given length, pushing the result back onto the stack. The length and offset popped from the stack will be interpreted as either 32-bit or 64-bit unsigned integers, depending on the address space of the debuggee. If the entire region of bytes to extract doesn't fall within the bounds of the value popped from the stack, an IL exception of code ByteExtractionOutOfBounds will be thrown. This is similar to the DkmILExtractBytes instruction, except the offset and length are popped from the stack and do not need to be known at the time that the IL is generated. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

Create a new DkmILExtractBytesPopArguments object instance. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

[Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Indicates a reason why an IL instruction failed to execute. In addition to these constants, negative values may be used to indicate customized error conditions resulting from the execution of intrinsic functions.

The IL was evaluated successfully.

An attempt was made to divide an integer by zero.

An attempt to read from the debuggee's memory failed.

An attempt to write to the debuggee's memory failed.

An attempt to read the value of a register from the debuggee failed.

An attempt to write to the value of a register from the debuggee failed.

Execution was terminated because the user cancelled the evaluation.

An attempt was made to read a string which was larger than the maximum length.

Execution was terminated because the evaluation timeout was exceeded.

A function evaluation is already in progress. Multiple function evaluations are not supported.

An attempt to abort the evaluation failed. The process is now in an indeterminate state.

This operation is not supported while debugging a minidump.

The evaluation was aborted because an unhandled exception occurred in the process.

This operation is not supported on a user-mode scheduled thread.

A DkmILExtractBytes instruction failed because the range of bytes to extract falls outside the bounds of the value.

An attempt was made to perform an unsupported operation with one or more pseudo-address operands.

An unknown error occurred during a function evaluation.

Flags affecting how arguments to a function evaluation are treated.

No flags are set.

Set if this argument is a floating point value. This can affect how the value is passed to the function.

Set if this argument is a scalar type. On some architectures, this will affect how the parameter is passed.

Set if the argument needs to be copied into the debuggee address space and then passed by reference. Used to support string literals in argument parameters.

Set if this argument is the this pointer for a call.

Flags affecting how a function evaluation should occur.

No flags are set.

Set if this function returns a floating point value which changes how the return value is found.

Set if this function returns a scalar type. On some architectures this changes how the value is returned.

Set if the caller needs by-value return values returned as a reference on the stack. The interpreter will make a copy of the return value on the debuggee stack and return a pointer to that value. The value will only be valid in the debuggee address space until the next continue or next function evaluation.

Set if the return value will not be enregistered by the called function regardless of return value size. This is used by the C++ expression evaluator when a class or struct has a copy constructor defined and an instance of that class is being returned by-value. The address of the return value on the stack will be returned from the function evaluation. The value will only be valid in the debuggee address space until the next continue or next function evaluation.

Set if the function being called has a this pointer. The this pointer is the first argument in the in the argument collection.

Set if the return value for the function will be an enregistered complex return type. This is used for the calling convention on arm where a composite type made up of a number of elements of the same type is returned in registers. The size of each element must be passed to the function evaluation instruction. FloatingPointReturn is used to determine if the return value is in the in the integer registers of the floating point registers.

A request to read data from a shader shared buffer. The offset in the buffer is popped from the IL stack. The result is pushed on the IL stack.

The VSD3D_REGISTER_SET value cast to a CvRegisterId.

The index of the register to read.

The number of bytes to read from the shared buffer.

Create a new DkmILHlslBufferRead object instance.

[In] The VSD3D_REGISTER_SET value cast to a CvRegisterId. [In] The index of the register to read. [In] The number of bytes to read from the shared buffer. [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

A request to 'read' the current group ID. The result is pushed on the stack.

Specifies what portion of the thread group ID should be pushed on the stack.

Create a new DkmILHlslGetGroupId object instance.

[In] Specifies what portion of the thread group ID should be pushed on the stack. [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

A request to 'read' the current thread ID. The result is pushed on the stack.

Indicates whether the thread ID should be returned relative to the dispatch (true) or relative to the tile (false).

Instructs the debugger to fetch the thread id in flat format (if true), or as a vector (if false).

Specifies what portion of the thread ID should be pushed on the stack.

Create a new DkmILHlslGetThreadId object instance.

[In] Indicates whether the thread ID should be returned relative to the dispatch (true) or relative to the tile (false). [In] Instructs the debugger to fetch the thread id in flat format (if true), or as a vector (if false). [In] Specifies what portion of the thread ID should be pushed on the stack. [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

A request to read the value of a specific register. The index of the first vector element to read is popped from the IL stack. The result is pushed on the IL stack.

The VSD3D_REGISTER_SET value cast to a CvRegisterId.

The index of the register to read.

The offset in bytes from the beginning of the register to begin reading.

The number of bytes to be read from each vector register.

The number of vector elements to read.

Create a new DkmILHlslIndexedRegisterRead object instance.

[In] The VSD3D_REGISTER_SET value cast to a CvRegisterId. [In] The index of the register to read. [In] The offset in bytes from the beginning of the register to begin reading. [In] The number of bytes to be read from each vector register. [In] The number of vector elements to read. [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

A request to read the value of a specific register. The result is pushed on the IL stack.

The VSD3D_REGISTER_SET value cast to a CvRegisterId.

The index of the register to read.

The offset in bytes from the beginning of the register to begin reading.

The number of bytes to be read from each vector register.

The index of the first vector element.

The number of vector elements to read.

Create a new DkmILHlslRegisterRead object instance.

[In] The VSD3D_REGISTER_SET value cast to a CvRegisterId. [In] The index of the register to read. [In] The offset in bytes from the beginning of the register to begin reading. [In] The number of bytes to be read from each vector register. [In] The index of the first vector element. [In] The number of vector elements to read. [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Abstract base class for the concrete debugger immediate language instructions used by expression evaluators to batch query information about the debuggee. Derived classes: DkmILAdd, DkmILAmpAdjustBufferTag, DkmILBeginTry, DkmILBitAnd, DkmILBitFieldRead, DkmILBitFieldReadFromBytes, DkmILBitFieldWrite, DkmILBitFieldWriteToBytes, DkmILBitNot, DkmILBitOr, DkmILBitShiftLeft, DkmILBitShiftRight, DkmILBitXor, DkmILCompareEqual, DkmILCompareGreaterThan, DkmILCompareGreaterThanOrEqual, DkmILCompareLessThan, DkmILCompareLessThanOrEqual, DkmILCompareNotEqual, DkmILConvert, DkmILDivide, DkmILDuplicateTop, DkmILEndTry, DkmILExecuteFunction, DkmILExecuteIntrinsic, DkmILExtractBytes, DkmILHlslBufferRead, DkmILHlslGetGroupId, DkmILHlslGetThreadId, DkmILHlslIndexedRegisterRead, DkmILHlslRegisterRead, DkmILIsFalse, DkmILIsTrue, DkmILJump, DkmILJumpIfFalse, DkmILJumpIfTrue, DkmILLoad, DkmILMemoryRead, DkmILMemoryStringRead, DkmILMemoryWrite, DkmILMultiply, DkmILNop, DkmILPop, DkmILPushConstant, DkmILRegisterRead, DkmILRegisterWrite, DkmILRemainder, DkmILReturnTop, DkmILSave, DkmILSetBytesRegion, DkmILSubtract, DkmILThrow, DkmILTlsGetValue, DkmILCheckTimeout, DkmILExtractBytesPopArguments, DkmILPushLocalVariablePseudoAddress, DkmILPushRegisterPseudoAddress

DkmILInstruction is an abstract base class. This enum indicates which derived class this object is an instance of.

Object is an instance of 'DkmILRegisterRead'.

Object is an instance of 'DkmILRegisterWrite'.

Object is an instance of 'DkmILMemoryRead'.

Object is an instance of 'DkmILMemoryWrite'.

Object is an instance of 'DkmILMemoryStringRead'.

Object is an instance of 'DkmILTlsGetValue'.

Object is an instance of 'DkmILBitFieldRead'.

Object is an instance of 'DkmILBitFieldWrite'.

Object is an instance of 'DkmILPushConstant'.

Object is an instance of 'DkmILDuplicateTop'.

Object is an instance of 'DkmILPop'.

Object is an instance of 'DkmILSave'.

Object is an instance of 'DkmILLoad'.

Object is an instance of 'DkmILNop'.

Object is an instance of 'DkmILAdd'.

Object is an instance of 'DkmILSubtract'.

Object is an instance of 'DkmILMultiply'.

Object is an instance of 'DkmILDivide'.

Object is an instance of 'DkmILRemainder'.

Object is an instance of 'DkmILExtractBytes'.

Object is an instance of 'DkmILSetBytesRegion'.

Object is an instance of 'DkmILBitFieldReadFromBytes'.

Object is an instance of 'DkmILBitFieldWriteToBytes'.

Object is an instance of 'DkmILBitAnd'.

Object is an instance of 'DkmILBitOr'.

Object is an instance of 'DkmILBitXor'.

Object is an instance of 'DkmILBitShiftLeft'.

Object is an instance of 'DkmILBitShiftRight'.

Object is an instance of 'DkmILBitNot'.

Object is an instance of 'DkmILIsTrue'.

Object is an instance of 'DkmILIsFalse'.

Object is an instance of 'DkmILCompareEqual'.

Object is an instance of 'DkmILCompareNotEqual'.

Object is an instance of 'DkmILCompareGreaterThan'.

Object is an instance of 'DkmILCompareGreaterThanOrEqual'.

Object is an instance of 'DkmILCompareLessThan'.

Object is an instance of 'DkmILCompareLessThanOrEqual'.

Object is an instance of 'DkmILConvert'.

Object is an instance of 'DkmILReturnTop'.

Object is an instance of 'DkmILThrow'.

Object is an instance of 'DkmILJump'.

Object is an instance of 'DkmILJumpIfTrue'.

Object is an instance of 'DkmILJumpIfFalse'.

Object is an instance of 'DkmILExecuteIntrinsic'.

Object is an instance of 'DkmILBeginTry'.

Object is an instance of 'DkmILEndTry'.

Object is an instance of 'DkmILExecuteFunction'.

Object is an instance of 'DkmILHlslRegisterRead'.

Object is an instance of 'DkmILHlslIndexedRegisterRead'.

Object is an instance of 'DkmILHlslBufferRead'.

Object is an instance of 'DkmILHlslGetThreadId'.

Object is an instance of 'DkmILHlslGetGroupId'.

Object is an instance of 'DkmILAmpAdjustBufferTag'.

Object is an instance of 'DkmILExtractBytesPopArguments'.

Object is an instance of 'DkmILPushLocalVariablePseudoAddress'.

Object is an instance of 'DkmILCheckTimeout'.

Object is an instance of 'DkmILPushRegisterPseudoAddress'.

DkmILInstruction is an abstract base class. This enum indicates which derived class this object is an instance of.

Uniquely identifies the DkmILInstruction object. Used as a hash-table key to allow for quickly matching up DkmIL instructions with their matching values.

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Pops a value off of the evaluation stack. If the value is zero, pushes a 32-bit value of 1 on the stack. Otherwise, pushes a 32-bit value of 0 on the stack.

The type of comparison to perform (e.g. integer vs. floating-point).

Create a new DkmILIsFalse object instance.

[In] The type of comparison to perform (e.g. integer vs. floating-point). [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Pops a value off of the evaluation stack. If the value is non-zero, pushes a 32-bit value of 1 on the stack. Otherwise, pushes a 32-bit value of 0 on the stack.

The type of comparison to perform (e.g. integer vs. floating-point).

Create a new DkmILIsTrue object instance.

[In] The type of comparison to perform (e.g. integer vs. floating-point). [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Jumps to another instruction in the instruction stream.

Location in the instruction stream to jump to.

Create a new DkmILJump object instance.

[In] Location in the instruction stream to jump to. [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Pops a value off the IL stack. Then, jumps to another instruction in the instruction stream only if the value bytes are all zero.

Location in the instruction stream to jump to.

Create a new DkmILJumpIfFalse object instance.

[In] Location in the instruction stream to jump to. [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Pops a value off the IL stack. Then, jumps to another instruction in the instruction stream only if the value bytes are not all zero.

Location in the instruction stream to jump to.

Create a new DkmILJumpIfTrue object instance.

[In] Location in the instruction stream to jump to. [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Loads a value from an index previously saved from a DkmSave instruction and pushes the value to the top of the stack.

The index at which to save the value.

Create a new DkmILLoad object instance.

[In] The index at which to save the value. [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

A request to read a sequence of bytes from memory. The address to read from is popped off the DkmIL stack and must have a size of 4 if the debuggee is 32-bit, or 8 if the debuggee is 64-bit. The bytes that are read from memory are pushed onto the stack.

Number of bytes to read.

Flags controlling the behavior of DkmProcess.ReadMemory and DkmProcess.ReadMemoryString.

Create a new DkmILMemoryRead object instance.

[In] Number of bytes to read. [In] Flags controlling the behavior of DkmProcess.ReadMemory and DkmProcess.ReadMemoryString. [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

A request to read a null-terminated string from the target process. The address to read from is popped off the DkmIL stack and must have a size of 4 if the debuggee is 32-bit, or 8 if the debuggee is 64-bit. The bytes that are read from memory are pushed onto the stack. This will include the null-terminator if this value is read. The null-terminator will be missing when DkmReadMemoryFlags.AllowPartialRead is true, and either the MaxCharacters is hit, or unreadable memory is hit before the null terminator.

Flags controlling the behavior of DkmProcess.ReadMemory and DkmProcess.ReadMemoryString.

Number of bytes in each character. This should be set to 1 (ANSI/UTF-8), 2 (UTF-16) or 4 (UTF-32).

The maximum number of characters to read from the target process. When DkmReadMemoryFlags.AllowPartialRead is false, the request will fail if a null terminator isn't found within this range with DkmILFailureReason.StringTooLong.

Create a new DkmILMemoryStringRead object instance.

[In] Flags controlling the behavior of DkmProcess.ReadMemory and DkmProcess.ReadMemoryString. [In] Number of bytes in each character. This should be set to 1 (ANSI/UTF-8), 2 (UTF-16) or 4 (UTF-32). [In] The maximum number of characters to read from the target process. When DkmReadMemoryFlags.AllowPartialRead is false, the request will fail if a null terminator isn't found within this range with DkmILFailureReason.StringTooLong. [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

A request to write a sequence of bytes from memory. Pops a value off the stack. Then, pops an address of the stack. Writes the value popped off the stack to debuggee memory at the address popped off the stack.

Create a new DkmILMemoryWrite object instance.

[Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Pops two values off the evaluation stack, multiplies them, and pushes the product onto the evaluation stack. Both operands popped off the stack must be the size indicated by DkmPrimitiveObjectType. In the event of overflow, the result will be truncated.

The type of subtraction to perform (e.g. integer vs. floating-point).

Create a new DkmILMultiply object instance.

[In] The type of subtraction to perform (e.g. integer vs. floating-point). [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Placeholder instruction that does no operation.

Create a new DkmILNop object instance.

[Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

A value that can be passed in as a parameter to an IL stream.

The index of the local variable within the IL that will receive the parameter value. When the IL stream begins executing, the local variable at this index will be preset to the parameter value.

The bytes representing the value to pass in as the parameter.

If true, the inspection query to execute will receive a pseudo-address of the specified value, rather than the value itself. If false, the inspection query will directly receive the value as the specified parameter. For details on pseudo-addresses, see the DkmILPushLocalVariablePseudoAddress instruction. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

Create a new DkmILParameterValue object instance.

Create a new DkmILParameterValue object instance. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

[In] The index of the local variable within the IL that will receive the parameter value. When the IL stream begins executing, the local variable at this index will be preset to the parameter value. [In] The bytes representing the value to pass in as the parameter. [In] If true, the inspection query to execute will receive a pseudo-address of the specified value, rather than the value itself. If false, the inspection query will directly receive the value as the specified parameter. For details on pseudo-addresses, see the DkmILPushLocalVariablePseudoAddress instruction. [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Pop the value on top of the DkmIL stack.

Create a new DkmILPop object instance.

[Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Pushes a constant value onto the DkmIL stack.

The value to push onto the DkmIL stack.

Create a new DkmILPushConstant object instance.

[In] The value to push onto the DkmIL stack. [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Pushes a pseudo address on the stack representing the IL local variable and a byte offset within that variable. When popped from the stack as an address, instructions that would ordinarily read or write memory in the debuggee process will instead read or write bytes at the IL local variable and offset specified in the pseudo-address. It is permissible to push a pseudo-address onto the stack corresponding to a local variable that does not exist or has fewer bytes than the specified offset. However, when the times to actually read or write data at a pseudo-address, the backing local variable must exist and must have enough data to encompass the entire read or write operation. (Reads may be truncated at the end of the buffer if AllowPartialRead is specified). A pseudo-address may be used as the operand of an arithmetic operation in the following cases: - adding an integer a pseudo-address. (The integer will be added to the offset) - subtracting an integer from a pseudo-address. (The integer will be subtracted from the offset). - subtracting two pseudo-addresses from each other, backed by the same local variable. (The result is the difference in offsets). - comparing a pseudo address with NULL. (Any pseudo-address is considered greater than NULL. An operand is considered to be NULL if all bytes are zero.) - comparing two pseudo-addresses for equality. - comparing two pseudo-addresses for inequality, when backed by the same variable. (The offsets will be compared). Pseudo-addresses may also be used with DkmILDuplicateTop or saved in local variables via DkmILLoad and DkmILSave. It is illegal to read or write data at a pseudo-address, however, if the backing local variable contains another pseudo-address. Pseudo-addresses may be returned as an IL result via the DkmILReturnTop instruction. The resulting DkmILEvaluationResult can be identified as a pseudo-address via the IsPseudoAddress property. The result bytes of a pseudo-address will be set to either the contents of the backing local variable, from the specified offset until the end of the variable, or empty if the backing local variable does not exist, is another pseudo-address, or does not store enough bytes to contain data at the given offset. Pseudo-addresses may also be passed in as a parameter to a DkmCompiledILInspectionQuery by setting IsByRef to true on the DkmILParameterValue. It is illegal to use a pseudo-address in any IL instruction, except as described above. An attempt to use a pseudo-address in any other manner will result in an IL exception of type DkmILFailureReason::InvalidPseudoAddressOperation. For example, you cannot multiply or divide with pseudo-addresses or store them anywhere in the debuggee process. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

The index of the IL variable this pseudo-address should be backed by. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

The offset, within the backing local variable, that this pseudo-address refers to. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

Create a new DkmILPushLocalVariablePseudoAddress object instance. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

[In] The index of the IL variable this pseudo-address should be backed by. [In] The offset, within the backing local variable, that this pseudo-address refers to. [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Pushes a pseudo-address onto the stack representing a register and a byte offset within that register. The semantics of a register-pseudo address are the same as that of a pseudo address pushed via a DkmILPushLocalVariablePseudoAddress instruction, except that reads and writes involving a register pseudo-address will read or write the register, rather than an IL local variable. This API was introduced in Visual Studio 15 RTM (DkmApiVersion.VS15RTM).

The index of the IL variable this pseudo-address should be backed by. This API was introduced in Visual Studio 15 RTM (DkmApiVersion.VS15RTM).

The offset, within the backing local variable, that this pseudo-address refers to. This API was introduced in Visual Studio 15 RTM (DkmApiVersion.VS15RTM).

Create a new DkmILPushRegisterPseudoAddress object instance. This API was introduced in Visual Studio 15 RTM (DkmApiVersion.VS15RTM).

[In] The index of the IL variable this pseudo-address should be backed by. [In] The offset, within the backing local variable, that this pseudo-address refers to. [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

A request to read the value of a specific register. The result is pushed on the DkmIL stack.

The code-view definition of which register to read. Values are defined in cvconst.h. This is architecture dependent.

Create a new DkmILRegisterRead object instance.

[In] The code-view definition of which register to read. Values are defined in cvconst.h. This is architecture dependent. [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Pops a value off the IL stack. Then, writes the value to the given register of the given thread. The write will be visible to the debuggee from the top frame of that thread.

The code-view definition of which register to write. Values are defined in cvconst.h. This is architecture dependent.

Create a new DkmILRegisterWrite object instance.

[In] The code-view definition of which register to write. Values are defined in cvconst.h. This is architecture dependent. [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Pops two values off the evaluation stack and computes the second value popped off the stack modulo the first value popped off the stack.

The type of operands to consume (e.g. integer vs. floating-point).

Create a new DkmILRemainder object instance.

[In] The type of operands to consume (e.g. integer vs. floating-point). [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Pop the value on top of the DkmIL stack and return it as an instance of DkmILEvaluationResult.

Create a new DkmILReturnTop object instance.

[Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Saves the value at the top of the stack in a temporary slot at the given index, from which it can later be loaded back.

The index at which to save the value.

Create a new DkmILSave object instance.

[In] The index at which to save the value. [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Pops a value off the IL stack. Then pops an offset, followed by a blob of bytes. Modifies the first value so that the segment at the offset is replaced with the blob of bytes provided. Pushes the resultant value back onto the IL stack.

Create a new DkmILSetBytesRegion object instance.

[Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Pops two values off the evaluation stack, subtracts them, and pushes the difference onto the evaluation stack. Both operands popped off the stack must be the size indicated by DkmPrimitiveObjectType. The first value popped from the stack will be subtracted from the second value popped, so to evaluate "a - b", you would push a, then push b, then subtract. The resultant value will have the same size as the operands. In the event of overflow, the result will be truncated.

The type of subtraction to perform (e.g. integer vs. floating-point).

Create a new DkmILSubtract object instance.

[In] The type of subtraction to perform (e.g. integer vs. floating-point). [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Throws a native IL exception within the given failure code.

Create a new DkmILThrow object instance.

[In] Indicates a reason why an IL instruction failed to execute. In addition to these constants, negative values may be used to indicate customized error conditions resulting from the execution of intrinsic functions. [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Pushes an index of a TLS slot off the IL stack. Reads the value of that TLS slot for the thread of the current stack frame and pushes the result onto the IL stack. If the TLS index is not valid, the result is undefined. It may read a random value from memory, or fail. The value that is pushed on the stack is a pointer-sized value (4 bytes if the debuggee is 32-bit, 8 bytes if the debuggee is 64-bit).

Create a new DkmILTlsGetValue object instance.

[Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Indicates the underlying primitive type (ex: UInt32) being operated on.

Represents a signed 8-bit integer.

Represents an unsigned 8-bit integer.

Represents a signed 16-bit integer.

Represents an unsigned signed 16-bit integer.

Represents a signed 32-bit integer.

Represents an unsigned 32-bit integer.

Represents a signed 64-bit integer.

Represents an unsigned 64-bit integer.

Represents a 32-bit single-precision floating-point value.

Represents a 64-bit double-precision floating-point value.

Represents a 10-byte floating-point value.

The results for a set of threads that match a specific context.

Result of the evaluation on this set of threads.

An array of result data structures that indicate the source instruction and the data buffer for all threads.

Create a new DkmContextGroupEvaluationILResult object instance.

[In] Result of the evaluation on this set of threads. [In] An array of result data structures that indicate the source instruction and the data buffer for all threads. [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

The results for a set of threads that match a specific context. Derived classes: DkmFailedContextGroupEvaluationResult, DkmSuccessContextGroupEvaluationResult

DkmContextGroupEvaluationResult is an abstract base class. This enum indicates which derived class this object is an instance of.

Object is an instance of 'DkmSuccessContextGroupEvaluationResult'.

Object is an instance of 'DkmFailedContextGroupEvaluationResult'.

DkmContextGroupEvaluationResult is an abstract base class. This enum indicates which derived class this object is an instance of.

The thread IDs for the evaluation results.

Result of the evaluation on this set of threads.

The name of the expression this result applies to.

Guid which uniquely identifies this evaluation result.

The DkmRuntimeInstance class represents an execution environment which is loaded into a DkmProcess and which contains code to be debugged.

Closes the compute thread evaluation result object to release the resources associated with it. This method must be invoked by the component which initiated the enumeration (ex: called DkmInspectionContext.EvaluateExpression, DkmEvaluationResultEnumContext.GetItems, etc). DkmContextGroupEvaluationResult objects are automatically closed when their associated DkmRuntimeInstance object is closed.

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Result of an asynchronous DkmInspectionContext.EvaluateExpressionOnThreads call.

Creates a new result structure to hold the error from a failed call to DkmInspectionContext.EvaluateExpressionOnThreads.

[In] exception object containing the error

Object containing the results of the evaluation. This object must be closed by the caller when the caller is done with the object.

Creates a new result structure to hold the output from a successful call to DkmInspectionContext.EvaluateExpressionOnThreads.

[In] Object containing the results of the evaluation. This object must be closed by the caller when the caller is done with the object.

Marshal a native struct to managed

Pointer to native struct. Managed object.

Obtain a pointer to the native object used to call into native.

Outgoing managed->native call Native object

Validate the fields of this structure

Struct that holds the field path (ex: "myArgument.StructField")

Result of an asynchronous DkmCompiledILInspectionQuery.ExecuteQueryOnThreads call.

Creates a new result structure to hold the error from a failed call to DkmCompiledILInspectionQuery.ExecuteQueryOnThreads.

[In] exception object containing the error

HRESULT code returned from the caller. This will be DkmExceptionCode.COR_E_OPERATIONCANCELED (0x8013153B) if the operation was canceled before processing was complete.

Results of the evaluations.

Creates a new result structure to hold the output from a successful call to DkmCompiledILInspectionQuery.ExecuteQueryOnThreads.

[In] Results of the evaluations.

Marshal a native struct to managed

Pointer to native struct. Managed object.

Obtain a pointer to the native object used to call into native.

Outgoing managed->native call Native object

Validate the fields of this structure

Struct that holds the field path (ex: "myArgument.StructField")

The formatted result of a failed evaluation, ready to be displayed in an expression evaluation window.

Specifies the error message to display to the user.

Specifies the evaluation failed because it would cause side effects and side effects are not allowed.

Create a new DkmFailedContextGroupEvaluationResult object instance.

[In] The thread IDs for the evaluation results. [In] Result of the evaluation on this set of threads. [In] The name of the expression this result applies to. [In,Optional] The full name of the expression this result applies to. This value is used to allow child elements to be added to the watch window (Add Watch from the context menu), and to refresh parts of the evaluation tree. As an example of how FullName differs from name, the name of the 0th element of an array in C++ is '[0]' while the full name would by 'myArrayVariable[0]'. [In] The DkmRuntimeInstance class represents an execution environment which is loaded into a DkmProcess and which contains code to be debugged. [In] Specifies the error message to display to the user. [In] Specifies the evaluation failed because it would cause side effects and side effects are not allowed. [In,Optional] Data object to add to the new DkmFailedContextGroupEvaluationResult instance. Pass 'null' in the case that the caller doesn't need to add a data item. [Out] Result of this method call.

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

A collection of parameters that should be used together.

[Optional] The parameter collection.

Create a new DkmILParameterValueCollection object instance.

[In,Optional] The parameter collection. [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

The formatted result of a successful evaluation, ready to be displayed in an expression evaluation window.

Flags which indicate attributes of an expression evaluation result.

The formatted values for each thread.

[Optional] A string that describes the type of the value.

The category (ex: Data, Method, etc) of this evaluation result.

The access control level (public, private, etc) of the evaluation result.

The storage type (ex: static) of the evaluation result.

Type modifier flags (ex: const) of the evaluation result.

[Optional] A list of custom viewers for this object.

Create a new DkmSuccessContextGroupEvaluationResult object instance.

[In] The thread IDs for the evaluation results. [In] Result of the evaluation on this set of threads. [In] The name of the expression this result applies to. [In,Optional] The full name of the expression this result applies to. This value is used to allow child elements to be added to the watch window (Add Watch from the context menu), and to refresh parts of the evaluation tree. As an example of how FullName differs from name, the name of the 0th element of an array in C++ is '[0]' while the full name would by 'myArrayVariable[0]'. [In] The DkmRuntimeInstance class represents an execution environment which is loaded into a DkmProcess and which contains code to be debugged. [In] Flags which indicate attributes of an expression evaluation result. [In] The formatted values for each thread. [In,Optional] A string that describes the type of the value. [In] The category (ex: Data, Method, etc) of this evaluation result. [In] The access control level (public, private, etc) of the evaluation result. [In] The storage type (ex: static) of the evaluation result. [In] Type modifier flags (ex: const) of the evaluation result. [In,Optional] A list of custom viewers for this object. [In,Optional] Data object to add to the new DkmSuccessContextGroupEvaluationResult instance. Pass 'null' in the case that the caller doesn't need to add a data item. [Out] Result of this method call.

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

The set of results from a single thread.

The set of results from processing the query on the given thread.

If an expected error occurs evaluating the DkmIL, indicates the reason for the failure.

Create a new DkmThreadEvaluationResultCollection object instance.

[In] The set of results from processing the query on the given thread. [In] If an expected error occurs evaluating the DkmIL, indicates the reason for the failure. [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Contains basic symbol info about an instruction. This is primarily used to provide symbol information for native stack frames to any frame filter. This is used as a network/IPC optimization when symbols are loaded in a separate process by gathering the basic information in a single round trip. This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTMPreview).

LanguageId/VendorId for the compiler which produced the code for this symbol. If this is unknown (ex: RVA doesn't point to an instruction), both values will be Guid.Empty. This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTMPreview).

Name of method without arguments (DkmVariableInfoFlags::None). This will be set to an empty string if the instruction symbol isn't within the range of a function. This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTMPreview).

[Optional] Source code location for this instruction. This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTMPreview).

Number of inline frames at the given instruction symbol. This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTMPreview).

Create a new DkmBasicInstructionSymbolInfo object instance. This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTMPreview).

[In] LanguageId/VendorId for the compiler which produced the code for this symbol. If this is unknown (ex: RVA doesn't point to an instruction), both values will be Guid.Empty. [In] Name of method without arguments (DkmVariableInfoFlags::None). This will be set to an empty string if the instruction symbol isn't within the range of a function. [In,Optional] Source code location for this instruction. [In] Number of inline frames at the given instruction symbol. [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Flags passed to DkmInstructionSymbol.GetBasicInfo and GetInlineFramesCount. This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTMPreview).

No flags are set.

Decoded stack frame is the top frame in the call stack.

If set, DkmInstructionSymbol.GetBasicInfo should compute the count of inline frames.

DkmCodeViewCompilerId is used to translate information that is within the S_COMPILE* code view records into a DkmCompilerId. This allows the debugger to load an appropriate expression evaluator for a stack frame. Symbol providers may obtain this collection through DkmEngineSettings. Expression evaluators may add additional entries to this collection by having their setup add sub key(s) to the '%VSRegistryRoot%\Debugger\CodeView Compilers' registry key.

Language enumeration value which is in the code view record. For example, CV_CFL_CXX is used for C++.

Name string within the code view record. '*' may be used to match against any name string.

CompilerId (Vendor/Language Guid pair) to map the LanguageEnumeration/CompilerName to.

Initialize a new DkmCodeViewCompilerId value.

[In] Language enumeration value which is in the code view record. For example, CV_CFL_CXX is used for C++. [In] Name string within the code view record. '*' may be used to match against any name string. [In] CompilerId (Vendor/Language Guid pair) to map the LanguageEnumeration/CompilerName to.

Marshal a native struct to managed

Pointer to native struct. Managed object.

Obtain a pointer to the native object used to call into native.

Outgoing managed->native call Native object

Validate the fields of this structure

Struct that holds the field path (ex: "myArgument.StructField")

Indicates the compression algorithm used for a buffer of bytes. This can be used to determine which algorithm to use to decompress the bytes. This API was introduced in Visual Studio 15 Update 5 (DkmApiVersion.VS15Update5).

The bytes are not compressed.

The bytes were compressed using the DEFLATE algorithm.

The custom debug info is populated when a module loads and the debug monitor does not understand the content of the debug directory.

'Type' value from the IMAGE_DEBUG_DIRECTORY. For example, IMAGE_DEBUG_TYPE_CODEVIEW (2) is used for PDB files. See winnt.h for a complete listing.

Raw bytes from the PE file header.

Create a new DkmCustomSymbolFileId object instance.

[In] Unique identifier for symbol files/symbol providers. [In] 'Type' value from the IMAGE_DEBUG_DIRECTORY. For example, IMAGE_DEBUG_TYPE_CODEVIEW (2) is used for PDB files. See winnt.h for a complete listing. [In] Raw bytes from the PE file header. [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Indicates how strong of a match there was between the DkmDocumentQuery and the resulting DkmResolvedDocument.

Document matched on file name and extension, but not on any part of the path, or on checksum.

Document matched on file name and at least one level of directory name, but not the full path nor the checksum.

Document matched on full path but not on checksum.

Document matched on checksum value in addition to at least a filename match.

Input path represented a URL for a dynamic document and the resulting document exactly matched this query. This value is currently never returned from the Microsoft PDB symbol provider but is reserved for future use.

This is used for in-memory dynamic modules when doing managed debugging.

Create a new DkmDynamicSymbolFileId object instance.

[In] Unique identifier for symbol files/symbol providers. [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

DkmEmbeddedDocument represents a source file embedded in a symbol file. This API was introduced in Visual Studio 15 Update 5 (DkmApiVersion.VS15Update5).

The module that contains this Module. This API was introduced in Visual Studio 15 Update 5 (DkmApiVersion.VS15Update5).

The raw bytes of the Content contained in the symbol file. These bytes may need to be decompressed. This API was introduced in Visual Studio 15 Update 5 (DkmApiVersion.VS15Update5).

The compression algorithm used to compress the bytes contained in Content. This API was introduced in Visual Studio 15 Update 5 (DkmApiVersion.VS15Update5).

The length, in bytes, of the Content field when decompressed. Will be 0 if Content is not compressed or if the uncompressed size is not available. This API was introduced in Visual Studio 15 Update 5 (DkmApiVersion.VS15Update5).

Create a new DkmEmbeddedDocument object instance. This API was introduced in Visual Studio 15 Update 5 (DkmApiVersion.VS15Update5).

[In] The module that contains this Module. [In] The raw bytes of the Content contained in the symbol file. These bytes may need to be decompressed. [In] The compression algorithm used to compress the bytes contained in Content. [In] The length, in bytes, of the Content field when decompressed. Will be 0 if Content is not compressed or if the uncompressed size is not available. [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Contains information from the 'MPDB' section of the module's debug directory. This API was introduced in Visual Studio 15 RTM (DkmApiVersion.VS15RTM).

The offset of the Embedded Portable PDB Debug Directory Entry (Type 17) in the DkmModuleInstance it resides in, relative to the base address of the DkmModuleInstance. If The DkmModuleMemoryLayout of the DkmModule is MemoryPE or DiskPE, the Embedded PDB Entry can be read from process memory at this RVA. If the DkmModuleMemoryLayout of the DkmModule is Unknown and the DkmModuleFlag::FileResolved flag is set, the Embedded PDB entry can be read from the module file on disk at this address. This API was introduced in Visual Studio 15 RTM (DkmApiVersion.VS15RTM).

The size in bytes of the Embedded Portable PDB Debug Directory Entry. This API was introduced in Visual Studio 15 RTM (DkmApiVersion.VS15RTM).

Create a new DkmEmbeddedPdbFileId object instance. This API was introduced in Visual Studio 15 RTM (DkmApiVersion.VS15RTM).

[In] Unique identifier for symbol files/symbol providers. [In] The offset of the Embedded Portable PDB Debug Directory Entry (Type 17) in the DkmModuleInstance it resides in, relative to the base address of the DkmModuleInstance. If The DkmModuleMemoryLayout of the DkmModule is MemoryPE or DiskPE, the Embedded PDB Entry can be read from process memory at this RVA. If the DkmModuleMemoryLayout of the DkmModule is Unknown and the DkmModuleFlag::FileResolved flag is set, the Embedded PDB entry can be read from the module file on disk at this address. [In] The size in bytes of the Embedded Portable PDB Debug Directory Entry. [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Contains the symbol path collection and the cache path.

A collection of the paths to search for symbols.

The path of the symbol cache.

A collection of modules to include when manual symbol loading is enabled.

A collection of modules to exclude when automatic symbol loading is enabled.

True if manual symbol loading is enabled. False otherwise.

True if all symbols adjacent to the matching module or at the path specified in the binary should be loaded regardless of include/exclude status.

Create a new DkmEngineSymbolSettings object instance.

[In] A collection of the paths to search for symbols. [In] The path of the symbol cache. [In] A collection of modules to include when manual symbol loading is enabled. [In] A collection of modules to exclude when automatic symbol loading is enabled. [In] True if manual symbol loading is enabled. False otherwise. [In] True if all symbols adjacent to the matching module or at the path specified in the binary should be loaded regardless of include/exclude status. [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Result of an asynchronous DkmModule.FindDocuments call.

Creates a new result structure to hold the error from a failed call to DkmModule.FindDocuments.

[In] exception object containing the error

HRESULT code returned from the caller. This will be DkmExceptionCode.COR_E_OPERATIONCANCELED (0x8013153B) if the operation was canceled before processing was complete.

[Optional] A collection of the documents that matched the query.

Creates a new result structure to hold the output from a successful call to DkmModule.FindDocuments.

[In] A collection of the documents that matched the query.

Marshal a native struct to managed

Pointer to native struct. Managed object.

Obtain a pointer to the native object used to call into native.

Outgoing managed->native call Native object

Validate the fields of this structure

Struct that holds the field path (ex: "myArgument.StructField")

Result of an asynchronous DkmResolvedDocument.FindSymbols call.

Creates a new result structure to hold the error from a failed call to DkmResolvedDocument.FindSymbols.

[In] exception object containing the error

HRESULT code returned from the caller. This will be DkmExceptionCode.COR_E_OPERATIONCANCELED (0x8013153B) if the operation was canceled before processing was complete. E_TEXT_SPAN_NOT_LOADED indicates that TextSpan is not currently loaded in the specified script document. E_SCRIPT_SPAN_MAPPING_FAILED indicates that TextSpan could not be mapped to a location in the specified script document. E_SCRIPT_FILE_DIFFERENT_CONTENT indicates that the content in the script file loaded by the target process doesn't match the provided Text.

[Optional] The found instruction symbols which are within the specified text span.

[Optional] The source location of each returned instruction symbol. The length of this array should be the same of the returned instruction symbol array.

Creates a new result structure to hold the output from a successful call to DkmResolvedDocument.FindSymbols.

[In] The found instruction symbols which are within the specified text span. [In] The source location of each returned instruction symbol. The length of this array should be the same of the returned instruction symbol array.

Marshal a native struct to managed

Pointer to native struct. Managed object.

Obtain a pointer to the native object used to call into native.

Outgoing managed->native call Native object

Validate the fields of this structure

Struct that holds the field path (ex: "myArgument.StructField")

Result of an asynchronous DkmInstructionSymbol.GetBasicInfo call.

Creates a new result structure to hold the error from a failed call to DkmInstructionSymbol.GetBasicInfo.

[In] exception object containing the error

HRESULT code returned from the caller. This will be DkmExceptionCode.COR_E_OPERATIONCANCELED (0x8013153B) if the operation was canceled before processing was complete.

Created DkmBasicInstructionSymbolInfo object which contains the requested information. This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTMPreview).

Creates a new result structure to hold the output from a successful call to DkmInstructionSymbol.GetBasicInfo.

[In] Created DkmBasicInstructionSymbolInfo object which contains the requested information.

Marshal a native struct to managed

Pointer to native struct. Managed object.

Obtain a pointer to the native object used to call into native.

Outgoing managed->native call Native object

Validate the fields of this structure

Struct that holds the field path (ex: "myArgument.StructField")

Result of an asynchronous DkmInstructionSymbol.GetCompilerId call.

Creates a new result structure to hold the error from a failed call to DkmInstructionSymbol.GetCompilerId.

[In] exception object containing the error

HRESULT code returned from the caller. This will be DkmExceptionCode.COR_E_OPERATIONCANCELED (0x8013153B) if the operation was canceled before processing was complete.

LanguageId/VendorId for the compiler which produced the code for this symbol. If this is unknown (ex: no symbols info for this block), both values will be Guid.Empty. Otherwise, both values should be non-zero. This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTMPreview).

Creates a new result structure to hold the output from a successful call to DkmInstructionSymbol.GetCompilerId.

[In] LanguageId/VendorId for the compiler which produced the code for this symbol. If this is unknown (ex: no symbols info for this block), both values will be Guid.Empty. Otherwise, both values should be non-zero.

Result of an asynchronous DkmModule.GetFunctionInfo call.

Creates a new result structure to hold the error from a failed call to DkmModule.GetFunctionInfo.

[In] exception object containing the error

HRESULT code returned from the caller. This will be DkmExceptionCode.COR_E_OPERATIONCANCELED (0x8013153B) if the operation was canceled before processing was complete.

The RVA / size pairs from the query.

Creates a new result structure to hold the output from a successful call to DkmModule.GetFunctionInfo.

[In] The RVA / size pairs from the query.

Marshal a native struct to managed

Pointer to native struct. Managed object.

Obtain a pointer to the native object used to call into native.

Outgoing managed->native call Native object

Validate the fields of this structure

Struct that holds the field path (ex: "myArgument.StructField")

Result of an asynchronous DkmInstructionSymbol.GetInlineFramesCount call.

Creates a new result structure to hold the error from a failed call to DkmInstructionSymbol.GetInlineFramesCount.

[In] exception object containing the error

HRESULT code returned from the caller. This will be DkmExceptionCode.COR_E_OPERATIONCANCELED (0x8013153B) if the operation was canceled before processing was complete.

The number of inline frames at the given RVA and frame. This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTMPreview).

Creates a new result structure to hold the output from a successful call to DkmInstructionSymbol.GetInlineFramesCount.

[In] The number of inline frames at the given RVA and frame.

Result of an asynchronous DkmInstructionSymbol.GetInlineSourcePosition call.

Creates a new result structure to hold the error from a failed call to DkmInstructionSymbol.GetInlineSourcePosition.

[In] exception object containing the error

HRESULT code returned from the caller. This will be DkmExceptionCode.COR_E_OPERATIONCANCELED (0x8013153B) if the operation was canceled before processing was complete.

True if this address is the first address in the line's range. False otherwise. This API was introduced in Visual Studio 15 RTM (DkmApiVersion.VS15RTM).

[Optional] Source code position which corresponds to a code element. The could represent a location which has been extracted from a symbol (PDB) file, or it could be the location of a breakpoint in the IDE. This API was introduced in Visual Studio 15 RTM (DkmApiVersion.VS15RTM).

Creates a new result structure to hold the output from a successful call to DkmInstructionSymbol.GetInlineSourcePosition.

[In] True if this address is the first address in the line's range. False otherwise. [In,Optional] Source code position which corresponds to a code element. The could represent a location which has been extracted from a symbol (PDB) file, or it could be the location of a breakpoint in the IDE.

Marshal a native struct to managed

Pointer to native struct. Managed object.

Obtain a pointer to the native object used to call into native.

Outgoing managed->native call Native object

Validate the fields of this structure

Struct that holds the field path (ex: "myArgument.StructField")

Result of an asynchronous DkmModule.GetMethodSymbolStoreData call.

Creates a new result structure to hold the error from a failed call to DkmModule.GetMethodSymbolStoreData.

[In] exception object containing the error

HRESULT code returned from the caller. This will be DkmExceptionCode.COR_E_OPERATIONCANCELED (0x8013153B) if the operation was canceled before processing was complete.

DkmClrMethodScopeData[] describes a scope within a method. These are defined using ISymUnmanagedWriter::OpenScope/CloseScope.

Creates a new result structure to hold the output from a successful call to DkmModule.GetMethodSymbolStoreData.

[In] DkmClrMethodScopeData[] describes a scope within a method. These are defined using ISymUnmanagedWriter::OpenScope/CloseScope.

Marshal a native struct to managed

Pointer to native struct. Managed object.

Obtain a pointer to the native object used to call into native.

Outgoing managed->native call Native object

Validate the fields of this structure

Struct that holds the field path (ex: "myArgument.StructField")

Result of an asynchronous DkmModule.GetMethodSymbolStoreDataPreRemap call.

Creates a new result structure to hold the error from a failed call to DkmModule.GetMethodSymbolStoreDataPreRemap.

[In] exception object containing the error

HRESULT code returned from the caller. This will be DkmExceptionCode.COR_E_OPERATIONCANCELED (0x8013153B) if the operation was canceled before processing was complete.

Method token after the Remap.

DkmClrMethodScopeData[] describes a scope within a method. These are defined using ISymUnmanagedWriter::OpenScope/CloseScope.

Creates a new result structure to hold the output from a successful call to DkmModule.GetMethodSymbolStoreDataPreRemap.

[In] Method token after the Remap. [In] DkmClrMethodScopeData[] describes a scope within a method. These are defined using ISymUnmanagedWriter::OpenScope/CloseScope.

Marshal a native struct to managed

Pointer to native struct. Managed object.

Obtain a pointer to the native object used to call into native.

Outgoing managed->native call Native object

Validate the fields of this structure

Struct that holds the field path (ex: "myArgument.StructField")

Result of an asynchronous DkmModule.GetPublicSymbolByNameCallback call.

Creates a new result structure to hold the error from a failed call to DkmModule.GetPublicSymbolByNameCallback.

[In] exception object containing the error

HRESULT code returned from the caller. This will be DkmExceptionCode.COR_E_OPERATIONCANCELED (0x8013153B) if the operation was canceled before processing was complete.

[Optional] The native instruction symbol for this public symbol.

Creates a new result structure to hold the output from a successful call to DkmModule.GetPublicSymbolByNameCallback.

[In,Optional] The native instruction symbol for this public symbol.

Marshal a native struct to managed

Pointer to native struct. Managed object.

Obtain a pointer to the native object used to call into native.

Outgoing managed->native call Native object

Validate the fields of this structure

Struct that holds the field path (ex: "myArgument.StructField")

Result of an asynchronous DkmModule.GetRegisterRelativeSymbolName call.

Creates a new result structure to hold the error from a failed call to DkmModule.GetRegisterRelativeSymbolName.

[In] exception object containing the error

HRESULT code returned from the caller. This will be DkmExceptionCode.COR_E_OPERATIONCANCELED (0x8013153B) if the operation was canceled before processing was complete.

[Optional] The symbol name for use in formatting. This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTM).

Creates a new result structure to hold the output from a successful call to DkmModule.GetRegisterRelativeSymbolName.

[In,Optional] The symbol name for use in formatting.

Marshal a native struct to managed

Pointer to native struct. Managed object.

Obtain a pointer to the native object used to call into native.

Outgoing managed->native call Native object

Validate the fields of this structure

Struct that holds the field path (ex: "myArgument.StructField")

Result of an asynchronous DkmInstructionSymbol.GetSourcePosition call.

Creates a new result structure to hold the error from a failed call to DkmInstructionSymbol.GetSourcePosition.

[In] exception object containing the error

HRESULT code returned from the caller. This will be DkmExceptionCode.COR_E_OPERATIONCANCELED (0x8013153B) if the operation was canceled before processing was complete.

True if this address is the first address in the line's range. False otherwise.

Creates a new result structure to hold the output from a successful call to DkmInstructionSymbol.GetSourcePosition.

Marshal a native struct to managed

Pointer to native struct. Managed object.

Obtain a pointer to the native object used to call into native.

Outgoing managed->native call Native object

Validate the fields of this structure

Struct that holds the field path (ex: "myArgument.StructField")

Result of an asynchronous DkmInstructionSymbol.GetSourcePositionCallback call.

Creates a new result structure to hold the error from a failed call to DkmInstructionSymbol.GetSourcePositionCallback.

[In] exception object containing the error

HRESULT code returned from the caller. This will be DkmExceptionCode.COR_E_OPERATIONCANCELED (0x8013153B) if the operation was canceled before processing was complete.

True if this address is the first address in the line's range. False otherwise.

Creates a new result structure to hold the output from a successful call to DkmInstructionSymbol.GetSourcePositionCallback.

Marshal a native struct to managed

Pointer to native struct. Managed object.

Obtain a pointer to the native object used to call into native.

Outgoing managed->native call Native object

Validate the fields of this structure

Struct that holds the field path (ex: "myArgument.StructField")

Result of an asynchronous DkmModule.GetSymbolNameForRVA call.

Creates a new result structure to hold the error from a failed call to DkmModule.GetSymbolNameForRVA.

[In] exception object containing the error

HRESULT code returned from the caller. This will be DkmExceptionCode.COR_E_OPERATIONCANCELED (0x8013153B) if the operation was canceled before processing was complete.

The symbol name for use in formatting. This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTM).

The symbol displacement. This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTM).

Creates a new result structure to hold the output from a successful call to DkmModule.GetSymbolNameForRVA.

[In] The symbol name for use in formatting. [In] The symbol displacement.

Marshal a native struct to managed

Pointer to native struct. Managed object.

Obtain a pointer to the native object used to call into native.

Outgoing managed->native call Native object

Validate the fields of this structure

Struct that holds the field path (ex: "myArgument.StructField")

Result of an asynchronous DkmModule.GetTokenSymbolStoreAttribute call.

Creates a new result structure to hold the error from a failed call to DkmModule.GetTokenSymbolStoreAttribute.

[In] exception object containing the error

HRESULT code returned from the caller. This will be DkmExceptionCode.COR_E_OPERATIONCANCELED (0x8013153B) if the operation was canceled before processing was complete.

The value of the requested symbol store attribute. This will be an empty array if the specified attribute name cannot be found.

Creates a new result structure to hold the output from a successful call to DkmModule.GetTokenSymbolStoreAttribute.

[In] The value of the requested symbol store attribute. This will be an empty array if the specified attribute name cannot be found.

Marshal a native struct to managed

Pointer to native struct. Managed object.

Obtain a pointer to the native object used to call into native.

Outgoing managed->native call Native object

Validate the fields of this structure

Struct that holds the field path (ex: "myArgument.StructField")

Result of an asynchronous DkmInstructionSymbol.GetUserCodeSourcePositionCallback call.

Creates a new result structure to hold the error from a failed call to DkmInstructionSymbol.GetUserCodeSourcePositionCallback.

[In] exception object containing the error

HRESULT code returned from the caller. This will be DkmExceptionCode.COR_E_OPERATIONCANCELED (0x8013153B) if the operation was canceled before processing was complete.

Creates a new result structure to hold the output from a successful call to DkmInstructionSymbol.GetUserCodeSourcePositionCallback.

[In,Optional] Source code position which corresponds to a code element. The could represent a location which has been extracted from a symbol (PDB) file, or it could be the location of a breakpoint in the IDE.

Marshal a native struct to managed

Pointer to native struct. Managed object.

Obtain a pointer to the native object used to call into native.

Outgoing managed->native call Native object

Validate the fields of this structure

Struct that holds the field path (ex: "myArgument.StructField")

Result of an asynchronous DkmInstructionSymbol.HasLineInfo call.

Creates a new result structure to hold the error from a failed call to DkmInstructionSymbol.HasLineInfo.

[In] exception object containing the error

HRESULT code returned from the caller. This will be DkmExceptionCode.COR_E_OPERATIONCANCELED (0x8013153B) if the operation was canceled before processing was complete.

True if there is line info for this location.

Creates a new result structure to hold the output from a successful call to DkmInstructionSymbol.HasLineInfo.

[In] True if there is line info for this location.

Identifier of a hash algorithm used to calculate a hash. This API was introduced in Visual Studio 15 RTM (DkmApiVersion.VS15RTM).

MD5 Hash Algorithm. MD5 Hash Values are 16 bytes long.

SHA1 Hash Algorithm. SHA1 Hash Values are 20 bytes long.

SHA256 Hash Algorithm, implemented by SHA-2 (256-bit internal state). SHA256 Hash Values are 32 bytes long.

SHA512 Hash Algorithm, implemented by SHA-2 (512-bit internal state). SHA512 Hash Values are 64 bytes long.

Value of a calculated cryptographic hash, possibly representing a checksum. This API was introduced in Visual Studio 15 Update 9 (DkmApiVersion.VS15Update9).

The name of the cryptographic hashing algorithm used to calculate this hash, e.g. "SHA1". This API was introduced in Visual Studio 15 Update 9 (DkmApiVersion.VS15Update9).

The bytes of the hash value. This API was introduced in Visual Studio 15 Update 9 (DkmApiVersion.VS15Update9).

Create a new DkmHashValue object instance. This API was introduced in Visual Studio 15 Update 9 (DkmApiVersion.VS15Update9).

[In] The name of the cryptographic hashing algorithm used to calculate this hash, e.g. "SHA1". [In] The bytes of the hash value. [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Windows dlls/exes contain a section for debugging information. Inside this section there are zero or more IMAGE_DEBUG_DIRECTORY structures, and inside each of these structures there is a 32-bit 'Type' field which indicates the format of the information within the debug directory. DkmImageDebugDirectoryFormat is used to map from this 'Type' value to the symbol provider which is used to handle this type of debugging information. The debugger initializes a collection of DkmImageDebugDirectoryFormat structs on startup by reading the '%VSRegistryRoot%\Debugger\Image Debug Directory Formats' registry keys.

'Type' value from the IMAGE_DEBUG_DIRECTORY. For example, IMAGE_DEBUG_TYPE_CODEVIEW (2) is used for PDB files. See winnt.h for a complete listing.

Symbol provider id to use for this.

Initialize a new DkmImageDebugDirectoryFormat value.

[In] 'Type' value from the IMAGE_DEBUG_DIRECTORY. For example, IMAGE_DEBUG_TYPE_CODEVIEW (2) is used for PDB files. See winnt.h for a complete listing. [In] Symbol provider id to use for this.

DkmInstructionSymbol represents a method in the target process. Derived classes: DkmClrInstructionSymbol, DkmClrNcInstructionSymbol, DkmCustomInstructionSymbol, DkmNativeInstructionSymbol, DkmScriptInstructionSymbol

DkmInstructionSymbol is an abstract base class. This enum indicates which derived class this object is an instance of.

Object is an instance of 'DkmNativeInstructionSymbol'.

Object is an instance of 'DkmClrInstructionSymbol'.

Object is an instance of 'DkmScriptInstructionSymbol'.

Object is an instance of 'DkmCustomInstructionSymbol'.

DkmInstructionSymbol is an abstract base class. This enum indicates which derived class this object is an instance of.

The DkmModule class represents a code bundle (ex: dll or exe) which is or once was loaded into one or more processes. The DkmModule class is the central object to the symbol APIs, and is 1:1 with the symbol handler's notation of what is loaded. If a code bundle loads into three different processes (or the same process but with three different base addresses or three different app domains) but the symbol handler thinks of all of these as being identical, there will be only one module object.

Binds an instruction symbol to a particular module instance. An instruction symbol is connected to a DkmModule rather than a DkmModuleInstance, so it is not bound to a particular process, app domain, or module base address.

This method returns address information to the GPU debug monitor.

[In,Optional] Abstract representation of an executable code location (ex: EIP value). If resolved, an Instruction Address will be within a particular module instance. An Instruction Address is always within a particular Runtime Instance. [In] The next instruction address which is used to determine inline function call. [Out,Optional] The address type information.

[Out] Array of no source ranges to always step through. This array will be empty if there are no no-source ranges for the given instruction.

Returns the source file position (ex: example.cs, line 12) of this instruction symbol. If this instruction symbol is not associated with a source file or not in user code then null is returned (E_INSTRUCTION_NO_SOURCE return code). Location constraint: API must be called from a Monitor component (component level < 100,000).

[In,Optional] A reference object describing the current inspection session. Common usage is for symbol providers to cache lookups using its data container. [Out,Optional] Source code position which corresponds to a code element. The could represent a location which has been extracted from a symbol (PDB) file, or it could be the location of a breakpoint in the IDE.

Returns the source file position (ex: example.cs, line 12) of this instruction symbol. If this instruction symbol is not associated with a source file or not in user code then null is returned (E_INSTRUCTION_NO_SOURCE return code). This method will append a new work item to the specified work list, and return once the work item has been appended. The actual processing of the work item is asynchronous. The caller will be notified that the request is complete through the completion routine. Location constraint: API must be called from a Monitor component (component level < 100,000).

WorkList to append the new work item to. [In,Optional] A reference object describing the current inspection session. Common usage is for symbol providers to cache lookups using its data container. Routine to fire when the request is complete. If the request is successfully appended to the work list, this will always fire (including when the operation is canceled). This will never fire if appending the work item fails.

Return the name of the symbol as it should appear in the disassembly window. For Microsoft C++ code, this is based on the public symbol name. Location constraint: API must be called from an IDE component (component level > 100,000).

[In,Optional] A reference object describing the current inspection session. Common usage is for symbol providers to cache lookups using its data container. [Out,Optional] The label to use for this instruction.

Returns the compiler id (LanguageId/VendorId) of a given symbol. For the Microsoft PDB reader, if the PDB was created by a compiler which used ISymUnmanagedWriter, then the PDB reader will be able to determine the correct DkmCompilerId from the LanguageId/VendorId pair passed from ISymUnmanagedWriter.DefineDocument. If the PDB was created by a compiler which did not use ISymUnmanagedWriter, the PDB reader may be able to obtain the DkmCompilerId from the S_COMPILE* PDB records. For this to work, the compiler must first emit the S_COMPILE* record for each compiland. The compiler needs to be sure to correctly fill out the language enumeration value, and the compiler string. The compiler should ensure that the compiler string is sufficiently specific to use for selecting an expression evaluator; it is recommended to include a company name. After emitting the Enum/Name pair, the setup for the expression evaluator should then register this pair with the debugger. To do so, the expression evaluator should set this registry key: %VSRegistryRoot%\Debugger\CodeView Compilers\%CodeViewLanguageCode%:%CompilerName% and define the VendorId/LanguageId.

[In,Optional] A reference object describing the current inspection session. Common usage is for symbol providers to cache lookups using its data container. [Out] LanguageId/VendorId for the compiler which produced the code for this symbol. If this is unknown (ex: no symbols info for this block), both values will be Guid.Empty. Otherwise, both values should be non-zero.

Returns if this instruction symbol is in hidden code. For instance, in managed code, the line number 0xfeefee marks a source line as hidden. This method will append a new work item to the specified work list, and return once the work item has been appended. The actual processing of the work item is asynchronous. The caller will be notified that the request is complete through the completion routine. Location constraint: API must be called from an IDE component (component level > 100,000).

WorkList to append the new work item to. [In] DkmInspectionSession allows the various components which inspect data to store private data which is associated with a group of evaluations. [In] Abstract representation of an executable code location (ex: EIP value). If resolved, an Instruction Address will be within a particular module instance. An Instruction Address is always within a particular Runtime Instance. Routine to fire when the request is complete. If the request is successfully appended to the work list, this will always fire (including when the operation is canceled). This will never fire if appending the work item fails.

Queries the symbol provider to determine the ranges of instructions which the base debug monitor should step through to implement a step. Location constraint: API must be called from a Monitor component (component level < 100,000).

[In] Indicates to the symbol provider the type of instructions to include in the 'no-step' regions. [In] True if the symbol provider should stop the stepping range when it encounters an inline functions. False otherwise. The Native DM will pass true for a step in so steps will stop in inline functions. It will pass false when doing a step-over so the stepper will not stop in inline functions. [Out] Array of ranges to step through. This array will be empty if there is no source information for the given instruction.

Queries the symbol provider to determine if we have line info. Used by debug monitor to decide if location can be considered user code. Location constraint: For ordinary symbols, can be called from any component. For dynamic symbols, can only be called on the server side.

[Out] True if there is line info for this location.

Queries the symbol provider to determine if we have line info. Used by debug monitor to decide if location can be considered user code. This method will append a new work item to the specified work list, and return once the work item has been appended. The actual processing of the work item is asynchronous. The caller will be notified that the request is complete through the completion routine. Location constraint: For ordinary symbols, can be called from any component. For dynamic symbols, can only be called on the server side.

This method returns the IL offset range that contains the current IL offset as specified in the instruction address. Location constraint: API must be called from a Monitor component (component level < 100,000).

[Out] A offset/size pair which is returned from the symbol provider to a debug monitor to indicate a range of instructions which the debugger should not stop at.

[In] Flags which affect the behavior of 'GetSourcePosition'. [In,Optional] A reference object describing the current inspection session. Common usage is for symbol providers to cache lookups using its data container. [Out] True if this address is the first address in the line's range. False otherwise. [Out,Optional] Source code position which corresponds to a code element. The could represent a location which has been extracted from a symbol (PDB) file, or it could be the location of a breakpoint in the IDE.

Returns the source file position (ex: example.cs, line 12) of this instruction symbol. If this instruction symbol is not associated with a source file then null is returned (S_FALSE return code in native). This method will append a new work item to the specified work list, and return once the work item has been appended. The actual processing of the work item is asynchronous. The caller will be notified that the request is complete through the completion routine. Location constraint: API must be called from an IDE component (component level > 100,000).

WorkList to append the new work item to. [In] Flags which affect the behavior of 'GetSourcePosition'. [In,Optional] A reference object describing the current inspection session. Common usage is for symbol providers to cache lookups using its data container. Routine to fire when the request is complete. If the request is successfully appended to the work list, this will always fire (including when the operation is canceled). This will never fire if appending the work item fails.

Returns an alternate source file position (ex: example.cs, line 12) for this instruction symbol. This is currently used in source map scenarios to return the original (unmapped) source location. This API will be called by the debugger UI in cases where the primary source location cannot be found. Location constraint: API must be called from an IDE component (component level > 100,000). This API was introduced in Visual Studio 12 Update 3 (DkmApiVersion.VS12Update3).

[In] Flags which affect the behavior of 'GetSourcePosition'. [Out] Associated source location for the instruction. Symbol provider doesn't support mapping this specified instruction to an alternate location.

Returns the source file position (ex: example.cs, line 12) of this instruction symbol at the specified inline frame number. If this instruction symbol is not associated with a source file then null is returned (S_FALSE return code in native). Location constraint: API must be called from an IDE component (component level > 100,000). This API was introduced in Visual Studio 15 RTM (DkmApiVersion.VS15RTM).

[In] Provides which inline frame to use. [Out] True if this address is the first address in the line's range. False otherwise. [Out,Optional] Source code position which corresponds to a code element. The could represent a location which has been extracted from a symbol (PDB) file, or it could be the location of a breakpoint in the IDE.

Returns the source file position (ex: example.cs, line 12) of this instruction symbol at the specified inline frame number. If this instruction symbol is not associated with a source file then null is returned (S_FALSE return code in native). This method will append a new work item to the specified work list, and return once the work item has been appended. The actual processing of the work item is asynchronous. The caller will be notified that the request is complete through the completion routine. Location constraint: API must be called from an IDE component (component level > 100,000). This API was introduced in Visual Studio 15 RTM (DkmApiVersion.VS15RTM).

WorkList to append the new work item to. [In] Provides which inline frame to use. Routine to fire when the request is complete. If the request is successfully appended to the work list, this will always fire (including when the operation is canceled). This will never fire if appending the work item fails.

Returns the embedded document containing this symbol. Returns S_FALSE if the embedded document does not exist. Location constraint: API must be called from an IDE component (component level > 100,000). This API was introduced in Visual Studio 15 Update 5 (DkmApiVersion.VS15Update5).

[Out,Optional] DkmEmbeddedDocument represents a source file embedded in a symbol file.

Tests if the given symbol has an embedded document. Embedded documents are when a source file (ex: main.cs) is embedded inside the symbol file (ex: example.pdb). Location constraint: API must be called from an IDE component (component level > 100,000). This API was introduced in Visual Studio 15 Update 8 (DkmApiVersion.VS15Update8).

[Out] True if the instruction symbol is in an embedded document.

Returns the number of inline frames at the given instruction symbol. Location constraint: API must be called from an IDE component (component level > 100,000). This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTMPreview).

[In] Flags passed to DkmInstructionSymbol.GetBasicInfo and GetInlineFramesCount. [Out] The number of inline frames at the given RVA and frame.

Returns the number of inline frames at the given instruction symbol. This method will append a new work item to the specified work list, and return once the work item has been appended. The actual processing of the work item is asynchronous. The caller will be notified that the request is complete through the completion routine. Location constraint: API must be called from an IDE component (component level > 100,000). This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTMPreview).

WorkList to append the new work item to. [In] Flags passed to DkmInstructionSymbol.GetBasicInfo and GetInlineFramesCount. Routine to fire when the request is complete. If the request is successfully appended to the work list, this will always fire (including when the operation is canceled). This will never fire if appending the work item fails.

Asynchronously computes basic symbol information for a given DkmInstructionSymbol. This method will append a new work item to the specified work list, and return once the work item has been appended. The actual processing of the work item is asynchronous. The caller will be notified that the request is complete through the completion routine. Location constraint: API must be called from an IDE component (component level > 100,000). This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTMPreview).

WorkList to append the new work item to. [In] Module containing the specified instruction symbol. [In] Flags passed to DkmInstructionSymbol.GetBasicInfo and GetInlineFramesCount. Routine to fire when the request is complete. If the request is successfully appended to the work list, this will always fire (including when the operation is canceled). This will never fire if appending the work item fails.

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Result of an asynchronous DkmInstructionSymbol.IsHiddenCode call.

Creates a new result structure to hold the error from a failed call to DkmInstructionSymbol.IsHiddenCode.

[In] exception object containing the error

HRESULT code returned from the caller. This will be DkmExceptionCode.COR_E_OPERATIONCANCELED (0x8013153B) if the operation was canceled before processing was complete.

Flags for DebuggerStepThrough DebuggerHidden, and/or DebuggerNonUserCode attributes set on method or class or marked hidden due to the 0xfeefee sequence point.

[Optional] The symbol for the next non-hidden source line. This is null if the current line is not hidden.

Creates a new result structure to hold the output from a successful call to DkmInstructionSymbol.IsHiddenCode.

[In] Flags for DebuggerStepThrough DebuggerHidden, and/or DebuggerNonUserCode attributes set on method or class or marked hidden due to the 0xfeefee sequence point. [In,Optional] The symbol for the next non-hidden source line. This is null if the current line is not hidden.

Marshal a native struct to managed

Pointer to native struct. Managed object.

Obtain a pointer to the native object used to call into native.

Outgoing managed->native call Native object

Validate the fields of this structure

Struct that holds the field path (ex: "myArgument.StructField")

Result of an asynchronous DkmInstructionAddress.IsUserCode call.

Creates a new result structure to hold the error from a failed call to DkmInstructionAddress.IsUserCode.

[In] exception object containing the error

HRESULT code returned from the caller. This will be DkmExceptionCode.COR_E_OPERATIONCANCELED (0x8013153B) if the operation was canceled before processing was complete.

True if the provided instruction address is user code. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

Creates a new result structure to hold the output from a successful call to DkmInstructionAddress.IsUserCode.

[In] True if the provided instruction address is user code.

Value of a calculated MD5 hash. MD5 hashes are used for the document checksum feature, which is a non-security purpose. MD5 should no longer be used for any security related purpose.

Compare two elements of the DkmMD5HashValue structure.

Value to comare against this instance. 'true' if the two elements are equal.

Compare two elements of the DkmMD5HashValue sructure.

Left side of the comparison Right side of the comparison

Compare two elements of the DkmMD5HashValue sructure.

Left side of the comparison Right side of the comparison

Compare two elements of the DkmMD5HashValue sructure.

Left side of the comparison Right side of the comparison

Compare two elements of the DkmMD5HashValue sructure.

Left side of the comparison Right side of the comparison

Compare two elements of the DkmMD5HashValue sructure.

Left side of the comparison Right side of the comparison

Compare two elements of the DkmMD5HashValue sructure.

Left side of the comparison Right side of the comparison

First 32-bits of the calculated hash.

Second 32-bits of the calculated hash.

Third 32-bits of the calculated hash.

Forth 32-bits of the calculated hash.

Initialize a new DkmMD5HashValue value.

[In] First 32-bits of the calculated hash. [In] Second 32-bits of the calculated hash. [In] Third 32-bits of the calculated hash. [In] Forth 32-bits of the calculated hash.

Guid pair used to uniquely identify a particular DkmModule instance.

Name of the module.

LanguageId/VendorId for the compiler which produced all of the code in this module. This is Guid.Empty/Guid.Empty if the module may contain a mixture of languages. This will almost always be Guid.Empty/Guid.Empty for PDB-based modules. It generally used by dynamic languages to avoid network round trips to discover the language of each symbol.

[Optional] For modules where symbols are loaded remotely, the connection property is used to determine where the Connection originated from. Otherwise this will be NULL.

[Optional] If non-null, this specifies a connection to a worker process where symbols for this DkmModule are processed. This will be null if symbols are loaded in the IDE process, or if they are loaded in the remote debugger (DkmModule.Connection is non-null). This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTMPreview).

[Optional] If specified, this contains the full path to the symbol file which backs the DkmModule (ex: c:\\myproj\\bin\\Debug\\myproj.pdb). This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTMPreview).

Find a DkmModule object. If no object with the given input key is present, FindModule will fail.

[In] Search key used to find the element. [Out,Optional] Result of the search.

GetModules enumerates all the created DkmModule objects.

[Out] Array containing the enumerated elements.

Creates a new DkmModule object, which represents the symbols for one or more loaded modules (module instances). These objects are created by symbol providers. After the DkmModule object is created, symbol providers should call DkmModuleInstance.SetModule to associate the DkmModuleInstance and DkmModule together. This method will send a ModuleCreate event.

[In] Guid pair used to uniquely identify a particular DkmModule instance. [In] Name of the module. [In] LanguageId/VendorId for the compiler which produced all of the code in this module. This is Guid.Empty/Guid.Empty if the module may contain a mixture of languages. This will almost always be Guid.Empty/Guid.Empty for PDB-based modules. It generally used by dynamic languages to avoid network round trips to discover the language of each symbol. [In,Optional] For modules where symbols are loaded remotely, the connection property is used to determine where the Connection originated from. Otherwise this will be NULL. [In,Optional] If non-null, this specifies a connection to a worker process where symbols for this DkmModule are processed. This will be null if symbols are loaded in the IDE process, or if they are loaded in the remote debugger (DkmModule.Connection is non-null). [In,Optional] If specified, this contains the full path to the symbol file which backs the DkmModule (ex: c:\\myproj\\bin\\Debug\\myproj.pdb). [In,Optional] Data object to add to the new DkmModule instance. Pass 'null' in the case that the caller doesn't need to add a data item. [Out] Result of this method call.

GetScriptDocuments enumerates the DkmScriptDocument elements of this DkmModule object.

[Out] Array containing the enumerated elements.

Returns the scopes within a method. There will always be at least one scope.

[In] DkmClrMethodId is a token/version pair which is used to uniquely identify the symbol store's understanding of a particular CLR method within a module. [Out] DkmClrMethodScopeData[] describes a scope within a method. These are defined using ISymUnmanagedWriter::OpenScope/CloseScope.

WorkList to append the new work item to. [In] DkmClrMethodId is a token/version pair which is used to uniquely identify the symbol store's understanding of a particular CLR method within a module. Routine to fire when the request is complete. If the request is successfully appended to the work list, this will always fire (including when the operation is canceled). This will never fire if appending the work item fails.

Returns the first method in the first document.

[Out] DkmClrMethodId is a token/version pair which is used to uniquely identify the symbol store's understanding of a particular CLR method within a module.

Returns the scopes within a method. There will always be at least one scope.

[In] Method Id PreRemap. [Out] Method token after the Remap. [Out] DkmClrMethodScopeData[] describes a scope within a method. These are defined using ISymUnmanagedWriter::OpenScope/CloseScope.

WorkList to append the new work item to. [In] Method Id PreRemap. Routine to fire when the request is complete. If the request is successfully appended to the work list, this will always fire (including when the operation is canceled). This will never fire if appending the work item fails.

Gets a custom attribute based upon its name. Not to be confused with Metadata custom attributes, these attributes are held in the symbol store.

[In] The token of the method where the symbol store attribute is stored. [In] True if the specified token value is not a real method token but rather was internally computed by the compiler before the method was emitted using the CLR image creation APIs. [In] The name of the attribute to find. [Out] The value of the requested symbol store attribute. This will be an empty array if the specified attribute name cannot be found.

WorkList to append the new work item to. [In] The token of the method where the symbol store attribute is stored. [In] True if the specified token value is not a real method token but rather was internally computed by the compiler before the method was emitted using the CLR image creation APIs. [In] The name of the attribute to find. Routine to fire when the request is complete. If the request is successfully appended to the work list, this will always fire (including when the operation is canceled). This will never fire if appending the work item fails.

Translate accelerator pointer tag into HLSL register attributes.

[In] Accelerator pointer tag found in symbols. [In] current instruction pointer used to get scope for pointer translation. [Out] HLSL register type. [Out] HLSL register index. [Out] Index of first vector element. [Out] Number of vector elements. [Out] Offset in bytes. [Out] Size of each vector element.

This method returns compiler flags of the given GPU module.

[Out,Optional] returns the compiler flags.

Translate accelerator pointer tag into HLSL register attributes using relative virtual address. Location constraint: API must be called from an IDE component (component level > 100,000).

[In] Accelerator pointer tag found in symbols. [In] RVA to use for filtering; ignored if zero. [Out] HLSL register type. [Out] HLSL register index. [Out] Index of first vector element. [Out] Number of vector elements. [Out] Offset in bytes. [Out] Size of each vector element.

Verify if the accelerator pointer tag is valid. Location constraint: API must be called from an IDE component (component level > 100,000).

[In] Accelerator pointer tag found in symbols. [In] RVA to use for filtering; ignored if zero. [Out] True if the given accelerator tag is valid at the given RVA. If RVA is zero, checks if the tag is valid anywhere including as a dynamically created tag.

Gets a C++ AMP address for a register. Location constraint: API must be called from an IDE component (component level > 100,000).

[In] Type of HLSL register. [In] Index of HLSL register. [In] Index of first vector element. [In] Number of vector elements. [In] Offset from beginning of register. [In] Size of vector element. [In] RVA to use for mapping register information and tag address. [In] Start of live range for the symbol. [In] End of live range for the symbol. [Out] Is the address newly generated using dynamic tag. [Out] Address for register.

Sets a C++ AMP address for a register. Location constraint: API must be called from an IDE component (component level > 100,000).

[In] Address for register. [In] Type of HLSL register. [In] Index of HLSL register. [In] Index of first vector element. [In] Number of vector elements. [In] Offset from beginning of register. [In] Size of vector element. [In] Start of live range for the symbol. [In] End of live range for the symbol.

Gets a C++ AMP address for a register. Location constraint: API must be called from an IDE component (component level > 100,000).

[Out] Maximum tag value that may be subject to buffer forwarding plus one. [Out] Maximum tag value found in actual C++ AMP pointers plus one.

GetInstructionOffsetForRva is used by components to query symbol provider to perform instruction offset and RVA translation for DPC++. Location constraint: API must be called from an IDE component (component level > 100,000).

[In] The RVA within a module. [Out] The instruction offset from stub function.

A DkmModule is the symbol handler's representation of a module, and is not bound to any process, connection or runtime instance. This method returns all the DkmModuleInstances which map to this DkmModule. A DkmModule can be bound to zero instances in the case that all of the modules are now unloaded. In this case, GetModuleInstances will return an empty array (S_FALSE return code in native).

[Out] The Module Instance class represent a code bundle (ex: dll or exe) which is loaded into a particular process at a particular location. Module Instance objects are 1:1 with the execution environment's notion of a code bundle. For example, in native code, Module Instance objects are 1:1 with base address.

Undecorates a symbol name. Location constraint: API must be called from an IDE component (component level > 100,000).

[In] The name to be undecorated. [In] Options to change the undecorated name. These are specific to the implementation being used. For Microsoft PDB, pass one or more of the values described in the documentation for DbgHelp.dll UnDecorateSymbolName or one of these three extended options: UNDNAME2_STRIP_ILT 0x10000 - to remove the leading ILT from Incremental Linking Thunks UNDNAME2_STRIP_CONST 0x20000 - to remove leading "const" from the front of the string UNDNAME2_STRINGS 0x30000 - to use pooled strings by name. [Out] The undecorated name.

Return the RVA for an S_PUBLIC32 for a particular name by string.

[In] The name of the public symbol to lookup. [Out,Optional] The native instruction symbol for this public symbol.

Return the RVA for an S_PUBLIC32 for a particular name by string. This method will append a new work item to the specified work list, and return once the work item has been appended. The actual processing of the work item is asynchronous. The caller will be notified that the request is complete through the completion routine.

WorkList to append the new work item to. [In] The name of the public symbol to lookup. Routine to fire when the request is complete. If the request is successfully appended to the work list, this will always fire (including when the operation is canceled). This will never fire if appending the work item fails.

Returns the contents of the source server stream data for a module if the stream exists. Location constraint: API must be called from an IDE component (component level > 100,000).

[In] The module instance for which symbol server data is being requested. [Out] True if this address is the first address in the line's range. False otherwise.

[In] Identifies a source file and provides the information which a symbol handler could use to search a symbol file (PDB) for information on this source file. [Out] A collection of the documents that matched the query.

Returns document objects from search parameters contained in the document query. If the symbol file does not contain a reference to this document the returned document object will be NULL (S_FALSE return code in native). The returned document objects must be explicitly closed by the caller when the caller is done with the document. This method will append a new work item to the specified work list, and return once the work item has been appended. The actual processing of the work item is asynchronous. The caller will be notified that the request is complete through the completion routine. Location constraint: API must be called from an IDE component (component level > 100,000).

WorkList to append the new work item to. [In] Identifies a source file and provides the information which a symbol handler could use to search a symbol file (PDB) for information on this source file. Routine to fire when the request is complete. If the request is successfully appended to the work list, this will always fire (including when the operation is canceled). This will never fire if appending the work item fails.

Returns the path to the symbol file which backs a DkmModule object. Location constraint: API must be called from an IDE component (component level > 100,000).

[Out] Full path to the symbol file (ex: c:\myproj\bin\debug\myproj.pdb).

[Out] DkmInstructionSymbol[] represents a method in the target process.

Search a module's symbols for a function with the specified name. Returns the RVA and size if it is found. Location constraint: API must be called from a Monitor component (component level < 100,000).

[In] The name of the function to search for. [Out] The RVA / size pairs from the query.

Search a module's symbols for a function with the specified name. Returns the RVA and size if it is found. This method will append a new work item to the specified work list, and return once the work item has been appended. The actual processing of the work item is asynchronous. The caller will be notified that the request is complete through the completion routine. Location constraint: API must be called from a Monitor component (component level < 100,000).

WorkList to append the new work item to. [In] The name of the function to search for. Routine to fire when the request is complete. If the request is successfully appended to the work list, this will always fire (including when the operation is canceled). This will never fire if appending the work item fails.

GetSymbolInterface is used to obtain a raw COM interface to a symbol store. This is useful to either callers that find the symbol abstraction presented by the debugger to be either too restrictive for their needs, or simply undesirable due to how their component is implemented. Location constraint: With the exception of managed symbols, this method must be called from the same process where the symbol provider has opened the symbol file. For Native PDB files, this means that the API must be called from the IDE process. For Managed symbols, a subset of the symbol provider API is provided on both sides of the remote connection.

[In] The GUID of the desired interface. Microsoft supports IID_IDiaSession for Native DkmModule's, and IID_ISymUnmanagedReader for Managed modules. [Out] Returned symbol interface. This may be cast to the interface pointer corresponding to 'InterfaceID'.

GetSymbolFileRawBytes is used to retrieve the raw bytes of a symbol file from the remote side. This is currently only supported for dynamic portable PDBs. This will return at most 10 MB. Location constraint: API must be called from an IDE component (component level > 100,000). This API was introduced in Visual Studio 14 Update 3 Micro Update (DkmApiVersion.VS14Update3MicroUpdate).

[Out] The raw bytes of the symbol file.

Returns SourceLink information from the symbol file for the requested file path. Location constraint: API must be called from an IDE component (component level > 100,000). This API was introduced in Visual Studio 15 RTM (DkmApiVersion.VS15RTM).

[In] The absolute file path of a source file as it appears in the Symbol File. [Out] The SourceLink information for the requested FilePath.

Fetches the linker fixup records for the module. Location constraint: API must be called from an IDE component (component level > 100,000). This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTM).

[Out] The array of fixup records.

Gets the symbol name for the RVA. Location constraint: API must be called from an IDE component (component level > 100,000). This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTM).

[In] The RVA of the symbol. [Out] The symbol displacement. [Out] The symbol name for use in formatting.

Gets the symbol name for the RVA. This method will append a new work item to the specified work list, and return once the work item has been appended. The actual processing of the work item is asynchronous. The caller will be notified that the request is complete through the completion routine. Location constraint: API must be called from an IDE component (component level > 100,000). This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTM).

WorkList to append the new work item to. [In] The RVA of the symbol. Routine to fire when the request is complete. If the request is successfully appended to the work list, this will always fire (including when the operation is canceled). This will never fire if appending the work item fails.

Gets the symbol name for a register relative value. Location constraint: API must be called from an IDE component (component level > 100,000). This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTM).

[In] The RVA of the symbol. [In] The register index. [In] The offset from the register. [In] The processor architecture. [Out,Optional] The symbol name for use in formatting.

Gets the symbol name for a register relative value. This method will append a new work item to the specified work list, and return once the work item has been appended. The actual processing of the work item is asynchronous. The caller will be notified that the request is complete through the completion routine. Location constraint: API must be called from an IDE component (component level > 100,000). This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTM).

WorkList to append the new work item to. [In] The RVA of the symbol. [In] The register index. [In] The offset from the register. [In] The processor architecture. Routine to fire when the request is complete. If the request is successfully appended to the work list, this will always fire (including when the operation is canceled). This will never fire if appending the work item fails.

Gets the RVA of the function containing the specified RVA. Location constraint: API must be called from an IDE component (component level > 100,000). This API was introduced in Visual Studio 16 Update 3 (DkmApiVersion.VS16Update3).

[In] The RVA to find the function for. [Out] The RVA of the function.

Gets the symbol name for the RVA. Location constraint: API must be called from an IDE component (component level > 100,000). This API was introduced in Visual Studio 16 Update 3 (DkmApiVersion.VS16Update3).

[In] The RVA to find function labels for. [Out] The set of labels contained in the function.

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Guid pair used to uniquely identify a particular DkmModule instance.

Compare two elements of the DkmModuleId structure.

Value to comare against this instance. 'true' if the two elements are equal.

Compare two elements of the DkmModuleId sructure.

Left side of the comparison Right side of the comparison

Compare two elements of the DkmModuleId sructure.

Left side of the comparison Right side of the comparison

Compare two elements of the DkmModuleId sructure.

Left side of the comparison Right side of the comparison

Compare two elements of the DkmModuleId sructure.

Left side of the comparison Right side of the comparison

Compare two elements of the DkmModuleId sructure.

Left side of the comparison Right side of the comparison

Compare two elements of the DkmModuleId sructure.

Left side of the comparison Right side of the comparison

Module version Identifier from the symbol file. This uniquely identifies the symbol file. For Microsoft C++ or Microsoft .NET Framework binaries, this is a unique value which is embedded in an exe/dll by linkers/compilers when the dll/exe is built. A new value is generated each time that the dll/exe is compiled.

Identifies the symbol provider (and therefore symbol format) used to examine these symbols.

Initialize a new DkmModuleId value.

[In] Module version Identifier from the symbol file. This uniquely identifies the symbol file. For Microsoft C++ or Microsoft .NET Framework binaries, this is a unique value which is embedded in an exe/dll by linkers/compilers when the dll/exe is built. A new value is generated each time that the dll/exe is compiled. [In] Identifies the symbol provider (and therefore symbol format) used to examine these symbols.

Contains the information which is in the 'RSDS' section of the module's debug directory. The Mvid portion of this information is in the Mvid immutable.

Module Version Identifier from the loaded module. This is a unique value which is embedded in an exe/dll by linkers/compilers when the dll/exe is built. A new value is generated each time that the dll/exe is compiled.

Age of the PDB. This is essentially a timestamp value which is embedded in an exe/dll by linkers/compilers when the dll/exe is built.

The name of the PDB file containing the debug information. This value is often a file path (ex: c:\myproject\bin\debug\myproject.pdb), but in some build environments it may be shortened to just a file name (ex: kernel32.pdb).

If specified, this is the TimeDateStamp field from the IMAGE_DEBUG_DIRECTORY. This API was introduced in Visual Studio 14 Update 2 (DkmApiVersion.VS14Update2).

If specified, contains the 'MajorVersion' and 'MinorVersion' from the IMAGE_DEBUG_DIRECTORY. This API was introduced in Visual Studio 14 Update 2 (DkmApiVersion.VS14Update2).

[Optional] Any PDB Hashes that were found in Debug Directory entries of the PE file. This API was introduced in Visual Studio 15 Update 9 (DkmApiVersion.VS15Update9).

Create a new DkmPdbFileId object instance.

[In] Unique identifier for symbol files/symbol providers. [In] Module Version Identifier from the loaded module. This is a unique value which is embedded in an exe/dll by linkers/compilers when the dll/exe is built. A new value is generated each time that the dll/exe is compiled. [In] Age of the PDB. This is essentially a timestamp value which is embedded in an exe/dll by linkers/compilers when the dll/exe is built. [In] The name of the PDB file containing the debug information. This value is often a file path (ex: c:\myproject\bin\debug\myproject.pdb), but in some build environments it may be shortened to just a file name (ex: kernel32.pdb). [Out] Result of this method call.

Create a new DkmPdbFileId object instance. This API was introduced in Visual Studio 14 Update 2 (DkmApiVersion.VS14Update2).

Create a new DkmPdbFileId object instance. This API was introduced in Visual Studio 15 Update 9 (DkmApiVersion.VS15Update9).

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

An RVA and size pair representing a symbol returned from DkmModule GetFunctionInfo.

The relative virtual address of a symbol.

The size of a symbol.

Initialize a new DkmRVASizePair value.

[In] The relative virtual address of a symbol. [In] The size of a symbol.

Object which represents the result of a source file query against a symbol file (PDB). The resolved document object might encapsulate multiple document records with the symbol file. For example, in C++ compilation, each time that a header file is included there is another reference within the PDB. However, there is only one DkmResolvedDocument object for the header file. Derived classes: DkmResolvedMappedDocument

Guid which uniquely identifies this object.

Name of the source file. This is generally a full path, but in some scenarios it make be a partial path or just a name with extension (ex: example.cpp). In the case of a dynamic document (ex: running script from internet explorer) 'Path' could be a URL rather than a local file path.

[Optional] Script document which this resolved document represents. This should be null for non script-based symbol providers.

Indicates how strong of a match there was between the DkmDocumentQuery and the resulting DkmResolvedDocument.

Warning that occurred during the match. Depending on context, these may need to be surfaced to the user.

If true, return the source text.

Closes the resolved document object. This method must be invoked when the component which requested the resolved document is done with the object. DkmResolvedDocument objects are automatically closed when their associated DkmModule object is closed.

Creates a new resolved document object. Resolved document objects are created by a symbol provider. They are a data container so that a symbol provider may back the resolved document with their own internal state.

[In] The DkmModule class represents a code bundle (ex: dll or exe) which is or once was loaded into one or more processes. The DkmModule class is the central object to the symbol APIs, and is 1:1 with the symbol handler's notation of what is loaded. If a code bundle loads into three different processes (or the same process but with three different base addresses or three different app domains) but the symbol handler thinks of all of these as being identical, there will be only one module object. [In] Name of the source file. This is generally a full path, but in some scenarios it make be a partial path or just a name with extension (ex: example.cpp). In the case of a dynamic document (ex: running script from internet explorer) 'Path' could be a URL rather than a local file path. [In,Optional] Script document which this resolved document represents. This should be null for non script-based symbol providers. [In] Indicates how strong of a match there was between the DkmDocumentQuery and the resulting DkmResolvedDocument. [In] Warning that occurred during the match. Depending on context, these may need to be surfaced to the user. [In] If true, return the source text. [In,Optional] Data object to add to the new DkmResolvedDocument instance. Pass 'null' in the case that the caller doesn't need to add a data item. [Out] Result of this method call.

[In] The text range (lines/column) to search for. [In,Optional] The text to search for. When available, this will be provided if ResolvedDocument.TextRequested is set. [Out] The source location of each returned instruction symbol. The length of this array should be the same of the returned instruction symbol array. [Out] The found instruction symbols which are within the specified text span. E_TEXT_SPAN_NOT_LOADED indicates that TextSpan is not currently loaded in the specified script document. E_SCRIPT_SPAN_MAPPING_FAILED indicates that TextSpan could not be mapped to a location in the specified script document. E_SCRIPT_FILE_DIFFERENT_CONTENT indicates that the content in the script file loaded by the target process doesn't match the provided Text.

Finds the symbols within the document which best match the input text span. For IL-based languages, the symbol handler always return the DkmInstructionSymbol for sequence points. It will prefer sequence points which exactly match the text span followed by the sequence point or points which is left-most and which is inside the input span. This method will append a new work item to the specified work list, and return once the work item has been appended. The actual processing of the work item is asynchronous. The caller will be notified that the request is complete through the completion routine. Location constraint: API must be called from an IDE component (component level > 100,000).

WorkList to append the new work item to. [In] The text range (lines/column) to search for. [In,Optional] The text to search for. When available, this will be provided if ResolvedDocument.TextRequested is set. Routine to fire when the request is complete. If the request is successfully appended to the work list, this will always fire (including when the operation is canceled). This will never fire if appending the work item fails.

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Warning that occurred during the match. Depending on context, these may need to be surfaced to the user.

No warning occurred during the match.

Both the symbol file and input request contained a source file checksum, however the checksum values did not match each other.

Both the symbol file and input request contained a source file checksum, and the symbol file contained a match to this checksum value. However, the symbol file also contained information about an identically named document with a different checksum value. This can occur in partial rebuild scenarios and may result in strange behavior.

Resolved document object which is created from a successful call to DkmModule.FindMappedDocuments or DkmScriptDocument.TryMappedResolve. This contains the information to map requests in server-side documents into requests on the client-side document.

[Optional] Collection of script blocks in the project item document.

Creates a new resolved mapped document object. This API is typically called by the script local agent.

[In] The DkmModule class represents a code bundle (ex: dll or exe) which is or once was loaded into one or more processes. The DkmModule class is the central object to the symbol APIs, and is 1:1 with the symbol handler's notation of what is loaded. If a code bundle loads into three different processes (or the same process but with three different base addresses or three different app domains) but the symbol handler thinks of all of these as being identical, there will be only one module object. [In] Name of the source file. This is generally a full path, but in some scenarios it make be a partial path or just a name with extension (ex: example.cpp). In the case of a dynamic document (ex: running script from internet explorer) 'Path' could be a URL rather than a local file path. [In,Optional] Script document which this resolved document represents. This should be null for non script-based symbol providers. [In] Indicates how strong of a match there was between the DkmDocumentQuery and the resulting DkmResolvedDocument. [In] Warning that occurred during the match. Depending on context, these may need to be surfaced to the user. [In] If true, return the source text. [In,Optional] Collection of script blocks in the project item document. [In,Optional] Data object to add to the new DkmResolvedMappedDocument instance. Pass 'null' in the case that the caller doesn't need to add a data item. [Out] Result of this method call.

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Value of a calculated SHA-1 hash. SHA-1 hashes are used for the document checksum feature, which is a non-security purpose. SHA-1 should no longer be used for any security related purpose.

Compare two elements of the DkmSHA1HashValue structure.

Value to comare against this instance. 'true' if the two elements are equal.

Compare two elements of the DkmSHA1HashValue sructure.

Left side of the comparison Right side of the comparison

Compare two elements of the DkmSHA1HashValue sructure.

Left side of the comparison Right side of the comparison

Compare two elements of the DkmSHA1HashValue sructure.

Left side of the comparison Right side of the comparison

Compare two elements of the DkmSHA1HashValue sructure.

Left side of the comparison Right side of the comparison

Compare two elements of the DkmSHA1HashValue sructure.

Left side of the comparison Right side of the comparison

Compare two elements of the DkmSHA1HashValue sructure.

Left side of the comparison Right side of the comparison

First 32-bits of the calculated hash.

Second 32-bits of the calculated hash.

Third 32-bits of the calculated hash.

Forth 32-bits of the calculated hash.

Fifth 32-bits of the calculated hash.

Initialize a new DkmSHA1HashValue value.

[In] First 32-bits of the calculated hash. [In] Second 32-bits of the calculated hash. [In] Third 32-bits of the calculated hash. [In] Forth 32-bits of the calculated hash. [In] Fifth 32-bits of the calculated hash.

Value of a calculated hash. Hashes are used for the document checksum feature, which has a non-security purpose. This API was introduced in Visual Studio 15 RTM (DkmApiVersion.VS15RTM).

The hash algorithm used to calculate this hash value. This API was introduced in Visual Studio 15 RTM (DkmApiVersion.VS15RTM).

Array of the calculated hash bytes. This API was introduced in Visual Studio 15 RTM (DkmApiVersion.VS15RTM).

Creates a new DkmSourceFileHash object. This API was introduced in Visual Studio 15 RTM (DkmApiVersion.VS15RTM).

[In] The hash algorithm used to calculate this hash value. [In] Array of the calculated hash bytes. [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Identifies a source file and provides the information which a symbol handler could use to search a symbol file (PDB) for information on this source file.

MD5 hash value for this document.

Value of a calculated MD5 hash. MD5 hashes are used for the document checksum feature, which is a non-security purpose. MD5 should no longer be used for any security related purpose.

Initialize a new MD5Hash value.

[In] Value of a calculated MD5 hash. MD5 hashes are used for the document checksum feature, which is a non-security purpose. MD5 should no longer be used for any security related purpose.

SHA-1 hash value for this document.

Value of a calculated SHA-1 hash. SHA-1 hashes are used for the document checksum feature, which is a non-security purpose. SHA-1 should no longer be used for any security related purpose.

Initialize a new SHA1Hash value.

[In] Value of a calculated SHA-1 hash. SHA-1 hashes are used for the document checksum feature, which is a non-security purpose. SHA-1 should no longer be used for any security related purpose.

[Optional] MD5 hash value for this document.

[Optional] SHA-1 hash value for this document.

[Optional] Script document object which this DkmSourceFileId wraps. For requests to find document requests, this can be non-NULL when the text position to search for is from the dynamic view of a document. For address->text position requests, this will be non-null when the the address is in a script document.

[Optional] Additional checksums that can be used to identify this source file. This is used for additional hash algorithms beyond SHA1 and MD5. It is also used to allow for multiple hash values for the same document. This can be used when the same document has semantically identical content but may have different on-disk bytes. For example, this can be used to provide another hash value for alternate line endings. This API was introduced in Visual Studio 15 RTM (DkmApiVersion.VS15RTM).

Create a new DkmSourceFileId object instance.

Create a new DkmSourceFileId object instance. This API was introduced in Visual Studio 15 RTM (DkmApiVersion.VS15RTM).

[In] Name of the source file. This is generally a full path, but in some scenarios it make be a partial path or just a name with extension (ex: example.cpp). In the case of a dynamic document (ex: running script from internet explorer) 'Path' could be a URL rather than a local file path. [In,Optional] Script document object which this DkmSourceFileId wraps. For requests to find document requests, this can be non-NULL when the text position to search for is from the dynamic view of a document. For address->text position requests, this will be non-null when the the address is in a script document. [In,Optional] Additional checksums that can be used to identify this source file. This is used for additional hash algorithms beyond SHA1 and MD5. It is also used to allow for multiple hash values for the same document. This can be used when the same document has semantically identical content but may have different on-disk bytes. For example, this can be used to provide another hash value for alternate line endings. [In,Optional] MD5 hash value for this document. [In,Optional] SHA-1 hash value for this document. [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

DkmSourceLinkInfo represents Source Link information obtained from a Symbol File. This API was introduced in Visual Studio 15 RTM (DkmApiVersion.VS15RTM).

A URL where the source file for this Source Link query can be retrieved using an HTTP GET request. This API was introduced in Visual Studio 15 RTM (DkmApiVersion.VS15RTM).

A relative file path for the Source Link entry. For example, if the SourceLink map contains 'C:\\foo\\*' and this maps to 'C:\\foo\\bar\\baz.cs', the RelativeFilePath is 'bar\\baz.cs'. For absolute SourceLink mappings, RelativeFilePath will simply be the name of the file. This API was introduced in Visual Studio 15 RTM (DkmApiVersion.VS15RTM).

Create a new DkmSourceLinkInfo object instance. This API was introduced in Visual Studio 15 RTM (DkmApiVersion.VS15RTM).

[In] A URL where the source file for this Source Link query can be retrieved using an HTTP GET request. [In] A relative file path for the Source Link entry. For example, if the SourceLink map contains 'C:\\foo\\*' and this maps to 'C:\\foo\\bar\\baz.cs', the RelativeFilePath is 'bar\\baz.cs'. For absolute SourceLink mappings, RelativeFilePath will simply be the name of the file. [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Source code position which corresponds to a code element. The could represent a location which has been extracted from a symbol (PDB) file, or it could be the location of a breakpoint in the IDE.

Identifies a source file and provides the information which a symbol handler could use to search a symbol file (PDB) for information on this source file.

The start/end line/column ranges for a contiguous span of text.

Create a new DkmSourcePosition object instance.

[In] Identifies a source file and provides the information which a symbol handler could use to search a symbol file (PDB) for information on this source file. [In] The start/end line/column ranges for a contiguous span of text. [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Flags which affect the behavior of 'GetSourcePosition'.

Instructs the symbol provider to use the default behavior of GetSourcePosition.

Instructs the symbol provider to extend the source range to include surrounding source code in addition to the source statement which corresponds to the instruction symbol. This option is used in the disassembly window.

A offset/size pair which is returned from the symbol provider to a debug monitor to indicate a range of instructions which the debugger should not stop at.

The start of a stepping range. The meaning is dependant on the the underlying runtime being stepped. For MSIL, this in the beginning IL offset relative to the start of the method. For native code, this is an RVA.

The length of a stepping range. The meaning is dependant on the the underlying runtime being stepped. For both native code and MSIL, this is a byte count of the number of instructions in the range. For MSIL, UInt32.MaxValue is used to indicate that the range should extend to the end of the method.

The source line number of the stepping range. The meaning is dependant on the the underlying runtime being stepped. For both native code and MSIL, this is the source line number of instructions in the range. For MSIL, UInt32.MaxValue is used to indicate that the range should extend to the end of the method.

Initialize a new DkmSteppingRange value.

[In] The start of a stepping range. The meaning is dependant on the the underlying runtime being stepped. For MSIL, this in the beginning IL offset relative to the start of the method. For native code, this is an RVA. [In] The length of a stepping range. The meaning is dependant on the the underlying runtime being stepped. For both native code and MSIL, this is a byte count of the number of instructions in the range. For MSIL, UInt32.MaxValue is used to indicate that the range should extend to the end of the method. [In] The source line number of the stepping range. The meaning is dependant on the the underlying runtime being stepped. For both native code and MSIL, this is the source line number of instructions in the range. For MSIL, UInt32.MaxValue is used to indicate that the range should extend to the end of the method.

Indicates to the symbol provider the type of instructions to include in the 'no-step' regions.

Step should complete at the first non-hidden instruction in the method. This value is used when stepping into a new function.

Step should complete on the next statement.

Step should complete on the next line.

Step should complete at the first instruction after the inline method. This value is used when stepping out an inline function.

Contains information needed to locate symbols for this module. On Win32, this information is contained within the IMAGE_DEBUG_DIRECTORY. Derived classes: DkmCustomSymbolFileId, DkmDynamicSymbolFileId, DkmPdbFileId, DkmEmbeddedPdbFileId

DkmSymbolFileId is an abstract base class. This enum indicates which derived class this object is an instance of.

Object is an instance of 'DkmPdbFileId'.

Object is an instance of 'DkmDynamicSymbolFileId'.

Object is an instance of 'DkmCustomSymbolFileId'.

Object is an instance of 'DkmEmbeddedPdbFileId'.

DkmSymbolFileId is an abstract base class. This enum indicates which derived class this object is an instance of.

Unique identifier for symbol files/symbol providers.

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Unique identifier for symbol files/symbol providers.

Reads symbol information from PDB/DBG files to decode native binaries.

Reads symbol information from PDB files to decode .NET Framework (CLR) binaries.

Provides symbol resolution from Metadata and a remote symbol store for .NET Framework (CLR) binaries. This is used for dynamically compiled managed code. It is also used for ASP.NET scenario where code is compiled on server side.

Provides symbol resolution for Microsoft ActiveScript based dynamic code.

Reads symbol information from PDB in D3D blob to decode HLSL binaries.

Reads symbol information from PDB files to decode DPC++ binaries.

Provides symbol resolution for Microsoft ActiveScript based dynamic code. This is the symbol provider used when interop debugging Script code with other runtimes.

Reads symbol information from a native-compiled CLR PDB file.

Reads symbol information from PDB files to decode DPC++ binaries. This is associated with GPU interop D3D runtime.

Provides symbol resolution from Metadata and a remote symbol store for .NET Core binaries using the Portable PDB symbol format. This is used for dynamically compiled managed code. It is also used for ASP.NET Core scenario where code is compiled on server side. This is used for .cshtml files for .NET Core Asp.Net Apps.

The start/end line/column ranges for a contiguous span of text.

Compare two elements of the DkmTextSpan structure.

Value to comare against this instance. 'true' if the two elements are equal.

Compare two elements of the DkmTextSpan sructure.

Left side of the comparison Right side of the comparison

Compare two elements of the DkmTextSpan sructure.

Left side of the comparison Right side of the comparison

Compare two elements of the DkmTextSpan sructure.

Left side of the comparison Right side of the comparison

Compare two elements of the DkmTextSpan sructure.

Left side of the comparison Right side of the comparison

Compare two elements of the DkmTextSpan sructure.

Left side of the comparison Right side of the comparison

Compare two elements of the DkmTextSpan sructure.

Left side of the comparison Right side of the comparison

1-based integer for the starting source line.

1-based integer for the ending source column.

1-based integer for the starting source column. If column information is missing (ex: language service doesn't support it), this value should be set to 0.

1-based integer for the ending source column. If column information is missing (ex: language service doesn't support it), this value should be set to 0.

Initialize a new DkmTextSpan value.

[In] 1-based integer for the starting source line. [In] 1-based integer for the ending source column. [In] 1-based integer for the starting source column. If column information is missing (ex: language service doesn't support it), this value should be set to 0. [In] 1-based integer for the ending source column. If column information is missing (ex: language service doesn't support it), this value should be set to 0.

Flags which affect how a search should be performed.

Input expression contains a wildcard search to bind.

Result of an asynchronous DkmRuntimeFunctionResolutionRequest.OnFunctionResolved call.

Creates a new result structure to hold the error from a failed call to DkmRuntimeFunctionResolutionRequest.OnFunctionResolved.

[In] exception object containing the error

HRESULT code returned from the caller. This will be DkmExceptionCode.COR_E_OPERATIONCANCELED (0x8013153B) if the operation was canceled before processing was complete.

Result of an asynchronous DkmRuntimeFunctionResolutionRequest.OnResolverMessage call.

Creates a new result structure to hold the error from a failed call to DkmRuntimeFunctionResolutionRequest.OnResolverMessage.

[In] exception object containing the error

HRESULT code returned from the caller. This will be DkmExceptionCode.COR_E_OPERATIONCANCELED (0x8013153B) if the operation was canceled before processing was complete.

DkmRuntimeFunctionResolutionRequest represents an expression to be parsed and evaluated by a runtime based expression evaluator and is bound to a particular process. Resolutions will send DkmModuleInstance::FunctionResolved events.

Uniquely identifies the DkmRuntimeFunctionResolutionRequest object.

Language/Vendor of the request. Vendor is usually set to Guid.Empty. Language and vendor will be set to Guid.Empty for function breakpoints set with an 'Unknown' language.

The name of the function to resolve to.

The line offset from the start of the function to bind to.

The name of the module to resolve to.

Flags which affect how a search should be performed.

Closes the DkmRuntimeFunctionResolutionRequest object. Once this is closed, no new resolutions will be sent. DkmRuntimeFunctionResolutionRequest objects are automatically closed when their associated DkmProcess object is closed. This method may only be called by the component which created the object.

Create a new DkmRuntimeFunctionResolutionRequest object instance. The caller is responsible for closing the created object after they are done.

[In] DkmProcess represents a target process which is being debugged. The debugger debugs processes, so this is the basic unit of debugging. A DkmProcess can represent a system process or a virtual process such as minidumps. [In] Language/Vendor of the request. Vendor is usually set to Guid.Empty. Language and vendor will be set to Guid.Empty for function breakpoints set with an 'Unknown' language. [In] The name of the function to resolve to. [In] The line offset from the start of the function to bind to. [In] The name of the module to resolve to. [In] Flags which affect how a search should be performed. [In,Optional] Data object to add to the new DkmRuntimeFunctionResolutionRequest instance. Pass 'null' in the case that the caller doesn't need to add a data item. [Out] Result of this method call.

Called by the breakpoint manager to add a pending resolve request. Expression evaluators, or other components will immediately try to bind the breakpoint against current modules, and will bind the breakpoint to additional locations as modules load. The caller of this interface should implement IDkmRuntimeFunctionResolverClient to obtain the results of the resolution. Implementations of this interface should stop attempting to bind the breakpoint when the DkmRuntimeFunctionResolutionRequest object is closed. This method will append a new work item to the specified work list, and return once the work item has been appended. The actual processing of the work item is asynchronous. The caller will be notified that the request is complete through the completion routine.

WorkList to append the new work item to.

Called by runtime function resolvers when a new resolution has been discovered for a DkmRuntimeFunctionResolutionRequest instance. Location constraint: API must be called from a Monitor component (component level < 100,000).

[In] The address the request bound to. Multiple addresses will result in multiple calls to this function.

Called by runtime function resolvers when a new resolution has been discovered for a DkmRuntimeFunctionResolutionRequest instance. This method will append a new work item to the specified work list, and return once the work item has been appended. The actual processing of the work item is asynchronous. The caller will be notified that the request is complete through the completion routine. Location constraint: API must be called from a Monitor component (component level < 100,000).

WorkList to append the new work item to. [In] The address the request bound to. Multiple addresses will result in multiple calls to this function. Routine to fire when the request is complete. If the request is successfully appended to the work list, this will always fire (including when the operation is canceled). This will never fire if appending the work item fails.

Called by runtime function resolvers when the resolver wishes to notify its client an error/warning occurred while attempting to resolve the breakpoint. Location constraint: API must be called from a Monitor component (component level < 100,000).

[In] Describes the severity of a message sent from a breakpoint manager back to the source component. This list is sorted in order of priority, as the UI will only display the most important warning. All warnings are ignored if the breakpoint is bound. [In] Message string to display to the user.

Called by runtime function resolvers when the resolver wishes to notify its client an error/warning occurred while attempting to resolve the breakpoint. This method will append a new work item to the specified work list, and return once the work item has been appended. The actual processing of the work item is asynchronous. The caller will be notified that the request is complete through the completion routine. Location constraint: API must be called from a Monitor component (component level < 100,000).

WorkList to append the new work item to. [In] Describes the severity of a message sent from a breakpoint manager back to the source component. This list is sorted in order of priority, as the UI will only display the most important warning. All warnings are ignored if the breakpoint is bound. [In] Message string to display to the user. Routine to fire when the request is complete. If the request is successfully appended to the work list, this will always fire (including when the operation is canceled). This will never fire if appending the work item fails.

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

DkmSymbolFunctionResolutionRequest represents an expression to be parsed and evaluated by a symbol based expression evaluator and is not bound to a particular process. Used to perform function breakpoint binds.

[Optional] The module to bind against. If null, then all modules should be checked. If the module's name does not match the module name parameter, no bind will occur.

Describes a programming language.

Source text of the parsed expression.

The line offset from the start of the function to bind to.

Module name to bind in.

Flags which affect how a search should be performed.

[Optional] If non-null, this specifies a connection to a worker process where this request should be processed. This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTMPreview).

Create a new DkmSymbolFunctionResolutionRequest object instance.

[In] DkmProcess represents a target process which is being debugged. The debugger debugs processes, so this is the basic unit of debugging. A DkmProcess can represent a system process or a virtual process such as minidumps. [In,Optional] The module to bind against. If null, then all modules should be checked. If the module's name does not match the module name parameter, no bind will occur. [In] Describes a programming language. [In] Source text of the parsed expression. [In] The line offset from the start of the function to bind to. [In] Module name to bind in. [In] Flags which affect how a search should be performed. [Out] Result of this method call.

Create a new DkmSymbolFunctionResolutionRequest object instance. This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTMPreview).

[In] DkmProcess represents a target process which is being debugged. The debugger debugs processes, so this is the basic unit of debugging. A DkmProcess can represent a system process or a virtual process such as minidumps. [In,Optional] The module to bind against. If null, then all modules should be checked. If the module's name does not match the module name parameter, no bind will occur. [In] Describes a programming language. [In] Source text of the parsed expression. [In] The line offset from the start of the function to bind to. [In] Module name to bind in. [In] Flags which affect how a search should be performed. [In,Optional] If non-null, this specifies a connection to a worker process where this request should be processed. [Out] Result of this method call.

Resolve an address string to zero or more address symbols. This is used to bind function breakpoints. Location constraint: API must be called from an IDE component (component level > 100,000).

[Out] DkmInstructionSymbol[] represents a method in the target process.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

ARM64 Registers. This API was introduced in Visual Studio 15 RTM (DkmApiVersion.VS15RTM).

Instruction Pointer. This API was introduced in Visual Studio 15 RTM (DkmApiVersion.VS15RTM).

Stack Pointer. This API was introduced in Visual Studio 15 RTM (DkmApiVersion.VS15RTM).

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Arm registers.

Instruction Pointer.

Stack Pointer.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Provides a context for walking async return stacks and task creation stacks. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

The inspection session that owns this task object. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

Extensible GUID indicating the task provider which a task is from. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

[Optional] If this stack walk context refers to a task that is associated with a particular stack frame, specifies the stack frame that this task object is associated with. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

[Optional] Internal stack frame used to perform inspection operations on async frames in the return stack, for example, the CLR requires an ICorDebugFrame to read static fields. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

[Optional] Optional evaluation result representing the frame that this stack walk context refers to. When C++ debugging, this is used to support inspection inside of return stack frames. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

[Optional] Optional task to use for inspection of async frames. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

[Optional] For native async frames, specifies an list of available functions in the return stack, from which captured local variables may be extracted from. Null for managed and JavaScript. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

The runtime instance associated with this task object. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

Guid which uniquely identifies this evaluation result. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

Create a new DkmAsyncStackWalkContext object instance. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

[In] The inspection session that owns this task object. [In] Extensible GUID indicating the task provider which a task is from. [In,Optional] If this stack walk context refers to a task that is associated with a particular stack frame, specifies the stack frame that this task object is associated with. [In,Optional] Internal stack frame used to perform inspection operations on async frames in the return stack, for example, the CLR requires an ICorDebugFrame to read static fields. [In,Optional] Optional evaluation result representing the frame that this stack walk context refers to. When C++ debugging, this is used to support inspection inside of return stack frames. [In,Optional] Optional task to use for inspection of async frames. [In,Optional] For native async frames, specifies an list of available functions in the return stack, from which captured local variables may be extracted from. Null for managed and JavaScript. [In] The runtime instance associated with this task object. [In,Optional] Data object to add to the new DkmAsyncStackWalkContext instance. Pass 'null' in the case that the caller doesn't need to add a data item. [Out] Result of this method call.

Gets the logged creation stack of this task. This method will append a new work item to the specified work list, and return once the work item has been appended. The actual processing of the work item is asynchronous. The caller will be notified that the request is complete through the completion routine. Location constraint: API must be called from an IDE component (component level > 100,000). This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

WorkList to append the new work item to. [In] The thread that the resultant frames should belong to. Routine to fire when the request is complete. If the request is successfully appended to the work list, this will always fire (including when the operation is canceled). This will never fire if appending the work item fails.

Returns a list of frames that will execute when this task completes. The order that the frames will execute in is arbitrary and might not be the order returned here. Only frames that will execute as a direct result of this task are included, not frames that will execute as a result of another task that will execute after this task completes. This method will append a new work item to the specified work list, and return once the work item has been appended. The actual processing of the work item is asynchronous. The caller will be notified that the request is complete through the completion routine. Location constraint: API must be called from an IDE component (component level > 100,000). This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

Gets the async call stack of this thread. This method will append a new work item to the specified work list, and return once the work item has been appended. The actual processing of the work item is asynchronous. The caller will be notified that the request is complete through the completion routine. Location constraint: This API can normally only be called on the client side normally. It can be called on the remote side for script. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Holds the list of implementations of the IDkmCallStackFilter interface which may be called by a component. This object is used to call these stack frame filters.

Returns the number of implemantions of the IDkmCallStackFilter interface which may be called through this object.

[In] Zero-based index into the collection of {0} implementations that the caller wishes to be invoked. This should be less than the 'Count' property. [In] DkmStackContext objects are created by components that wish to request the stack from the stack provider. A component needs to close the context after they have completed the stack walk. To obtain the stack a component should create this object and then call GetNextFrames. [In,Optional] Input is the next frame to examine. After all frame have been filtered, this function will be called one last time with a null input frame. This lets the filter know that the call stack is fully processed. [Out] DkmStackWalkFrame[] represents a frame on a call stack which has been walked, but may not have been formatted or filtered. Formatted frames are represented by DkmStackFrame instead.

Create a new DkmCallStackFilterList object instance. Location constraint: API must be called from an IDE component (component level > 100,000).

[Out] Result of this method call.

Options for how the call stack should be filtered.

No filter option flags are set.

Remove frames from the call stack which are in hidden code.

Remove non-user code from the call stack.

Indicates that async frames should be included in the call stack.

If JustMyCode is enabled, indicates that the frames on the topmost block of nonuser code should still be shown.

If JustMyCode is enabled and ShowTopNonUserBlock is also specified, indicates that frames involved with the implementation of throwing an exception should still be collapsed.

Collection of settings that affect how the stack provider formats a DkmStackFrame.

Flags that indicate what information is requested for a variable.

Flags which affect how the stack provider create DkmStackFrame objects.

Flags which effect how an input expression should be parsed, compiled or displayed.

This is the timeout to be used for potentially slow operations such as a function evaluation. This value is in milliseconds.

The radix to use when formatting integer data. Currently supported values are '16' and '10'.

Initialize a new DkmFrameFormatOptions value.

[In] Flags that indicate what information is requested for a variable. [In] Flags which affect how the stack provider create DkmStackFrame objects. [In] Flags which effect how an input expression should be parsed, compiled or displayed. [In] This is the timeout to be used for potentially slow operations such as a function evaluation. This value is in milliseconds. [In] The radix to use when formatting integer data. Currently supported values are '16' and '10'.

Flags which affect how the stack provider create DkmStackFrame objects.

No additional information is included in the frame name.

Include the module name in the frame name.

Include the number of lines at the end of the frame name.

Include the byte offset at the end of the frame name.

Include the return type in the frame name.

Include the return type field in the frame object.

Include the document position in the frame object.

Include the task id (if any) in the frame name.

DkmFrameRegisters represents the registers of a stack frame. Derived classes: DkmArmFrameRegisters, DkmX64FrameRegisters, DkmX86FrameRegisters, DkmArm64FrameRegisters

DkmFrameRegisters is an abstract base class. This enum indicates which derived class this object is an instance of.

Object is an instance of 'DkmArmFrameRegisters'.

Object is an instance of 'DkmX86FrameRegisters'.

Object is an instance of 'DkmX64FrameRegisters'.

Object is an instance of 'DkmArm64FrameRegisters'.

DkmFrameRegisters is an abstract base class. This enum indicates which derived class this object is an instance of.

The register set that was actually unwound by the unwinder.

Returns the processor-independent instruction pointer which is stored in this frame register object.

[Out] Instruction pointer value which is stored in the specified registers structure (ex: EIP on x86, RIP on x64).

Returns the processor-independent stack pointer which is stored in this frame register object.

[Out] Stack pointer value which is stored in the specified registers structure (ex: ESP on x86, RSP on x64).

A helper function for searching the array of unwound register values for a DkmStackWalkFrame. If the register was not unwound, a failed HRESULT is returned.

[In] The unique constant for the requested register. Normally, this is a cvconst value such as CV_REG_EIP. [In,Out] A buffer that receives the value of the register. [In] The size of the value in bytes. [Out] The caller allocated buffer that receives the contents of the requested register.

A helper function for searching the array of unwound register values for a DkmStackWalkFrame. If the register was not unwound, a failed HRESULT is returned.

[In] The unique constant for the requested register. Normally, this is a cvconst value such as CV_REG_EIP. [In,Out] A buffer that receives the value of the register. [Out] The caller allocated buffer that receives the contents of the requested register.

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Result of an asynchronous DkmStackWalkFrameAnnotation.GetAnnotationText call.

Creates a new result structure to hold the error from a failed call to DkmStackWalkFrameAnnotation.GetAnnotationText.

[In] exception object containing the error

HRESULT code returned from the caller. This will be DkmExceptionCode.COR_E_OPERATIONCANCELED (0x8013153B) if the operation was canceled before processing was complete.

[Optional] The annotation text. This API was introduced in Visual Studio 15 Update 8 (DkmApiVersion.VS15Update8).

Creates a new result structure to hold the output from a successful call to DkmStackWalkFrameAnnotation.GetAnnotationText.

[In,Optional] The annotation text.

Marshal a native struct to managed

Pointer to native struct. Managed object.

Obtain a pointer to the native object used to call into native.

Outgoing managed->native call Native object

Validate the fields of this structure

Struct that holds the field path (ex: "myArgument.StructField")

Result of an asynchronous DkmAsyncStackWalkContext.GetAsyncCallStack call.

Creates a new result structure to hold the error from a failed call to DkmAsyncStackWalkContext.GetAsyncCallStack.

[In] exception object containing the error

HRESULT code returned from the caller. This will be DkmExceptionCode.COR_E_OPERATIONCANCELED (0x8013153B) if the operation was canceled before processing was complete.

The frames that will display in the call stack window. May be any combination of creation stack frames, return stack frames, or annotated frames. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

Creates a new result structure to hold the output from a successful call to DkmAsyncStackWalkContext.GetAsyncCallStack.

[In] The frames that will display in the call stack window. May be any combination of creation stack frames, return stack frames, or annotated frames.

Marshal a native struct to managed

Pointer to native struct. Managed object.

Obtain a pointer to the native object used to call into native.

Outgoing managed->native call Native object

Validate the fields of this structure

Struct that holds the field path (ex: "myArgument.StructField")

Result of an asynchronous DkmStackWalkFrame.GetClrGenericParameters call.

Creates a new result structure to hold the error from a failed call to DkmStackWalkFrame.GetClrGenericParameters.

[In] exception object containing the error

HRESULT code returned from the caller. This will be DkmExceptionCode.COR_E_OPERATIONCANCELED (0x8013153B) if the operation was canceled before processing was complete.

The list of assembly qualified names for the type parameters, if any, followed by the method parameters, if any. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

Creates a new result structure to hold the output from a successful call to DkmStackWalkFrame.GetClrGenericParameters.

[In] The list of assembly qualified names for the type parameters, if any, followed by the method parameters, if any.

Marshal a native struct to managed

Pointer to native struct. Managed object.

Obtain a pointer to the native object used to call into native.

Outgoing managed->native call Native object

Validate the fields of this structure

Struct that holds the field path (ex: "myArgument.StructField")

Result of an asynchronous DkmAsyncStackWalkContext.GetContinuationFramesFromTaskObject call.

Creates a new result structure to hold the error from a failed call to DkmAsyncStackWalkContext.GetContinuationFramesFromTaskObject.

[In] exception object containing the error

HRESULT code returned from the caller. This will be DkmExceptionCode.COR_E_OPERATIONCANCELED (0x8013153B) if the operation was canceled before processing was complete.

The frames that will execute when this task completes. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

Creates a new result structure to hold the output from a successful call to DkmAsyncStackWalkContext.GetContinuationFramesFromTaskObject.

[In] The frames that will execute when this task completes.

Marshal a native struct to managed

Pointer to native struct. Managed object.

Obtain a pointer to the native object used to call into native.

Outgoing managed->native call Native object

Validate the fields of this structure

Struct that holds the field path (ex: "myArgument.StructField")

Result of an asynchronous DkmThread.GetCurrentLocation call.

Creates a new result structure to hold the error from a failed call to DkmThread.GetCurrentLocation.

[In] exception object containing the error

HRESULT code returned from the caller. This will be DkmExceptionCode.COR_E_OPERATIONCANCELED (0x8013153B) if the operation was canceled before processing was complete.

The name of the current location.

Creates a new result structure to hold the output from a successful call to DkmThread.GetCurrentLocation.

[In] The name of the current location.

Marshal a native struct to managed

Pointer to native struct. Managed object.

Obtain a pointer to the native object used to call into native.

Outgoing managed->native call Native object

Validate the fields of this structure

Struct that holds the field path (ex: "myArgument.StructField")

Result of an asynchronous DkmAsyncStackWalkContext.GetManagedTaskContinuationFrames call.

Creates a new result structure to hold the error from a failed call to DkmAsyncStackWalkContext.GetManagedTaskContinuationFrames.

[In] exception object containing the error

HRESULT code returned from the caller. This will be DkmExceptionCode.COR_E_OPERATIONCANCELED (0x8013153B) if the operation was canceled before processing was complete.

The frames that will execute when this task completes. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

Creates a new result structure to hold the output from a successful call to DkmAsyncStackWalkContext.GetManagedTaskContinuationFrames.

[In] The frames that will execute when this task completes.

Marshal a native struct to managed

Pointer to native struct. Managed object.

Obtain a pointer to the native object used to call into native.

Outgoing managed->native call Native object

Validate the fields of this structure

Struct that holds the field path (ex: "myArgument.StructField")

Result of an asynchronous DkmStackContext.GetNextFrames call.

Creates a new result structure to hold the error from a failed call to DkmStackContext.GetNextFrames.

[In] exception object containing the error

HRESULT code returned from the caller. This will be DkmExceptionCode.COR_E_OPERATIONCANCELED (0x8013153B) if the operation was canceled before processing was complete.

[Optional] DkmStackFrame[] represents a frame on the call stack after filtering and translation.

Creates a new result structure to hold the output from a successful call to DkmStackContext.GetNextFrames.

[In] DkmStackFrame[] represents a frame on the call stack after filtering and translation.

Marshal a native struct to managed

Pointer to native struct. Managed object.

Obtain a pointer to the native object used to call into native.

Outgoing managed->native call Native object

Validate the fields of this structure

Struct that holds the field path (ex: "myArgument.StructField")

Result of an asynchronous DkmRawStackContext.GetNextRawFrames call.

Creates a new result structure to hold the error from a failed call to DkmRawStackContext.GetNextRawFrames.

[In] exception object containing the error

HRESULT code returned from the caller. This will be DkmExceptionCode.COR_E_OPERATIONCANCELED (0x8013153B) if the operation was canceled before processing was complete.

[Optional] DkmStackWalkFrame[] represents a frame on a call stack which has been walked, but may not have been formatted or filtered. Formatted frames are represented by DkmStackFrame instead. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

Creates a new result structure to hold the output from a successful call to DkmRawStackContext.GetNextRawFrames.

[In] DkmStackWalkFrame[] represents a frame on a call stack which has been walked, but may not have been formatted or filtered. Formatted frames are represented by DkmStackFrame instead.

Marshal a native struct to managed

Pointer to native struct. Managed object.

Obtain a pointer to the native object used to call into native.

Outgoing managed->native call Native object

Validate the fields of this structure

Struct that holds the field path (ex: "myArgument.StructField")

Result of an asynchronous DkmAsyncStackWalkContext.GetTaskContinuationFrames call.

Creates a new result structure to hold the error from a failed call to DkmAsyncStackWalkContext.GetTaskContinuationFrames.

[In] exception object containing the error

HRESULT code returned from the caller. This will be DkmExceptionCode.COR_E_OPERATIONCANCELED (0x8013153B) if the operation was canceled before processing was complete.

The frames that will execute when this task completes. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

Creates a new result structure to hold the output from a successful call to DkmAsyncStackWalkContext.GetTaskContinuationFrames.

[In] The frames that will execute when this task completes.

Marshal a native struct to managed

Pointer to native struct. Managed object.

Obtain a pointer to the native object used to call into native.

Outgoing managed->native call Native object

Validate the fields of this structure

Struct that holds the field path (ex: "myArgument.StructField")

Result of an asynchronous DkmAsyncStackWalkContext.GetTaskCreationStack call.

Creates a new result structure to hold the error from a failed call to DkmAsyncStackWalkContext.GetTaskCreationStack.

[In] exception object containing the error

HRESULT code returned from the caller. This will be DkmExceptionCode.COR_E_OPERATIONCANCELED (0x8013153B) if the operation was canceled before processing was complete.

The creation stack of this task. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

Creates a new result structure to hold the output from a successful call to DkmAsyncStackWalkContext.GetTaskCreationStack.

[In] The creation stack of this task.

Marshal a native struct to managed

Pointer to native struct. Managed object.

Obtain a pointer to the native object used to call into native.

Outgoing managed->native call Native object

Validate the fields of this structure

Struct that holds the field path (ex: "myArgument.StructField")

Result of an asynchronous DkmStackWalkContext.HeuristicWalkFrames call.

Creates a new result structure to hold the error from a failed call to DkmStackWalkContext.HeuristicWalkFrames.

[In] exception object containing the error

HRESULT code returned from the caller. This will be DkmExceptionCode.COR_E_OPERATIONCANCELED (0x8013153B) if the operation was canceled before processing was complete.

DkmStackWalkFrame[] represents a frame on a call stack which has been walked, but may not have been formatted or filtered. Formatted frames are represented by DkmStackFrame instead.

[Optional] NextRegisters indicates the registers of the next frame (the caller of 'FrameObject'). This will be null if the stack is complete, or if the EndStackPointer was reached.

Returns true if the monitor reached the end of the stack.

Creates a new result structure to hold the output from a successful call to DkmStackWalkContext.HeuristicWalkFrames.

[In] DkmStackWalkFrame[] represents a frame on a call stack which has been walked, but may not have been formatted or filtered. Formatted frames are represented by DkmStackFrame instead. [In,Optional] NextRegisters indicates the registers of the next frame (the caller of 'FrameObject'). This will be null if the stack is complete, or if the EndStackPointer was reached. [In] Returns true if the monitor reached the end of the stack.

Marshal a native struct to managed

Pointer to native struct. Managed object.

Obtain a pointer to the native object used to call into native.

Outgoing managed->native call Native object

Validate the fields of this structure

Struct that holds the field path (ex: "myArgument.StructField")

DkmMonitorStackWalkContext allows the various components DkmSymbolStackWalkContext with this call stack.

The DkmRuntimeInstance class represents an execution environment which is loaded into a DkmProcess and which contains code to be debugged.

DkmThread represents a thread running in the target process.

[Optional] The initial Win32 CONTEXT to use when performing the stack walk. This value is normally 'null' but can be set in order to view another call stack (ex: .cxr).

Guid which uniquely identifies this DkmMonitorStackWalkContext.

Closes a DkmMonitorStackWalkContext object instance. This will release any resources associated with this object across all components. This includes resources across computer or managed/native marshalling boundaries. DkmMonitorStackWalkContext objects are automatically closed when their associated DkmThread object is closed. This method may only be called by the component which created the object. Location constraint: API must be called from a Monitor component (component level < 100,000).

Create a new DkmMonitorStackWalkContext object instance. The caller is responsible for closing the created object after they are done. Location constraint: API must be called from a Monitor component (component level < 100,000).

[In] The DkmRuntimeInstance class represents an execution environment which is loaded into a DkmProcess and which contains code to be debugged. [In] DkmThread represents a thread running in the target process. [In,Optional] The initial Win32 CONTEXT to use when performing the stack walk. This value is normally 'null' but can be set in order to view another call stack (ex: .cxr). [In,Optional] Data object to add to the new DkmMonitorStackWalkContext instance. Pass 'null' in the case that the caller doesn't need to add a data item. [Out] Result of this method call.

Initialize is invoked on each walker exactly once at the beginning of the walk process. This gives each walker a chance to initialize any state. Location constraint: API must be called from a Monitor component (component level < 100,000).

[In] Registers to attempt to walk from. [In] Size of the stack range that the debugger will attempt to walk through.

Attempt to walk the next stack frame. The DkmMonitorStackWalkResult structure indicates if this monitor was able to walk the frame. Location constraint: API must be called from a Monitor component (component level < 100,000).

[Out] Return result from IDkmMonitorStackWalk.

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Return result from IDkmMonitorStackWalk.

Status code for the walk.

[Optional] NextRegisters is required when 'Status' is 'FrameFound'. NextRegisters is used to inform other walkers where the previous walker left off. If an walker fails to return the next registers then the walk will be truncated.

[Optional] FrameObject is required when 'Status' is 'FrameFound'. This object contains information about the stack frame.

NextStackPointer is required when 'Status' is 'OutsideOfRuntime'. This is used by the stack frame merger to advance the stack walk when frames are encountered which cannot be monitor walked (walking requires symbols). The stack frame merger will not invoke the walker again until it has progressed to this stack pointer value, and the walker should update its state so that the next call to 'WalkNextFrame' retrieves the frame at this position.

Initialize a new DkmMonitorStackWalkResult value. Location constraint: API must be called from a Monitor component (component level < 100,000).

[In] Status code for the walk. [In,Optional] NextRegisters is required when 'Status' is 'FrameFound'. NextRegisters is used to inform other walkers where the previous walker left off. If an walker fails to return the next registers then the walk will be truncated. [In,Optional] FrameObject is required when 'Status' is 'FrameFound'. This object contains information about the stack frame. [In] NextStackPointer is required when 'Status' is 'OutsideOfRuntime'. This is used by the stack frame merger to advance the stack walk when frames are encountered which cannot be monitor walked (walking requires symbols). The stack frame merger will not invoke the walker again until it has progressed to this stack pointer value, and the walker should update its state so that the next call to 'WalkNextFrame' retrieves the frame at this position.

Marshal a native struct to managed

Pointer to native struct. Managed object.

Obtain a pointer to the native object used to call into native.

Outgoing managed->native call Native object

Validate the fields of this structure

Struct that holds the field path (ex: "myArgument.StructField")

DkmRawStackContext objects are created by components that wish to request the raw (unfiltered and unformatted) stack from the stack provider. A component needs to close the context after they have completed the stack walk. To obtain the stack a component should create this object and then call GetNextRawFrames. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

DkmThread represents a thread running in the target process. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

[Optional] The initial thread context to use when performing the stack walk. This value is normally 'null' but can be set in order to view another call stack (ex: .cxr). This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

Guid which uniquely identifies this DkmRawStackContext. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

Closes a DkmRawStackContext object instance. This will release any resources associated with this object across all components. This includes resources across computer or managed/native marshalling boundaries. DkmRawStackContext objects are automatically closed when their associated DkmThread object is closed. This method may only be called by the component which created the object. Location constraint: API must be called from an IDE component (component level > 100,000). This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

Create a new DkmRawStackContext object instance. The caller is responsible for closing the created object after they are done. Location constraint: API must be called from an IDE component (component level > 100,000). This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

[In] DkmThread represents a thread running in the target process. [In,Optional] The initial thread context to use when performing the stack walk. This value is normally 'null' but can be set in order to view another call stack (ex: .cxr). [In,Optional] Data object to add to the new DkmRawStackContext instance. Pass 'null' in the case that the caller doesn't need to add a data item. [Out] Result of this method call.

Obtain the next raw frames from the call stack. If this is the first call on a particular DkmRawStackContext then this will return the first frames. This method is the recommended way to obtain the call stack because the stack provider maintains a cache of the physical stack. This method will append a new work item to the specified work list, and return once the work item has been appended. The actual processing of the work item is asynchronous. The caller will be notified that the request is complete through the completion routine. Location constraint: API must be called from an IDE component (component level > 100,000). This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

WorkList to append the new work item to. [In] RequestCount is the number of frames that the caller would like returned. The implementation of GetNextRawFrames may return fewer frames in the case that stack does not contain that many frames. Negative values, or request to read more than MaxFrames (currently 5,000) will be capped to MaxFrames. Routine to fire when the request is complete. If the request is successfully appended to the work list, this will always fire (including when the operation is canceled). This will never fire if appending the work item fails.

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Result of an asynchronous DkmStackWalkContext.RuntimeWalkNextFramesAndCheckCache164 call.

Creates a new result structure to hold the error from a failed call to DkmStackWalkContext.RuntimeWalkNextFramesAndCheckCache164.

[In] exception object containing the error

HRESULT code returned from the caller. This will be DkmExceptionCode.COR_E_OPERATIONCANCELED (0x8013153B) if the operation was canceled before processing was complete.

Array of walked frames. For, unresolved frames, both InstructionAddress and Description will be null. This API was introduced in Visual Studio 16 Update 4 (DkmApiVersion.VS16Update4).

Returns true if the monitor reached the end of the stack. This API was introduced in Visual Studio 16 Update 4 (DkmApiVersion.VS16Update4).

[Optional] The actual hash of the call stack. This may be NULL for runtimes that don't support call stack hashing. This API was introduced in Visual Studio 16 Update 4 (DkmApiVersion.VS16Update4).

The DkmStackWalkContext object that can used later to continue the walk. If the cache is valid, this is the original context. If the cache is invalid, this will be a new DkmStackWalkContext object. This API was introduced in Visual Studio 16 Update 4 (DkmApiVersion.VS16Update4).

True if the cache was valid, false if not. This API was introduced in Visual Studio 16 Update 4 (DkmApiVersion.VS16Update4).

Creates a new result structure to hold the output from a successful call to DkmStackWalkContext.RuntimeWalkNextFramesAndCheckCache164.

[In] Array of walked frames. For, unresolved frames, both InstructionAddress and Description will be null. [In] Returns true if the monitor reached the end of the stack. [In,Optional] The actual hash of the call stack. This may be NULL for runtimes that don't support call stack hashing. [In] The DkmStackWalkContext object that can used later to continue the walk. If the cache is valid, this is the original context. If the cache is invalid, this will be a new DkmStackWalkContext object. [In] True if the cache was valid, false if not.

Marshal a native struct to managed

Pointer to native struct. Managed object.

Obtain a pointer to the native object used to call into native.

Outgoing managed->native call Native object

Validate the fields of this structure

Struct that holds the field path (ex: "myArgument.StructField")

Result of an asynchronous DkmStackWalkContext.RuntimeWalkNextFramesAndCheckCache call.

Creates a new result structure to hold the error from a failed call to DkmStackWalkContext.RuntimeWalkNextFramesAndCheckCache.

[In] exception object containing the error

HRESULT code returned from the caller. This will be DkmExceptionCode.COR_E_OPERATIONCANCELED (0x8013153B) if the operation was canceled before processing was complete.

Array of walked frames. For, unresolved frames, both InstructionAddress and Description will be null.

Returns true if the monitor reached the end of the stack.

[Optional] The actual hash of the call stack. This may be NULL for runtimes that don't support call stack hashing.

The DkmStackWalkContext object that can used later to continue the walk. If the cache is valid, this is the original context. If the cache is invalid, this will be a new DkmStackWalkContext object.

True if the cache was valid, false if not.

Creates a new result structure to hold the output from a successful call to DkmStackWalkContext.RuntimeWalkNextFramesAndCheckCache.

Marshal a native struct to managed

Pointer to native struct. Managed object.

Obtain a pointer to the native object used to call into native.

Outgoing managed->native call Native object

Validate the fields of this structure

Struct that holds the field path (ex: "myArgument.StructField")

Result of an asynchronous DkmStackWalkContext.RuntimeWalkNextFrames call.

Creates a new result structure to hold the error from a failed call to DkmStackWalkContext.RuntimeWalkNextFrames.

[In] exception object containing the error

HRESULT code returned from the caller. This will be DkmExceptionCode.COR_E_OPERATIONCANCELED (0x8013153B) if the operation was canceled before processing was complete.

Array of walked frames. For, unresolved frames, both InstructionAddress and Description will be null.

Returns true if the monitor reached the end of the stack.

Creates a new result structure to hold the output from a successful call to DkmStackWalkContext.RuntimeWalkNextFrames.

[In] Array of walked frames. For, unresolved frames, both InstructionAddress and Description will be null. [In] Returns true if the monitor reached the end of the stack.

Marshal a native struct to managed

Pointer to native struct. Managed object.

Obtain a pointer to the native object used to call into native.

Outgoing managed->native call Native object

Validate the fields of this structure

Struct that holds the field path (ex: "myArgument.StructField")

DkmStackContext objects are created by components that wish to request the stack from the stack provider. A component needs to close the context after they have completed the stack walk. To obtain the stack a component should create this object and then call GetNextFrames. Derived classes: DkmStackTraceContext

DkmInspectionSession allows the various components which inspect data to store private data which is associated with a group of evaluations.

DkmThread represents a thread running in the target process.

Options for how the call stack should be filtered.

Collection of settings that affect how the stack provider formats a DkmStackFrame.

[Optional] The initial thread context to use when performing the stack walk. This value is normally 'null' but can be set in order to view another call stack (ex: .cxr).

Guid which uniquely identifies this DkmStackContext.

[Optional] If we are fetching the continuation frames or task creation frames, specifies the context for the async stack walk operation. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

Which type of stack walk we are doing. If the operation is AsyncReturnStackWalk or AsyncTaskCreationStackWalk, "Task" must be non-null. Otherwise, "AsyncContext" must be NULL. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

Closes a DkmStackContext object instance. This will release any resources associated with this object across all components. This includes resources across computer or managed/native marshalling boundaries. DkmStackContext objects are automatically closed when their associated DkmInspectionSession object is closed. This method may only be called by the component which created the object. Location constraint: API must be called from an IDE component (component level > 100,000).

Create a new DkmStackContext object instance. The caller is responsible for closing the created object after they are done. Location constraint: API must be called from an IDE component (component level > 100,000).

[In] DkmInspectionSession allows the various components which inspect data to store private data which is associated with a group of evaluations. [In] DkmThread represents a thread running in the target process. [In] Options for how the call stack should be filtered. [In] Collection of settings that affect how the stack provider formats a DkmStackFrame. [In,Optional] The initial thread context to use when performing the stack walk. This value is normally 'null' but can be set in order to view another call stack (ex: .cxr). [In,Optional] If we are fetching the continuation frames or task creation frames, specifies the context for the async stack walk operation. [In] Which type of stack walk we are doing. If the operation is AsyncReturnStackWalk or AsyncTaskCreationStackWalk, "Task" must be non-null. Otherwise, "AsyncContext" must be NULL. [In,Optional] Data object to add to the new DkmStackContext instance. Pass 'null' in the case that the caller doesn't need to add a data item. [Out] Result of this method call.

Obtain the next frames from the call stack. If this is the first call on a particular DkmStackContext then this will return the first frames. This method is the recommended way to obtain the call stack because the stack provider maintains a cache of the physical stack. This method will append a new work item to the specified work list, and return once the work item has been appended. The actual processing of the work item is asynchronous. The caller will be notified that the request is complete through the completion routine. Location constraint: API must be called from an IDE component (component level > 100,000).

WorkList to append the new work item to. [In] RequestSize is the number of frames that the caller would like returned. The implementation of GetNextFrames may return fewer frames in the case that stack does not contain that many frames. Negative values, or request to read more than MaxFrames (currently 5,000) will be capped to MaxFrames. Routine to fire when the request is complete. If the request is successfully appended to the work list, this will always fire (including when the operation is canceled). This will never fire if appending the work item fails.

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

DkmStackFrame represents a frame on the call stack after filtering and translation.

Collection of settings that affect how the stack provider formats a DkmStackFrame.

LanguageId/VendorId for the compiler which produced the code for this stack frame. If this is unknown (ex: no symbols loaded for this module), both values will be Guid.Empty. Otherwise, both values should be non-zero.

Name of the stack frame. DkmStackFrame.FormatOptions determines the format of the function name.

[Optional] Name of the stack frame's return type. This is only provided when DkmFrameNameFormatOptions.ReturnTypeField is set.

[Optional] Source code location for this stack frame. This is only provided when DkmFrameNameFormatOptions.DocumentPositionField is set.

Specifies if this stack frame is stale or not after an Edit and Continue. This API was introduced in Visual Studio 15 Update 6 (DkmApiVersion.VS15Update6).

Create a new DkmStackFrame object instance. Location constraint: API must be called from an IDE component (component level > 100,000).

[In] Frame represents a frame on the call stack after filtering and translation. [In] Collection of settings that affect how the stack provider formats a DkmStackFrame. [In] LanguageId/VendorId for the compiler which produced the code for this stack frame. If this is unknown (ex: no symbols loaded for this module), both values will be Guid.Empty. Otherwise, both values should be non-zero. [In] Name of the stack frame. DkmStackFrame.FormatOptions determines the format of the function name. [In,Optional] Name of the stack frame's return type. This is only provided when DkmFrameNameFormatOptions.ReturnTypeField is set. [In,Optional] Source code location for this stack frame. This is only provided when DkmFrameNameFormatOptions.DocumentPositionField is set. [Out] Result of this method call.

Create a new DkmStackFrame object instance. Location constraint: API must be called from an IDE component (component level > 100,000). This API was introduced in Visual Studio 15 Update 6 (DkmApiVersion.VS15Update6).

[In] The address for which to obtain the effective addresses. [Out] The collection of effective addresses for this instruction if any.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Obtains a DkmStackFrame from a DTE (debugger automation) stack frame object. This API is used by Visual Studio packages or addins which wish to access the Concord API to obtain more detailed information about the debugged process. The automation object is often obtained from the 'OnContextChanged' automation event, or from the Debugger.CurrentStackFrame property. This API will only function correctly from the main thread of Visual Studio.

AD7 stack frame object [Optional] DkmStackFrame which backs the AD7 object. NULL in the case that this stack frame is not backed by a Concord frame (ex: frame from the SQL debug engine).

Obtains a DkmStackFrame from an AD7 stack frame object. This API is used by Visual Studio packages or addins which wish to access the Concord API to obtain more detailed information about the debugged process. This API will only function correctly from the main thread of Visual Studio.

AD7 stack frame object [Optional] DkmStackFrame which backs the AD7 object. NULL in the case that this stack frame is not backed by a Concord frame (ex: frame from the SQL debug engine).

Information used to determine whether a cache of a call stack is valid.

The thread the cache applies to.

The range of the thread's stack.

MD5 hash of the thread's CONTEXT structure at the point in which the cache was created.

MD5 hash of the stack memory of the thread at the point in which the cache was created.

Create a new DkmStackHash object instance.

[In] The thread the cache applies to. [In] The range of the thread's stack. [In] MD5 hash of the thread's CONTEXT structure at the point in which the cache was created. [In] MD5 hash of the stack memory of the thread at the point in which the cache was created. [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Information used to determine whether a cache of a call stack is valid. This. This API was introduced in Visual Studio 16 Update 4 (DkmApiVersion.VS16Update4).

The thread the cache applies to. This API was introduced in Visual Studio 16 Update 4 (DkmApiVersion.VS16Update4).

The range of the thread's stack. This API was introduced in Visual Studio 16 Update 4 (DkmApiVersion.VS16Update4).

Hash of the thread's CONTEXT structure at the point in which the cache was created. This API was introduced in Visual Studio 16 Update 4 (DkmApiVersion.VS16Update4).

Hash of the stack memory of the thread at the point in which the cache was created. This API was introduced in Visual Studio 16 Update 4 (DkmApiVersion.VS16Update4).

Creates a new DkmStackHash164 object. This API was introduced in Visual Studio 16 Update 4 (DkmApiVersion.VS16Update4).

[In] The thread the cache applies to. [In] The range of the thread's stack. [In] Hash of the thread's CONTEXT structure at the point in which the cache was created. [In] Hash of the stack memory of the thread at the point in which the cache was created. [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

The limit/base address for the memory containing a thread's stack.

Compare two elements of the DkmStackMemoryRange structure.

Value to comare against this instance. 'true' if the two elements are equal.

Compare two elements of the DkmStackMemoryRange sructure.

Left side of the comparison Right side of the comparison

Compare two elements of the DkmStackMemoryRange sructure.

Left side of the comparison Right side of the comparison

Compare two elements of the DkmStackMemoryRange sructure.

Left side of the comparison Right side of the comparison

Compare two elements of the DkmStackMemoryRange sructure.

Left side of the comparison Right side of the comparison

Compare two elements of the DkmStackMemoryRange sructure.

Left side of the comparison Right side of the comparison

Compare two elements of the DkmStackMemoryRange sructure.

Left side of the comparison Right side of the comparison

The address where this thread's stack began. Since stacks grow down in Windows, these value will be larger than the limit.

The minimum address which is allocated in the stack's range.

Initialize a new DkmStackMemoryRange value.

[In] The address where this thread's stack began. Since stacks grow down in Windows, these value will be larger than the limit. [In] The minimum address which is allocated in the stack's range.

A stack context backed by an explicit list of frames, for example, a captured stack trace from an exception. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

The captured frames to use. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

Create a new DkmStackTraceContext object instance. The caller is responsible for closing the created object after they are done. Location constraint: API must be called from an IDE component (component level > 100,000). This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

[In] DkmInspectionSession allows the various components which inspect data to store private data which is associated with a group of evaluations. [In] DkmThread represents a thread running in the target process. [In] Options for how the call stack should be filtered. [In] Collection of settings that affect how the stack provider formats a DkmStackFrame. [In,Optional] The initial thread context to use when performing the stack walk. This value is normally 'null' but can be set in order to view another call stack (ex: .cxr). [In,Optional] If we are fetching the continuation frames or task creation frames, specifies the context for the async stack walk operation. [In] Which type of stack walk we are doing. If the operation is AsyncReturnStackWalk or AsyncTaskCreationStackWalk, "Task" must be non-null. Otherwise, "AsyncContext" must be NULL. [In] The captured frames to use. [In,Optional] Data object to add to the new DkmStackTraceContext instance. Pass 'null' in the case that the caller doesn't need to add a data item. [Out] Result of this method call.

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

DkmStackWalkContext allows the various components which walk, filter, or examine call stacks to store private data which is associated with this call stack.

DkmThread represents a thread running in the target process.

[Optional] The initial Win32 CONTEXT to use when performing the stack walk. This value is normally 'null' but can be set in order to view another call stack (ex: .cxr).

Guid which uniquely identifies this DkmStackWalkContext.

Stack pointer for the top stack frame. This API was introduced in Visual Studio 15 Update 6 (DkmApiVersion.VS15Update6).

Closes a DkmStackWalkContext object instance. This will release any resources associated with this object across all components. This includes resources across computer or managed/native marshalling boundaries. DkmStackWalkContext objects are automatically closed when their associated DkmThread object is closed.

Create a new DkmStackWalkContext object instance.

[In] DkmThread represents a thread running in the target process. [In,Optional] The initial Win32 CONTEXT to use when performing the stack walk. This value is normally 'null' but can be set in order to view another call stack (ex: .cxr). [In,Optional] Data object to add to the new DkmStackWalkContext instance. Pass 'null' in the case that the caller doesn't need to add a data item. [Out] Result of this method call.

Create a new DkmStackWalkContext object instance. This API was introduced in Visual Studio 15 Update 6 (DkmApiVersion.VS15Update6).

[In] DkmThread represents a thread running in the target process. [In,Optional] The initial Win32 CONTEXT to use when performing the stack walk. This value is normally 'null' but can be set in order to view another call stack (ex: .cxr). [In] Stack pointer for the top stack frame. [In,Optional] Data object to add to the new DkmStackWalkContext instance. Pass 'null' in the case that the caller doesn't need to add a data item. [Out] Result of this method call.

Find a DkmSymbolStackWalkContext element within this DkmStackWalkContext. If no element with the given input key is present, FindSymbolStackWalkContext will fail.

[In] Search key used to find the element. [Out,Optional] Result of the search.

[In] Registers to attempt to walk from. [In] RequestSize is the number of frames that the caller would like returned. The implementation of HeuristicWalkFrames may return fewer frames in the case that stack does not contain that many frames. [In] Stack address to stop the unwinding at. This value is UInt64.MaxValue if the no end stack pointer is present. [Out,Optional] NextRegisters indicates the registers of the next frame (the caller of 'FrameObject'). This will be null if the stack is complete, or if the EndStackPointer was reached. [Out] Returns true if the monitor reached the end of the stack. [Out] DkmStackWalkFrame[] represents a frame on a call stack which has been walked, but may not have been formatted or filtered. Formatted frames are represented by DkmStackFrame instead.

Attempt to walk through a region of the stack using a heuristic stack walk algorithm. This is used in x86 when no symbols are available. It is not implemented on other platforms as PDATA allows walking of all frames. This method will append a new work item to the specified work list, and return once the work item has been appended. The actual processing of the work item is asynchronous. The caller will be notified that the request is complete through the completion routine.

WorkList to append the new work item to. [In] Registers to attempt to walk from. [In] RequestSize is the number of frames that the caller would like returned. The implementation of HeuristicWalkFrames may return fewer frames in the case that stack does not contain that many frames. [In] Stack address to stop the unwinding at. This value is UInt64.MaxValue if the no end stack pointer is present. Routine to fire when the request is complete. If the request is successfully appended to the work list, this will always fire (including when the operation is canceled). This will never fire if appending the work item fails.

[In] RequestSizeHintIfCacheIsValid is a hint as to the number of frame that the caller needs. This value is treated as a hint because this API can return frames which are not yet walked, so this API may return more or less than the hint value. A request size hint of 0 means not to do any stack walking at all if the cache is valid. [In] RequestSizeHintIfCacheIsInvalid is a hint as to the number of frame that the caller needs. This value is treated as a hint because this API can return frames which are not yet walked, so this API may return more or less than the hint value. [In,Optional] Cached call stack hash, will not walk the stack if cache is still valid. This parameter is optional. If null, we will still compute the actual hash and do the stack walk, but will skip the comparing of the actual hash against the cached hash to suppress the stack walk. [Out] Returns true if the monitor reached the end of the stack. [Out,Optional] The actual hash of the call stack. This may be NULL for runtimes that don't support call stack hashing. [Out] The DkmStackWalkContext object that can used later to continue the walk. If the cache is valid, this is the original context. If the cache is invalid, this will be a new DkmStackWalkContext object. [Out] True if the cache was valid, false if not. [Out] Array of walked frames. For, unresolved frames, both InstructionAddress and Description will be null.

Deprecated. Do not use this method, it returns out-dated hash values; use IDkmMergedMonitorStackWalk164::RuntimeWalkNextFramesAndCheckCache164 instead. Version of RuntimeWalkNextFrames() that also checks if a cached copy of the call stack is still valid. This method will append a new work item to the specified work list, and return once the work item has been appended. The actual processing of the work item is asynchronous. The caller will be notified that the request is complete through the completion routine.

WorkList to append the new work item to. [In] RequestSizeHintIfCacheIsValid is a hint as to the number of frame that the caller needs. This value is treated as a hint because this API can return frames which are not yet walked, so this API may return more or less than the hint value. A request size hint of 0 means not to do any stack walking at all if the cache is valid. [In] RequestSizeHintIfCacheIsInvalid is a hint as to the number of frame that the caller needs. This value is treated as a hint because this API can return frames which are not yet walked, so this API may return more or less than the hint value. [In,Optional] Cached call stack hash, will not walk the stack if cache is still valid. This parameter is optional. If null, we will still compute the actual hash and do the stack walk, but will skip the comparing of the actual hash against the cached hash to suppress the stack walk. Routine to fire when the request is complete. If the request is successfully appended to the work list, this will always fire (including when the operation is canceled). This will never fire if appending the work item fails.

[In] RequestSizeHint is a hint as to the number of frame that the caller needs. This value is treated as a hint because this API can return frames which are not yet walked, so this API may return more or less than the hint value. [Out] Returns true if the monitor reached the end of the stack. [Out] Array of walked frames. For, unresolved frames, both InstructionAddress and Description will be null.

Attempt to walk the stack without the use of symbols. This will call into various components that know how to walk portions of the stack (ex: CLR frames will be walked by the CLR debug monitor). An 'unresolved' frame will be left for portions of the stack which cannot be walked without information stored within the symbol file. These 'unresolved' frames have no InstructionAddress or Description. This method will append a new work item to the specified work list, and return once the work item has been appended. The actual processing of the work item is asynchronous. The caller will be notified that the request is complete through the completion routine.

WorkList to append the new work item to. [In] RequestSizeHint is a hint as to the number of frame that the caller needs. This value is treated as a hint because this API can return frames which are not yet walked, so this API may return more or less than the hint value. Routine to fire when the request is complete. If the request is successfully appended to the work list, this will always fire (including when the operation is canceled). This will never fire if appending the work item fails.

Version of RuntimeWalkNextFrames() that also checks if a cached copy of the call stack is still valid. This API was introduced in Visual Studio 16 Update 4 (DkmApiVersion.VS16Update4).

Version of RuntimeWalkNextFrames() that also checks if a cached copy of the call stack is still valid. This method will append a new work item to the specified work list, and return once the work item has been appended. The actual processing of the work item is asynchronous. The caller will be notified that the request is complete through the completion routine. This API was introduced in Visual Studio 16 Update 4 (DkmApiVersion.VS16Update4).

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

DkmStackWalkFrame represents a frame on a call stack which has been walked, but may not have been formatted or filtered. Formatted frames are represented by DkmStackFrame instead. Derived classes: DkmStackFrame

The thread that this stack frame is on.

[Optional] The instruction of this frame. This can be omitted for annotated frames.

Base stack pointer of the frame. This is used by the SDM to sort the frame, and it is used by the stack merger to assess walk progress, so this value is required even for annotated frames. This value should only be invalid in the case that the debuggee's stack is corrupt.

Number of bytes of the stack consumed by this frame. This value will be zero for annotated frames, or if the value is unknown.

Flags properties of a DkmStackWalkFrame.

[Optional] Description of the frame which will be displayed in the call stack window. This should be provided for annotated frames.

[Optional] Registers of the walked frame. These should be provided for non-annotated frames.

[Optional] A read only collection of stack frame annotations. These are defined by an unwinder and are specific to that unwinder. An example usage is how inline frame data is passed from inline stack filter to the formatter.

[Optional] If we have an annotated frame, specifies an optional module instance to associate with this frame. If present, the user will be able to load binaries or symbols for this module by right-clicking on this frame in the call stack window. This is NULL for non-annotated frames. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

[Optional] Optional context for walking async return stacks and task creation stacks. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

[Optional] Optional object to attach to a DkmStackWalkFrame, allowing components to associate additional private data with the frame. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

[Optional] Contains basic info about the DkmInstructionSymbol corresponding to the frame's InstructionAddress. For native frames, this will be computed by the StackProvider before the frame is passed to a stack filter. This will always be null for a DkmStackFrame. This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTMPreview).

[Optional] The DkmRuntimeInstance class represents an execution environment which is loaded into a DkmProcess and which contains code to be debugged.

Create a new DkmStackWalkFrame object instance.

Create a new DkmStackWalkFrame object instance. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

[In] The thread that this stack frame is on. [In,Optional] The instruction of this frame. This can be omitted for annotated frames. [In] Base stack pointer of the frame. This is used by the SDM to sort the frame, and it is used by the stack merger to assess walk progress, so this value is required even for annotated frames. This value should only be invalid in the case that the debuggee's stack is corrupt. [In] Number of bytes of the stack consumed by this frame. This value will be zero for annotated frames, or if the value is unknown. [In] Flags properties of a DkmStackWalkFrame. [In,Optional] Description of the frame which will be displayed in the call stack window. This should be provided for annotated frames. [In,Optional] Registers of the walked frame. These should be provided for non-annotated frames. [In,Optional] A read only collection of stack frame annotations. These are defined by an unwinder and are specific to that unwinder. An example usage is how inline frame data is passed from inline stack filter to the formatter. [In,Optional] If we have an annotated frame, specifies an optional module instance to associate with this frame. If present, the user will be able to load binaries or symbols for this module by right-clicking on this frame in the call stack window. This is NULL for non-annotated frames. [In,Optional] Optional context for walking async return stacks and task creation stacks. [In,Optional] Optional object to attach to a DkmStackWalkFrame, allowing components to associate additional private data with the frame. [Out] Result of this method call.

Create a new DkmStackWalkFrame object instance. This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTMPreview).

OnSetNextStatementCompleted is a general purpose method to allow components to clear state after a set next statement completed. The DkmStackWalkFrame will be the frame prior to to the SetNextStatement call. Location constraint: This API should generally be called only from client-side components. However, it is safe for a monitor-side component to call this API if the set next statement is being called from an event handler.

InterceptCurrentException is used to unwind to this frame as if there was an exception handler at that frame.

[In] Specifies exception interception actions. [Out] Cookie that represents this intercept request. The value is returned when an exception interception completed event is sent.

Returns the address that represents the location if an exception were to be intercepted to this frame.

[Out] Possible new address if an exception was unwound to this frame.

SetNextStatement moves the IP of a stack frame. The stack frame is always the leaf stack frame on a particular thread.

[In] Abstract representation of an executable code location (ex: EIP value). If resolved, an Instruction Address will be within a particular module instance. An Instruction Address is always within a particular Runtime Instance. [Out] The error code to return to the UI. This should be S_OK or the value of a failed HRESULT that the UI can map to an error message.

[In] DkmInspectionSession allows the various components which inspect data to store private data which is associated with a group of evaluations. [In] Collection of settings that affect how the stack provider formats a DkmStackFrame. [Out] DkmStackFrame represents a frame on the call stack after filtering and translation.

Return a DkmInstructionSymbol for a stack frame. If the stack frame has no instruction address (annotated frame) or the instruction address has no associated DkmModule, then GetInstructionSymbol will return null (S_FALSE in native code).

[Out,Optional] DkmInstructionSymbol represents a method in the target process.

GetInspectionInterface is used to obtain a ICorDebugFrame or other implementation-specific interfaces which a component can use to deeply inspect the stack frame. The returned interface may ONLY be used to inspect the target process, and should NEVER be used to control execution (no stepping, no breakpoints, no continue, etc). Doing so is unsupported and will result in undefined behavior. NOTE: Using this method from managed code is not recommended for performance reasons. Marshalling of DkmStackWalkFrame between native and managed code is expensive. Use DkmRuntimeInstance.GetFrameInspectionInterface instead. Location constraint: This API must be called from the same process where the target runtime implements stack walk. For managed debugging, this means that when debugging 64-bit or remote processes, this API must be called from a debug monitor component.

[In] DkmInspectionSession allows the various components which inspect data to store private data which is associated with a group of evaluations. [In] The GUID of the desired interface. IID_ICorDebugFrame can be used to obtain the CorDebug frame interface for a managed frame. Other debug monitors or stack walkers may provide their own interface. [Out] Returned frame interface. This may be cast to the interface pointer corresponding to 'InterfaceID'.

Determines whether or not a frame is user code. Location constraint: API must be called from an IDE component (component level > 100,000). This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

[In,Optional] Optional inspection session which may be used for caching purposes. The same inspection session is reused when computing the user status of multiple frames in succession. [Out] True if the frame is library code that implements the throwing of exceptions. This will cause the frame to be collapsed if we are stopped here in response to an exception being thrown. [Out] True if the frame is user code, false if the frame is nonuser code.

Gets the generic parameters for the current stack frame as a list of assembly qualified names. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

[Out] The list of assembly qualified names for the type parameters, if any, followed by the method parameters, if any.

Gets the generic parameters for the current stack frame as a list of assembly qualified names. This method will append a new work item to the specified work list, and return once the work item has been appended. The actual processing of the work item is asynchronous. The caller will be notified that the request is complete through the completion routine. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

Evaluates a property on the given ICorDebugValue. The value's type must be loaded by the DkmClrAppDomain of the DkmStackWalkFrame that this $Name$ is being called on. Location constraint: This must be on the remote side because we are passing an ICorDebugHandleValue. This API was introduced in Visual Studio 15 Update 3 (DkmApiVersion.VS15Update3).

[In] The object to interpret a property on. This can be an ICorDebugHandleValue or an ICorDebugObjectValue. [In] The name of the property to interpret. [Out,Optional] The result of the property interpretation.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

A Guid / Value pair set by a frame filter or unwinder. Can be used to pass custom flags about the frame from one component to another.

The Guid that uniquely identifies this annotation flag. This is specific to the creator of the stack walk frame.

The value of this annotation. The meaning of this value is specific to the creator.

[Optional] A variant value of the annotation. The meaning of this value is specific to the creator. This API was introduced in Visual Studio 15 Update 8 (DkmApiVersion.VS15Update8).

Create a new DkmStackWalkFrameAnnotation object instance.

Create a new DkmStackWalkFrameAnnotation object instance. This API was introduced in Visual Studio 15 Update 8 (DkmApiVersion.VS15Update8).

[In] The Guid that uniquely identifies this annotation flag. This is specific to the creator of the stack walk frame. [In] The value of this annotation. The meaning of this value is specific to the creator. [In,Optional] A variant value of the annotation. The meaning of this value is specific to the creator. [Out] Result of this method call.

Gets formatted text associated with the annotation. This is prefixed to the frame name. Location constraint: API must be called from an IDE component (component level > 100,000). This API was introduced in Visual Studio 15 Update 8 (DkmApiVersion.VS15Update8).

[In] The frame containing the annotation. [In] The options specifying the format of the frame. [Out,Optional] The annotation text.

Gets formatted text associated with the annotation. This is prefixed to the frame name. This method will append a new work item to the specified work list, and return once the work item has been appended. The actual processing of the work item is asynchronous. The caller will be notified that the request is complete through the completion routine. Location constraint: API must be called from an IDE component (component level > 100,000). This API was introduced in Visual Studio 15 Update 8 (DkmApiVersion.VS15Update8).

WorkList to append the new work item to. [In] The frame containing the annotation. [In] The options specifying the format of the frame. Routine to fire when the request is complete. If the request is successfully appended to the work list, this will always fire (including when the operation is canceled). This will never fire if appending the work item fails.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Optional reference object that can be used to attach data items to a DkmStackWalkFrame. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

The inspection session that owns this frame data object. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

Guid which uniquely identifies this evaluation result. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

Create a new DkmStackWalkFrameData object instance. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

[In] The inspection session that owns this frame data object. [In,Optional] Data object to add to the new DkmStackWalkFrameData instance. Pass 'null' in the case that the caller doesn't need to add a data item. [Out] Result of this method call.

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Flags properties of a DkmStackWalkFrame.

No flags are set on this stack frame.

Stack frame is the top frame in the call stack. This is used to detect the top frame when the full stack frame collection is not available. Unwinders should set this on top frame when doing an unwind. Unwinders must decide if it makes sense for logical frames (such as inline frames) that appear above physical frame should also be marked. Doing so would result in multiple frames being marked as a top frame.

Stack frame is located within hidden code.

Stack frame is located within non-user code.

Stack frame is an inlined optimized frame, not a physical frame.

Stack frame is used to indicate that the maximum number of walked stack frame has been exceeded.

Stack frame can be unwound to after an exception has been thrown.

Stack frame is an annotated frame that shows what is being evaluated example 'Evaluation of: xyz'.

Indicates that this frame is part of an async return stack and is not actually executing on the current thread.

Indicates that this frame was logged from the call stack of the creation of an async task and is not actually executing on the current thread at this time.

Indicates that it is not yet known whether or not the frame is user code or non-user code. The stack provider will call back to find out.

Indicates that we are an annotated frame indicating that frames below may be missing or incorrect due binaries or symbols not being loaded for a module.

Indicates that we are in nonuser code that is known to be part of the implementation of throwing exceptions.

Indicates that this is an annotated frame denoting an async call (i.e. [Async Call]).

Indicates that this is an annotated frame denoting resuming an async method (i.e. [Resuming async method]).

Indicates that this frame is fake and not backed by a real frame in the target. This flag will never be used for stack frames obtained from stack walk, but can be used for pseudo-frames used to allow inspection.

Indicates that we are an annotated frame and frames below may be missing due to binary not being loaded for a module.

Indicates a type of stack walking operation. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

A regular stack walk of a thread.

A walk of a task's async return stack.

A walk of the logged stack from when a task was created.

A walk of the logic async frames related to a thread that should be displayed in the call stack window.

A walk of a stack trace consisting of a caller-defined list of frames.

Return status from a monitor walk operation.

The walker found a frame within its runtime.

The walker determined that the current frame is outside of it's runtime. Lower priority walkers will be given a chance to walk.

The walker determined that the end of the stack has been reached. StackWalking should stop.

DkmSymbolStackWalkContext allows the various symbol providers which walk the call stack to store private data which is associated with this call stack.

DkmStackWalkContext allows the various components which walk, filter, or examine call stacks to store private data which is associated with this call stack.

Unique identifier for symbol files/symbol providers.

DkmThread represents a thread running in the target process.

[Optional] The initial Win32 CONTEXT to use when performing the stack walk. This value is normally 'null' but can be set in order to view another call stack (ex: .cxr).

Closes a DkmSymbolStackWalkContext object instance. This will release any resources associated with this object across all components. This includes resources across computer or managed/native marshalling boundaries. DkmSymbolStackWalkContext objects are automatically closed when their associated DkmStackWalkContext object is closed. This method may only be called by the component which created the object. Location constraint: API must be called from an IDE component (component level > 100,000).

Create a new DkmSymbolStackWalkContext object instance. The caller is responsible for closing the created object after they are done. Location constraint: API must be called from an IDE component (component level > 100,000).

[In] DkmStackWalkContext allows the various components which walk, filter, or examine call stacks to store private data which is associated with this call stack. [In] Unique identifier for symbol files/symbol providers. [In,Optional] Data object to add to the new DkmSymbolStackWalkContext instance. Pass 'null' in the case that the caller doesn't need to add a data item. [Out] Result of this method call.

[In] Registers to attempt to walk from. [In] Size of the stack range that the debugger will attempt to walk through.

UpdatePosition is invoked by the stack provider after another walker has walked one or more frames, and so this walker must be updated before invoking WalkNextFrame. Location constraint: API must be called from an IDE component (component level > 100,000).

[In] Registers to attempt to walk from. [In] Size of the stack range that the debugger will attempt to walk through. [In] Address from the instruction pointer in the registers. This will be either a 'Native' or 'Unresolved' address.

Walk the next stack frame from the call stack. Location constraint: API must be called from an IDE component (component level > 100,000).

[Out,Optional] NextRegisters indicates the registers of the next frame (the caller of 'FrameObject'). It is used to invoke UpdatePosition if the next frame is owned by a different symbol provider. A null NextRegisters value indicates that the returned frame is the last frame of the call stack, so the stack walk will end here. [Out,Optional] Created frame object for the current registers.

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

DkmUnwoundRegister represents a register of a stack frame that was unwound by an unwinder.

the code-view register constant for this value.

A byte array representing the contents of the register. The size of the register in bytes can be found by the length of this array.

Create a new DkmUnwoundRegister object instance.

[In] the code-view register constant for this value. [In] A byte array representing the contents of the register. The size of the register in bytes can be found by the length of this array. [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

X64 registers. For leaf frames, all registers will be available. For non-leaf frames, only the registers actually unwound by the unwinder will be available. Unwound registers can be found in the DkmFrameRegisters' UnwoundRegisters collection. Rip and Rsp are provided because they are always unwound and accessed often.

Instruction pointer.

Stack pointer.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

X86 registers. For leaf frames, all registers will be available. For non-leaf frames, only the registers actually unwound by the unwinder will be available. Unwound registers can be found in the DkmFrameRegisters' UnwoundRegisters collection. Eip and Esp are provided because they are always unwound and accessed often.

Instruction pointer.

Stack pointer.

VFrame virtual register.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Result of an asynchronous DkmProcess.AddExceptionTrigger call.

Creates a new result structure to hold the error from a failed call to DkmProcess.AddExceptionTrigger.

[In] exception object containing the error

HRESULT code returned from the caller. This will be DkmExceptionCode.COR_E_OPERATIONCANCELED (0x8013153B) if the operation was canceled before processing was complete.

Indicates the type of exception.

C++ Exception.

Win32 Exception.

Common Language Runtime Exception.

Native Run-Time Check.

Managed Debugging Assistant (MDA). These are notifications that come of the CLR to notify the user of problems.

ActiveScript Exception.

GPU Exception.

Describes an entire category (ex: .NET exceptions, Win32 exceptions) that a component wants to break on.

Indicates the type of exception.

Create a new DkmExceptionCategoryTrigger object instance.

Create a new DkmExceptionCategoryTrigger object instance. This API was introduced in Visual Studio 15 RTM (DkmApiVersion.VS15RTM).

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Describe an exception that a component wants to break on by its exception code. Code triggers are used for exception categories which use exception codes to identify exceptions (ex: Win32 exceptions). Code triggers will not fire for exception categories which use a name string to identify exceptions (ex: CLR exceptions).

Indicates the type of exception.

32-bit integer code for the exception. For Win32 exceptions, this is the code passed to RaiseException (ex:EXCEPTION_ACCESS_VIOLATION). This value is zero for exception categories that identify exceptions by string (ex: CLR).

Create a new DkmExceptionCodeTrigger object instance.

[In] The debugger receives notifications from the target process at various stages within exception processing (ex: exception thrown, exception unhandled). This enumeration is a bit mask of which of these stages the trigger should fire for. [In,Optional] Thread on which this trigger applies. If null, the trigger will be examined for all threads. [In] Indicates the type of exception. [In] 32-bit integer code for the exception. For Win32 exceptions, this is the code passed to RaiseException (ex:EXCEPTION_ACCESS_VIOLATION). This value is zero for exception categories that identify exceptions by string (ex: CLR). [Out] Result of this method call.

Create a new DkmExceptionCodeTrigger object instance. This API was introduced in Visual Studio 15 RTM (DkmApiVersion.VS15RTM).

[In] The debugger receives notifications from the target process at various stages within exception processing (ex: exception thrown, exception unhandled). This enumeration is a bit mask of which of these stages the trigger should fire for. [In,Optional] Thread on which this trigger applies. If null, the trigger will be examined for all threads. [In,Optional] Exception condition information. [In] Indicates the type of exception. [In] 32-bit integer code for the exception. For Win32 exceptions, this is the code passed to RaiseException (ex:EXCEPTION_ACCESS_VIOLATION). This value is zero for exception categories that identify exceptions by string (ex: CLR). [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Defines a single exception condition, see DkmExceptionTrigger.ExceptionConditionInfo on setting multiple exception conditions. This API was introduced in Visual Studio 15 RTM (DkmApiVersion.VS15RTM).

Defines what to compare the Value property against. This API was introduced in Visual Studio 15 RTM (DkmApiVersion.VS15RTM).

Defines what part of the call stack of the exception should be scanned. This API was introduced in Visual Studio 15 RTM (DkmApiVersion.VS15RTM).

Determines type of comparison operator to use between the exception and the value. This API was introduced in Visual Studio 15 RTM (DkmApiVersion.VS15RTM).

String comparison value to match against. This API was introduced in Visual Studio 15 RTM (DkmApiVersion.VS15RTM).

Create a new DkmExceptionConditionInfo object instance. This API was introduced in Visual Studio 15 RTM (DkmApiVersion.VS15RTM).

[In] Defines what to compare the Value property against. [In] Defines what part of the call stack of the exception should be scanned. [In] Determines type of comparison operator to use between the exception and the value. [In] String comparison value to match against. [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Contains details about an exception or inner exception object. This API was introduced in Visual Studio 15 RTM (DkmApiVersion.VS15RTM).

The inspection session used to track the lifetime of this instance. This API was introduced in Visual Studio 15 RTM (DkmApiVersion.VS15RTM).

The original exception object. This is always for the original raised exception. If this DkmExceptionDetails came from GetInnerException, this value still represents the containing exception. This API was introduced in Visual Studio 15 RTM (DkmApiVersion.VS15RTM).

Guid which uniquely identifies this exception details object. This API was introduced in Visual Studio 15 RTM (DkmApiVersion.VS15RTM).

Indicates the type of exception. This API was introduced in Visual Studio 15 RTM (DkmApiVersion.VS15RTM).

Closes the exception details object and the resources associated with it. DkmExceptionDetails objects are automatically closed when their associated DkmInspectionSession object is closed. This API was introduced in Visual Studio 15 RTM (DkmApiVersion.VS15RTM).

Create a new DkmExceptionDetails object instance. This API was introduced in Visual Studio 15 RTM (DkmApiVersion.VS15RTM).

[In] The inspection session used to track the lifetime of this instance. [In] The original exception object. This is always for the original raised exception. If this DkmExceptionDetails came from GetInnerException, this value still represents the containing exception. [In,Optional] Data object to add to the new DkmExceptionDetails instance. Pass 'null' in the case that the caller doesn't need to add a data item. [Out] Result of this method call.

[Out] The formatted description.

Gets the message associated with the exception. The message is not formatted. This API was introduced in Visual Studio 15 RTM (DkmApiVersion.VS15RTM).

[Out,Optional] The exception message.

Gets the type name of the exception. This API was introduced in Visual Studio 15 RTM (DkmApiVersion.VS15RTM).

[In] A value indicating whether to return the full name of the exception. [Out] The type name.

Gets the source for this exception. If no source is available, this method returns null. This API was introduced in Visual Studio 15 RTM (DkmApiVersion.VS15RTM).

[Out,Optional] The source string or null if not available. E_NODATA indicates that this exception does not have a source.

Gets the HResult code of this exception. If no stack trace is available, this method returns null. This API was introduced in Visual Studio 15 RTM (DkmApiVersion.VS15RTM).

[Out] The HResult of the exception. E_NODATA indicates that this exception does not have an HResult.

Gets the stack trace for this exception. If no stack trace is available, this method returns null. This API was introduced in Visual Studio 15 RTM (DkmApiVersion.VS15RTM).

[Out,Optional] The stack trace string or null if not available. E_NODATA indicates that this exception does not have a stack trace.

Gets the inner exception if available. If there is no inner exception, this method returns null. This API was introduced in Visual Studio 15 RTM (DkmApiVersion.VS15RTM).

[Out,Optional] The inner exception or null if not available. E_NODATA indicates that this exception does not hold inner exceptions.

Gets the expression that represents the exception object. If no such object is available, this method returns null. This API was introduced in Visual Studio 15 RTM (DkmApiVersion.VS15RTM).

[Out,Optional] Expression for exception object. E_NODATA indicates that there is no EE expression to evaluate to get details for the exception.

Get the ICorDebugValue for the exception object. Location constraint: API must be called from a Monitor component (component level < 100,000). This API was introduced in Visual Studio 15 Update 7 (DkmApiVersion.VS15Update7).

[Out] ICorDebug interface representing an exception.

Gets the call stack for this exception. This API was introduced in Visual Studio 16 Update 4 (DkmApiVersion.VS16Update4).

[In] Specifies whether the call stack is formatted to contain bold/italic/hyperlinked text or not. [In] Flags to indicate what information about the arguments should be included when formulating the call stack. [In] Flags to indicate what filters should be considered when formulating the call stack. [Out] The instruction addresses referenced using 'navigate-to-context' links in formatted stack. Example: '[insert-description-here](navigate-to-context:0)' would indicate the first instruction address should be used. The first element of this array is used to decide if the exception is still at its original location. [Out] The call stack formatted in markdown.

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

An exception trigger which will fire regardless of exception category, exception name, or exception code. Thus, this type of exception trigger can only be conditioned based on processing stage or thread.

Create a new DkmExceptionGlobalTrigger object instance.

Create a new DkmExceptionGlobalTrigger object instance. This API was introduced in Visual Studio 15 RTM (DkmApiVersion.VS15RTM).

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Provides information about an exception which was raised in the target process. This information includes details of what exception was raised and the current stage of exception processing. Derived classes: DkmClrExceptionInformation, DkmCppExceptionInformation, DkmCustomExceptionInformation, DkmGPUMemoryAccessExceptionInformation, DkmWin32ExceptionInformation

DkmExceptionInformation is an abstract base class. This enum indicates which derived class this object is an instance of.

Object is an instance of 'DkmWin32ExceptionInformation'.

Object is an instance of 'DkmClrExceptionInformation'.

Object is an instance of 'DkmCppExceptionInformation'.

Object is an instance of 'DkmGPUMemoryAccessExceptionInformation'.

Object is an instance of 'DkmCustomExceptionInformation'.

DkmExceptionInformation is an abstract base class. This enum indicates which derived class this object is an instance of.

The DkmRuntimeInstance class represents an execution environment which is loaded into a DkmProcess and which contains code to be debugged.

Indicates the type of exception.

DkmThread represents a thread running in the target process.

[Optional] Address where the exception occurred. This will always be present for C++ and Win32 exceptions. It may be missing from CLR exceptions or MDAs as these may originate from inside the runtime.

[Optional] Name of the exception. For C++ or CLR exceptions, this is the type name. This value will be null for exception categories that identify exceptions by code (ex: Win32).

The debugger receives notifications from the target process at various stages within exception processing (ex: exception thrown, exception unhandled). This enumeration indicates the stage(s) for a notification.

[Optional] Information about the underlying exception used to implement a higher level exception. For example, CLR and C++ exceptions may be implemented on top of Win32 exceptions. So this may store the DkmWin32ExceptionInformation for CLR or C++ exceptions.

Raise a DebugMonitorException event. Components which implement the event sink interface will receive the event notification. Control will return once all components have been notified. Location constraint: API must be called from a Monitor component (component level < 100,000).

Raise a ExceptionContinued event. Components which implement the event sink interface will receive the event notification. Control will return once all components have been notified. Location constraint: API must be called from a Monitor component (component level < 100,000).

[Out] True if the debug monitor is able to modify the processing of this exceptions.

Provides a string description for an exception. This is used when tracing the exception to the output window. Location constraint: API must be called from a Monitor component (component level < 100,000).

[Out] String description of the exception.

Provides additional information about an exception which will appear when Visual Studio stops on the exception. For CLR exceptions, this contains the 'Message' property from the System.Exception which was thrown. Location constraint: API must be called from a Monitor component (component level < 100,000).

[Out,Optional] String description of the exception. If no other information is available, null is returned.

Provides developer-oriented additional information about the exception. This info should be displayed along with GetDescription and GetAdditionalInformation to clarify the cause of the error. Location constraint: API must be called from a Monitor component (component level < 100,000).

[Out,Optional] RestrictedErrorInfo description of the exception. Due to security restrictions, this may not be available even if RestrictedErrorInfo is available for the exception. [Out,Optional] If present, used to retrieve IRestrictedErrorInfo via the RoResolvedRestrictedErrorInfoReference API. [Out,Optional] If present specifies the missing capability.

Raise a OutOfBandException event. Components which implement the event sink interface will receive the event notification. Control will return once all components have been notified. Location constraint: API must be called from a Monitor component (component level < 100,000). This API was introduced in Visual Studio 11 Update 1 (DkmApiVersion.VS11FeaturePack1).

Obtains the captured stack trace associated with the exception, if one is available. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

[Out,Optional] An array of frames that were running at the time the exception got thrown.

Get the exception details for this exception. This API was introduced in Visual Studio 15 RTM (DkmApiVersion.VS15RTM).

[In] The inspection session used to track the lifetime of the exception details object. [Out] Contains details about an exception or inner exception object.

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Specifies exception interception actions.

No flags set.

Intercept exception.

Cancel intercept request.

Describes an exception that a component wants to break on by its name. NameTriggers are used for exception categories that use names to identify exceptions. For example, CLR exceptions and C++ exceptions are identified by type name. Name triggers will not fire for code-based exception categories (ex: Win32 exceptions).

Indicates the type of exception.

Name of the exception. For C++ or CLR exceptions, this is the type name. This value will be null for exception categories that identify exceptions by code (ex: Win32 exceptions).

Create a new DkmExceptionNameTrigger object instance.

[In] The debugger receives notifications from the target process at various stages within exception processing (ex: exception thrown, exception unhandled). This enumeration is a bit mask of which of these stages the trigger should fire for. [In,Optional] Thread on which this trigger applies. If null, the trigger will be examined for all threads. [In] Indicates the type of exception. [In] Name of the exception. For C++ or CLR exceptions, this is the type name. This value will be null for exception categories that identify exceptions by code (ex: Win32 exceptions). [Out] Result of this method call.

Create a new DkmExceptionNameTrigger object instance. This API was introduced in Visual Studio 15 RTM (DkmApiVersion.VS15RTM).

[In] The debugger receives notifications from the target process at various stages within exception processing (ex: exception thrown, exception unhandled). This enumeration is a bit mask of which of these stages the trigger should fire for. [In,Optional] Thread on which this trigger applies. If null, the trigger will be examined for all threads. [In,Optional] Exception condition information. [In] Indicates the type of exception. [In] Name of the exception. For C++ or CLR exceptions, this is the type name. This value will be null for exception categories that identify exceptions by code (ex: Win32 exceptions). [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

An exception was thrown. This notification occurs for all types of exceptions.

The target process has begun searching for an exception handler and this search has entered user code. This notification is provided only for exception categories which support Just My Code. Currently, only the CLR & Script exception categories support Just My Code. In CLR devices scenarios or when Just My Code stepping is disabled in the UI, the back end will not have support for Just My Code. In this case, when an exception is thrown, both the 'Thrown' and 'UserCodeSearch' flags will be set.

The target process is about to swallow the exception at an app domain transition.

The target process is about to pass the exception from managed code into unmanaged code.

An exception handler has been found outside of user code. This notification is provided only for exception categories which support Just My Code. Currently, only the CLR exception category supports Just My Code.\n.

No handler was found for this exception.

Exception should be visible to users. When set, the exception will be sent to the output window if the user doesn't wish to stop at the exception.

Describes an exception or collection of exceptions which a component wants to break on. When a higher level components wants to be notified about certain exceptions, it should create one or more exception triggers, and then enable these triggers (DkmProcess.EnableExceptionTriggers). After this, when the exception occurs, a ExceptionTriggerHit exception will be fired whenever this trigger is met. Derived classes: DkmExceptionCategoryTrigger, DkmExceptionCodeTrigger, DkmExceptionGlobalTrigger, DkmExceptionNameTrigger

DkmExceptionTrigger is an abstract base class. This enum indicates which derived class this object is an instance of.

Object is an instance of 'DkmExceptionGlobalTrigger'.

Object is an instance of 'DkmExceptionCategoryTrigger'.

Object is an instance of 'DkmExceptionNameTrigger'.

Object is an instance of 'DkmExceptionCodeTrigger'.

DkmExceptionTrigger is an abstract base class. This enum indicates which derived class this object is an instance of.

The debugger receives notifications from the target process at various stages within exception processing (ex: exception thrown, exception unhandled). This enumeration is a bit mask of which of these stages the trigger should fire for.

[Optional] Thread on which this trigger applies. If null, the trigger will be examined for all threads.

[Optional] Exception condition information. This API was introduced in Visual Studio 15 RTM (DkmApiVersion.VS15RTM).

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Provides information about an exception trigger which was satisfied (hit) by an exception coming from the target process.

Provides information about an exception which was raised in the target process. This information includes details of what exception was raised and the current stage of exception processing.

Description string for the exception. This is obtained from IDkmExceptionFormatter.GetDescription.

[Optional] Optional WinRT Restricted Description for the error, obtained from the IDkmExceptionFormatterCallback.GetRestrictedErrorInfo.

[Optional] Specifies the missing capability if there is one which resulted in a runtime exception.

[Optional] Specifies the restricted reference. This is provided instead of the RestrictedDescription and any CapabilitySid. A scenario for this is when the debuggee process is not running in same session as debugger process. Components above will need to use this to work out the restricted description and any missing capability.

[Optional] Optional additional information about this exception. For CLR exceptions, this contains the 'Message' property from the System.Exception which was thrown. This information is obtained from IDkmExceptionFormatter.GetAdditionalInformation.

[Optional] The stack trace of the exception, if available. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

[Optional] Exception condition information. This API was introduced in Visual Studio 15 RTM (DkmApiVersion.VS15RTM).

DkmThread represents a thread running in the target process.

The DkmRuntimeInstance class represents an execution environment which is loaded into a DkmProcess and which contains code to be debugged.

Create a new DkmExceptionTriggerHit object instance.

[In] Provides information about an exception which was raised in the target process. This information includes details of what exception was raised and the current stage of exception processing. [In] Description string for the exception. This is obtained from IDkmExceptionFormatter.GetDescription. [In,Optional] Optional WinRT Restricted Description for the error, obtained from the IDkmExceptionFormatterCallback.GetRestrictedErrorInfo. [In,Optional] Specifies the missing capability if there is one which resulted in a runtime exception. [In,Optional] Specifies the restricted reference. This is provided instead of the RestrictedDescription and any CapabilitySid. A scenario for this is when the debuggee process is not running in same session as debugger process. Components above will need to use this to work out the restricted description and any missing capability. [In,Optional] Optional additional information about this exception. For CLR exceptions, this contains the 'Message' property from the System.Exception which was thrown. This information is obtained from IDkmExceptionFormatter.GetAdditionalInformation. [In] Identifies the source of an object. SourceIds are used to enable filtering in scenarios when multiple components may be creating instances of a class. For example, source ids can be used to determine if a breakpoint comes from the AD7 AL (ex: user breakpoint, or other breakpoint visible at the SDM level) instead of a breakpoint which may be created by another component (for example an internal breakpoint used for stepping). [Out] Result of this method call.

Create a new DkmExceptionTriggerHit object instance. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

[In] Provides information about an exception which was raised in the target process. This information includes details of what exception was raised and the current stage of exception processing. [In] Description string for the exception. This is obtained from IDkmExceptionFormatter.GetDescription. [In,Optional] Optional WinRT Restricted Description for the error, obtained from the IDkmExceptionFormatterCallback.GetRestrictedErrorInfo. [In,Optional] Specifies the missing capability if there is one which resulted in a runtime exception. [In,Optional] Specifies the restricted reference. This is provided instead of the RestrictedDescription and any CapabilitySid. A scenario for this is when the debuggee process is not running in same session as debugger process. Components above will need to use this to work out the restricted description and any missing capability. [In,Optional] Optional additional information about this exception. For CLR exceptions, this contains the 'Message' property from the System.Exception which was thrown. This information is obtained from IDkmExceptionFormatter.GetAdditionalInformation. [In] Identifies the source of an object. SourceIds are used to enable filtering in scenarios when multiple components may be creating instances of a class. For example, source ids can be used to determine if a breakpoint comes from the AD7 AL (ex: user breakpoint, or other breakpoint visible at the SDM level) instead of a breakpoint which may be created by another component (for example an internal breakpoint used for stepping). [In,Optional] The stack trace of the exception, if available. [Out] Result of this method call.

Create a new DkmExceptionTriggerHit object instance. This API was introduced in Visual Studio 15 RTM (DkmApiVersion.VS15RTM).

[In] Provides information about an exception which was raised in the target process. This information includes details of what exception was raised and the current stage of exception processing. [In] Description string for the exception. This is obtained from IDkmExceptionFormatter.GetDescription. [In,Optional] Optional WinRT Restricted Description for the error, obtained from the IDkmExceptionFormatterCallback.GetRestrictedErrorInfo. [In,Optional] Specifies the missing capability if there is one which resulted in a runtime exception. [In,Optional] Specifies the restricted reference. This is provided instead of the RestrictedDescription and any CapabilitySid. A scenario for this is when the debuggee process is not running in same session as debugger process. Components above will need to use this to work out the restricted description and any missing capability. [In,Optional] Optional additional information about this exception. For CLR exceptions, this contains the 'Message' property from the System.Exception which was thrown. This information is obtained from IDkmExceptionFormatter.GetAdditionalInformation. [In] Identifies the source of an object. SourceIds are used to enable filtering in scenarios when multiple components may be creating instances of a class. For example, source ids can be used to determine if a breakpoint comes from the AD7 AL (ex: user breakpoint, or other breakpoint visible at the SDM level) instead of a breakpoint which may be created by another component (for example an internal breakpoint used for stepping). [In,Optional] The stack trace of the exception, if available. [In,Optional] Exception condition information. [Out] Result of this method call.

Raise a ExceptionTriggerHit event. Components which implement the event sink interface will receive the event notification. This method will enqueue the event and control will immediately return to the caller.

Tries to get a detailed information about the source of the problem. Location constraint: API must be called from an IDE component (component level > 100,000). This API was introduced in Visual Studio 14 Update 1 (DkmApiVersion.VS14Update1).

[Out,Optional] Result of the analysis.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Result of an asynchronous DkmProcess.RemoveExceptionTrigger call.

Creates a new result structure to hold the error from a failed call to DkmProcess.RemoveExceptionTrigger.

[In] exception object containing the error

HRESULT code returned from the caller. This will be DkmExceptionCode.COR_E_OPERATIONCANCELED (0x8013153B) if the operation was canceled before processing was complete.

Provides information about a stowed exception. In modern apps, when an exception is thrown, it is caught by COM Interop and another exception is thrown by the framework. The original exception is captured as a stowed exception. This API was introduced in Visual Studio 12 Update 3 (DkmApiVersion.VS12Update3).

Stowed Exceptions can contain a nested exception. If this is non-null, the Stowed exception contains additional information in the NestedException. This API was introduced in Visual Studio 12 Update 3 (DkmApiVersion.VS12Update3).

A pointer to the Nested Exception record.

The type of Exception that NestedExceptionAddress is pointing to.

Initialize a new NestedException value. This API was introduced in Visual Studio 12 Update 3 (DkmApiVersion.VS12Update3).

[In] A pointer to the Nested Exception record. [In] The type of Exception that NestedExceptionAddress is pointing to.

[Optional] Stowed Exceptions can contain a nested exception. If this is non-null, the Stowed exception contains additional information in the NestedException. This API was introduced in Visual Studio 12 Update 3 (DkmApiVersion.VS12Update3).

The HRESULT of the original thrown exception. This API was introduced in Visual Studio 12 Update 3 (DkmApiVersion.VS12Update3).

The ID of the thread that the exception was thrown on. This is just an ID and not a DkmThread because the thread may have exited before the dump is taken. This API was introduced in Visual Studio 12 Update 3 (DkmApiVersion.VS12Update3).

[Optional] The error text from the Stowed Exception. If this is non null, it is a Text Stowed Exception (as opposed to binary), and the ExceptionAddress, StackTraceWordSize, StackTraceWords, and StackTrace fields will be invalid. This API was introduced in Visual Studio 12 Update 3 (DkmApiVersion.VS12Update3).

The address of the exception. This API was introduced in Visual Studio 12 Update 3 (DkmApiVersion.VS12Update3).

Size, in bytes, of each word in the stack trace that the StackTrace member points to. This value is set to 4 for 32-bit platforms and 8 for 64-bit platforms. This API was introduced in Visual Studio 12 Update 3 (DkmApiVersion.VS12Update3).

The number of words in the stack trace that the StackTrace member points to. The number of words is equal to the number of elements in the array. This API was introduced in Visual Studio 12 Update 3 (DkmApiVersion.VS12Update3).

A pointer to a memory block that contains the stack trace. This API was introduced in Visual Studio 12 Update 3 (DkmApiVersion.VS12Update3).

Create a new DkmStowedExceptionInformation object instance. This API was introduced in Visual Studio 12 Update 3 (DkmApiVersion.VS12Update3).

[In] The HRESULT of the original thrown exception. [In] The ID of the thread that the exception was thrown on. This is just an ID and not a DkmThread because the thread may have exited before the dump is taken. [In,Optional] The error text from the Stowed Exception. If this is non null, it is a Text Stowed Exception (as opposed to binary), and the ExceptionAddress, StackTraceWordSize, StackTraceWords, and StackTrace fields will be invalid. [In] The address of the exception. [In] Size, in bytes, of each word in the stack trace that the StackTrace member points to. This value is set to 4 for 32-bit platforms and 8 for 64-bit platforms. [In] The number of words in the stack trace that the StackTrace member points to. The number of words is equal to the number of elements in the array. [In] A pointer to a memory block that contains the stack trace. [In,Optional] Stowed Exceptions can contain a nested exception. If this is non-null, the Stowed exception contains additional information in the NestedException. [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

DkmStowedExceptionNestedType describes the type of DkmStowedExceptionInformation.NestedException.NestedExceptionAddress. This API was introduced in Visual Studio 12 Update 3 (DkmApiVersion.VS12Update3).

This value specifies that there is no nested exception object.

This value specifies that the NestedException member points to an EXCEPTION_RECORD object.

This value specifies that the NestedException member points to another stowed exception object.

This value specifies that the NestedException member points to a language exception object.

Represents a breakpoint which has been bound (resolved) to a particular code instruction address or a particular data element. For example, in C++ templates one could create a DkmPendingBreakpoint for a source line. The breakpoint manager would resolve it to zero (ex: module not loaded), one (ex: template is only used on 'int') or many (ex: template is used with many template arguments) location. Each location would have a DkmBoundBreakpoint object.

Guid which uniquely identifies this bound breakpoint object.

[Optional] The low-level runtime breakpoint which backs this high-level bound breakpoint.

[Optional] An optional reference to the document and text position this breakpoint bound to. This should be set unless the bound location does not have source information.

Identifies the source language (ex: C#) and compiler vendor (ex: Microsoft) that the breakpoint should bind against. 'LanguageId' may be left as Guid.Empty to indicate that the breakpoint should bind against all languages. 'VendorId' is nearly always left as Guid.Empty, which indicates that only the language is known (not the compiler).

Closes the bound breakpoint. This is done by breakpoint manager. DkmBoundBreakpoint objects are automatically closed when their associated DkmPendingBreakpoint object is closed.

Called by a breakpoint manager to create a DkmBoundBreakpoint object for each location that a DkmPendingBreakpoint binds to.

[In] High level breakpoint object which is tied to a user-level construct (ex: source file, function name) which may map to zero or more code-level constructs (DkmBoundBreakpoint) and which may be tracked over time. [In,Optional] The low-level runtime breakpoint which backs this high-level bound breakpoint. [In,Optional] An optional reference to the document and text position this breakpoint bound to. This should be set unless the bound location does not have source information. [In,Optional] Data object to add to the new DkmBoundBreakpoint instance. Pass 'null' in the case that the caller doesn't need to add a data item. [Out] Result of this method call.

Raise a BoundBreakpointHit event. Components which implement the event sink interface will receive the event notification. This method will enqueue the event and control will immediately return to the caller. This method may only be called by the component which created the object.

Enables the bound breakpoint so that it can be hit. If the bound breakpoint is already enabled, this operation has no effect. This method will append a new work item to the specified work list, and return once the work item has been appended. The actual processing of the work item is asynchronous. The caller will be notified that the request is complete through the completion routine. Location constraint: API must be called from an IDE component (component level > 100,000).

Disable the bound breakpoint so that it will no longer hit. If the bound breakpoint is already disabled, this operation has no effect. This method will append a new work item to the specified work list, and return once the work item has been appended. The actual processing of the work item is asynchronous. The caller will be notified that the request is complete through the completion routine. Location constraint: API must be called from an IDE component (component level > 100,000).

Query to determine if the bound breakpoint is enabled. Location constraint: API must be called from an IDE component (component level > 100,000).

[Out] 'true' if the breakpoint is enabled.

Initialize or update or clear the condition on a breakpoint. If the same breakpoint has both a language-level condition, and a hit count condition, the language-level condition is applied first. Location constraint: API must be called from an IDE component (component level > 100,000).

[In,Optional] Condition to apply to this breakpoint. This value may be 'null' if the caller wishes to remove the condition.

Initialize, update or clear the hit count condition on a breakpoint. If the same breakpoint has both a language-level condition, and a hit count condition, the language-level condition is applied first. Location constraint: API must be called from an IDE component (component level > 100,000).

[In,Optional] Condition to apply to this breakpoint. This value may be 'null' if the caller wishes to remove the condition.

Modifies the value for a breakpoint hit count. Location constraint: API must be called from an IDE component (component level > 100,000).

[In] New value for the hit count.

Returns the number of times that a bound breakpoint has been hit. This value should not include any times when the breakpoint's instruction was executed, but the breakpoint's condition indicated that the debugger should not stop. This method will append a new work item to the specified work list, and return once the work item has been appended. The actual processing of the work item is asynchronous. The caller will be notified that the request is complete through the completion routine. Location constraint: API must be called from an IDE component (component level > 100,000).

Raise a DataBreakpointHit event. Components which implement the event sink interface will receive the event notification. This method will enqueue the event and control will immediately return to the caller. This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTM).

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Conditions under which a breakpoint should fire.

Indicates how the breakpoint text should be used ('BreakWhenTrue' or 'BreakWhenChanged').

Language of the breakpoint condition. May be Guid.Empty/Guid.Empty to indicate that the language of the stack frame should be used. If present, the vendor id must be defined.

Flags which effect how the condition text should be compiled by the expression evaluator.

Source text of the parsed expression.

This is the timeout to be used for potentially slow operations such as a function evaluation. This value is in milliseconds.

Create a new DkmBreakpointCondition object instance.

[In] Indicates how the breakpoint text should be used ('BreakWhenTrue' or 'BreakWhenChanged'). [In] Language of the breakpoint condition. May be Guid.Empty/Guid.Empty to indicate that the language of the stack frame should be used. If present, the vendor id must be defined. [In] Flags which effect how the condition text should be compiled by the expression evaluator. [In] Source text of the parsed expression. [In] This is the timeout to be used for potentially slow operations such as a function evaluation. This value is in milliseconds. [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Indicates how the breakpoint text should be used ('BreakWhenTrue' or 'BreakWhenChanged').

Breakpoint should fire when the expression evaluates to Boolean 'true'.

Breakpoint should fire when the value of the input expression changes.

Object used to send file update notifications to breakpoint managers.

File path to the various files which have been updated.

Create a new DkmBreakpointFileUpdateNotification object instance.

[In] File path to the various files which have been updated. [Out] Result of this method call.

Provides notification that one or more files containing breakpoints have been updated. This method will append a new work item to the specified work list, and return once the work item has been appended. The actual processing of the work item is asynchronous. The caller will be notified that the request is complete through the completion routine. Location constraint: API must be called from an IDE component (component level > 100,000).

WorkList to append the new work item to.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Values of the breakpoints hit count which should cause the breakpoint to fire.

Operator to use between the current hit count and the condition operand to decide if the hit count condition has been satisfied.

Value to apply against the current hit when evaluating this condition.

Create a new DkmBreakpointHitCountCondition object instance.

[In] Operator to use between the current hit count and the condition operand to decide if the hit count condition has been satisfied. [In] Value to apply against the current hit when evaluating this condition. [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Operator to use between the current hit count and the condition operand to decide if the hit count condition has been satisfied.

Break when 'CurrentHitCount == Operand'.

Break when 'CurrentHitCount >= Operand'.

Break when 'CurrentHitCount % Operand == 0'.

Describes the severity of a message sent from a breakpoint manager back to the source component. This list is sorted in order of priority, as the UI will only display the most important warning. All warnings are ignored if the breakpoint is bound.

This is the message level for the least significant breakpoint warnings. This level is used for catch-all messages such as the 'The specified module has not been loaded' message. This is equivalent to BPET_SEV_LOW in AD7.

This is the message level reserved for 3rd party components that wish to provide their own catch-all errors. Warning levels go from 1 to 16 and in order of increasing severity (1 = Lowest, 15 = Highest).

Level 3 warning. Warning levels go from 1 to 16 and in order of increasing severity (1 = Lowest, 15 = Highest).

Level 4 warning. Warning levels go from 1 to 16 and in order of increasing severity (1 = Lowest, 15 = Highest).

Level 5 warning. Warning levels go from 1 to 16 and in order of increasing severity (1 = Lowest, 15 = Highest).

Level 6 warning. Warning levels go from 1 to 16 and in order of increasing severity (1 = Lowest, 15 = Highest).

Level 7 warning. This is equivalent to BPET_SEV_GENERAL in AD7. Warning levels go from 1 to 16 and in order of increasing severity (1 = Lowest, 15 = Highest).

Level 8 warning. Warning levels go from 1 to 16 and in order of increasing severity (1 = Lowest, 15 = Highest).

Level 9 warning. Warning levels go from 1 to 16 and in order of increasing severity (1 = Lowest, 15 = Highest).

Level 10 warning. Warning levels go from 1 to 16 and in order of increasing severity (1 = Lowest, 15 = Highest).

Level 11 warning. Warning levels go from 1 to 16 and in order of increasing severity (1 = Lowest, 15 = Highest).

Level 12 warning. Warning levels go from 1 to 16 and in order of increasing severity (1 = Lowest, 15 = Highest).

Level 13 warning. Warning levels go from 1 to 16 and in order of increasing severity (1 = Lowest, 15 = Highest).

Level 14 warning. Warning levels go from 1 to 16 and in order of increasing severity (1 = Lowest, 15 = Highest).

Highest warning level. This is equivalent to BPET_SEV_HIGH in AD7. Warning levels go from 1 to 16 and in order of increasing severity (1 = Lowest, 15 = Highest).

Lowest level breakpoint error.

Typical level for errors binding breakpoints.

Highest level breakpoint error.

Describes the reason for a breakpoint to be unbound.

Breakpoint is being unbound because the target code element has been unloaded.

Breakpoint is being unbound because it is being rebound to a different location. (For example, this can happen after an ENC when the breakpoint moves, or if this breakpoint was originally bound with a less than perfect file name match.) Generally, the IDE will discard any persisted information about this breakpoint.

Result of an asynchronous DkmRuntimeBreakpoint.ClearConditions call.

Creates a new result structure to hold the error from a failed call to DkmRuntimeBreakpoint.ClearConditions.

[In] exception object containing the error

HRESULT code returned from the caller. This will be DkmExceptionCode.COR_E_OPERATIONCANCELED (0x8013153B) if the operation was canceled before processing was complete.

Result of an asynchronous DkmRuntimeBreakpoint.ClearHitCountCondition call.

Creates a new result structure to hold the error from a failed call to DkmRuntimeBreakpoint.ClearHitCountCondition.

[In] exception object containing the error

HRESULT code returned from the caller. This will be DkmExceptionCode.COR_E_OPERATIONCANCELED (0x8013153B) if the operation was canceled before processing was complete.

Number of times that the breakpoint has been hit as of the time that the condition was removed.

Creates a new result structure to hold the output from a successful call to DkmRuntimeBreakpoint.ClearHitCountCondition.

[In] Number of times that the breakpoint has been hit as of the time that the condition was removed.

Mask of reasons why the data breakpoint should fire. For example, if 'Write' is set, then the breakpoint will fire when the memory location is written.

Stop when the CPU writes to the specified address.

Stop when the CPU reads or writes to the specified address.

Stop when the CPU tries to execute an instruction at the specified address.

Result of an asynchronous DkmBoundBreakpoint.Disable call.

Creates a new result structure to hold the error from a failed call to DkmBoundBreakpoint.Disable.

[In] exception object containing the error

HRESULT code returned from the caller. This will be DkmExceptionCode.COR_E_OPERATIONCANCELED (0x8013153B) if the operation was canceled before processing was complete.

Result of an asynchronous DkmPendingBreakpoint.Disable call.

Creates a new result structure to hold the error from a failed call to DkmPendingBreakpoint.Disable.

[In] exception object containing the error

HRESULT code returned from the caller. This will be DkmExceptionCode.COR_E_OPERATIONCANCELED (0x8013153B) if the operation was canceled before processing was complete.

Result of an asynchronous DkmRuntimeBreakpoint.Disable call.

Creates a new result structure to hold the error from a failed call to DkmRuntimeBreakpoint.Disable.

[In] exception object containing the error

HRESULT code returned from the caller. This will be DkmExceptionCode.COR_E_OPERATIONCANCELED (0x8013153B) if the operation was canceled before processing was complete.

Result of an asynchronous DkmBoundBreakpoint.Enable call.

Creates a new result structure to hold the error from a failed call to DkmBoundBreakpoint.Enable.

[In] exception object containing the error

HRESULT code returned from the caller. This will be DkmExceptionCode.COR_E_OPERATIONCANCELED (0x8013153B) if the operation was canceled before processing was complete.

Result of an asynchronous DkmPendingBreakpoint.Enable call.

Creates a new result structure to hold the error from a failed call to DkmPendingBreakpoint.Enable.

[In] exception object containing the error

HRESULT code returned from the caller. This will be DkmExceptionCode.COR_E_OPERATIONCANCELED (0x8013153B) if the operation was canceled before processing was complete.

Result of an asynchronous DkmRuntimeBreakpoint.Enable call.

Creates a new result structure to hold the error from a failed call to DkmRuntimeBreakpoint.Enable.

[In] exception object containing the error

HRESULT code returned from the caller. This will be DkmExceptionCode.COR_E_OPERATIONCANCELED (0x8013153B) if the operation was canceled before processing was complete. E_BP_MODULE_UNLOADED indicates that the module instance specified by the breakpoint is no longer loaded. E_TEXT_SPAN_NOT_LOADED indicates that TextSpan is not currently loaded in the specified script document. E_RUNTIME_BREAKPOINT_ERROR indicates that an error has occurred in a monitor component while enabling the runtime breakpoint and that the monitor component has provided an error message via IDkmDataBreakpointErrorInfoClient.OnError.

Result of an asynchronous DkmPendingBreakpoint.Enroll call.

Creates a new result structure to hold the error from a failed call to DkmPendingBreakpoint.Enroll.

[In] exception object containing the error

HRESULT code returned from the caller. This will be DkmExceptionCode.COR_E_OPERATIONCANCELED (0x8013153B) if the operation was canceled before processing was complete.

Result of an asynchronous DkmRuntimeBreakpoint.EvaluateConditionAndSelectThread call.

Creates a new result structure to hold the error from a failed call to DkmRuntimeBreakpoint.EvaluateConditionAndSelectThread.

[In] exception object containing the error

HRESULT code returned from the caller. This will be DkmExceptionCode.COR_E_OPERATIONCANCELED (0x8013153B) if the operation was canceled before processing was complete.

[Optional] The thread whose condition is true. The value is null in the case that no thread is found to have a true condition. This API was introduced in Visual Studio 11 Update 1 (DkmApiVersion.VS11FeaturePack1).

Creates a new result structure to hold the output from a successful call to DkmRuntimeBreakpoint.EvaluateConditionAndSelectThread.

[In,Optional] The thread whose condition is true. The value is null in the case that no thread is found to have a true condition.

Marshal a native struct to managed

Pointer to native struct. Managed object.

Obtain a pointer to the native object used to call into native.

Outgoing managed->native call Native object

Validate the fields of this structure

Struct that holds the field path (ex: "myArgument.StructField")

Represents a condition which is evaluated on the target computer. These objects are used for languages where the expression evaluator is implemented on the target.

Runtime breakpoint that this condition is used on.

The breakpoint condition which is evaluated.

Language used to parse the condition.

Guid which uniquely identifies this condition object.

The DkmRuntimeInstance class represents an execution environment which is loaded into a DkmProcess and which contains code to be debugged.

Closes a DkmEvaluationBreakpointCondition object instance. This will release any resources associated with this object across all components. This includes resources across computer or managed/native marshalling boundaries. DkmEvaluationBreakpointCondition objects are automatically closed when their associated DkmRuntimeBreakpoint object is closed. This method may only be called by the component which created the object. Location constraint: API must be called from a Monitor component (component level < 100,000).

Create a new DkmEvaluationBreakpointCondition object instance. The caller is responsible for closing the created object after they are done. Location constraint: API must be called from a Monitor component (component level < 100,000).

[In] Runtime breakpoint that this condition is used on. [In] The breakpoint condition which is evaluated. [In] Language used to parse the condition. [In,Optional] Data object to add to the new DkmEvaluationBreakpointCondition instance. Pass 'null' in the case that the caller doesn't need to add a data item. [Out] Result of this method call.

[Out,Optional] If the condition could not be parsed, this indicates the reason why. This value should be null if the compile succeeded.

Evaluates a condition to decide if the debugger should stop. Location constraint: API must be called from a Monitor component (component level < 100,000).

[In] The stack frame to use when evaluating the condition. [Out] True if the breakpoint condition indicated that the IDE should stop. [Out,Optional] If the condition could not be evaluated, this indicates the reason why. This value should be null if the compile succeeded.

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Result of an asynchronous DkmBoundBreakpoint.GetHitCountValue call.

Creates a new result structure to hold the error from a failed call to DkmBoundBreakpoint.GetHitCountValue.

[In] exception object containing the error

HRESULT code returned from the caller. This will be DkmExceptionCode.COR_E_OPERATIONCANCELED (0x8013153B) if the operation was canceled before processing was complete.

Number of times that the breakpoint has been hit.

Creates a new result structure to hold the output from a successful call to DkmBoundBreakpoint.GetHitCountValue.

[In] Number of times that the breakpoint has been hit.

Result of an asynchronous DkmRuntimeBreakpoint.GetHitCountConditionStatus call.

Creates a new result structure to hold the error from a failed call to DkmRuntimeBreakpoint.GetHitCountConditionStatus.

[In] exception object containing the error

HRESULT code returned from the caller. This will be DkmExceptionCode.COR_E_OPERATIONCANCELED (0x8013153B) if the operation was canceled before processing was complete.

Number of times that the breakpoint has been hit.

Creates a new result structure to hold the output from a successful call to DkmRuntimeBreakpoint.GetHitCountConditionStatus.

[In] Number of times that the breakpoint has been hit.

Pending breakpoint which is requested to bind against a particular instruction address. Within the IDE, these breakpoints are set from the call stack window, disassembly window, or by entering a hex address into the function breakpoint dialog. Because the DkmInstructionAddress is given as input, these breakpoints can support Runtimes which cannot persist their addresses to a string (ex: an interpreter).

Abstract representation of an executable code location (ex: EIP value). If the instruction address is unresolved (DkmUnknownInstructionAddress) and contains a CPU instruction, the breakpoint manager will attempt to bind the instruction if a module within that range loads.

Creates a new pending breakpoint object. After creation, the returned object will still be disabled and will not be tracked by the breakpoint manager. To complete initialization, the caller should set additional properties on the breakpoint and 'Enable' or 'Enroll' it. The caller is responsible for closing the created object after they are done.

[In] Identifies the source of an object. SourceIds are used to enable filtering in scenarios when multiple components may be creating instances of a class. For example, source ids can be used to determine if a breakpoint comes from the AD7 AL (ex: user breakpoint, or other breakpoint visible at the SDM level) instead of a breakpoint which may be created by another component (for example an internal breakpoint used for stepping). [In] Identifies the source language (ex: C#) and compiler vendor (ex: Microsoft) that the breakpoint should bind against. 'LanguageId' may be left as Guid.Empty to indicate that the breakpoint should bind against all languages. 'VendorId' is nearly always left as Guid.Empty, which indicates that only the language is known (not the compiler). [In,Optional] Thread on which this breakpoint should fire. If null, the breakpoint will fire on all threads. [In] Indicates if this breakpoint is a barrier that should be set on the hardware, this works for GPU debugging. [In] Abstract representation of an executable code location (ex: EIP value). If the instruction address is unresolved (DkmUnknownInstructionAddress) and contains a CPU instruction, the breakpoint manager will attempt to bind the instruction if a module within that range loads. [In,Optional] Data object to add to the new DkmPendingAddressBreakpoint instance. Pass 'null' in the case that the caller doesn't need to add a data item. [Out] Result of this method call.

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Pending breakpoint which is requested to bind against the code element at a specific instruction address string. Within the IDE, these breakpoints are created when the user sets a breakpoint in the call stack or disassembly window, and then the debugger is asked to rebind the breakpoint in another debug session or in another process within the same debug session.

Name of the module to search for the breakpoint.

String representation of the address to bind to.

[Optional] Name of the function which contains the address.

[In] DkmProcess represents a target process which is being debugged. The debugger debugs processes, so this is the basic unit of debugging. A DkmProcess can represent a system process or a virtual process such as minidumps. [In] Identifies the source of an object. SourceIds are used to enable filtering in scenarios when multiple components may be creating instances of a class. For example, source ids can be used to determine if a breakpoint comes from the AD7 AL (ex: user breakpoint, or other breakpoint visible at the SDM level) instead of a breakpoint which may be created by another component (for example an internal breakpoint used for stepping). [In] Identifies the source language (ex: C#) and compiler vendor (ex: Microsoft) that the breakpoint should bind against. 'LanguageId' may be left as Guid.Empty to indicate that the breakpoint should bind against all languages. 'VendorId' is nearly always left as Guid.Empty, which indicates that only the language is known (not the compiler). [In,Optional] Thread on which this breakpoint should fire. If null, the breakpoint will fire on all threads. [In] Indicates if this breakpoint is a barrier that should be set on the hardware, this works for GPU debugging. [In] Name of the module to search for the breakpoint. [In] String representation of the address to bind to. [In,Optional] Name of the function which contains the address. [In,Optional] Data object to add to the new DkmPendingAddressNameBreakpoint instance. Pass 'null' in the case that the caller doesn't need to add a data item. [Out] Result of this method call.

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

High level breakpoint object which is tied to a user-level construct (ex: source file, function name) which may map to zero or more code-level constructs (DkmBoundBreakpoint) and which may be tracked over time. Derived classes: DkmPendingAddressBreakpoint, DkmPendingAddressNameBreakpoint, DkmPendingDataBreakpoint, DkmPendingFileLineBreakpoint, DkmPendingFunctionBreakpoint

DkmPendingBreakpoint is an abstract base class. This enum indicates which derived class this object is an instance of.

Object is an instance of 'DkmPendingFileLineBreakpoint'.

Object is an instance of 'DkmPendingFunctionBreakpoint'.

Object is an instance of 'DkmPendingAddressBreakpoint'.

Object is an instance of 'DkmPendingAddressNameBreakpoint'.

Object is an instance of 'DkmPendingDataBreakpoint'.

DkmPendingBreakpoint is an abstract base class. This enum indicates which derived class this object is an instance of.

Guid which uniquely identifies this pending breakpoint object.

[Optional] Thread on which this breakpoint should fire. If null, the breakpoint will fire on all threads.

Indicates if this breakpoint is a barrier that should be set on the hardware, this works for GPU debugging.

Closes a DkmPendingBreakpoint object instance. This will release any resources associated with this object across all components. This includes resources across computer or managed/native marshalling boundaries. DkmPendingBreakpoint objects are automatically closed when their associated DkmProcess object is closed. This method may only be called by the component which created the object.

GetBoundBreakpoints enumerates the DkmBoundBreakpoint elements of this DkmPendingBreakpoint object.

[Out] Array containing the enumerated elements.

Sets the state of the pending breakpoint so that instances of the breakpoint that bind in the future will get hit. If the pending breakpoint is not yet enrolled, then this method will also enroll the breakpoint. Enrolling a pending breakpoint consists of attempting to resolve the breakpoint against any modules which are currently loaded and adding the breakpoint to the list of breakpoints which the breakpoint manager will bind on any module load. If the pending breakpoint is already enrolled, existing bound breakpoints will not automatically get enabled. Bound breakpoints must get enabled separately. This method will append a new work item to the specified work list, and return once the work item has been appended. The actual processing of the work item is asynchronous. The caller will be notified that the request is complete through the completion routine. Location constraint: API must be called from an IDE component (component level > 100,000).

Disable the pending breakpoint object so that it will no longer fire. If the pending breakpoint is already bound, any bound breakpoints will be implicitly disabled. This method will append a new work item to the specified work list, and return once the work item has been appended. The actual processing of the work item is asynchronous. The caller will be notified that the request is complete through the completion routine. Location constraint: API must be called from an IDE component (component level > 100,000).

This method will enroll the pending breakpoint without enabling it. The result is a breakpoint which the breakpoint manager will attempt to resolve, but which will not fire. Enrolling a pending breakpoint consists of attempting to resolve the breakpoint against any modules which are currently loaded and adding the breakpoint to the list of breakpoints which the breakpoint manager will bind on any module load. This method will append a new work item to the specified work list, and return once the work item has been appended. The actual processing of the work item is asynchronous. The caller will be notified that the request is complete through the completion routine. Location constraint: API must be called from an IDE component (component level > 100,000).

Initialize, update or clear the language-level condition on all bound breakpoints of this condition breakpoint. If the same breakpoint has both a language-level condition, and a hit count condition, the language-level condition is applied first. This method will append a new work item to the specified work list, and return once the work item has been appended. The actual processing of the work item is asynchronous. The caller will be notified that the request is complete through the completion routine. Location constraint: API must be called from an IDE component (component level > 100,000).

WorkList to append the new work item to. [In,Optional] Condition to apply to this breakpoint. This value may be 'null' if the caller wishes to remove the condition. Routine to fire when the request is complete. If the request is successfully appended to the work list, this will always fire (including when the operation is canceled). This will never fire if appending the work item fails.

Initialize, update or clear the hit count condition on all bound breakpoints of this pending breakpoint. If the same breakpoint has both a language-level condition, and a hit count condition, the language-level condition is applied first. Note that the hit count condition acts independently on each bound breakpoint, rather than being aggregated together on the pending breakpoint. For example, if the hit count is configured to stop at hit #2, and the breakpoint to two separate locations, each of which hit the breakpoint once, the UI will still not have gone into break mode because neither individual bound breakpoint has hit twice. This method will append a new work item to the specified work list, and return once the work item has been appended. The actual processing of the work item is asynchronous. The caller will be notified that the request is complete through the completion routine. Location constraint: API must be called from an IDE component (component level > 100,000).

Notification from the breakpoint manager which indicates that the given breakpoint is being unbound.

Notification from the breakpoint manager concerning the status of binding the breakpoint.

Raise a BreakpointHitWithError event. Components which implement the event sink interface will receive the event notification. This method will enqueue the event and control will immediately return to the caller. This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTM).

[In] DkmThread represents a thread running in the target process. [In] Contains true if the source runtime instance can determine that an exception is in flight on the thread which hit the breakpoint. Currently, only managed runtime instances ever set this. This is used to quickly determine if exception specific logic should apply without making another network round-trip. [In] Describes the severity of a message sent from a breakpoint manager back to the source component. This list is sorted in order of priority, as the UI will only display the most important warning. All warnings are ignored if the breakpoint is bound. [In] The error message to be reported.

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Pending breakpoint which is tied to a data expression instead of a code expression. Data breakpoints fire when the specified element is written to.

Indicates the location of the data value to watch.

Specifies the size of the location, in bytes, to monitor for access. Valid sizes may depend on the target processor (x86, x64, etc) and type of code being debugging. For example, native code utilizes the CPU's breakpoint registers, and x86-based processor supports sizes of 1, 2, and 4.

[In] DkmProcess represents a target process which is being debugged. The debugger debugs processes, so this is the basic unit of debugging. A DkmProcess can represent a system process or a virtual process such as minidumps. [In] Identifies the source of an object. SourceIds are used to enable filtering in scenarios when multiple components may be creating instances of a class. For example, source ids can be used to determine if a breakpoint comes from the AD7 AL (ex: user breakpoint, or other breakpoint visible at the SDM level) instead of a breakpoint which may be created by another component (for example an internal breakpoint used for stepping). [In] Identifies the source language (ex: C#) and compiler vendor (ex: Microsoft) that the breakpoint should bind against. 'LanguageId' may be left as Guid.Empty to indicate that the breakpoint should bind against all languages. 'VendorId' is nearly always left as Guid.Empty, which indicates that only the language is known (not the compiler). [In,Optional] Thread on which this breakpoint should fire. If null, the breakpoint will fire on all threads. [In] Indicates if this breakpoint is a barrier that should be set on the hardware, this works for GPU debugging. [In] Indicates the location of the data value to watch. [In] Specifies the size of the location, in bytes, to monitor for access. Valid sizes may depend on the target processor (x86, x64, etc) and type of code being debugging. For example, native code utilizes the CPU's breakpoint registers, and x86-based processor supports sizes of 1, 2, and 4. [In,Optional] Data object to add to the new DkmPendingDataBreakpoint instance. Pass 'null' in the case that the caller doesn't need to add a data item. [Out] Result of this method call.

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Pending breakpoint which is requested to bind against code elements that point back to a text span within a source file.

[In] DkmProcess represents a target process which is being debugged. The debugger debugs processes, so this is the basic unit of debugging. A DkmProcess can represent a system process or a virtual process such as minidumps. [In] Identifies the source of an object. SourceIds are used to enable filtering in scenarios when multiple components may be creating instances of a class. For example, source ids can be used to determine if a breakpoint comes from the AD7 AL (ex: user breakpoint, or other breakpoint visible at the SDM level) instead of a breakpoint which may be created by another component (for example an internal breakpoint used for stepping). [In] Identifies the source language (ex: C#) and compiler vendor (ex: Microsoft) that the breakpoint should bind against. 'LanguageId' may be left as Guid.Empty to indicate that the breakpoint should bind against all languages. 'VendorId' is nearly always left as Guid.Empty, which indicates that only the language is known (not the compiler). [In,Optional] Thread on which this breakpoint should fire. If null, the breakpoint will fire on all threads. [In] Indicates if this breakpoint is a barrier that should be set on the hardware, this works for GPU debugging. [In,Optional] Data object to add to the new DkmPendingFileLineBreakpoint instance. Pass 'null' in the case that the caller doesn't need to add a data item. [Out] Result of this method call.

Returns the current location of a file/line breakpoint. In edit and continue scenarios, the location of the text marker may change within a debug session.

[Out] Source code position which corresponds to a code element. The could represent a location which has been extracted from a symbol (PDB) file, or it could be the location of a breakpoint in the IDE.

Returns the current text at the location of a file/line breakpoint.

[Out,Optional] The current source text.

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Pending breakpoint which is requested to bind against code elements that have a specific function name.

[Optional] Name of the module to search for the breakpoint. If null, all modules will be searched.

Name of the function to bind to.

The line of the function to bind to.

[In] DkmProcess represents a target process which is being debugged. The debugger debugs processes, so this is the basic unit of debugging. A DkmProcess can represent a system process or a virtual process such as minidumps. [In] Identifies the source of an object. SourceIds are used to enable filtering in scenarios when multiple components may be creating instances of a class. For example, source ids can be used to determine if a breakpoint comes from the AD7 AL (ex: user breakpoint, or other breakpoint visible at the SDM level) instead of a breakpoint which may be created by another component (for example an internal breakpoint used for stepping). [In] Identifies the source language (ex: C#) and compiler vendor (ex: Microsoft) that the breakpoint should bind against. 'LanguageId' may be left as Guid.Empty to indicate that the breakpoint should bind against all languages. 'VendorId' is nearly always left as Guid.Empty, which indicates that only the language is known (not the compiler). [In,Optional] Thread on which this breakpoint should fire. If null, the breakpoint will fire on all threads. [In] Indicates if this breakpoint is a barrier that should be set on the hardware, this works for GPU debugging. [In,Optional] Name of the module to search for the breakpoint. If null, all modules will be searched. [In] Name of the function to bind to. [In] The line of the function to bind to. [In,Optional] Data object to add to the new DkmPendingFunctionBreakpoint instance. Pass 'null' in the case that the caller doesn't need to add a data item. [Out] Result of this method call.

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Result of an asynchronous DkmRuntimeBreakpoint.RequestBreakpointEventOnModifiedThread call.

Creates a new result structure to hold the error from a failed call to DkmRuntimeBreakpoint.RequestBreakpointEventOnModifiedThread.

[In] exception object containing the error

HRESULT code returned from the caller. This will be DkmExceptionCode.COR_E_OPERATIONCANCELED (0x8013153B) if the operation was canceled before processing was complete.

Low-level breakpoint object which is supported by debug monitors. Derived classes: DkmRuntimeHardwareDataBreakpoint, DkmRuntimeInstructionBreakpoint, DkmRuntimeClrDataBreakpoint, DkmRuntimeCustomDataBreakpoint

DkmRuntimeBreakpoint is an abstract base class. This enum indicates which derived class this object is an instance of.

Object is an instance of 'DkmRuntimeInstructionBreakpoint'.

Object is an instance of 'DkmRuntimeHardwareDataBreakpoint'.

Object is an instance of 'DkmRuntimeCustomDataBreakpoint'.

Object is an instance of 'DkmRuntimeClrDataBreakpoint'.

DkmRuntimeBreakpoint is an abstract base class. This enum indicates which derived class this object is an instance of.

The DkmRuntimeInstance class represents an execution environment which is loaded into a DkmProcess and which contains code to be debugged.

Guid which uniquely identifies this pending breakpoint object.

[Optional] Thread on which this breakpoint should fire. If null, the breakpoint will fire on all threads.

Closes the breakpoint object instance. This will release any resources associated with this object across all components. If the breakpoint is currently enabled, it will be implicitly disabled. DkmRuntimeBreakpoint objects are automatically closed when their associated DkmRuntimeInstance object is closed. This method may only be called by the component which created the object.

This method is similar to SetCompiledCondition, but is used in cases where the instruction address is not known up front, such as data breakpoints. In these cases, when the breakpoint is first hit at a particular address, a call will be made to the breakpoint client to obtain a new compiled condition for this address (IDkmBreakpointConditionProcessorClient.GetCompiledCondition). This is used for languages which are evaluated in the IDE process (ex: C++). This method will append a new work item to the specified work list, and return once the work item has been appended. The actual processing of the work item is asynchronous. The caller will be notified that the request is complete through the completion routine.

Sets a breakpoint condition which is evaluated on the target computer. This is used for .NET languages.

[In] Conditions under which a breakpoint should fire. [Out,Optional] If the condition could not be parsed, this indicates the reason why. This value should be null if the compile succeeded.

Sets a breakpoint condition which is evaluated on the target computer. This is used for .NET languages. This method will append a new work item to the specified work list, and return once the work item has been appended. The actual processing of the work item is asynchronous. The caller will be notified that the request is complete through the completion routine.

WorkList to append the new work item to. [In] Conditions under which a breakpoint should fire. Routine to fire when the request is complete. If the request is successfully appended to the work list, this will always fire (including when the operation is canceled). This will never fire if appending the work item fails.

Clear any compiled/evaluation condition associated with the specified DkmRuntimeBreakpoint. This method is implicitly called when the DkmRuntimeBreakpoint is closed.

Clear any compiled/evaluation condition associated with the specified DkmRuntimeBreakpoint. This method is implicitly called when the DkmRuntimeBreakpoint is closed. This method will append a new work item to the specified work list, and return once the work item has been appended. The actual processing of the work item is asynchronous. The caller will be notified that the request is complete through the completion routine.

[In] Condition to apply to this breakpoint. [In] The initial value of the breakpoint's hit count. A value of -1/MAXDWORD indicates that the current hit count value should be preserved.

Initialize or update the hit count condition/value on a breakpoint. If the same breakpoint has both a language-level condition, and a hit count condition, the language-level condition is applied first. The condition is implicitly removed if the DkmRuntimeBreakpoint is closed. This method will append a new work item to the specified work list, and return once the work item has been appended. The actual processing of the work item is asynchronous. The caller will be notified that the request is complete through the completion routine.

WorkList to append the new work item to. [In] Condition to apply to this breakpoint. [In] The initial value of the breakpoint's hit count. A value of -1/MAXDWORD indicates that the current hit count value should be preserved. Routine to fire when the request is complete. If the request is successfully appended to the work list, this will always fire (including when the operation is canceled). This will never fire if appending the work item fails.

Clears the hit count condition on a breakpoint.

[In] Condition to apply to this breakpoint. [Out] Number of times that the breakpoint has been hit as of the time that the condition was removed.

Clears the hit count condition on a breakpoint. This method will append a new work item to the specified work list, and return once the work item has been appended. The actual processing of the work item is asynchronous. The caller will be notified that the request is complete through the completion routine.

WorkList to append the new work item to. [In] Condition to apply to this breakpoint. Routine to fire when the request is complete. If the request is successfully appended to the work list, this will always fire (including when the operation is canceled). This will never fire if appending the work item fails.

Obtains the current hit count value for a DkmRuntimeBreakpoint which has a hit count condition. This function will fail if the DkmRuntimeBreakpoint does not currently have a hit count condition.

[Out] Number of times that the breakpoint has been hit.

Obtains the current hit count value for a DkmRuntimeBreakpoint which has a hit count condition. This function will fail if the DkmRuntimeBreakpoint does not currently have a hit count condition. This method will append a new work item to the specified work list, and return once the work item has been appended. The actual processing of the work item is asynchronous. The caller will be notified that the request is complete through the completion routine.

[In] The instruction address to compile the condition against. [Out] Operator to use when evaluating the condition. [Out,Optional] The compiled condition to be used for the specified instruction address. This value is null in the case that the condition failed to compile. In this case, the condition processor should stop on the breakpoint.

Call back invoked from the breakpoint condition processor to the breakpoint manager when a breakpoint condition encounters a runtime error. Location constraint: API must be called from a Monitor component (component level < 100,000).

[In] The message to display to the user.

[In] The base debug monitor should re-send breakpoint event on this thread.

The breakpoint condition processor decides not to break on the given thread but another thread of the same warp, so the breakpoint condition processor instructs the base debug monitor to re-send the breakpoint event on the other thread. This method will append a new work item to the specified work list, and return once the work item has been appended. The actual processing of the work item is asynchronous. The caller will be notified that the request is complete through the completion routine.

WorkList to append the new work item to. [In] The base debug monitor should re-send breakpoint event on this thread. Routine to fire when the request is complete. If the request is successfully appended to the work list, this will always fire (including when the operation is canceled). This will never fire if appending the work item fails.

E_BP_MODULE_UNLOADED indicates that the module instance specified by the breakpoint is no longer loaded. E_TEXT_SPAN_NOT_LOADED indicates that TextSpan is not currently loaded in the specified script document. E_RUNTIME_BREAKPOINT_ERROR indicates that an error has occurred in a monitor component while enabling the runtime breakpoint and that the monitor component has provided an error message via IDkmDataBreakpointErrorInfoClient.OnError.

Determines if the given DkmRuntimeBreakpoint could be enabled. This is used from within the breakpoints dialog to validate breakpoints before the dialog is closed.

E_BP_MODULE_UNLOADED indicates that the module instance specified by the breakpoint is no longer loaded. E_TEXT_SPAN_NOT_LOADED indicates that TextSpan is not currently loaded in the specified script document. E_RUNTIME_BREAKPOINT_ERROR indicates that an error has occurred in a monitor component while testing the runtime breakpoint and that the monitor component has provided an error message via IDkmDataBreakpointErrorInfoClient.OnError.

Determines if the given DkmRuntimeBreakpoint could be enabled. This is used from within the breakpoints dialog to validate breakpoints before the dialog is closed. This method will append a new work item to the specified work list, and return once the work item has been appended. The actual processing of the work item is asynchronous. The caller will be notified that the request is complete through the completion routine.

Disables a breakpoint. Disabling a breakpoint is typically implemented by modifying the state of the target process so the breakpoint will no longer fire. For example, removing a previously inserted 'int3' from the instruction stream. If the breakpoint is already disabled, this operation has no effect. In addition to this method, a breakpoint is implicitly disabled when it is closed. If multiple breakpoints are set on the same instruction, disabling one breakpoint does not affect the other breakpoints set on this instruction. This method will append a new work item to the specified work list, and return once the work item has been appended. The actual processing of the work item is asynchronous. The caller will be notified that the request is complete through the completion routine. This method may only be called by the component which created the object.

Raise a RuntimeBreakpoint event. Components which implement the event sink interface will receive the event notification. This method will enqueue the event and control will immediately return to the caller.

The base debug monitor asks the breakpoint condition processor to evaluate on all stopped threads, and selects the thread whose condition is true. Location constraint: API must be called from a Monitor component (component level < 100,000). This API was introduced in Visual Studio 11 Update 1 (DkmApiVersion.VS11FeaturePack1).

[In] The first stopped thread. [Out,Optional] The thread whose condition is true. The value is null in the case that no thread is found to have a true condition.

The base debug monitor asks the breakpoint condition processor to evaluate on all stopped threads, and selects the thread whose condition is true. This method will append a new work item to the specified work list, and return once the work item has been appended. The actual processing of the work item is asynchronous. The caller will be notified that the request is complete through the completion routine. Location constraint: API must be called from a Monitor component (component level < 100,000). This API was introduced in Visual Studio 11 Update 1 (DkmApiVersion.VS11FeaturePack1).

WorkList to append the new work item to. [In] The first stopped thread. Routine to fire when the request is complete. If the request is successfully appended to the work list, this will always fire (including when the operation is canceled). This will never fire if appending the work item fails.

[In] Failure code explaining why the IL-based breakpoint query failed to execute.

This method will be called when an breakpoint has been invalid and needs to inform the UI. Location constraint: This can be called from any component. This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTM).

Raise a RuntimeBreakpointHitWithError event. Components which implement the event sink interface will receive the event notification. This method will enqueue the event and control will immediately return to the caller. This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTM).

Raise a RuntimeDataBreakpointHit event. Components which implement the event sink interface will receive the event notification. This method will enqueue the event and control will immediately return to the caller. This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTM).

Raise a RuntimeBreakpointConditionFailed event. Components which implement the event sink interface will receive the event notification. This method will enqueue the event and control will immediately return to the caller. This API was introduced in Visual Studio 16 Update 3 (DkmApiVersion.VS16Update3).

[In] The thread of the stack frame of the target process. [In,Optional] The message to display to the user. [In] Failure code explaining why the IL-based breakpoint query failed to execute.

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Low-level data breakpoint which is set using the hardware breakpoint registers of the CPU for managed values. This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTM).

Represents a CLR instance running in a target process. This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTM).

Mask of reasons why the data breakpoint should fire. For example, if 'Write' is set, then the breakpoint will fire when the memory location is written. This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTM).

Creates a new DkmRuntimeClrDataBreakpoint object. After creation, the breakpoint is in the disabled state, and must be explicitly enabled. The caller is responsible for closing the created object after they are done. This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTM).

This method retrieves the address and size of field the DkmRuntimeClrDataBreakpoint is following. Location constraint: API must be called from a Monitor component (component level < 100,000). This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTM).

[Out] The address of the data breakpoint. If not found, this will be set to 0. [Out] The size of the data breakpoint.

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

A low level breakpoint that can be implemented by a monitor based on an arbitrary string description. This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTM).

A description of where/how to set the custom data breakpoint. The format of this string is monitor dependent. This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTM).

Creates a new DkmRuntimeCustomDataBreakpoint object. After creation, the breakpoint is in the disabled state, and must be explicitly enabled. The caller is responsible for closing the created object after they are done. This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTM).

[In] The DkmRuntimeInstance class represents an execution environment which is loaded into a DkmProcess and which contains code to be debugged. [In] Identifies the source of an object. SourceIds are used to enable filtering in scenarios when multiple components may be creating instances of a class. For example, source ids can be used to determine if a breakpoint comes from the AD7 AL (ex: user breakpoint, or other breakpoint visible at the SDM level) instead of a breakpoint which may be created by another component (for example an internal breakpoint used for stepping). [In,Optional] Thread on which this breakpoint should fire. If null, the breakpoint will fire on all threads. [In] A description of where/how to set the custom data breakpoint. The format of this string is monitor dependent. [In] Mask of reasons why the data breakpoint should fire. For example, if 'Write' is set, then the breakpoint will fire when the memory location is written. [In,Optional] Data object to add to the new DkmRuntimeCustomDataBreakpoint instance. Pass 'null' in the case that the caller doesn't need to add a data item. [Out] Result of this method call.

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Low-level data breakpoint which is set using the hardware breakpoint registers of the CPU.

Address to stop on. This address must be suitably aligned to match the Size parameter (example: if Size is 4, Address must be a multiple of 4).

Mask of reasons why the data breakpoint should fire. For example, if 'Write' is set, then the breakpoint will fire when the memory location is written.

Specifies the size of the location, in bytes, to monitor for access. On an x86-based processor, this parameter can be 1, 2, or 4. However, if Access is DkmDataAccessStopMask.Execute, Size must be 1. On an x64-based processor, this parameter can be 1, 2, 4, or 8. However, if Access equals Access is DkmDataAccessStopMask.Execute, Size must be 1. On an Itanium-based processor, this parameter can be any power of 2, from 1 to 0x80000000.

Creates a new DkmRuntimeHardwareDataBreakpoint object. After creation, the breakpoint is in the disabled state, and must be explicitly enabled. The caller is responsible for closing the created object after they are done.

[In] The DkmRuntimeInstance class represents an execution environment which is loaded into a DkmProcess and which contains code to be debugged. [In] Identifies the source of an object. SourceIds are used to enable filtering in scenarios when multiple components may be creating instances of a class. For example, source ids can be used to determine if a breakpoint comes from the AD7 AL (ex: user breakpoint, or other breakpoint visible at the SDM level) instead of a breakpoint which may be created by another component (for example an internal breakpoint used for stepping). [In,Optional] Thread on which this breakpoint should fire. If null, the breakpoint will fire on all threads. [In] Address to stop on. This address must be suitably aligned to match the Size parameter (example: if Size is 4, Address must be a multiple of 4). [In] Mask of reasons why the data breakpoint should fire. For example, if 'Write' is set, then the breakpoint will fire when the memory location is written. [In] Specifies the size of the location, in bytes, to monitor for access. On an x86-based processor, this parameter can be 1, 2, or 4. However, if Access is DkmDataAccessStopMask.Execute, Size must be 1. On an x64-based processor, this parameter can be 1, 2, 4, or 8. However, if Access equals Access is DkmDataAccessStopMask.Execute, Size must be 1. On an Itanium-based processor, this parameter can be any power of 2, from 1 to 0x80000000. [In,Optional] Data object to add to the new DkmRuntimeHardwareDataBreakpoint instance. Pass 'null' in the case that the caller doesn't need to add a data item. [Out] Result of this method call.

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Low-level breakpoint which is set on an instruction address.

Indicates if this instruction breakpoint works as a barrier, used in GPU debugging scenarios.

Creates a new DkmRuntimeInstructionBreakpoint object. After creation, the breakpoint is in the disabled state, and must be explicitly enabled. The caller is responsible for closing the created object after they are done.

[In] Identifies the source of an object. SourceIds are used to enable filtering in scenarios when multiple components may be creating instances of a class. For example, source ids can be used to determine if a breakpoint comes from the AD7 AL (ex: user breakpoint, or other breakpoint visible at the SDM level) instead of a breakpoint which may be created by another component (for example an internal breakpoint used for stepping). [In,Optional] Thread on which this breakpoint should fire. If null, the breakpoint will fire on all threads. [In] Abstract representation of an executable code location (ex: EIP value). If resolved, an Instruction Address will be within a particular module instance. An Instruction Address is always within a particular Runtime Instance. [In] Indicates if this instruction breakpoint works as a barrier, used in GPU debugging scenarios. [In,Optional] Data object to add to the new DkmRuntimeInstructionBreakpoint instance. Pass 'null' in the case that the caller doesn't need to add a data item. [Out] Result of this method call.

[In] Compiled query used to evaluate the condition. [In] Operator to use when evaluating the condition.

This sets an associated compiled condition on the specified runtime instruction breakpoint. The breakpoint condition processor will then test the condition whenever it is hit. This is used for languages which are evaluated in the IDE process (ex: C++). This method will append a new work item to the specified work list, and return once the work item has been appended. The actual processing of the work item is asynchronous. The caller will be notified that the request is complete through the completion routine.

WorkList to append the new work item to. [In] Compiled query used to evaluate the condition. [In] Operator to use when evaluating the condition. Routine to fire when the request is complete. If the request is successfully appended to the work list, this will always fire (including when the operation is canceled). This will never fire if appending the work item fails.

[In] Compiled query used to evaluate the condition. [In] Operator to use when evaluating the condition.

This tries to push the associated condition on the specified runtime instruction breakpoint to the target. This is useful for GPU debugging since testing the condition on the target (GPU hardware or VSD3D ref) is much more efficient than doing it in the debugger. Once this method succeeds, breakpoint event will only be received by the debugger when the condition tests to be true on the debuggee; if it fails, the debugger can still test the condition. This method will append a new work item to the specified work list, and return once the work item has been appended. The actual processing of the work item is asynchronous. The caller will be notified that the request is complete through the completion routine.

Clear any condition associated with the specified DkmRuntimeInstructionBreakpoint.

Clear any condition associated with the specified DkmRuntimeInstructionBreakpoint. This method will append a new work item to the specified work list, and return once the work item has been appended. The actual processing of the work item is asynchronous. The caller will be notified that the request is complete through the completion routine.

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Result of an asynchronous DkmRuntimeInstructionBreakpoint.SetCompiledCondition call.

Creates a new result structure to hold the error from a failed call to DkmRuntimeInstructionBreakpoint.SetCompiledCondition.

[In] exception object containing the error

HRESULT code returned from the caller. This will be DkmExceptionCode.COR_E_OPERATIONCANCELED (0x8013153B) if the operation was canceled before processing was complete.

Result of an asynchronous DkmRuntimeBreakpoint.SetCompiledConditionPending call.

Creates a new result structure to hold the error from a failed call to DkmRuntimeBreakpoint.SetCompiledConditionPending.

[In] exception object containing the error

HRESULT code returned from the caller. This will be DkmExceptionCode.COR_E_OPERATIONCANCELED (0x8013153B) if the operation was canceled before processing was complete.

Result of an asynchronous DkmRuntimeBreakpoint.SetEvaluationCondition call.

Creates a new result structure to hold the error from a failed call to DkmRuntimeBreakpoint.SetEvaluationCondition.

[In] exception object containing the error

HRESULT code returned from the caller. This will be DkmExceptionCode.COR_E_OPERATIONCANCELED (0x8013153B) if the operation was canceled before processing was complete.

[Optional] If the condition could not be parsed, this indicates the reason why. This value should be null if the compile succeeded.

Creates a new result structure to hold the output from a successful call to DkmRuntimeBreakpoint.SetEvaluationCondition.

[In,Optional] If the condition could not be parsed, this indicates the reason why. This value should be null if the compile succeeded.

Marshal a native struct to managed

Pointer to native struct. Managed object.

Obtain a pointer to the native object used to call into native.

Outgoing managed->native call Native object

Validate the fields of this structure

Struct that holds the field path (ex: "myArgument.StructField")

Result of an asynchronous DkmPendingBreakpoint.SetCondition call.

Creates a new result structure to hold the error from a failed call to DkmPendingBreakpoint.SetCondition.

[In] exception object containing the error

HRESULT code returned from the caller. This will be DkmExceptionCode.COR_E_OPERATIONCANCELED (0x8013153B) if the operation was canceled before processing was complete.

Result of an asynchronous DkmPendingBreakpoint.SetHitCountCondition call.

Creates a new result structure to hold the error from a failed call to DkmPendingBreakpoint.SetHitCountCondition.

[In] exception object containing the error

HRESULT code returned from the caller. This will be DkmExceptionCode.COR_E_OPERATIONCANCELED (0x8013153B) if the operation was canceled before processing was complete.

Result of an asynchronous DkmRuntimeBreakpoint.SetHitCountCondition call.

Creates a new result structure to hold the error from a failed call to DkmRuntimeBreakpoint.SetHitCountCondition.

[In] exception object containing the error

HRESULT code returned from the caller. This will be DkmExceptionCode.COR_E_OPERATIONCANCELED (0x8013153B) if the operation was canceled before processing was complete.

Result of an asynchronous DkmRuntimeBreakpoint.Test call.

Creates a new result structure to hold the error from a failed call to DkmRuntimeBreakpoint.Test.

[In] exception object containing the error

HRESULT code returned from the caller. This will be DkmExceptionCode.COR_E_OPERATIONCANCELED (0x8013153B) if the operation was canceled before processing was complete. E_BP_MODULE_UNLOADED indicates that the module instance specified by the breakpoint is no longer loaded. E_TEXT_SPAN_NOT_LOADED indicates that TextSpan is not currently loaded in the specified script document. E_RUNTIME_BREAKPOINT_ERROR indicates that an error has occurred in a monitor component while testing the runtime breakpoint and that the monitor component has provided an error message via IDkmDataBreakpointErrorInfoClient.OnError.

Result of an asynchronous DkmRuntimeInstructionBreakpoint.TryClearConditionOnTargetDevice call.

Creates a new result structure to hold the error from a failed call to DkmRuntimeInstructionBreakpoint.TryClearConditionOnTargetDevice.

[In] exception object containing the error

HRESULT code returned from the caller. This will be DkmExceptionCode.COR_E_OPERATIONCANCELED (0x8013153B) if the operation was canceled before processing was complete.

Result of an asynchronous DkmRuntimeInstructionBreakpoint.TryPushConditionToTargetDevice call.

Creates a new result structure to hold the error from a failed call to DkmRuntimeInstructionBreakpoint.TryPushConditionToTargetDevice.

[In] exception object containing the error

HRESULT code returned from the caller. This will be DkmExceptionCode.COR_E_OPERATIONCANCELED (0x8013153B) if the operation was canceled before processing was complete.

Flags which describe how to proceed with a Step-Into action.

The function stepping should not deviate from default.

The function should not be stepped into.

DkmNativeSteppingCallSite specifies a call instruction and it's target..

The address of the call instruction.

[Optional] The address of the instruction that would be called by the call instruction.

[Optional] For indirect calls only, the address being dereferenced by the call instruction.

Create a new DkmNativeSteppingCallSite object instance.

[In] The address of the call instruction. [In,Optional] The address of the instruction that would be called by the call instruction. [In,Optional] For indirect calls only, the address being dereferenced by the call instruction. [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

DkmSingleStepRequest represents a request to single step a thread.

DkmThread represents a thread running in the target process.

Create a new DkmSingleStepRequest object instance.

Raise a GPUSingleStepComplete event. Components which implement the event sink interface will receive the event notification. This method will enqueue the event and control will immediately return to the caller.

[In] DkmThread represents a thread running in the target process.

Enable temporary breakpoint in stepping on a thread. This is similar to single step except one or more instructions are advanced. When breakpoint is hit, step complete event is sent.

[In] The instruction offset of temporary breakpoints to set.

Clear temporary breakpoint in stepping on a thread.

Disable single step on a thread.

Raise a SingleStepComplete event. Components which implement the event sink interface will receive the event notification. This method will enqueue the event and control will immediately return to the caller.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

DkmStepArbitrationReason the reason step arbitration is occurring.

The stepping manager is looking for a runtime to start a new step.

The instruction pointer has landed in a location not in a known DkmModuleInstance.

The instruction pointer has landed in a location in a known DkmModuleInstance with no symbols.

The instruction pointer has landed in a location within a DkmModuleInstance marked as a transition module.

The current runtime instance has just finished stepping through a known exit from its runtime. The instruction pointer should be on the first instruction of the next runtime's entry point.

Another runtime instance has detected that the instruction pointer has hit an entry point into its runtime. This is only used after a call to StepControlRequested that return true.

The instruction pointer has landed at a location in a known module but with no source info.

An exception unwind was in flight and a handler was found. If a runtime's exception model can be used by other runtimes, stepping arbitration should be performed. For instance, CLR exceptions use native SEH exceptions. So, during a managed step, if an exception is thrown and a handler is found, native will receive its handler found notification. However, native should not take control of that step. Managed should listen for stepping arbitration with ExceptionHandlerFound as its reason and finish stepping to the managed catch block.

Used by the stepping manager to override a line or statement step with an instruction level step. This is only passed to the native runtime instance if no controlling runtime instance was found during initial stepping arbitration.

A runtime instance asked for stepping arbitration for an unknown reason.

A runtime instance that understands the async pattern has taken control of the step. The step will complete asynchronously on another thread. Steppers should clear all step state to allow for that.

DkmStepKind describes how to step the thread when the Step Method is called.

Step the thread into calls.

Step the thread over calls.

Step the thread out of the current frame.

Step into specific request.

DkmStepUnit describes the granularity of the step when the Step method is called.

Step the thread to the next statement.

Step the thread to the next line.

Step the thread to the next instruction.

DkmStepper represents a request to step a thread. It facilitates shared object lifetime between the various runtime debug monitors that participate in stepping.

Guid which uniquely identifies this DkmStepper.

DkmThread represents a thread running in the target process.

[Optional] The instruction address of the process at the time this step started. This will be NULL if the step originated on a thread with no frames (Script & Managed Only).

The frame base of the first frame at the beginning of the step. This value will be MAXUINT64 if the StartingAddress was not specified.

DkmStepKind describes how to step the thread when the Step Method is called.

DkmStepUnit describes the granularity of the step when the Step method is called.

[Optional] If StepKind is StepIntoSpecific, specifies which call we are stepping into. Otherwise it is NULL.

[Optional] If a new stepper is created using OnCrossThreadStepArbitration, the stepping manager will set this field to make is easy to get back to the original stepper if the cross thread step fails or needs to fallback.

In managed debugging, it indicates if the stepper wanted to capture return value during stepping. Default it is false. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

[Optional] In managed debugging, it contains all code paths in current step range. Otherwise it is NULL. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

[Optional] In managed debugging, it contains current method name. Otherwise it is NULL. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

Closes the stepper object. This should be closed by components when the stepper is done, such as when a step complete event is suppressed, or if the stepper fails to initialize. Steppers will be implicitly closed if their thread exits, or the debugger is stopped. They will be closed by the stepping manager if a different user-level execution request is issued. DkmStepper objects are automatically closed when their associated DkmThread object is closed.

DkmStepper objects are created by components that wish to issue a step. User-level steppers are created by the AD7-AL. To initialize a stepper object, Enable must be called. Stepper objects will live until the step completes, or is aborted.

[In] DkmThread represents a thread running in the target process. [In,Optional] The instruction address of the process at the time this step started. This will be NULL if the step originated on a thread with no frames (Script & Managed Only). [In] The frame base of the first frame at the beginning of the step. This value will be MAXUINT64 if the StartingAddress was not specified. [In] DkmStepKind describes how to step the thread when the Step Method is called. [In] DkmStepUnit describes the granularity of the step when the Step method is called. [In] Identifies the source of an object. SourceIds are used to enable filtering in scenarios when multiple components may be creating instances of a class. For example, source ids can be used to determine if a breakpoint comes from the AD7 AL (ex: user breakpoint, or other breakpoint visible at the SDM level) instead of a breakpoint which may be created by another component (for example an internal breakpoint used for stepping). [In,Optional] If StepKind is StepIntoSpecific, specifies which call we are stepping into. Otherwise it is NULL. [In,Optional] If a new stepper is created using OnCrossThreadStepArbitration, the stepping manager will set this field to make is easy to get back to the original stepper if the cross thread step fails or needs to fallback. [In,Optional] Data object to add to the new DkmStepper instance. Pass 'null' in the case that the caller doesn't need to add a data item. [Out] Result of this method call.

[In] DkmThread represents a thread running in the target process. [In,Optional] The instruction address of the process at the time this step started. This will be NULL if the step originated on a thread with no frames (Script & Managed Only). [In] The frame base of the first frame at the beginning of the step. This value will be MAXUINT64 if the StartingAddress was not specified. [In] DkmStepKind describes how to step the thread when the Step Method is called. [In] DkmStepUnit describes the granularity of the step when the Step method is called. [In] Identifies the source of an object. SourceIds are used to enable filtering in scenarios when multiple components may be creating instances of a class. For example, source ids can be used to determine if a breakpoint comes from the AD7 AL (ex: user breakpoint, or other breakpoint visible at the SDM level) instead of a breakpoint which may be created by another component (for example an internal breakpoint used for stepping). [In,Optional] If StepKind is StepIntoSpecific, specifies which call we are stepping into. Otherwise it is NULL. [In,Optional] If a new stepper is created using OnCrossThreadStepArbitration, the stepping manager will set this field to make is easy to get back to the original stepper if the cross thread step fails or needs to fallback. [In] In managed debugging, it indicates if the stepper wanted to capture return value during stepping. Default it is false. [In,Optional] In managed debugging, it contains all code paths in current step range. Otherwise it is NULL. [In,Optional] In managed debugging, it contains current method name. Otherwise it is NULL. [In,Optional] Data object to add to the new DkmStepper instance. Pass 'null' in the case that the caller doesn't need to add a data item. [Out] Result of this method call.

[In] Set to true if other steppers are to be removed. This is normally only set in response to user initiated step requests.

[In] The calling runtime instance that wishes to take control of the step.

Returns the runtime instance currently in-control of this DkmStepper. Location constraint: API must be called from a Monitor component (component level < 100,000).

[Out] The runtime instance currently in control of this stepper.

[In] DkmStepArbitrationReason the reason step arbitration is occurring. [In] The calling runtime instance that wishes to take control of the step. [Out] The the controlling runtime can stop the step and give control to the caller, then it should set this to true.

[In] Set to true by the caller if it would like the current controlling runtime instance to leave guards in place to stop the step if necessary. For instance, this can be used to leave guard breakpoints after a call instruction so another runtime can step back out if the target of the call doesn't have source. However, any stepping state that affects the immediate step, such as trap flags, should be removed by the controlling runtime instance. [In] DkmStepArbitrationReason the reason step arbitration is occurring. [In] The calling runtime instance that wishes to take control of the step.

[In] DkmStepArbitrationReason the reason step arbitration is occurring. [In] The runtime instance requesting arbitration.

[In] DkmStepArbitrationReason the reason step arbitration is occurring. [In] The runtime instance requesting arbitration. [In] The thread on which to create the new stepper. [In] Starting address of the new stepper. [Out,Optional] The new stepper.

Raise a ReturnValues event. Components which implement the event sink interface will receive the event notification. Control will return once all components have been notified.

[In,Optional] DkmRawReturnValues recorded. [In] If true, it is valid to use the current thread context to evaluate the last return value. This is true only in the case immediately after processing the return instruction, and so should only be set if raising this event immediately before, and on the same thread, as the StepComplete event.

Raise a StepComplete event. Components which implement the event sink interface will receive the event notification. This method will enqueue the event and control will immediately return to the caller.

[In] The thread the step actually finished on. Normally, this is the same as the thread in DkmStepper, but in some scenarios, it could be different. [In] Contains true if the source runtime instance can determine that an exception is in flight on the stepping thread. Currently, only managed runtime instances ever set this. This is used to quickly determine if exception specific logic should apply without making another network round-trip.

Runtime monitors call this to set or clear a flag on the DkmStepper that can be used by cooperating runtimes to change the behavior of stepping if an exception is current in flight. Called by runtime monitors when an exception is encountered while stepping. Location constraint: API must be called from a Monitor component (component level < 100,000). This API was introduced in Visual Studio 11 Update 1 (DkmApiVersion.VS11FeaturePack1).

[In] If true, the exception in flight flag is set. If false, it is cleared.

Gets the flag on the DkmStepper that states if a runtime monitor believes an exception is currently in flight during this step. This can be used by runtime monitors to change the behavior of stepping. Location constraint: API must be called from a Monitor component (component level < 100,000). This API was introduced in Visual Studio 11 Update 1 (DkmApiVersion.VS11FeaturePack1).

[Out] If true, the exception in flight flag is set. If false, it is cleared.

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

DkmSteppingCodePath represents a location that user can step to from current location.

The string that represents a possible code path user can select.

For managed this represents the IL offset to call instruction. For native it is the RVA of the call instruction.

Represents end offset for current step unit.

[Optional] Additional data about the code path. Meaning is implementation specific.

Create a new DkmSteppingCodePath object instance.

[In] The string that represents a possible code path user can select. [In] For managed this represents the IL offset to call instruction. For native it is the RVA of the call instruction. [In] Represents end offset for current step unit. [In,Optional] Additional data about the code path. Meaning is implementation specific. [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Object used for filtering for step into specific.

The instruction symbol at the location to begin looking for step into specific code paths.

The instruction address at the location to begin looking for step into specific code paths.

The language of the location to begin looking for step into specific code paths.

Create a new DkmSteppingCodePathSource object instance.

[In] The instruction symbol at the location to begin looking for step into specific code paths. [In] The instruction address at the location to begin looking for step into specific code paths. [In] The language of the location to begin looking for step into specific code paths. [Out] Result of this method call.

GetCodePaths is called to get step into specific targets. Location constraint: API must be called from an IDE component (component level > 100,000).

[In] Specifies the current frame. [In] Specifies if code paths are for current statement or line. [Out] DkmSteppingCodePath[] represents a location that user can step to from current location.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Result of an asynchronous DkmTransportConnection.ActivateAppPackage call.

Creates a new result structure to hold the error from a failed call to DkmTransportConnection.ActivateAppPackage.

[In] exception object containing the error

HRESULT code returned from the caller. This will be DkmExceptionCode.COR_E_OPERATIONCANCELED (0x8013153B) if the operation was canceled before processing was complete.

Information required to activate an App Package. This API was introduced in Visual Studio 15 Update 1 (DkmApiVersion.VS15Update1).

Indicates if the specified application package is a Windows Phone or Windows Store app. This API was introduced in Visual Studio 15 Update 1 (DkmApiVersion.VS15Update1).

Identifier for the application to launch. This API was introduced in Visual Studio 15 Update 1 (DkmApiVersion.VS15Update1).

If true, the app is being debugged. This API was introduced in Visual Studio 15 Update 1 (DkmApiVersion.VS15Update1).

[Optional] Command line arguments to pass to the app. This API was introduced in Visual Studio 15 Update 1 (DkmApiVersion.VS15Update1).

Flags indicating options for AppPackage activation. This API was introduced in Visual Studio 15 Update 1 (DkmApiVersion.VS15Update1).

[Optional] Target monitor index (see: ActivateAppPackageOnTargetMonitor). This API was introduced in Visual Studio 15 Update 1 (DkmApiVersion.VS15Update1).

Create a new DkmActivateAppPackageInfo object instance. This API was introduced in Visual Studio 15 Update 1 (DkmApiVersion.VS15Update1).

[In] This represents a connection between the monitor and the IDE. It can either be a local connection if the monitor is running in the same process as the IDE, or it can be a remote connection. In the monitor process, there is only one connection. [In] Indicates if the specified application package is a Windows Phone or Windows Store app. [In] Identifier for the application to launch. [In] If true, the app is being debugged. [In,Optional] Command line arguments to pass to the app. [In] Flags indicating options for AppPackage activation. [In,Optional] Target monitor index (see: ActivateAppPackageOnTargetMonitor). [Out] Result of this method call.

Activates the specified packaged application. This will cause the application to start if it has not already started, and will bring it back as the active application if it is already running. When launching under the debugger, IDkmProcessLaunchNotifyListener.StartListener will be called before this API. This method will append a new work item to the specified work list, and return once the work item has been appended. The actual processing of the work item is asynchronous. The caller will be notified that the request is complete through the completion routine. This API was introduced in Visual Studio 15 Update 1 (DkmApiVersion.VS15Update1).

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Settings supplied during a start debugging operation from a project system or other caller of LaunchDebugTargets (or various other start debugging APIs).

Additional information provided by a project system when calling LaunchDebugTargets through VsDebugTarget[2/3/etc].bstrOptions).

[Optional] Guids for the set of debug engines being used to debug this process. This will be null if the process was launched outside the debugger.

Create a new DkmDebugLaunchSettings object instance.

[In] Additional information provided by a project system when calling LaunchDebugTargets through VsDebugTarget[2/3/etc].bstrOptions). [In,Optional] Guids for the set of debug engines being used to debug this process. This will be null if the process was launched outside the debugger. [Out] Result of this method call.

Obtains any environment variables which the extension would like to add. Location constraint: API must be called from a Monitor component (component level < 100,000).

[In] Enumeration of the scenarios where IDkmProcessLaunchEnvironmentFilter implementations are invoked. [Out,Optional] One or more environment variables which should be passed to the target process. Multiple variables are separated with an embedded null ('\0'). For example: "MyVariable1=1\0MyVariable2=12". Null or empty string are returned if the caller doesn't want to customize the environment block for this launch.

Engine is capable of debugging native code. This will be 'false' when debugging .NET CLR v2 code, or .NET code on the device. Note that even when true, native debugging may not be currently enabled (see DkmProcessSettings.IsNativeDebuggingEnabled). This API was introduced in Visual Studio 12 Update 2 (DkmApiVersion.VS12Update2).

[In] EngineSettings to check native code support. [Out] Boolean value indicates if native code is supported.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Object used to send a request to the IDE to request that Visual Studio should debug an additional process. This may be used, for example, to debug a child process. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

Process which the debugger should attach to. In general, this should be a new process which is still at the initial suspension point. However, in some cases such as when a base dm is already attached to the process, and sends the request merely to get the rest of the debugger ready to debug the process, this restriction may not apply. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

64-bit date time value indicating when the process was started. The start time along with the id and the machine where the process was started can uniquely identify a process. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

The process which is logically the parent of the new process which is going to be debugged. For something like child process debugging, this should generally be the actual parent process. In other cases, it could simply be the process which is performing, an action which motivates the request to debug. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

Full path to the starting executable of the process. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

[Optional] Guids for the set of debug engines to be used to debug this process. If null, debugger will determine the correct engine filter based on any child process debugging settings. Currently, this will simply use the engine from the parent process, but this is subject to change in the future. To force the same engine to be used, the caller should pass LogicalParentProcess.DebugLaunchSettings.EngineFilter rather than null. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

Flags passed in the DkmDebugProcessRequest object. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

Create a new DkmDebugProcessRequest object instance. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

[In] Process which the debugger should attach to. In general, this should be a new process which is still at the initial suspension point. However, in some cases such as when a base dm is already attached to the process, and sends the request merely to get the rest of the debugger ready to debug the process, this restriction may not apply. [In] 64-bit date time value indicating when the process was started. The start time along with the id and the machine where the process was started can uniquely identify a process. [In] The process which is logically the parent of the new process which is going to be debugged. For something like child process debugging, this should generally be the actual parent process. In other cases, it could simply be the process which is performing, an action which motivates the request to debug. [In] Full path to the starting executable of the process. [In,Optional] Guids for the set of debug engines to be used to debug this process. If null, debugger will determine the correct engine filter based on any child process debugging settings. Currently, this will simply use the engine from the parent process, but this is subject to change in the future. To force the same engine to be used, the caller should pass LogicalParentProcess.DebugLaunchSettings.EngineFilter rather than null. [In] Flags passed in the DkmDebugProcessRequest object. [Out] Result of this method call.

Sends the debug request to the IDE. The completion routine will be notified when the attach completes. This method will append a new work item to the specified work list, and return once the work item has been appended. The actual processing of the work item is asynchronous. The caller will be notified that the request is complete through the completion routine. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Result of an asynchronous DkmDebugProcessRequest.Send call.

Creates a new result structure to hold the error from a failed call to DkmDebugProcessRequest.Send.

[In] exception object containing the error

Flags passed in the DkmDebugProcessRequest object. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

No flags are set.

Detach from the process on stop debugging instead of terminating it.

DkmLaunchedProcessInfo is returned from APIs that launch a process.

Id of the launched process. Minidump implementations can set this to 0.

64-bit date time value indicating when the process was started. The start time along with the id and the machine where the process was started can uniquely identify a process. This can be set to 0 if this is unknown/invalid (ex: minidumps).

Id of the first thread in the launched process. Minidump implementations can set this to 0.

Initialize a new DkmLaunchedProcessInfo value.

[In] Id of the launched process. Minidump implementations can set this to 0. [In] 64-bit date time value indicating when the process was started. The start time along with the id and the machine where the process was started can uniquely identify a process. This can be set to 0 if this is unknown/invalid (ex: minidumps). [In] Id of the first thread in the launched process. Minidump implementations can set this to 0.

Object created by runtime debug monitors in order to defer the sending of the LoadComplete event. This is important in attach scenario as load complete is used to indicate that process attach has finished and that all breakpoints in running code have been bound. This API was introduced in Visual Studio 12 Update 2 (DkmApiVersion.VS12Update2).

Id to uniquely identify the deferral within a specific process. This API was introduced in Visual Studio 12 Update 2 (DkmApiVersion.VS12Update2).

Create a new DkmLoadCompleteEventDeferral object instance. The deferral is not initially active, call 'Add' in order to all the deferral to the list of active deferrals. Location constraint: API must be called from a Monitor component (component level < 100,000). This API was introduced in Visual Studio 12 Update 2 (DkmApiVersion.VS12Update2).

[In] DkmProcess represents a target process which is being debugged. The debugger debugs processes, so this is the basic unit of debugging. A DkmProcess can represent a system process or a virtual process such as minidumps. [In] Id to uniquely identify the deferral within a specific process. [Out] Result of this method call.

Adds a request to defer load complete. This method should be called before the base debug monitor issues the load complete event (calls DkmProcess.OnLoadComplete). Location constraint: API must be called from a Monitor component (component level < 100,000). This API was introduced in Visual Studio 12 Update 2 (DkmApiVersion.VS12Update2).

E_LOAD_COMPLETE_ALREADY_SENT indicates that DkmLoadCompleteEventDeferral.Add was called after the load complete event has been sent.

Removes the load complete defer request. This method must be called on the event thread is response to a stopping/pausing event. If the base debug monitor has already called DkmProcess.OnLoadComplete prior to the final call to Remove, the final call to Remove will then fire the load complete event. Location constraint: API must be called from a Monitor component (component level < 100,000). This API was introduced in Visual Studio 12 Update 2 (DkmApiVersion.VS12Update2).

E_WRONG_THREAD indicates that Remove was not called on an event thread. E_LOAD_COMPLETE_DEFERRAL_NOT_FOUND indicates that Remove was called on a deferral object was was not in the list of active deferrals.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

DkmProcessAttachRequest is used to describe the process that debugger should attach to.

Full path to the starting executable of the process.

Id of the process which the debugger should attach to.

Value to assign to the 'DkmProcess.UniqueId' field. This Guid is generated by the port, and is used to uniquely identifies the process object.

DkmStartMethod describes how the debug engine started debugging this process.

[Optional] Unique id for a programming language. These values must also be registered under $(RegRoot)\AD7Metric\ExpressionEvaluator and returned from symbol providers (through GetCompilerId) and language services (through IVsLanguageDebugInfo.GetLanguageID).

Contains the session-wide debug settings. There is one instance of this object per engine Guid (ex: one instance for COMPlusOnlyEng2, one instance for COMPlusNativeEng).

Settings supplied during a start debugging operation from a project system or other caller of LaunchDebugTargets (or various other start debugging APIs).

64-bit date time value indicating when the process was started. The start time along with the id and the machine where the process was started can uniquely identify a process. This can be set to 0 if this is unknown/invalid (ex: minidumps). This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

Create a new DkmProcessAttachRequest object instance.

Create a new DkmProcessAttachRequest object instance. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

[In] This represents a connection between the monitor and the IDE. It can either be a local connection if the monitor is running in the same process as the IDE, or it can be a remote connection. In the monitor process, there is only one connection. [In] Full path to the starting executable of the process. [In] Id of the process which the debugger should attach to. [In] Value to assign to the 'DkmProcess.UniqueId' field. This Guid is generated by the port, and is used to uniquely identifies the process object. [In] DkmStartMethod describes how the debug engine started debugging this process. [In,Optional] Unique id for a programming language. These values must also be registered under $(RegRoot)\AD7Metric\ExpressionEvaluator and returned from symbol providers (through GetCompilerId) and language services (through IVsLanguageDebugInfo.GetLanguageID). [In] Contains the session-wide debug settings. There is one instance of this object per engine Guid (ex: one instance for COMPlusOnlyEng2, one instance for COMPlusNativeEng). [In] Settings supplied during a start debugging operation from a project system or other caller of LaunchDebugTargets (or various other start debugging APIs). [In] 64-bit date time value indicating when the process was started. The start time along with the id and the machine where the process was started can uniquely identify a process. This can be set to 0 if this is unknown/invalid (ex: minidumps). [Out] Result of this method call.

[Out] DkmProcess represents a target process which is being debugged. The debugger debugs processes, so this is the basic unit of debugging. A DkmProcess can represent a system process or a virtual process such as minidumps. E_ATTACH_USER_CANCELED indicates that the attach to process operation was canceled. Returning this error will suppress most error messages. So it can be used in combination with DkmUserMessage.Post or DkmCustomMessage.SendToVsService as a way of providing custom failure messages to the user.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

DkmProcessLaunchEnvironmentFilterInputData is used to provide input to a IDkmProcessLaunchEnvironmentFilter140 implementation. It describes the process which is about to be started. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

Settings supplied during a start debugging operation from a project system or other caller of LaunchDebugTargets (or various other start debugging APIs). This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

[Optional] Path to the executable file to launch. For a desktop app launch (AppPackageId is null) this will be the full path to the executable which will be launched. For Windows Store or a project system using the IVsDebugLaunchNotifyListener110 API, this value is a hint from the project system. It could be null, it could be just the file name of the executable rather than a full path, or it could represent only one of the executables that could be launched in the package. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

[Optional] The Windows Store (or possibly other container in the future) app package of the app which is about to be started. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

Flags associated with a request to launch a process. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

Create a new DkmProcessLaunchEnvironmentFilterInputData object instance. Location constraint: API must be called from a Monitor component (component level < 100,000). This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

[In] This represents a connection between the monitor and the IDE. It can either be a local connection if the monitor is running in the same process as the IDE, or it can be a remote connection. In the monitor process, there is only one connection. [In] Settings supplied during a start debugging operation from a project system or other caller of LaunchDebugTargets (or various other start debugging APIs). [In,Optional] Path to the executable file to launch. For a desktop app launch (AppPackageId is null) this will be the full path to the executable which will be launched. For Windows Store or a project system using the IVsDebugLaunchNotifyListener110 API, this value is a hint from the project system. It could be null, it could be just the file name of the executable rather than a full path, or it could represent only one of the executables that could be launched in the package. [In,Optional] The Windows Store (or possibly other container in the future) app package of the app which is about to be started. [In] Flags associated with a request to launch a process. [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Holds the list of implementations of the IDkmProcessLaunchEnvironmentFilter interface which may be called by a component. This object is used to call these environment filters.

Returns the number of implemantions of the IDkmProcessLaunchEnvironmentFilter interface which may be called through this object.

Obtains any environment variables which the extension would like to add. Location constraint: API must be called from a Monitor component (component level < 100,000).

[In] Zero-based index into the collection of {0} implementations that the caller wishes to be invoked. This should be less than the 'Count' property. [In] Settings supplied during a start debugging operation from a project system or other caller of LaunchDebugTargets (or various other start debugging APIs). [In] Enumeration of the scenarios where IDkmProcessLaunchEnvironmentFilter implementations are invoked. [Out,Optional] One or more environment variables which should be passed to the target process. Multiple variables are separated with an embedded null ('\0'). For example: "MyVariable1=1\0MyVariable2=12". Null or empty string are returned if the caller doesn't want to customize the environment block for this launch.

Create a new DkmProcessLaunchEnvironmentFilterList object instance. Location constraint: API must be called from a Monitor component (component level < 100,000).

[Out] Result of this method call.

Holds the list of implementations of the IDkmProcessLaunchEnvironmentFilter interface which may be called by a component. This object is used to call these environment filters. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

Returns the number of implemantions of the IDkmProcessLaunchEnvironmentFilter140 interface which may be called through this object.

Obtains any environment variables which the extension would like to add. Location constraint: API must be called from a Monitor component (component level < 100,000). This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

[In] Zero-based index into the collection of {0} implementations that the caller wishes to be invoked. This should be less than the 'Count' property. [In] DkmProcessLaunchEnvironmentFilterInputData is used to provide input to a IDkmProcessLaunchEnvironmentFilter140 implementation. It describes the process which is about to be started. [Out,Optional] One or more environment variables which should be passed to the target process. Multiple variables are separated with an embedded null ('\0'). For example: "MyVariable1=1\0MyVariable2=12". Null or empty string are returned if the caller doesn't want to customize the environment block for this launch.

Create a new DkmProcessLaunchEnvironmentFilterList140 object instance. Location constraint: API must be called from a Monitor component (component level < 100,000). This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

[Out] Result of this method call.

Enumeration of the scenarios where IDkmProcessLaunchEnvironmentFilter implementations are invoked.

Application is about to be launched with CreateProcess.

Windows Store app package or Windows Phone app package is about to be started.

Flags associated with a request to launch a process. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

No flags are set.

Indicates that one or more vsdebugeng.dll-based debug engines are being used to debug this process. This will be clear if the process is being started outside of the debugger, or if another engine, such as the legacy managed debug engine, is being used to debug the process.

Indicates that this process launch is for profiling and so the IDkmProfileProcessLaunch140 callbacks should be called.

Flag traits of a DkmProcessLaunchRequest.

No launch flags are set.

Launch the process without debugging (Ctrl+F5).

Launch the process with Edit and Continue enabled.

Merge DkmProcessLaunchRequest.Environment with the environment block of the monitor. If this flag is missing and DkmProcessLaunchRequest.Environment is specified then the processed will be launched with only environment variables from the input block.

Redirect the standard output and standard error of the process to the output window.

Launch in the integrated console.

DkmProcessLaunchRequest is used to describe the process that debugger should launch.

Path to the executable file to launch.

[Optional] Arguments to pass to the executable file on the command line.

The full path to the current directory for the process. The string can also specify a UNC path.

[Optional] A pointer to the environment block for the new process. If this parameter is NULL, the new process uses the environment of the calling process. An environment block consists of a null-terminated block of null-terminated strings. Each string is in the following form: 'name=value\0'. Because the equal sign is used as a separator, it must not be used in the name of an environment variable.

[Optional] Additional information used to launch a new process. This information is contained within the 'STARTUPINFO' structure in Win32.

Flag traits of a DkmProcessLaunchRequest.

Win32 process creation flags used when launching the process. For example, CREATE_NO_WINDOW (0x08000000) could be passed to disable the creation of the console window. The following flags should never be passed, and the behavior is undefined if they are present: DEBUG_PROCESS, DEBUG_ONLY_THIS_PROCESS, CREATE_SUSPENDED, EXTENDED_STARTUPINFO_PRESENT, CREATE_SEPARATE_WOW_VDM, CREATE_SHARED_WOW_VDM, and CREATE_UNICODE_ENVIRONMENT.

UniqueId uniquely identifies the launch request.

[Optional] Settings to use when launching this executable under the debugger. This may be omitted if the process is not being launched under the debugger (ex: Ctrl-F5).

Settings supplied during a start debugging operation from a project system or other caller of LaunchDebugTargets (or various other start debugging APIs).

Flags associated with a request to launch a process. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

Closes a DkmProcessLaunchRequest object instance. This will release any resources associated with this object across all components. This includes resources across computer or managed/native marshalling boundaries. DkmProcessLaunchRequest objects are automatically closed when their associated DkmTransportConnection object is closed. This method may only be called by the component which created the object.

Create a new DkmProcessLaunchRequest object instance. The caller is responsible for closing the created object after they are done.

[In] Path to the executable file to launch. [In,Optional] Arguments to pass to the executable file on the command line. [In] The full path to the current directory for the process. The string can also specify a UNC path. [In,Optional] A pointer to the environment block for the new process. If this parameter is NULL, the new process uses the environment of the calling process. An environment block consists of a null-terminated block of null-terminated strings. Each string is in the following form: 'name=value\0'. Because the equal sign is used as a separator, it must not be used in the name of an environment variable. [In,Optional] Additional information used to launch a new process. This information is contained within the 'STARTUPINFO' structure in Win32. [In] Flag traits of a DkmProcessLaunchRequest. [In] Win32 process creation flags used when launching the process. For example, CREATE_NO_WINDOW (0x08000000) could be passed to disable the creation of the console window. The following flags should never be passed, and the behavior is undefined if they are present: DEBUG_PROCESS, DEBUG_ONLY_THIS_PROCESS, CREATE_SUSPENDED, EXTENDED_STARTUPINFO_PRESENT, CREATE_SEPARATE_WOW_VDM, CREATE_SHARED_WOW_VDM, and CREATE_UNICODE_ENVIRONMENT. [In] This represents a connection between the monitor and the IDE. It can either be a local connection if the monitor is running in the same process as the IDE, or it can be a remote connection. In the monitor process, there is only one connection. [In,Optional] Settings to use when launching this executable under the debugger. This may be omitted if the process is not being launched under the debugger (ex: Ctrl-F5). [In] Settings supplied during a start debugging operation from a project system or other caller of LaunchDebugTargets (or various other start debugging APIs). [In,Optional] Data object to add to the new DkmProcessLaunchRequest instance. Pass 'null' in the case that the caller doesn't need to add a data item. [Out] Result of this method call.

Create a new DkmProcessLaunchRequest object instance. The caller is responsible for closing the created object after they are done. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

[In] Path to the executable file to launch. [In,Optional] Arguments to pass to the executable file on the command line. [In] The full path to the current directory for the process. The string can also specify a UNC path. [In,Optional] A pointer to the environment block for the new process. If this parameter is NULL, the new process uses the environment of the calling process. An environment block consists of a null-terminated block of null-terminated strings. Each string is in the following form: 'name=value\0'. Because the equal sign is used as a separator, it must not be used in the name of an environment variable. [In,Optional] Additional information used to launch a new process. This information is contained within the 'STARTUPINFO' structure in Win32. [In] Flag traits of a DkmProcessLaunchRequest. [In] Win32 process creation flags used when launching the process. For example, CREATE_NO_WINDOW (0x08000000) could be passed to disable the creation of the console window. The following flags should never be passed, and the behavior is undefined if they are present: DEBUG_PROCESS, DEBUG_ONLY_THIS_PROCESS, CREATE_SUSPENDED, EXTENDED_STARTUPINFO_PRESENT, CREATE_SEPARATE_WOW_VDM, CREATE_SHARED_WOW_VDM, and CREATE_UNICODE_ENVIRONMENT. [In] This represents a connection between the monitor and the IDE. It can either be a local connection if the monitor is running in the same process as the IDE, or it can be a remote connection. In the monitor process, there is only one connection. [In,Optional] Settings to use when launching this executable under the debugger. This may be omitted if the process is not being launched under the debugger (ex: Ctrl-F5). [In] Settings supplied during a start debugging operation from a project system or other caller of LaunchDebugTargets (or various other start debugging APIs). [In] Flags associated with a request to launch a process. [In,Optional] Data object to add to the new DkmProcessLaunchRequest instance. Pass 'null' in the case that the caller doesn't need to add a data item. [Out] Result of this method call.

[In] Win32 process creation flags in addition to those found in the DkmProcessLaunchRequest.Win32Flags. This is often used to pass DEBUG_PROCESS (0x1), DEBUG_ONLY_THIS_PROCESS (0x2), or CREATE_SUSPENDED (0x4). [Out] DkmLaunchedProcessInfo is returned from APIs that launch a process.

This API is used to resume a process which was launched from CreateProcess with the LaunchSuspended flag set to true.

[Out] DkmLaunchedProcessInfo is returned from APIs that launch a process.

[In] Value to assign to the 'DkmProcess.UniqueId' field. This Guid is generated by the port, and is used to uniquely identifies the process object. [Out] DkmProcess represents a target process which is being debugged. The debugger debugs processes, so this is the basic unit of debugging. A DkmProcess can represent a system process or a virtual process such as minidumps.

This API is used to resume a process which was launched from CreateProcess with the LaunchSuspended flag set to true. This API was introduced in Visual Studio 15 Update 3 (DkmApiVersion.VS15Update3).

[In] The process that should be resumed.

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Additional information used to launch a new process. This information is contained within the 'STARTUPINFO' structure in Win32.

[Optional] The name of the desktop, or the name of both the desktop and window station for this process. A backslash in the string indicates that the string includes both the desktop and window station names. For more information, see Thread Connection to a Desktop.

[Optional] For console processes, this is the title displayed in the title bar if a new console window is created. If NULL, the name of the executable file is used as the window title instead. This parameter must be NULL for GUI or console processes that do not create a new console window.

If 'Flags' specifies STARTF_USEPOSITION, this member is the x offset of the upper left corner of a window if a new window is created, in pixels. Otherwise, this member is ignored.

If 'Flags' specifies STARTF_USEPOSITION, this member is the y offset of the upper left corner of a window if a new window is created, in pixels. Otherwise, this member is ignored.

If 'Flags' specifies STARTF_USESIZE, this member is the width of the window if a new window is created, in pixels. Otherwise, this member is ignored.

If 'Flags' specifies STARTF_USESIZE, this member is the height of the window if a new window is created, in pixels. Otherwise, this member is ignored.

If 'Flags' specifies STARTF_USECOUNTCHARS, if a new console window is created in a console process, this member specifies the screen buffer width, in character columns. Otherwise, this member is ignored.

If 'Flags' specifies STARTF_USECOUNTCHARS, if a new console window is created in a console process, this member specifies the screen buffer height, in character rows. Otherwise, this member is ignored.

If 'Flags' specifies STARTF_USEFILLATTRIBUTE, this member is the initial text and background colors if a new console window is created in a console application. Otherwise, this member is ignored.

'STARTF_*' flags for this request. More information can be found in Win32 documentation under 'STARTUPINFO.dwFlags'.

If 'Flags' specifies STARTF_USESHOWWINDOW, this member can be any of the values that can be specified in the nCmdShow parameter for the ShowWindow function, except for SW_SHOWDEFAULT. Otherwise, this member is ignored.

If 'Flags' specifies STARTF_USESTDHANDLES, this member is the standard input handle for the process. Otherwise, this value should be zero.

If 'Flags' specifies STARTF_USESTDHANDLES, this member is the standard output handle for the process. Otherwise, this value should be zero.

If 'Flags' specifies STARTF_USESTDHANDLES, this member is the standard error handle for the process. Otherwise, this value should be zero.

Create a new DkmProcessStartupInfo object instance.

[In,Optional] The name of the desktop, or the name of both the desktop and window station for this process. A backslash in the string indicates that the string includes both the desktop and window station names. For more information, see Thread Connection to a Desktop. [In,Optional] For console processes, this is the title displayed in the title bar if a new console window is created. If NULL, the name of the executable file is used as the window title instead. This parameter must be NULL for GUI or console processes that do not create a new console window. [In] If 'Flags' specifies STARTF_USEPOSITION, this member is the x offset of the upper left corner of a window if a new window is created, in pixels. Otherwise, this member is ignored. [In] If 'Flags' specifies STARTF_USEPOSITION, this member is the y offset of the upper left corner of a window if a new window is created, in pixels. Otherwise, this member is ignored. [In] If 'Flags' specifies STARTF_USESIZE, this member is the width of the window if a new window is created, in pixels. Otherwise, this member is ignored. [In] If 'Flags' specifies STARTF_USESIZE, this member is the height of the window if a new window is created, in pixels. Otherwise, this member is ignored. [In] If 'Flags' specifies STARTF_USECOUNTCHARS, if a new console window is created in a console process, this member specifies the screen buffer width, in character columns. Otherwise, this member is ignored. [In] If 'Flags' specifies STARTF_USECOUNTCHARS, if a new console window is created in a console process, this member specifies the screen buffer height, in character rows. Otherwise, this member is ignored. [In] If 'Flags' specifies STARTF_USEFILLATTRIBUTE, this member is the initial text and background colors if a new console window is created in a console application. Otherwise, this member is ignored. [In] 'STARTF_*' flags for this request. More information can be found in Win32 documentation under 'STARTUPINFO.dwFlags'. [In] If 'Flags' specifies STARTF_USESHOWWINDOW, this member can be any of the values that can be specified in the nCmdShow parameter for the ShowWindow function, except for SW_SHOWDEFAULT. Otherwise, this member is ignored. [In] If 'Flags' specifies STARTF_USESTDHANDLES, this member is the standard input handle for the process. Otherwise, this value should be zero. [In] If 'Flags' specifies STARTF_USESTDHANDLES, this member is the standard output handle for the process. Otherwise, this value should be zero. [In] If 'Flags' specifies STARTF_USESTDHANDLES, this member is the standard error handle for the process. Otherwise, this value should be zero. [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

DkmStartMethod describes how the debug engine started debugging this process.

Process was launched under the debugger.

Process was launched outside the debugger and the debugger attached.

Process was launched suspended by the project system or SDM. Then the engine was asked to attach to the process while the process was still at the initial suspension point. This is used for Low-rights IE (LoRIE).

Hosting process was launched by the project system and then the project system asked the debugger to attach to the process.

Flags indicating options for AppPackage activation. This API was introduced in Visual Studio 14 Update 1 (DkmApiVersion.VS14Update1).

Default value.

App should be launched in Prelaunch mode.

Result of an asynchronous DkmTransportConnection.ActivateBackgroundTask call.

Creates a new result structure to hold the error from a failed call to DkmTransportConnection.ActivateBackgroundTask.

[In] exception object containing the error

HRESULT code returned from the caller. This will be DkmExceptionCode.COR_E_OPERATIONCANCELED (0x8013153B) if the operation was canceled before processing was complete.

Identifies a Windows Store app package or Windows Phone app package.

Indicates if the specified application package is a Windows Phone or Windows Store app.

The full name of the application. For DkmApplicationPlatform.WindowsAppx, this is the package full name.

Create a new DkmAppPackageId object instance.

[In] Indicates if the specified application package is a Windows Phone or Windows Store app. [In] The full name of the application. For DkmApplicationPlatform.WindowsAppx, this is the package full name. [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Object representing an arbitrary executable which is executed on the target computer.

Guid which uniquely identifies this object.

Transport connection to the target where the command should execute.

Path to the remote executable. Environment variables will be expanded (ex: %TMP%\mycommand.exe). If this is not a full path, the remote debugger will look next to itself, and then search the PATH environment variable.

[Optional] Arguments to pass to the remote command. This value may be null to pass no arguments.

[Optional] Initial current directory for the target process. This value may be null to use the directory of the remote debugger.

Flags effecting the processing of deployment commands.

Closes the deployment command object. This should be called by the creator of the DkmDeploymentCommand object after execution has completed (IDkmDeploymentCommandCallback.OnProcessExit is called). DkmDeploymentCommand objects are automatically closed when their associated DkmTransportConnection object is closed. This method may only be called by the component which created the object.

Creates a new DkmDeploymentCommand object. The command will not begin executing until Start is called. The caller is responsible for closing the created object after they are done.

[In] Transport connection to the target where the command should execute. [In] Identifies the source of an object. SourceIds are used to enable filtering in scenarios when multiple components may be creating instances of a class. For example, source ids can be used to determine if a breakpoint comes from the AD7 AL (ex: user breakpoint, or other breakpoint visible at the SDM level) instead of a breakpoint which may be created by another component (for example an internal breakpoint used for stepping). [In] Path to the remote executable. Environment variables will be expanded (ex: %TMP%\mycommand.exe). If this is not a full path, the remote debugger will look next to itself, and then search the PATH environment variable. [In,Optional] Arguments to pass to the remote command. This value may be null to pass no arguments. [In,Optional] Initial current directory for the target process. This value may be null to use the directory of the remote debugger. [In] Flags effecting the processing of deployment commands. [In,Optional] Data object to add to the new DkmDeploymentCommand instance. Pass 'null' in the case that the caller doesn't need to add a data item. [Out] Result of this method call.

Indication that the launched command has completed. After this is received, no further notifications will be sent. Location constraint: API must be called from a Monitor component (component level < 100,000).

[In] 32-bit value which the processed returned on exit. This is the same value that would be reported from the kernel32!GetExitCodeProcess.

Indication that the target wrote to stdout. This is also used for StdErr if the DkmDeploymentCommandFlags.CombineStdErr flag is used. Location constraint: API must be called from a Monitor component (component level < 100,000).

[In] Text written to stdout.

[In] Text written to stderr.

Begin execution of the deployment command. This method will return once the deployed command has begun execution. Callers of this method would typically implement IDkmDeploymentCommandCallback with a SourceId filter to receive information about the command.

Abort execution of the command by terminating the launched process. If successful, this will cause IDkmDeploymentCommandCallback.OnProcessExit to be called.

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Flags effecting the processing of deployment commands.

No flags are set.

Launched program writes to StdOut/StdErr with the target computer's console code page rather than Unicode (UTF-16).

Combine StdErr with StdOut. When this flag is set, IDkmDeploymentCommandCallback.OnStdErr will not be called. This is helpful to synchronize StdErr/StdOut content.

Show the UI for the executed command instead of running hidden.

The device information for current system, available for Windows 10 or later. This includes the physical form factor of the device, and the OS family and version number of the operating system. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

The family of the device, say Windows.Universal, Windows.Server, Windows.Xbox, Windows.IoT, or many others. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

The version number of the Operating System running on the device. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

The physical form of the device, say Phone, Tablet, Desktop, Notebook, or many others. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

[Optional] The unique identifier of the device. This API was introduced in Visual Studio 15 RTM (DkmApiVersion.VS15RTM).

Create a new DkmDeviceInfo object instance. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

[In] The family of the device, say Windows.Universal, Windows.Server, Windows.Xbox, Windows.IoT, or many others. [In] The version number of the Operating System running on the device. [In] The physical form of the device, say Phone, Tablet, Desktop, Notebook, or many others. [Out] Result of this method call.

Create a new DkmDeviceInfo object instance. This API was introduced in Visual Studio 15 RTM (DkmApiVersion.VS15RTM).

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Result of an asynchronous DkmTransportConnection.DownloadFile call.

Creates a new result structure to hold the error from a failed call to DkmTransportConnection.DownloadFile.

[In] exception object containing the error

HRESULT code returned from the caller. This will be DkmExceptionCode.COR_E_OPERATIONCANCELED (0x8013153B) if the operation was canceled before processing was complete.

Result of an asynchronous DkmTransportConnection.EnumerateBackgroundTasks call.

Creates a new result structure to hold the error from a failed call to DkmTransportConnection.EnumerateBackgroundTasks.

[In] exception object containing the error

HRESULT code returned from the caller. This will be DkmExceptionCode.COR_E_OPERATIONCANCELED (0x8013153B) if the operation was canceled before processing was complete.

Background task ids (GUIDs).

Background task names.

Creates a new result structure to hold the output from a successful call to DkmTransportConnection.EnumerateBackgroundTasks.

[In] Background task ids (GUIDs). [In] Background task names.

Marshal a native struct to managed

Pointer to native struct. Managed object.

Obtain a pointer to the native object used to call into native.

Outgoing managed->native call Native object

Validate the fields of this structure

Struct that holds the field path (ex: "myArgument.StructField")

Contains basic information about a file which is returned from DefaultPort.DkmTransportConnection.GetFileListing.

Name of the file or sub directory. This name does not contain the directory (ex: example.txt instead of c:\folder\example.txt).

Full path to the file or sub directory (ex: c:\folder\example.txt).

Win32 File attribute values (ex: FILE_ATTRIBUTE_DIRECTORY (0x10)).

Time the the file was created in FILETIME units (number of 100-nanosecond intervals since January 1, 1601 (UTC)).

Time the file was accessed in FILETIME units (number of 100-nanosecond intervals since January 1, 1601 (UTC)).

Time the file was written to in FILETIME units (number of 100-nanosecond intervals since January 1, 1601 (UTC)).

Size of the file in bytes.

Create a new DkmFileInfo object instance.

[In] Name of the file or sub directory. This name does not contain the directory (ex: example.txt instead of c:\folder\example.txt). [In] Full path to the file or sub directory (ex: c:\folder\example.txt). [In] Win32 File attribute values (ex: FILE_ATTRIBUTE_DIRECTORY (0x10)). [In] Time the the file was created in FILETIME units (number of 100-nanosecond intervals since January 1, 1601 (UTC)). [In] Time the file was accessed in FILETIME units (number of 100-nanosecond intervals since January 1, 1601 (UTC)). [In] Time the file was written to in FILETIME units (number of 100-nanosecond intervals since January 1, 1601 (UTC)). [In] Size of the file in bytes. [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Represents a file stream which can be used to transfer a large file over the remote debugger connection.

Guid which uniquely identifies this object.

Transport connection over which the file will be transferred.

Path to the file being transferred. Environment variables will be expanded (ex: %TMP%\deploy.txt). The path must be a full path to the file.

Closes the file transfer object. This will close the underlying file handle if it is not already closed because all the bytes have been transferred. This method must be called by the component which created the file file transfer object. DkmFileTransferStream objects are automatically closed when their associated DkmTransportConnection object is closed. This method may only be called by the component which created the object.

Creates a new file transfer stream object which is used to represent a file which is being streamed over the network. Note that the file is not immediately opened when the object is created. The caller should close the file transfer object when done. The caller is responsible for closing the created object after they are done.

[In] Transport connection over which the file will be transferred. [In] Path to the file being transferred. Environment variables will be expanded (ex: %TMP%\deploy.txt). The path must be a full path to the file. [In,Optional] Data object to add to the new DkmFileTransferStream instance. Pass 'null' in the case that the caller doesn't need to add a data item. [Out] Result of this method call.

Begins a remote file write operation. The remote file will be opened and the bytes from Content will be written to it. If additional bytes beyond what is in Content should be transferred, then WriteNext should be called to transfer those. If the directory of this file does not exist, the debugger will attempt to create it.

[In] The initial set of bytes to write to the file. [In] Indicates the number of bytes which will be written to the file. The file system handle will automatically be closed once this number of bytes has been received. Attempts to write past this number of bytes will fail. If the DkmFileTransferStream is closed before this number of bytes is transferred, the file will be deleted. [In] The date/time to set for when this file was last modified. The format of this is the same as a Win32 FILETIME structure, which is a 64-bit value representing the number of 100-nanosecond intervals since January 1, 1601. The value 0xffffffffffffffff may be used to specify that the current time should be used. [In] true if the debugger should attempt to overwrite any existing file. This will fail if the existing file is read-only.

Writes the next set of bytes to the remote file. This API will fail if WriteFirst has not already been called on the DkmFileTransferStream.

[In] The next set of bytes to write to the file.

Begins a remote file read operation. The remote file will be opened and bytes up to the size of the content buffer will be transferred. If the file is too large to fit into the content buffer, than ReadNext can be called to read the remaining bytes.

[In,Out] Buffer which receives the starting bytes of the file. [In] Indicates the size of the content buffer. [Out] Indicates the number of bytes read into the content buffer. This will be the minimum of the file size and the buffer size. [Out] The date/time to set for when this file was last modified. The format of this is the same as a Win32 FILETIME structure, which is a 64-bit value representing the number of 100-nanosecond intervals since January 1, 1601. [Out] Indicates the size of the file on disk.

[In,Out] Buffer which receives the starting bytes of the file. [Out] Indicates the number of bytes read into the content buffer. This will be the minimum of the file size and the buffer size. [Out] The date/time to set for when this file was last modified. The format of this is the same as a Win32 FILETIME structure, which is a 64-bit value representing the number of 100-nanosecond intervals since January 1, 1601. [Out] Indicates the size of the file on disk.

Reads the next set of bytes from the remote file. This API will fail if ReadFirst has not already been called on the DkmFileTransferStream.

[In,Out] Buffer which receives the next bytes of the file. [In] Indicates the size of the content buffer. [Out] Indicates the number of bytes read into the content buffer. This value is the smaller of the number of bytes left in the file (TotalFileSize returned from ReadFirst minus bytes already returned), and the size of the input buffer. In pseudo-code: min(TotalFileSize-BytesAlreadyReturned, BufferSize).

Reads the next set of bytes from the remote file. This API will fail if ReadFirst has not already been called on the DkmFileTransferStream.

[In,Out] Buffer which receives the next bytes of the file. [Out] Indicates the number of bytes read into the content buffer. This value is the smaller of the number of bytes left in the file (TotalFileSize returned from ReadFirst minus bytes already returned), and the size of the input buffer. In pseudo-code: min(TotalFileSize-BytesAlreadyReturned, BufferSize).

[In] The address at which to begin reading the remote file. [In,Out] Buffer which receives the starting bytes of the file. [In] Indicates the size of the content buffer. [Out] Indicates the number of bytes read into the content buffer. This will be the minimum of the file size and the buffer size. [Out] The date/time to set for when this file was last modified. The format of this is the same as a Win32 FILETIME structure, which is a 64-bit value representing the number of 100-nanosecond intervals since January 1, 1601. [Out] Indicates the size of the file on disk.

[In] The address at which to begin reading the remote file. [In,Out] Buffer which receives the starting bytes of the file. [Out] Indicates the number of bytes read into the content buffer. This will be the minimum of the file size and the buffer size. [Out] The date/time to set for when this file was last modified. The format of this is the same as a Win32 FILETIME structure, which is a 64-bit value representing the number of 100-nanosecond intervals since January 1, 1601. [Out] Indicates the size of the file on disk.

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Identifies an installed Windows Store App Package.

Identifies a Windows Store app package or Windows Phone app package.

The App Package display name.

The App Package version.

[Optional] The App Package logo path. For remote this will be the path on the remote system.

[Optional] Array of applications found in the App Package.

[Optional] Returns the package architecture. This API was introduced in Visual Studio 14 Update 3 (DkmApiVersion.VS14Update3).

Create a new DkmInstalledAppPackageInfo object instance.

[In] Identifies a Windows Store app package or Windows Phone app package. [In] The App Package display name. [In] The App Package version. [In,Optional] The App Package logo path. For remote this will be the path on the remote system. [In,Optional] Array of applications found in the App Package. [Out] Result of this method call.

Create a new DkmInstalledAppPackageInfo object instance. This API was introduced in Visual Studio 14 Update 3 (DkmApiVersion.VS14Update3).

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Identifies an installed Windows Store App.

The app user model id.

The application display name.

[Optional] The executable name.

[Optional] The application small logo path. For remote this will be the path on the remote system.

[Optional] The application background color.

The application description name.

The default debug engine to use for debugging this app. If unable to determine, the default is native.

[Optional] The application entry point. This API was introduced in Visual Studio 14 Update 2 (DkmApiVersion.VS14Update2).

Create a new DkmInstalledApplicationInfo object instance.

[In] The app user model id. [In] The application display name. [In,Optional] The executable name. [In,Optional] The application small logo path. For remote this will be the path on the remote system. [In,Optional] The application background color. [In] The application description name. [In] The default debug engine to use for debugging this app. If unable to determine, the default is native. [Out] Result of this method call.

Create a new DkmInstalledApplicationInfo object instance. This API was introduced in Visual Studio 14 Update 2 (DkmApiVersion.VS14Update2).

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Describes the application package's current execution state. For Windows Store apps, the values match the values in PACKAGE_EXECUTION_STATE.

The application's state is unknown.

The application is running.

The application is being suspended.

The application is suspended.

The application is terminated.

Indicates if the specified application package is a Windows Phone or Windows Store app.

Used for Windows Store app.

Used for Windows Phone XAP applications.

Flags indicating features which are available in the processor on which this system/process/thread is running. These generally deal with register set availability.

Processor does not support any additional features.

On X86, used to indicate that the CPU supports MMX registers.

On X86, used to indicate that the CPU supports SSE registers.

On X86, used to indicate that the CPU supports SSE2 registers.

On X86, used to indicate that the CPU supports 3DNow! registers.

On X86/X64, used to indicate that the CPU supports AVX registers.

On ARM, used to indicate that the CPU supports the full set of floating-point registers (Q0-Q15, D0-D31, and S0-S63, ). On arm, when this flag is cleared, the only supported floating-point registers include Q0-Q3, D0-D7, and S0-S15.

On X86/X64, used to indicate that the CPU supports AVX512 registers.

On X86/X64, used to indicate that the CPU supports MPX registers.

DkmProductionAgent represents an agent process launched using the StartAgent method of DkmProductionConnection. This API was introduced in Visual Studio 15 Update 2 (DkmApiVersion.VS15Update2).

Guid which uniquely identifies this UniqueId object. This will be passed as the source id when an event calls SendToVsService. This API was introduced in Visual Studio 15 Update 2 (DkmApiVersion.VS15Update2).

The command that was used to launch this agent. This API was introduced in Visual Studio 15 Update 2 (DkmApiVersion.VS15Update2).

The DkmProductionConnection object this agent was created using. This API was introduced in Visual Studio 15 Update 2 (DkmApiVersion.VS15Update2).

The Guid of the VS service to send the contents of writes to stdout to. This API was introduced in Visual Studio 15 Update 2 (DkmApiVersion.VS15Update2).

This method is called to close the object. DkmProductionAgent objects are automatically closed when their associated DkmProductionConnection object is closed. This API was introduced in Visual Studio 15 Update 2 (DkmApiVersion.VS15Update2).

Send a message to a production agent. This API was introduced in Visual Studio 15 Update 2 (DkmApiVersion.VS15Update2).

[In] The message to send to the agent encoded as a UTF8 string.

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

This represents a connection between the monitor and the IDE with the purpose of transporting messages related to the production scenario. This API was introduced in Visual Studio 15 Update 2 (DkmApiVersion.VS15Update2).

Guid which uniquely identifies this object. This API was introduced in Visual Studio 15 Update 2 (DkmApiVersion.VS15Update2).

Connection used to send the message to the debugger. This will value is usually obtained from DkmProcess.Connection unless the message needs to be sent before the DkmProcess is created. This API was introduced in Visual Studio 15 Update 2 (DkmApiVersion.VS15Update2).

This method is called to close the object. DkmProductionConnection objects are automatically closed when their associated DkmTransportConnection object is closed. This API was introduced in Visual Studio 15 Update 2 (DkmApiVersion.VS15Update2).

DkmProductionConnection is created to connect to a production session. This API was introduced in Visual Studio 15 Update 2 (DkmApiVersion.VS15Update2).

[In] Guid which uniquely identifies this object. [In] Connection used to send the message to the debugger. This will value is usually obtained from DkmProcess.Connection unless the message needs to be sent before the DkmProcess is created. [In,Optional] Data object to add to the new DkmProductionConnection instance. Pass 'null' in the case that the caller doesn't need to add a data item. [Out] Result of this method call.

GetProductionAgents enumerates the DkmProductionAgent elements of this DkmProductionConnection object. This API was introduced in Visual Studio 15 Update 2 (DkmApiVersion.VS15Update2).

[Out] Array containing the enumerated elements.

Start an agent process with input and output redirected. This API was introduced in Visual Studio 15 Update 2 (DkmApiVersion.VS15Update2).

[In] The path of the agent executable. The path will have environment variables expanded. [In] The command line parameters to pass to the agent. [In] The Guid of the VS service to send the contents of writes to stdout to. [Out] The DkmProductionAgent instance that represents this agent.

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Contains information about a debuggable runtime which has been loaded into a process on the computer (included processes which aren't being debugged). This will be used to represent programs published through pdm.dll, which is used for active script programs or other programs published through CLSID_ProgramPublisher (IDebugProgramPublisher2.PublishProgram/PublishProgramNode). It can also be used for other runtimes that might be loaded in the target process, such as CoreCLR.

[Optional] A friendly name for the program. This may be displayed in the attach to processes window. This is exposed to the AD7 API via IDebugProgramNode2.GetHostName(GHN_FRIENDLY_NAME).

The collection of engines which are capable of debugging this code. Generally, this collection only has one entry. For script, this value is DkmEngineId.Script.

Create a new DkmPublishedProgramInfo object instance.

[In,Optional] A friendly name for the program. This may be displayed in the attach to processes window. This is exposed to the AD7 API via IDebugProgramNode2.GetHostName(GHN_FRIENDLY_NAME). [In] The collection of engines which are capable of debugging this code. Generally, this collection only has one entry. For script, this value is DkmEngineId.Script. [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Basic information about a non-executable file that can be debugged. This non-executable file can be a recording of a running process, e.g. a time travel debug trace file. This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTM).

Full path to the file. This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTM).

The process info object is closed by the UI. DkmRecordedProcessInfo objects are automatically closed when their associated DkmTransportConnection object is closed. This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTM).

Creates a new recorded process object. This method is called from the base debug monitor. Location constraint: API must be called from a Monitor component (component level < 100,000). This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTM).

[In] Connection used to send the message to the debugger. This will value is usually obtained from DkmProcess.Connection unless the message needs to be sent before the DkmProcess is created. [In] Full path to the file. [In,Optional] Data object to add to the new DkmRecordedProcessInfo instance. Pass 'null' in the case that the caller doesn't need to add a data item. [Out] Result of this method call.

Get information about the computer where the recorded process ran. This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTM).

[Out] Object describing the system where the recorded process ran.

Get the lists of modules that loaded in the recorded process. This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTM).

[Out] The collection of the paths of the modules.

Get all the version number for all the CLR instances loaded into the recorded process. This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTM).

[Out] Version number for all the CLR instances loaded into the recorded process.

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Authentication mode to use when connecting over a standard remote connection.

Use built-in Windows authentication. Client and server will negotiate either Kerberos or NTLM. This is the default value.

Use built-in Windows Kerberos Authentication.

Use built-in NTLM authentication. This option can be used when Kerberos is malfunctioning.

Disable authentication. This value can only be used on trusted networks.

Other form of authentication used by a custom transport.

Flags containing Boolean properties of the running process.

Default value for DkmRunningProcessFlags.

Process is a 32-bit process running on a 64-bit computer. This is computed when DkmRunningProcessInfoPropertyMask.BasicInfoFlags is set.

There is a Win32 debugger attached to the process. This is computed when DkmRunningProcessInfoPropertyMask.BasicInfoFlags is set.

Process is running under a different user account than the debug monitor.

A security warning should be displayed before attaching to this process.

Process is running in AppContainer.

Process should be hidden in the process listing unless the user wants all processes to be shown. This is computed when DkmRunningProcessInfoPropertyMask.FilterFlags is set.

The runtime used to execute native-compiled .NET Framework code is loaded in the target process. This is computed when DkmRunningProcessInfoPropertyMask.ClrVersions is specified.

Snapshot of basic information about a running process. Unlike DkmProcess, this information is for a process which is not necessarily being debugged. This can either be returned as part of a task list, or information can be returned for a single process.

Process Id (PID) assigned by the operating system.

64-bit date time value indicating when the process was started. The start time along with the id and the machine where the process was started can uniquely identify a process.

Terminal server session id for the process (-1 if not obtained).

[Optional] Full path to the starting executable of the process. If the full path cannot be obtained, this may only contain the base executable name.

[Optional] Title of the process's main window (if any).

[Optional] User name that the process is running under (ex: MyCompany\MyAlias).

[Optional] Version number for all the CLR instances loaded into the debugged process.

[Optional] Command line used to start the process.

[Optional] Current directory of the process.

[Optional] Environment block of the process.

SECURITY_MANDATORY_*_RID value used to indicate the integrity level of this process. -1/MAXDWORD is used if the integrity level is unknown/invalid such as on pre-Vista operating systems where integrity levels do not exist, or if the user identity of process could not be obtained.

[Optional] Provides information about which runtimes are active in the target process. Currently this is used for script debugging and CoreCLR debugging, and it is likely to be used for other runtimes in the future.

Flags containing Boolean properties of the running process.

Example: PROCESSOR_ARCHITECTURE_INTEL (0), PROCESSOR_ARCHITECTURE_ARM (5), PROCESSOR_ARCHITECTURE_AMD64 (9), or PROCESSOR_ARCHITECTURE_ARM64 (12). This is computed when DkmRunningProcessInfoPropertyMask.BasicInfoFlags is set.

[Optional] The id of the application package for this process. Null if the process is not part of a Windows Store app, or Windows Phone application. This is computed when DkmRunningProcessInfoPropertyMask.AppPackageId is set.

Create a new DkmRunningProcessInfo object instance.

[In] Process Id (PID) assigned by the operating system. [In] 64-bit date time value indicating when the process was started. The start time along with the id and the machine where the process was started can uniquely identify a process. [In] Terminal server session id for the process (-1 if not obtained). [In,Optional] Full path to the starting executable of the process. If the full path cannot be obtained, this may only contain the base executable name. [In,Optional] Title of the process's main window (if any). [In,Optional] User name that the process is running under (ex: MyCompany\MyAlias). [In,Optional] Version number for all the CLR instances loaded into the debugged process. [In,Optional] Command line used to start the process. [In,Optional] Current directory of the process. [In,Optional] Environment block of the process. [In] SECURITY_MANDATORY_*_RID value used to indicate the integrity level of this process. -1/MAXDWORD is used if the integrity level is unknown/invalid such as on pre-Vista operating systems where integrity levels do not exist, or if the user identity of process could not be obtained. [In,Optional] Provides information about which runtimes are active in the target process. Currently this is used for script debugging and CoreCLR debugging, and it is likely to be used for other runtimes in the future. [In] Flags containing Boolean properties of the running process. [In] Example: PROCESSOR_ARCHITECTURE_INTEL (0), PROCESSOR_ARCHITECTURE_ARM (5), PROCESSOR_ARCHITECTURE_AMD64 (9), or PROCESSOR_ARCHITECTURE_ARM64 (12). This is computed when DkmRunningProcessInfoPropertyMask.BasicInfoFlags is set. [In,Optional] The id of the application package for this process. Null if the process is not part of a Windows Store app, or Windows Phone application. This is computed when DkmRunningProcessInfoPropertyMask.AppPackageId is set. [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Flags indicating which properties of DkmRunningProcessInfo should be computed.

No information should be computed.

'StartTime' field should be computed.

'SessionId' field should be computed.

'Name' field should be computed.

'Title' field should be computed.

'UserName' field should be computed.

Compute the 'ClrVersions' field and 'DkmRunningProcessFlags.ClrNativeCompilationRuntimeLoaded'.

'CommandLine' field should be computed.

'CurrentDirectory' field should be computed.

'EnvironmentBlock' field should be computed.

'IntegrityLevel' field should be computed.

'DkmRunningProcessFlags.Wow64' and 'DkmRunningProcessFlags.DebuggerAttached' should be computed.

'DkmRunningProcessFlags.OtherUser' and 'DkmRunningProcessFlags.SecurityWarningOnAttach' should be computed.

'DkmRunningProcessFlags.HideFromDefaultProcessList' should be computed.

PublishedPrograms field should be computed.

'AppPackageId' field should be computed.

Indicates if Core CLR DkmPublishedProgramInfo should be computed.

Result of an asynchronous DkmTransportConnection.ShutDownAppPackage call.

Creates a new result structure to hold the error from a failed call to DkmTransportConnection.ShutDownAppPackage.

[In] exception object containing the error

HRESULT code returned from the caller. This will be DkmExceptionCode.COR_E_OPERATIONCANCELED (0x8013153B) if the operation was canceled before processing was complete.

This represents a remote connection between the monitor and the IDE over the standard transport. This class derives from DkmTransportConnection, and defines options used to connect to the target computer.

Authentication mode to use when connecting over a standard remote connection.

[Optional] Proxy server used when connecting to this computer. This is null if the debugger is directly connected to the computer.

Silently aborts the transport connection in a similar way to what happens if the Visual Studio or the Remote Debugger is terminated. The underlying connection will be dropped, any in-flight operations will be aborted, and currently any debugged processes will be terminated. This API was introduced in Visual Studio 11 Update 2 (DkmApiVersion.VS11Update2).

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Result of an asynchronous DkmTransportConnection.SuspendAppPackage call.

Creates a new result structure to hold the error from a failed call to DkmTransportConnection.SuspendAppPackage.

[In] exception object containing the error

HRESULT code returned from the caller. This will be DkmExceptionCode.COR_E_OPERATIONCANCELED (0x8013153B) if the operation was canceled before processing was complete.

Contains information about the computer system that a process or connection is using. It can be obtained through the 'SystemInformation' property of a process, or from DefaultPort.DkmTransportConnection.GetSystemInformation.

Example: PROCESSOR_ARCHITECTURE_INTEL (0), PROCESSOR_ARCHITECTURE_ARM (5), PROCESSOR_ARCHITECTURE_AMD64 (9), or PROCESSOR_ARCHITECTURE_ARM64 (12).

Minimum size for a virtual memory page. This value may be zero in remote device scenarios where the page size is unknown.

4-byte value containing the operating system version packed as {platform id, major version, minor version, service pack major version}. The platform id from the OSVERSIONINFO structure and is currently always defined to VER_PLATFORM_WIN32_NT (2).

VER_SUITE_* flags from the OSVERSIONINFOEX structure.

Flags which provide information about the system that a computer system that a process/thread/connection is using.

Flags indicating features which are available in the processor on which this system/process/thread is running. These generally deal with register set availability.

If dump debugging, specifies the MINIDUMP_TYPE flags of the mini dump being debugged. If live debugging, this value is always zero. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

[Optional] The path of the system directory. For both 32-bit and 64-bit Windows, this value is typically C:\Windows\System32. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

[Optional] The path of the WOW64 system directory. This value is typically C:\Windows\SysWOW64. On 32-bit Windows, this value will be NULL. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

[Optional] The device information for current system, available for Windows 10 or later. This includes the physical form factor of the device, and the OS family and version number of the operating system. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

Create a new DkmSystemInformation object instance.

Create a new DkmSystemInformation object instance. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

[In] Example: PROCESSOR_ARCHITECTURE_INTEL (0), PROCESSOR_ARCHITECTURE_ARM (5), PROCESSOR_ARCHITECTURE_AMD64 (9), or PROCESSOR_ARCHITECTURE_ARM64 (12). [In] Minimum size for a virtual memory page. This value may be zero in remote device scenarios where the page size is unknown. [In] 4-byte value containing the operating system version packed as {platform id, major version, minor version, service pack major version}. The platform id from the OSVERSIONINFO structure and is currently always defined to VER_PLATFORM_WIN32_NT (2). [In] VER_SUITE_* flags from the OSVERSIONINFOEX structure. [In] Flags which provide information about the system that a computer system that a process/thread/connection is using. [In] Flags indicating features which are available in the processor on which this system/process/thread is running. These generally deal with register set availability. [In] If dump debugging, specifies the MINIDUMP_TYPE flags of the mini dump being debugged. If live debugging, this value is always zero. [In,Optional] The path of the system directory. For both 32-bit and 64-bit Windows, this value is typically C:\Windows\System32. [In,Optional] The path of the WOW64 system directory. This value is typically C:\Windows\SysWOW64. On 32-bit Windows, this value will be NULL. [Out] Result of this method call.

Create a new DkmSystemInformation object instance. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Flags which provide information about the system that a computer system that a process/thread/connection is using.

No flags are set.

The process/OS is 64-bit.

Indicates that the process/OS is from a .dmp file or other snapshot of a single point in time.

Indicates that if target process/OS allows debugger to arbitrarily access file system.

Indicates that the target OS is a core system. (Examples: XBox, Phone, etc.).

Indicates that msvsmon has been launched inside a chamber. (Phone execution model).

Indicates that the process is a process snapshot.

Indicates that the process is a static image and no execution control is possible.

Indicates that the process can execute in the reversed direction.

Guid which uniquely identifies this connection. The local connection will use the value 'DkmTransportKind.Local'. The value for other connections will be randomly generated.

[Optional] String indicating the connection destination. This will be null for the local connection. For default remote debugging, this is computer name and port number that we are trying to connect to.

Indicates the type of transport being used to debug.

Flags indicating traits of the underlying connection.

The version of the protocol used between Visual Studio and the target computer. This is the minimum of the protocol version that Visual Studio understands, and the protocol version that the remote debugger understands. This API was introduced in Visual Studio 11 Update 1 (DkmApiVersion.VS11FeaturePack1).

Find a DkmTransportConnection object. If no object with the given input key is present, FindConnection will fail.

[In] Search key used to find the element. [Out,Optional] Result of the search.

GetConnections enumerates all the created DkmTransportConnection objects.

[Out] Array containing the enumerated elements.

Find a DkmProcess element within this DkmTransportConnection. If no element with the given input key is present, FindProcess will fail.

[In] Search key used to find the element. [Out,Optional] Result of the search.

GetProcesses enumerates the DkmProcess elements of this DkmTransportConnection object.

[Out] Array containing the enumerated elements.

Find a DkmProcess element within this DkmTransportConnection. If no element with the given input key is present, FindLiveProcess will fail. If an object is found, it will always contain the 'Live' Part.

[In] Search key used to find the element. [Out,Optional] Result of the search.

GetLiveProcesses enumerates the DkmProcess elements of this DkmTransportConnectionobject. All objects contain the 'Live' Part.

[Out] Array containing the enumerated elements.

GetRequests enumerates the DkmProcessLaunchRequest elements of this DkmTransportConnection object.

[Out] Array containing the enumerated elements.

WorkList to append the new work item to. [In] Indicates if the specified application package is a Windows Phone or Windows Store app. [In] Identifier for the application to launch. [In] If true, the app is being debugged. Routine to fire when the request is complete. If the request is successfully appended to the work list, this will always fire (including when the operation is canceled). This will never fire if appending the work item fails.

Performs a simulated process lifetime management-based suspend on the specified application. This is used by developers to test their app's suspend handler. This method will append a new work item to the specified work list, and return once the work item has been appended. The actual processing of the work item is asynchronous. The caller will be notified that the request is complete through the completion routine.

WorkList to append the new work item to. [In] Identifies a Windows Store app package or Windows Phone app package. [In] The id of the session where the application is running. Routine to fire when the request is complete. If the request is successfully appended to the work list, this will always fire (including when the operation is canceled). This will never fire if appending the work item fails.

Performs a simulated process lifetime management-based resume on the specified application. This is used by developers to test their app's resume handler.

[In] Identifies a Windows Store app package or Windows Phone app package. [In] The id of the session where the application is running.

Suspend and then shut down the specified application using the process lifetime management services. Using this followed by a second app launch, developers can test their app's ability to restart from suspended state. This method will append a new work item to the specified work list, and return once the work item has been appended. The actual processing of the work item is asynchronous. The caller will be notified that the request is complete through the completion routine.

Obtain the full path to the isolated storage root directory for the specified application. This API is not yet implemented for Windows Store apps, but is reserved for future use.

[In] Identifies a Windows Store app package or Windows Phone app package. [Out,Optional] Full path to the directory on the target system. Null if the application has no isolated storage directory.

Get the execution state of the Windows Store app. The values in this field are specified in PACKAGE_EXECUTION_STATE.

[In] Identifies a Windows Store app package or Windows Phone app package. [In] The id of the session where the application is running. [Out] The execution state of the application.

Enumerates the existing background tasks. This is used by developers to test their app's enum handler. This method will append a new work item to the specified work list, and return once the work item has been appended. The actual processing of the work item is asynchronous. The caller will be notified that the request is complete through the completion routine.

Activate an background task. This is used by developers to test their app's activate handler. This method will append a new work item to the specified work list, and return once the work item has been appended. The actual processing of the work item is asynchronous. The caller will be notified that the request is complete through the completion routine.

WorkList to append the new work item to. [In] Identifies a Windows Store app package or Windows Phone app package. [In] The id of the session where the application is running. [In] Activating task id (GUID). Routine to fire when the request is complete. If the request is successfully appended to the work list, this will always fire (including when the operation is canceled). This will never fire if appending the work item fails.

Enumerates installed and launchable (App Packages with applications) App Packages. Location constraint: API must be called from an IDE component (component level > 100,000).

[Out] Array of App Packages found.

Deploy a file to the target computer. Note that this will copy the file content and last write time, but not attributes. Location constraint: API must be called from an IDE component (component level > 100,000).

[In] Path to the local file which will be copied. The path must be a full path. [In] Path to the remote file that will be written. Environment variables will be expanded (ex: %TMP%\deploy.txt). This must be a full path. If the directory of this file does not exist, the debugger will attempt to create it. [In] true if the debugger should attempt to overwrite any existing file. This will fail if the existing file is read-only.

Download a file from the target computer. Note that this will copy the file content and last write time, but not attributes. Location constraint: API must be called from an IDE component (component level > 100,000).

[In] Path to the remote file that will be written. Environment variables will be expanded (ex: %TMP%\deploy.txt). [In] Local path where the download file will be placed. The path must be a full path, and the directory must already exist. [In] true if the debugger should attempt to overwrite any existing file. This will fail if the existing file is read-only.

Download a file from the target computer. Note that this will copy the file content and last write time, but not attributes. This method will append a new work item to the specified work list, and return once the work item has been appended. The actual processing of the work item is asynchronous. The caller will be notified that the request is complete through the completion routine. Location constraint: API must be called from an IDE component (component level > 100,000).

WorkList to append the new work item to. [In] Path to the remote file that will be written. Environment variables will be expanded (ex: %TMP%\deploy.txt). [In] Local path where the download file will be placed. The path must be a full path, and the directory must already exist. [In] true if the debugger should attempt to overwrite any existing file. This will fail if the existing file is read-only. Routine to fire when the request is complete. If the request is successfully appended to the work list, this will always fire (including when the operation is canceled). This will never fire if appending the work item fails.

Delete a file on the target computer.

[In] Path to the remote file that will be deleted. Environment variables will be expanded (ex: %TMP%\deploy.txt).

Provides the physical DNS host name that the target computer uses.

[Out] Computer name. For more information, see ComputerNamePhysicalDnsHostname in the Win32 documentation for GetComputerNameEx.

Creates a directory on the target computer. Note that directories are implicitly created when deploying files. So this API does not need to be used in that scenario.

[In] Path to the remote directory that will be created. Environment variables will be expanded (ex: %TMP%\MyDirectory). The directory cannot be a relative path.

Removes a directory on the target computer.

[In] Path to the remote directory that will be removed. Environment variables will be expanded (ex: %TMP%\MyDirectory). The directory cannot be a relative path. [In] True if all files and subdirectories under 'RootDirectoryPath' should be removed. If false, this operation will fail unless the directory is empty.

Obtains a listing of files and subdirectories that exist on the target computer.

[In] Path to a remote directory under which the search will be preformed. Environment variables will be expanded (ex: %TMP%\MyDirectory). The directory cannot be a relative path. [In] Wildcard search string to use when matching files. For example, '*' to obtain all files and directories, or 'example.txt' to obtain information on just 'example.txt'. [In] True if all subdirectories under 'RootDirectoryPath' should be checked for files. This option excludes reparse points like mounted drives and symbolic links. [Out] File information for all found files and subdirectories.

Provides a listing of all the processes running on the target computer (including processes not being debugged).

[In] If true, processes from all users should be included. [In] Flags indicating which properties of DkmRunningProcessInfo should be computed. [Out] Array of processes running on the target computer.

Obtain information about a process running on the target computer.

[In] Process Id (PID) assigned by the operating system. [In] 64-bit date time value indicating when the process was started. The start time along with the id and the machine where the process was started can uniquely identify a process. '0' can be passed if the start time is unknown. [In] When true, the request will fail if the debugger has insufficient privileges to complete the request. If false, the implementation should calculate what it can. [In] Flags indicating which properties of DkmRunningProcessInfo should be computed. [Out] Information about the requested process.

Terminates a process running on target computer which is not being debugged.

[In] Process Id (PID) assigned by the operating system. [In] 64-bit date time value indicating when the process was started. The start time along with the id and the machine where the process was started can uniquely identify a process. '0' can be passed if the start time is unknown. [In] The exit code to be used by the process and threads terminated as a result of this call. Use the GetExitCodeProcess function to retrieve a process's exit value. Use the GetExitCodeThread function to retrieve a thread's exit value.

Provides information about the computer where the debug monitor is running.

[In] If true and if the debug monitor is running under WOW64, this function will return information about the native subsystem rather than WOW. If the debug monitor is not running under WOW, this function is ignored. [Out] Object describing the system where the debugger is running.

[In] Path to the executable file. [Out] Version string of the CLR. Ex:'v4.0.30319'.

Deprecated. Use QueryExecutableArchitecture. Determines if the given executable file will execute within WOW64 (Windows On Windows), which is used to execute 32-bit processes on a 64-bit OS.

[In] Path to the executable file. [Out] true if the specified executable file will execute under WOW.

Returns the version of the CLR which is loaded in the monitor process.

[Out] Version string of the CLR. Ex:'v4.0.30319'.

This function is used to force all object close notifications to be immediately exchanged with the monitor process. Like 'GC.Collect' in managed code, this function is normally unnecessary, as the system automatically flushes the queue. However, this method can be used if it is important that all updates are immediately exchanged. An object close notification is created (and queued) when a component calls 'Close' on a given object. Both the monitor process and the engine process maintain a queue of closed objects. This method may only be called from the engine process, but it is used to flush both queues. Location constraint: API must be called from an IDE component (component level > 100,000).

Triggers application content prefetch. This API was introduced in Visual Studio 12 Update 2 (DkmApiVersion.VS12Update2).

[In] Triggering application full name (package moniker). [In] Application platform. [Out] The result of trigger prefetch.

Removes an immersive app icon from the taskbar by closing it. This API was introduced in Visual Studio 12 Update 3 (DkmApiVersion.VS12Update3).

[In] The DkmAppPackageId of the app package to be closed. [In] The ID of the session that the app package is running in.

Activates a packaged application on the specified monitor. This will cause the application to start if it has not already started, and will bring it back as the active application if it is already running. This method will append a new work item to the specified work list, and return once the work item has been appended. The actual processing of the work item is asynchronous. The caller will be notified that the request is complete through the completion routine. This API was introduced in Visual Studio 12 Update 3 (DkmApiVersion.VS12Update3).

WorkList to append the new work item to. [In] Application platform id. [In] Identifier for the application to launch. [In] If true, the app is being debugged. [In] Target monitor index. Routine to fire when the request is complete. If the request is successfully appended to the work list, this will always fire (including when the operation is canceled). This will never fire if appending the work item fails.

WorkList to append the new work item to. [In] Identifier for the package to launch. [In] If true, the app is being debugged. Routine to fire when the request is complete. If the request is successfully appended to the work list, this will always fire (including when the operation is canceled). This will never fire if appending the work item fails.

WorkList to append the new work item to. [In] Indicates if the specified application package is a Windows Phone or Windows Store app. [In] Identifier for the application to launch. [In] If true, the app is being debugged. [In] Flags indicating options for AppPackage activation. Routine to fire when the request is complete. If the request is successfully appended to the work list, this will always fire (including when the operation is canceled). This will never fire if appending the work item fails.

Find a DkmProductionConnection element within this DkmTransportConnection. If no element with the given input key is present, FindProductionConnection will fail. This API was introduced in Visual Studio 15 Update 2 (DkmApiVersion.VS15Update2).

[In] Search key used to find the element. [Out,Optional] Result of the search.

GetProductionConnections enumerates the DkmProductionConnection elements of this DkmTransportConnection object. This API was introduced in Visual Studio 15 Update 2 (DkmApiVersion.VS15Update2).

[Out] Array containing the enumerated elements.

Gets the architecture of the executable. This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTMPreview).

[In] Path to the executable file. [Out] Example: PROCESSOR_ARCHITECTURE_INTEL (0), PROCESSOR_ARCHITECTURE_ARM (5), PROCESSOR_ARCHITECTURE_AMD64 (9), or PROCESSOR_ARCHITECTURE_ARM64 (12).

Find a DkmRecordedProcessInfo element within this DkmTransportConnection. If no element with the given input key is present, FindRecordedProcessInfo will fail. This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTM).

[In] Search key used to find the element. [Out,Optional] Result of the search.

GetRecordedProcesses enumerates the DkmRecordedProcessInfo elements of this DkmTransportConnection object. This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTM).

[Out] Array containing the enumerated elements.

Obtain information about a recorded file. This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTM).

[In] The path to the recorded file. [Out] Information about the recorded process.

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Obtains the DkmTransportConnection object which backs this port object. This will fail in remote debugging scenarios if the port is not currently connected, and reconnect was unsuccessful. This API will only function correctly from the main thread of Visual Studio.

AD7 default port object DkmTransportConnection which backs the AD7 object.

Obtains the DkmTransportConnection object which backs the deploy connection. This can be used to bridge from the debugger deploy API, to the debugger engine (Dkm) APIs. As an example, this can be used to send DkmCustomMessages. The caller must still hold onto deployConnection to avoid the underlying DkmTransportConnection from being disposed. Note that, by default, concord components will be unloaded during stop debugging. This behavior can be overwritten by setting 'StayLoadedForDeployConnection="true"' in the component's .vsdconfigxml file. This is useful if the caller wants to extract the deploy connection in order to send custom messages and wants to do so after the debugger session ended.

AD7 default port object DkmTransportConnection which backs the AD7 object.

Flags indicating traits of the underlying connection.

Connection is to the local computer. This is used for both the 'pseudo-remote' connection and the local connection.

Requests that cross from the higher level debugger components (ex: AD7 AL, symbol handler, etc) to the low-level debugger components (ex: debug monitor) require marshalling.

This connection is considered the default way to connect to the destination computer. This flag will be used for the local connection, and for connections running on the default port of remote computers.

Indicates the type of transport being used to debug.

Local is used when the monitor and engine are in the same process. This is used to debug local 32-bit processes.

PseudoRemote is used when the monitor and engine are in separate processes on the same machine. This is used for debugging 64-bit processes.

StandardRemote is used for remote debugging over the standard remoting infrastructure.

This represents a transport connection used for symbol processing, or other memory intensive activities. This worker process may be remote or local. This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTMPreview).

Guid which uniquely identifies this connection. This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTMPreview).

[Optional] String indicating the connection destination. This value should be null for a local worker process (worker process on the same computer as Visual Studio). Currently this value will always be null as remote worker processes aren't supported. This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTMPreview).

Flags indicating traits of the underlying connection. This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTMPreview).

The version of the protocol used between Visual Studio and the worker process. This is the minimum of the protocol version that Visual Studio understands, and the protocol version that the worker process understands. This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTMPreview).

Find a DkmWorkerProcessConnection object. If no object with the given input key is present, FindWorkerProcessConnection will fail. This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTMPreview).

[In] Search key used to find the element. [Out,Optional] Result of the search.

GetWorkerProcessConnections enumerates all the created DkmWorkerProcessConnection objects. This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTMPreview).

[Out] Array containing the enumerated elements.

Closes a DkmWorkerProcessConnection object instance. This will release any resources associated with this object across all components. This includes resources across computer or managed/native marshalling boundaries. This method may only be called by the component which created the object. This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTMPreview).

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Opens a new connection to a worker process and returns the DkmWorkerProcessConnection object that represents this connection. This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTM).

[In,Optional] String that indicates the connection destination. This should be null for a local worker process, and currently only local worker processes are allowed. The created DkmWorkerProcessConnection object

When running in a worker process, this returns the DkmWorkerProcessConnection that represents the connection to the current worker process. Otherwise this returns null.

[Optional] The current connection object if this is one. Otherwise null.

This obtains the worker process connection for the local symbols worker process. If the locals symbols worker process is not already started, this API will start it and connect. This API may only be called from within the IDE.

The connection object for the local connection.

Represents current location on the stack. This API was introduced in Visual Studio 15 Update 5 (DkmApiVersion.VS15Update5).

Incrementing id to identify the statement (0, 1, 2, ..). This API was introduced in Visual Studio 15 Update 5 (DkmApiVersion.VS15Update5).

Thread that this statement belongs to. This API was introduced in Visual Studio 15 Update 5 (DkmApiVersion.VS15Update5).

Provides method token, version info. This API was introduced in Visual Studio 15 Update 5 (DkmApiVersion.VS15Update5).

Specifies address of the statement. This API was introduced in Visual Studio 15 Update 5 (DkmApiVersion.VS15Update5).

Method version. This API was introduced in Visual Studio 15 Update 5 (DkmApiVersion.VS15Update5).

Specifies location/additional information of this active statement. This API was introduced in Visual Studio 15 Update 5 (DkmApiVersion.VS15Update5).

Create a new DkmActiveStatement object instance. This API was introduced in Visual Studio 15 Update 5 (DkmApiVersion.VS15Update5).

[In] Incrementing id to identify the statement (0, 1, 2, ..). [In] Thread that this statement belongs to. [In] Provides method token, version info. [In] Specifies address of the statement. [In] Method version. [In] Specifies location/additional information of this active statement. [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Specifies active statement location. This API was introduced in Visual Studio 15 Update 5 (DkmApiVersion.VS15Update5).

No location specified.

Active statement is in a leaf frame.

Active statement is partially executed.

Active statement IL is not in user code.

The method is up to date.

Active statement affected by a managed update. Important when remapping the instruction pointer to the appropriate location. This API was introduced in Visual Studio 16 Update 3 (DkmApiVersion.VS16Update3).

Thread ID of the target active statement. This API was introduced in Visual Studio 16 Update 3 (DkmApiVersion.VS16Update3).

Method ID. It has the method token for the active statement, and the method version when the change was made. This API was introduced in Visual Studio 16 Update 3 (DkmApiVersion.VS16Update3).

Old IL offset for the active statement. This API was introduced in Visual Studio 16 Update 3 (DkmApiVersion.VS16Update3).

New text span for the active statement, must be 1-based. This API was introduced in Visual Studio 16 Update 3 (DkmApiVersion.VS16Update3).

Create a new DkmActiveStatementUpdate object instance. Location constraint: API must be called from an IDE component (component level > 100,000). This API was introduced in Visual Studio 16 Update 3 (DkmApiVersion.VS16Update3).

[In] Thread ID of the target active statement. [In] Method ID. It has the method token for the active statement, and the method version when the change was made. [In] Old IL offset for the active statement. [In] New text span for the active statement, must be 1-based. [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Describes an alias that is understood by CLR expression evaluators. An alias is a symbol that can be used to refer to a value known by the debugger. Examples of these values are the current exception and values returned by the last method call. The Expression Compiler can use this method to determine which aliases are valid for use in expressions and their types. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

The kind of alias this is. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

The name of this alias. This is the value displayed in the "Name" column of the variable inspection windows. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

The full name of this alias. This is the expression to evaluate if this alias is added to the Watch window. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

The assembly qualified name of the runtime type of this alias. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

If this is a variable with custom type information, this is the identifier that is used to identify the compiler that generated the custom type information. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

The custom type information payload used by the compiler to embed custom type information. The compiler should verify that the id stored in CustomTypeInfoPayloadTypeId matches the expected id before using this value. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

Create a new DkmClrAlias object instance. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

[In] The kind of alias this is. [In] The name of this alias. This is the value displayed in the "Name" column of the variable inspection windows. [In] The full name of this alias. This is the expression to evaluate if this alias is added to the Watch window. [In] The assembly qualified name of the runtime type of this alias. [In] If this is a variable with custom type information, this is the identifier that is used to identify the compiler that generated the custom type information. [In] The custom type information payload used by the compiler to embed custom type information. The compiler should verify that the id stored in CustomTypeInfoPayloadTypeId matches the expected id before using this value. [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Enum that defines the kinds of aliases returned by DkmClrRuntimeInstance.GetAliases. The methods referred to below are defined in the virtual module Microsoft.VisualStudio.Debugger.Clr.IntrinsicMethods. The metadata for this module is available by calling DkmClrRuntimeInstance.GetIntrinsicAssemblyMetaDataBytesPtr. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

The alias is the exception on the given thread. To get this value, the Expression Compiler should emit a call to GetException.

The alias is a stowed exception To get this value, the Expression Compiler should emit a call to GetStowedException.

The alias is a return value To get this value, the Expression Compiler should emit a call to GetReturnValue.

The alias is a variable defined by the user using the Expression Evaluator To get this value, the Expression Compiler should emit a call to GetObjectByAlias. The value can be set by getting its address via GetVariableAddress then storing the new value at that address.

The alias is a heap value being tracked due to a call to CreateObjectId To get this value, the Expression Compiler should emit a call to GetObjectByAlias.

DkmClrAppDomain represents a CLR app domain inside a process which is being debugged.

Guid which uniquely identifies this app domain object.

Id of the underlying CLR app domain. While running, this uniquely identifies the app domain within a particular DkmRuntimeInstance.

Represents a CLR instance running in a target process.

AppDomain Name.

Closes a DkmClrAppDomain object instance. This will release any resources associated with this object across all components. This includes resources across computer or managed/native marshalling boundaries. DkmClrAppDomain objects are automatically closed when their associated DkmClrRuntimeInstance object is closed. This method may only be called by the component which created the object.

This method is called by the managed debug monitor to create a DkmClrAppDomain object. It is called on the event thread in response to the target process creating an AppDomain. The caller is responsible for closing the created object after they are done.

[In] Id of the underlying CLR app domain. While running, this uniquely identifies the app domain within a particular DkmRuntimeInstance. [In] Represents a CLR instance running in a target process. [In] AppDomain Name. [In,Optional] Data object to add to the new DkmClrAppDomain instance. Pass 'null' in the case that the caller doesn't need to add a data item. [Out] Result of this method call.

Find a DkmClrModuleInstance element within this DkmClrAppDomain. If no element with the given input key is present, FindClrModuleInstance will fail.

[In] Search key used to find the element. [Out,Optional] Result of the search.

Find all DkmClrModuleInstance[] elements within this DkmClrAppDomain. If no element with the given input key is present, FindAllClrModuleInstances will fail.

[In] Search key used to find the element. [Out,Optional] Result of the search.

GetClrModuleInstances enumerates the DkmClrModuleInstance elements of this DkmClrAppDomain object.

[Out] Array containing the enumerated elements.

[Out] ICorDebug interface representing an app domain inspection.

Get the managed runtime module instance.(mscorlib.dll). Location constraint: API must be called from a Monitor component (component level < 100,000). This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

[Out] The CLR runtime module instance found.

[In] The fully qualified name of the assembly to load. [Out] The size of the metadata buffer. [Out] A pointer to the metadata buffer. CORDB_E_MISSING_METADATA indicates that the assembly was not found or could not be loaded.

Used internally to support DkmClrAppDomain.GetMetaDataBytesPtr. For performance reasons, use GetMetaDataBytesPtr instead of this method. Location constraint: API must be called from an IDE component (component level > 100,000). This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

[In] The fully qualified name of the assembly to load. [Out] The MVID of the module that was loaded. [Out] The metadata blob. CORDB_E_MISSING_METADATA indicates that the assembly was not found or could not be loaded.

Resolve an assembly by name and return the MVID of its manifest module. Location constraint: API must be called from an IDE component (component level > 100,000). This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

[In] The fully qualified name of the assembly to resolve. [Out] The MVID of the resolved assembly's manifest module. COR_E_FILENOTFOUND/System.IO.FileNotFoundException indicates that the assembly was not found or could not be loaded.

Evaluates a property on the given ICorDebugValue. The value's type must be loaded by the DkmClrAppDomain that this $Name$ is being called on. Location constraint: This must be on the remote side because we are passing an ICorDebugHandleValue. This API was introduced in Visual Studio 15 RTM (DkmApiVersion.VS15RTM).

Raise a AppDomainCreated event. Components which implement the event sink interface will receive the event notification. Control will return once all components have been notified. This method may only be called by the component which created the object. Location constraint: API must be called from a Monitor component (component level < 100,000). This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTM).

Mark the Unload object as unloaded and notify components which implement the event sink interface. Control will return once all components have been notified. This method may only be called by the component which created the object. Location constraint: API must be called from a Monitor component (component level < 100,000). This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTM).

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

In an async method. all the possible locations the debugger could have stopped.

Not an async method.

First statement of an async method. We step out synchronously here.

In an async method but not at an await expression.

In an await statement and before an yield point.

At an yield point.

Last statement of the method - step into or step over should turn into step out.

Contains the offsets for an await expression.

The offset at which the expression yields.

The offset at which the expression resumes.

The method in which the expression resumes.

Initialize a new DkmClrAwaitExpressionInfo value.

[In] The offset at which the expression yields. [In] The offset at which the expression resumes. [In] The method in which the expression resumes.

Options for the GetClrCastExpression method. This API was introduced in Visual Studio 15 RTM (DkmApiVersion.VS15RTM).

None of the options are needed.

Used if an ISINST.

Argument requires parentheses to avoid parse error.

Resulting cast expression requires parentheses to avoid parse error.

Provides information about an exception which was caught in the target process. This information includes details of the exception that was caught. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

DkmThread represents a thread running in the target process. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

Start Address the current frame. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

End Address the current frame. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

The Instruction address for this caught exception. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

The IL offset of the catch handler which is about to catch this exception. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

Name of the Exception. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

Create a new DkmClrCaughtExceptionInformation object instance. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

[In] DkmThread represents a thread running in the target process. [In] Start Address the current frame. [In] End Address the current frame. [In] The Instruction address for this caught exception. [In] The IL offset of the catch handler which is about to catch this exception. [In] Name of the Exception. [Out] Result of this method call.

Raise a ClrDebugMonitorExceptionCaught event. Components which implement the event sink interface will receive the event notification. Control will return once all components have been notified. Location constraint: API must be called from a Monitor component (component level < 100,000). This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

DkmClrCodePath represents a code path in IL. This API was introduced in Visual Studio 15 RTM (DkmApiVersion.VS15RTM).

[Optional] The language-specific name of the code path, if any. This API was introduced in Visual Studio 15 RTM (DkmApiVersion.VS15RTM).

[Optional] The name of the code path in metadata, if the language-specific name is not available. This API was introduced in Visual Studio 15 RTM (DkmApiVersion.VS15RTM).

[Optional] The return type (if any) of the code path. This API was introduced in Visual Studio 15 RTM (DkmApiVersion.VS15RTM).

The kind of code path. This API was introduced in Visual Studio 15 RTM (DkmApiVersion.VS15RTM).

[Optional] Additional data about the code path. Meaning is implementation specific. This API was introduced in Visual Studio 15 RTM (DkmApiVersion.VS15RTM).

Create a new DkmClrCodePath object instance. This API was introduced in Visual Studio 15 RTM (DkmApiVersion.VS15RTM).

[In,Optional] The language-specific name of the code path, if any. [In,Optional] The name of the code path in metadata, if the language-specific name is not available. [In,Optional] The return type (if any) of the code path. [In] The kind of code path. [In,Optional] Additional data about the code path. Meaning is implementation specific. [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

DkmClrCodePathKind describes the kind of code path (Managed only). This API was introduced in Visual Studio 15 RTM (DkmApiVersion.VS15RTM).

A method call.

A type constructor.

A property getter or setter.

A cast (for example, 'as' keyword in C#).

Indicates which version of the CLR debugging services (mscordbi.dll or other implementation of the ICorDebug API) should be used when debugging this process.

Debug an application using .NET Framework version 4 or later out-of-process CLR execution pipeline.

Debug an application running under .NET Framework version 4 or later. Note that this value can use either the in-process (helper-thread based) or out-of-process implementation of ICorDebug.

Debug an application running under .NET Framework version 2.0 or earlier.

Debug an application running using Silverlight on a Windows operating system.

Debug an application running on using Silverlight on a Mac operating system.

Debug an application running under the .NET Framework on a Windows CE device.

Debug an application running under the CoreCLR on a Windows Phone device.

Provides information about a CLR exception which was raised in the target process.

Type name of the exception. Example: 'System.NullReferenceException'.

[Optional] Address where the exception occurred. This will be null if the CLR exception occurred inside the runtime when no managed code was on the stack.

Create a new DkmClrExceptionInformation object instance.

[In] The DkmRuntimeInstance class represents an execution environment which is loaded into a DkmProcess and which contains code to be debugged. [In] DkmThread represents a thread running in the target process. [In] The debugger receives notifications from the target process at various stages within exception processing (ex: exception thrown, exception unhandled). This enumeration indicates the stage(s) for a notification. [In] Type name of the exception. Example: 'System.NullReferenceException'. [In,Optional] Address where the exception occurred. This will be null if the CLR exception occurred inside the runtime when no managed code was on the stack. [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Contains information from the 'Flags' field of the IMAGE_COR20_HEADER of the loaded module. This indicates which type of binary was loaded.

The binary contains no CLR code. This value is used for binaries without a IMAGE_COR20_HEADER.

The binary contains both managed and native code. This value is used for binaries with a IMAGE_COR20_HEADER and without the COMIMAGE_FLAGS_ILONLY flag.

The binary contains only managed code. This value is used for binaries with a IMAGE_COR20_HEADER and with the COMIMAGE_FLAGS_ILONLY flag.

The binary contains only pre-JITed managed code. This value is used for binaries with a IMAGE_COR20_HEADER and with the COMIMAGE_FLAGS_IL_LIBRARY flag.

DkmClrInstructionAddress is used for addresses in managed code. Derived classes: DkmClrNcInstructionAddress

Represents a CLR instance running in a target process.

The module containing the InstructionPointer.

The version/token pair for this method.

For the standard .NET Framework, NativeOffset is a byte offset relative to start of the method where the CPU instruction can be found. For the purpose of this value, the method should be treated as a contiguous block of bytes. If the method has not been Just-in-time compiled or if this address is being used to refer purely to the IL address, NativeOffset will be set to UInt32.MaxValue. For native-compiled .NET Framework modules, this value is the RVA of the native instruction in the module.

ILOffset is the index of the IL instruction that this address represents. This value may be set to UInt32.MaxValue for an instruction that is within the given method, but not tied to a particular IL instruction. This is used for CLR native instructions that don't map to an IL instruction. (ICorDebugILFrame::GetIP indicates MAPPING_UNMAPPED_ADDRESS).

Create a new DkmClrInstructionAddress object instance.

[In] Represents a CLR instance running in a target process. [In] The module containing the InstructionPointer. [In] The version/token pair for this method. [In] For the standard .NET Framework, NativeOffset is a byte offset relative to start of the method where the CPU instruction can be found. For the purpose of this value, the method should be treated as a contiguous block of bytes. If the method has not been Just-in-time compiled or if this address is being used to refer purely to the IL address, NativeOffset will be set to UInt32.MaxValue. For native-compiled .NET Framework modules, this value is the RVA of the native instruction in the module. [In] ILOffset is the index of the IL instruction that this address represents. This value may be set to UInt32.MaxValue for an instruction that is within the given method, but not tied to a particular IL instruction. This is used for CLR native instructions that don't map to an IL instruction. (ICorDebugILFrame::GetIP indicates MAPPING_UNMAPPED_ADDRESS). [In,Optional] CPUInstruction provides the address that the CPU will execute. This is always provided for native instructions. It may be provided for CLR or custom addresses depending on how the address object was created. [Out] Result of this method call.

Obtains non user code status for this instruction address.

[Out] The non user code status for this instruction address.

Provides the map of how this method was compiled to native code.

[In,Optional] Stack frame where this address is from. This is necessary for CLR v2 support. This argument will be ignored for CLR v4. [Out] Structure to define the IL instruction mapping for one or more native instructions.

[Out] ICorDebug interface representing an app domain inspection.

Helper method implemented by the managed DM and used by the shim EE to determine if a method is user code while we're walking async return stacks. We won't want to use the regular IsUserCode() method because that method makes a round trip to the symbol provider to see if there's line info. To avoid this, we use this method to have the managed DM do its other checks. Then, when the shim EE returns to the symbol provider, the symbol provider will then check for line info. Doing it this way allows the entire managed return stack to be calculated in one round trip to the remote side, without the need for extra chatting back and forth just to determine if return stack frames are user code or not. Location constraint: API must be called from a Monitor component (component level < 100,000). This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

[Out] True if the provided instruction address is user code.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

DkmClrInstructionSymbol represents an IL instruction that runs under the Common Language Runtime (CLR) in the target process. This object contains the method version number. So in Edit-and-Continue scenarios, the instruction symbol would be different for different versions of the method. This object does not contain information about generic binding parameters. So different generic instantiations of a method (ex: MyMethod<string> and MyMethod<int>) are represented by the same instruction symbol since the CLR represents them with a single method token. Derived classes: DkmClrNcInstructionSymbol

The version/token pair for this method.

ILOffset is the index of the IL instruction that this symbol represents. This value may be set to UInt32.MaxValue for an instruction that is within the given method, but not tied to a particular instruction. This is used for CLR native instructions that don't map to an IL instruction.

Create a new DkmClrInstructionSymbol object instance.

Gets the location of the instruction symbol in it's method.

[Out] The location of the given instruction.

Gets the location of the instruction symbol in it's method. This method will append a new work item to the specified work list, and return once the work item has been appended. The actual processing of the work item is asynchronous. The caller will be notified that the request is complete through the completion routine.

Gets the yield and resume points contained within the statement surrounding the given instruction symbol.

[Out] An array of the yield and resume points for the statement.

Gets the yield and resume points contained within the statement surrounding the given instruction symbol. This method will append a new work item to the specified work list, and return once the work item has been appended. The actual processing of the work item is asynchronous. The caller will be notified that the request is complete through the completion routine.

Gets the optional starting IL offset of an async method's generated catch handler.

[Out] The catch handler's starting IL offset. [Out] True if async method has a catch handler IL offset in the PDB.

Get the yield and resume information of the next await expression.

[Out] Next await expression info.

Get the yield and resume information of the next await expression. This method will append a new work item to the specified work list, and return once the work item has been appended. The actual processing of the work item is asynchronous. The caller will be notified that the request is complete through the completion routine.

If the current method is an async method then return the kickoff method for this async method.

[Out] Kickoff method token.

If the current method is an async method then return the kickoff method for this async method. This method will append a new work item to the specified work list, and return once the work item has been appended. The actual processing of the work item is asynchronous. The caller will be notified that the request is complete through the completion routine.

Returns the scopes within a method. There will always be at least one scope. Location constraint: This API will fail when called from an IDE component to query information for server-side compiled ASP.NET code, or dynamically compiled code. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

[Out] DkmClrMethodScopeData[] describes a scope within a method. These are defined using ISymUnmanagedWriter::OpenScope/CloseScope.

Returns the scopes within a method. There will always be at least one scope. This method will append a new work item to the specified work list, and return once the work item has been appended. The actual processing of the work item is asynchronous. The caller will be notified that the request is complete through the completion routine. Location constraint: This API will fail when called from an IDE component to query information for server-side compiled ASP.NET code, or dynamically compiled code. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

Gets a custom attribute based upon its name. Not to be confused with Metadata custom attributes, these attributes are held in the symbol store. Location constraint: This API will fail when called from an IDE component to query information for server-side compiled ASP.NET code, or dynamically compiled code. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

[In] The name of the attribute to find. [Out] The value of the requested symbol store attribute. This will be an empty array if the specified attribute name cannot be found.

Gets a custom attribute based upon its name. Not to be confused with Metadata custom attributes, these attributes are held in the symbol store. This method will append a new work item to the specified work list, and return once the work item has been appended. The actual processing of the work item is asynchronous. The caller will be notified that the request is complete through the completion routine. Location constraint: This API will fail when called from an IDE component to query information for server-side compiled ASP.NET code, or dynamically compiled code. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

WorkList to append the new work item to. [In] The name of the attribute to find. Routine to fire when the request is complete. If the request is successfully appended to the work list, this will always fire (including when the operation is canceled). This will never fire if appending the work item fails.

Returns symbol information concerning the innermost active scope of the location indicated by the given instruction symbol, which is assumed to have been compiled with managed C++. Location constraint: API must be called from an IDE component (component level > 100,000). This API was introduced in Visual Studio 14 Update 1 (DkmApiVersion.VS14Update1).

[In] Inspection session to use for the creation of native C++ types, if needed. [Out] The innermost active scope of the given instruction symbol.

Obtains the parameters to the managed C++ function represented by the given function symbol. Location constraint: API must be called from an IDE component (component level > 100,000). This API was introduced in Visual Studio 14 Update 1 (DkmApiVersion.VS14Update1).

[In] The process we are currently debugging. [Out] The parameters to the given function.

Gets the sequence points for a CLR method from the symbol file. Location constraint: This API will fail when called from an IDE component to query information for server-side compiled ASP.NET code, or dynamically compiled code. This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTMPreview).

[Out] The result sequence points. This will be null if there are no sequence point for the method.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Represents a local constant defined within a method scope. These are defined with ISymUnmanagedWriter::DefineConstant or ISymUnmanagedWriter2::DefineConstant2.

Module where this local constant is defined.

Name of the constant.

[Optional] Value assigned to this constant. No value implies VT_EMPTY.

[Optional] Additional data used by the symbol provider to identify the constant. Meaning is implementation specific.

Create a new DkmClrLocalConstant object instance.

[In] Module where this local constant is defined. [In] Name of the constant. [In,Optional] Value assigned to this constant. No value implies VT_EMPTY. [In,Optional] Additional data used by the symbol provider to identify the constant. Meaning is implementation specific. [Out] Result of this method call.

Provides the COR_SIGNATURE for a local constant. Location constraint: This API will fail when called from an IDE component to query information for server-side compiled ASP.NET code, or dynamically compiled code.

[Out] The COR_SIGNATURE for the constant, which defines the type of this constant.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Represents a local variable defined within a method scope. These are defined with ISymUnmanagedWriter::DefineLocalVariable or ISymUnmanagedWriter2::DefineLocalVariable2.

Module where this local variable is defined.

Name of the local variable.

Variable attributes defined in CorSymVarFlag. Currently, the only defined bit is VAR_IS_COMP_GEN (0x1).

The local slot used by the IL in stloc/ldloc instructions.

[Optional] Additional data used by the symbol provider to identify the local variable. Meaning is implementation specific.

Create a new DkmClrLocalVariable object instance.

[In] Module where this local variable is defined. [In] Name of the local variable. [In] Variable attributes defined in CorSymVarFlag. Currently, the only defined bit is VAR_IS_COMP_GEN (0x1). [In] The local slot used by the IL in stloc/ldloc instructions. [In,Optional] Additional data used by the symbol provider to identify the local variable. Meaning is implementation specific. [Out] Result of this method call.

Provides the COR_SIGNATURE for a local Variable. Location constraint: This API will fail when called from an IDE component to query information for server-side compiled ASP.NET code, or dynamically compiled code.

[Out] The COR_SIGNATURE for the Variable, which defines the type of this Variable.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

DkmClrMethodId is a token/version pair which is used to uniquely identify the symbol store's understanding of a particular CLR method within a module.

Compare two elements of the DkmClrMethodId structure.

Value to comare against this instance. 'true' if the two elements are equal.

Compare two elements of the DkmClrMethodId sructure.

Left side of the comparison Right side of the comparison

Compare two elements of the DkmClrMethodId sructure.

Left side of the comparison Right side of the comparison

Compare two elements of the DkmClrMethodId sructure.

Left side of the comparison Right side of the comparison

Compare two elements of the DkmClrMethodId sructure.

Left side of the comparison Right side of the comparison

Compare two elements of the DkmClrMethodId sructure.

Left side of the comparison Right side of the comparison

Compare two elements of the DkmClrMethodId sructure.

Left side of the comparison Right side of the comparison

The method definition metadata token of the method that contains this symbol.

Version is a 1-based index. This will be '1' for methods that have not been edited through Edit-and-continue. For edited methods, the version indicates the ENC apply of this method. Thus if the user does 5 ENC applies and a particular method is only edited in the 5th apply, then there are two method ids for this method, and they have Version=1 and Version=5. The debugger needs to deal with old versions of the method because they will continue to be on the call stack until control is unwound. The debugger can also hit breakpoints or stop for exceptions within exception handling regions of old methods. In other words, if the user sets a breakpoint within the catch block of a non-leaf method, the debugger needs to set that breakpoint within the old version of the method. In scenarios such as function breakpoint binding, the value '0' may used to indicate the current version of the method.

Initialize a new DkmClrMethodId value.

[In] The method definition metadata token of the method that contains this symbol. [In] Version is a 1-based index. This will be '1' for methods that have not been edited through Edit-and-continue. For edited methods, the version indicates the ENC apply of this method. Thus if the user does 5 ENC applies and a particular method is only edited in the 5th apply, then there are two method ids for this method, and they have Version=1 and Version=5. The debugger needs to deal with old versions of the method because they will continue to be on the call stack until control is unwound. The debugger can also hit breakpoints or stop for exceptions within exception handling regions of old methods. In other words, if the user sets a breakpoint within the catch block of a non-leaf method, the debugger needs to set that breakpoint within the old version of the method. In scenarios such as function breakpoint binding, the value '0' may used to indicate the current version of the method.

DkmClrMethodScopeData describes a scope within a method. These are defined using ISymUnmanagedWriter::OpenScope/CloseScope.

The IL range of this scope.

The index of the parent scope in the array of scopes for the method.

Local variables defined in the PDB.

Local constants defined in the PDB.

Namespaces that are being 'used' within this scope.

Initialize a new DkmClrMethodScopeData value.

[In] The IL range of this scope. [In] The index of the parent scope in the array of scopes for the method. [In] Local variables defined in the PDB. [In] Local constants defined in the PDB. [In] Namespaces that are being 'used' within this scope.

Marshal a native struct to managed

Pointer to native struct. Managed object.

Obtain a pointer to the native object used to call into native.

Outgoing managed->native call Native object

Validate the fields of this structure

Struct that holds the field path (ex: "myArgument.StructField")

Flags which indicates traits of a DkmModuleInstance which has been loaded by the CLR.

No CLR module flags are set.

Module is a dynamic module (types can be added to the module as it runs).

Set if the module is the core module for the managed runtime (mscorlib.dll).

Corresponds to the value returned by ICorDebugAssembly2::IsFullyTrusted. If the CLR the process is running on does not implement ICorDebugAssembly2 or ICorDebugAssembly2::IsFullyTrusted fails, this flag will not be set.

'DkmClrModuleInstance' is used for modules which are loaded into the Common Language Runtime. Derived classes: DkmClrNcModuleInstance

Represents a CLR instance running in a target process.

Flags which indicates traits of a DkmModuleInstance which has been loaded by the CLR.

DkmClrAppDomain represents a CLR app domain inside a process which is being debugged.

Specifies the size of the IL image of this module. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

Create a new DkmClrModuleInstance object instance. This method will send a ModuleInstanceLoad event. Location constraint: API must be called from a Monitor component (component level < 100,000).

[In] Short representation of the module name. For file-based modules, this is the file name and extension (ex: kernel32.dll). [In] Fully qualified module name. For file-based modules, this is the full path to the module (ex: c:\windows\system32\kernel32.dll. [In] Date/Time of when the loaded module was built. This value is obtained from the IMAGE_NT_HEADERS of the loaded module. The unit of measurement is a FILETIME value, which is a 64-bit value representing the number of 100-nanosecond intervals since January 1, 1601 (UTC). [In,Optional] File version information. [In,Optional] Contains information needed to locate symbols for this module. On Win32, this information is contained within the IMAGE_DEBUG_DIRECTORY. [In] Flags which indicate traits of a DkmModuleInstance. [In] Enumeration that indicates how a module is laid out in memory. [In,Optional] The starting memory address of where the module loaded. This value will be zero if the module did not load in a contiguous block of memory. [In] The integer count of the number of module instances that have loaded up to and including this module. Each runtime instance keeps track of its own load order count. [In,Optional] The number of bytes in the module's memory region. This value will be zero if the module did not load in a contiguous block of memory. [In] String description of the context under which this module has been loaded. ex: 'Win32' or 'CLR v2.0.50727: Default Domain'. [In] Represents a CLR instance running in a target process. [In] Module Version Identifier from the loaded module. This is a unique value which is embedded in an exe/dll by linkers/compilers when the dll/exe is built. A new value is generated each time that the dll/exe is compiled. [In] Flags which indicates traits of a DkmModuleInstance which has been loaded by the CLR. [In] DkmClrAppDomain represents a CLR app domain inside a process which is being debugged. [In] Indicates if this module instance has been disabled. Disabled modules are largely ignored by the debugger. For native modules, the address range of the disabled module is treated as if it is unmapped. For CLR modules, any frames from these modules is hidden from the call stack. [In,Optional] The symbol handler's representation of a module (DkmModule) which is associated with this module instance. This value is initially null, and is assigned if and when symbols are associated with this module instance. [In,Optional] 'MinidumpInfo' is used to convey additional information about modules in a DkmProcess for a minidump. [In,Optional] Data object to add to the new DkmClrModuleInstance instance. Pass 'null' in the case that the caller doesn't need to add a data item. [Out] Result of this method call.

Create a new DkmClrModuleInstance object instance. This method will send a ModuleInstanceLoad event. Location constraint: API must be called from a Monitor component (component level < 100,000). This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

[In] Short representation of the module name. For file-based modules, this is the file name and extension (ex: kernel32.dll). [In] Fully qualified module name. For file-based modules, this is the full path to the module (ex: c:\windows\system32\kernel32.dll. [In] Date/Time of when the loaded module was built. This value is obtained from the IMAGE_NT_HEADERS of the loaded module. The unit of measurement is a FILETIME value, which is a 64-bit value representing the number of 100-nanosecond intervals since January 1, 1601 (UTC). [In,Optional] File version information. [In,Optional] Contains information needed to locate symbols for this module. On Win32, this information is contained within the IMAGE_DEBUG_DIRECTORY. [In] Flags which indicate traits of a DkmModuleInstance. [In] Enumeration that indicates how a module is laid out in memory. [In,Optional] The starting memory address of where the module loaded. This value will be zero if the module did not load in a contiguous block of memory. [In] The integer count of the number of module instances that have loaded up to and including this module. Each runtime instance keeps track of its own load order count. [In,Optional] The number of bytes in the module's memory region. This value will be zero if the module did not load in a contiguous block of memory. [In] String description of the context under which this module has been loaded. ex: 'Win32' or 'CLR v2.0.50727: Default Domain'. [In] Represents a CLR instance running in a target process. [In] Module Version Identifier from the loaded module. This is a unique value which is embedded in an exe/dll by linkers/compilers when the dll/exe is built. A new value is generated each time that the dll/exe is compiled. [In] Flags which indicates traits of a DkmModuleInstance which has been loaded by the CLR. [In] DkmClrAppDomain represents a CLR app domain inside a process which is being debugged. [In] Specifies the size of the IL image of this module. [In] Indicates if this module instance has been disabled. Disabled modules are largely ignored by the debugger. For native modules, the address range of the disabled module is treated as if it is unmapped. For CLR modules, any frames from these modules is hidden from the call stack. [In,Optional] The symbol handler's representation of a module (DkmModule) which is associated with this module instance. This value is initially null, and is assigned if and when symbols are associated with this module instance. [In,Optional] 'MinidumpInfo' is used to convey additional information about modules in a DkmProcess for a minidump. [In,Optional] Data object to add to the new DkmClrModuleInstance instance. Pass 'null' in the case that the caller doesn't need to add a data item. [Out] Result of this method call.

[Out] The IMetaDataImport interface for this managed module instance. When consuming this API from managed code, the RCW which wraps the native implementation will have its reference count increased by 1 by this API. The caller should use Marshal.IsComObject + Marshal.ReleaseComObject to release this reference.

Obtains the bytes of the CLR metadata from a given module. These bytes can then be passed to IMetaDataDispenser::OpenScope to decode the metadata.

[Out] The raw metadata for this module.

[Out] ICorDebug interface representing an app domain inspection.

Resolves a type name into a type. If the type is generic, the generic parameters will not be instantiated. Location constraint: API must be called from a Monitor component (component level < 100,000). This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

[In] The name of the type. [In,Optional] If the type is generic, specifies the generic parameters for the type. [Out] A DkmClrType describing the type.

[In] The method to be interpreted. This function does not support interpreting certain types of methods, including, but not limited to: - Methods that consume ref or out parameters - Methods whose implementation calls into native code via P/Invoke, COM interop, or some other means. [In,Optional] If the method belongs to a generic class, specifies the instantiations of the type's generic parameters. [In,Optional] If the method is generic, specifies the instantiations of the method's generic parameters. [In,Optional] If the method to be interpreted is non-static, specifies the non-null object instance that the method should be called on. If the method to be interpreted is a class constructor, this can be either null or non-null. A null this parameter on a class constructor will cause us to virtually create a new object and interpret the constructor. A non-null this parameter to a constructor will cause us to interpret the call to the constructor on the existing object. [In,Optional] Parameters to be passed into the function, excluding the 'this' parameter. This may be null if the function to be interpreted takes no parameters. If the function takes parameters, the length of this array must be equal to the number of parameters specified in the method signature. [In] The maximum number of total IL instructions that we are allowed to interpret. The IL interpretation will be aborted with an error code of E_ABORT if the actual number of instructions exceeds this limit. This limit prevents Visual Studio from hanging if the code being interpreted enters an infinite loop. [In] Additional options for the IL interpreter. [Out,Optional] If the method throws an unhandled exception, the type of the exception that got thrown. [Out,Optional] The return value of the method. This will be null if the method returns void or throws an exception.

Get metadata status. Location constraint: API must be called from a Monitor component (component level < 100,000). This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

[Out] Metadata status.

[Out] The size of the metadata buffer. [Out] A pointer to the metadata buffer.

Gets the signature token for a local variable signature given a method token. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

[In] Token of the method to get the local variable signature for. [Out] The local variable signature blob token.

Provides a mechanism for obtaining metadata tokens for a method given a class. Equivalent to IMetaDataImport::EnumMethodsWithName. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

[In] The name of the class containing the method. [In] The name of the method. [Out] Array of tokens for the method.

Provides a mechanism for obtaining metadata tokens for a method given a class. Equivalent to IMetaDataImport::EnumMethodsWithName. This method will append a new work item to the specified work list, and return once the work item has been appended. The actual processing of the work item is asynchronous. The caller will be notified that the request is complete through the completion routine. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

WorkList to append the new work item to. [In] The name of the class containing the method. [In] The name of the method. Routine to fire when the request is complete. If the request is successfully appended to the work list, this will always fire (including when the operation is canceled). This will never fire if appending the work item fails.

This API provides a partial ISymUnmanagedReader2 implementation for a CLR module. Location constraint: Provides a partial implementation of ISymUnmanagedReader2 to both sides of the remote connection. This API was introduced in Visual Studio 15 RTM (DkmApiVersion.VS15RTM).

[Out,Optional] The ISymUnmanagedReader for this module. If no symbols are available, this will return null.

Get a pointer to the original raw metadata bytes for the given module. Location constraint: None. This API was introduced in Visual Studio 15 Update 5 (DkmApiVersion.VS15Update5).

[Out] The size of the metadata buffer. [Out] A pointer to the metadata buffer.

Obtains the baseline bytes of the CLR metadata from a given module. This API was introduced in Visual Studio 15 Update 5 (DkmApiVersion.VS15Update5).

[Out] The original raw metadata for this module.

Checks whether Edit and Continue is supported for the corresponding managed module instance. Location constraint: API must be called from an IDE component (component level > 100,000). This API was introduced in Visual Studio 16 Update 1 (DkmApiVersion.VS16Update1).

[Out,Optional] Reason text message. This value should be null if EnC is available. [Out] Status regarding the availability of Edit and Continue for the module.

Gets the information needed to read the metadata directly from a file on disk. This API was introduced in Visual Studio 16 Update 2 (DkmApiVersion.VS16Update2).

[In] Whether or not the baseline metadata bytes are needed. [Out] The offset into the file to get the metadata. [Out] The size of the metadata in the file.

Responsible for querying the IL delta associated with a CLR module instance. The IL delta are the resulting bytes from a code change, which might affect several methods. This is consumed by VIL when querying information about a modified method within a module. Location constraint: API must be called from a Monitor component (component level < 100,000). This API was introduced in Visual Studio 16 Update 3 (DkmApiVersion.VS16Update3).

[In] The version for the edit, 1-based. This will be used for finding the appropriate update version of the IL delta bytes. For example, if the version is one, we will return the IL delta bytes for the first edit. [Out] The IL delta according to the update version. These are the bytes affected by the update to the module.

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Structure to define the IL instruction mapping for one or more native instructions.

Starting address for this block of native code.

Number of bytes of native instruction memory described by this DkmClrNativeCodeMapEntry.

Offset of the native instruction.

Offset of the IL instruction. '-1' is used to indicate that the native instructions cannot be mapped to an IL instruction. '-2' is used to indicate that the native instructions are part of the prolog. '-3' is used to indicate that the naive instructions are part of the epilog.

Initialize a new DkmClrNativeCodeMapEntry value.

[In] Starting address for this block of native code. [In] Number of bytes of native instruction memory described by this DkmClrNativeCodeMapEntry. [In] Offset of the native instruction. [In] Offset of the IL instruction. '-1' is used to indicate that the native instructions cannot be mapped to an IL instruction. '-2' is used to indicate that the native instructions are part of the prolog. '-3' is used to indicate that the naive instructions are part of the epilog.

Represents a CLR instance running in a target process. Derived classes: DkmClrNcRuntimeInstance

[Optional] The installation directory of the common language runtime (CLR) instance. For example 'c:\Windows\Microsoft.NET\Framework\v2.0.50727\'. This is the same path returned from the GetCORSystemDirectory API, and it always includes the trailing slash.

[Optional] The version string for the CLR instance (ex: 'v2.0.50727').

Creates a new runtime instance object from a debug monitor. This method must be called from the event thread when a debug monitor detects that a new runtime instance has loaded (for example, when the corresponding runtime dll loads in the target process). This method will send a RuntimeInstanceLoad event. Location constraint: API must be called from a Monitor component (component level < 100,000).

[In] DkmProcess represents a target process which is being debugged. The debugger debugs processes, so this is the basic unit of debugging. A DkmProcess can represent a system process or a virtual process such as minidumps. [In] Identifies a DkmRuntimeInstance object within a process. [In,Optional] The installation directory of the common language runtime (CLR) instance. For example 'c:\Windows\Microsoft.NET\Framework\v2.0.50727\'. This is the same path returned from the GetCORSystemDirectory API, and it always includes the trailing slash. [In,Optional] The version string for the CLR instance (ex: 'v2.0.50727'). [In,Optional] Data object to add to the new DkmClrRuntimeInstance instance. Pass 'null' in the case that the caller doesn't need to add a data item. [Out] Result of this method call.

[In] DkmProcess represents a target process which is being debugged. The debugger debugs processes, so this is the basic unit of debugging. A DkmProcess can represent a system process or a virtual process such as minidumps. [In] Identifies a DkmRuntimeInstance object within a process. [In] Enumeration of runtime capabilities. [In,Optional] For runtimes that are implemented on top of another runtime, this can optionally be used to indicant the logical parent. This can then be used to request services from the parent when the child runtime doesn't implement the service. This is currently used only for obtaining the top stack frame to evaluate a conditional breakpoint when the child runtime doesn't walk stacks itself. [In,Optional] The installation directory of the common language runtime (CLR) instance. For example 'c:\Windows\Microsoft.NET\Framework\v2.0.50727\'. This is the same path returned from the GetCORSystemDirectory API, and it always includes the trailing slash. [In,Optional] The version string for the CLR instance (ex: 'v2.0.50727'). [In,Optional] Data object to add to the new DkmClrRuntimeInstance instance. Pass 'null' in the case that the caller doesn't need to add a data item. [Out] Result of this method call.

Find a DkmClrAppDomain element within this DkmClrRuntimeInstance. If no element with the given input key is present, FindAppDomain will fail.

[In] Search key used to find the element. [Out,Optional] Result of the search.

GetAppDomains enumerates the DkmClrAppDomain elements of this DkmClrRuntimeInstance object.

[Out] Array containing the enumerated elements.

Obtains the DkmClrModuleInstance from an ICorDebugModule. Location constraint: API must be called from a Monitor component (component level < 100,000).

[In] The CLR module to get the module instance for. [Out] The DkmClrModuleInstance that matches the provided ICorDebugModule.

[In] DkmThread object that should be mapped to the CorDebug thread. [Out] ICorDebug interface representing an app domain inspection.

[Out] ICorDebug interface representing a process.

Checks to see if we should load the FEQA DLL. Location constraint: API must be called from a Monitor component (component level < 100,000).

[In] DkmThread represents a thread running in the target process. [Out] Specifies if the FEQA DLL should be loaded. The hosting process could have loaded it already. [Out] Specifies the address in debuggee process. Valid only if AlreadyLoaded is false.

Notifies the result of the attempt to load the FEQA DLL. Location constraint: API must be called from a Monitor component (component level < 100,000).

[In] DkmThread represents a thread running in the target process. [In] Specifies if the FEQA DLL was successfully loaded.

Continue the process and wait for a func-eval to complete. Location constraint: API must be called from a Monitor component (component level < 100,000).

[In] The thread for which to do the func-eval. [In] The object. [In] Function evaluation flags. [In] The timeout. [In] The text being evaluated. Displayed in the call stack window if the function evaluation re-enters break mode. [Out] The result of doing the function evaluation. S_OK if all went well. Other possible values include S_EVAL_TIMEDOUT, S_EVAL_ABORTED, or E_PROCESS_DESTROYED.

Checks if the given thread is in a state in which the CLR supports managed func-evals. Location constraint: API must be called from a Monitor component (component level < 100,000).

[In] DkmThread represents a thread running in the target process. [Out] The result of doing the function evaluation. S_OK if all went well. Other possible values include E_EVAL_FUNCEVAL_IN_MINIDUMP or S_EVAL_BAD_THREAD_STATE.

Gets the list of aliases that can currently be used in expressions. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

[In,Optional] The current InspectionContext. If null, aliases that depend on the current thread or app domain will not be returned by this method. [Out] The list of alias that can currently be used in expressions.

[Out] The size of the metadata buffer. [Out] A pointer to the metadata buffer.

GetCorFrame is used to obtain a ICorDebugFrame which a component can use to deeply inspect the stack frame. The returned interface may ONLY be used to inspect the target process, and should NEVER be used to control execution (no stepping, no breakpoints, no continue, etc). Doing so is unsupported and will result in undefined behavior. Location constraint: This API must be called from the same process where the target runtime implements stack walk. For managed debugging, this means that when debugging 64-bit or remote processes, this API must be called from a debug monitor component. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

[In] The thread the stack frame came from. [In] The frame base of the stack frame to get the inspection interface for. [In] The GUID of the desired interface. IID_ICorDebugFrame can be used to obtain the CorDebug frame interface for a managed frame. [Out] Returned frame interface. This may be cast to the interface pointer corresponding to 'InterfaceID'.

Continue the process and wait for a func-eval to complete. Location constraint: API must be called from a Monitor component (component level < 100,000). This API was introduced in Visual Studio 15 RTM (DkmApiVersion.VS15RTM).

[In] The thread for which to do the func-eval. [In] The object. [In] Function evaluation flags. [In] The timeout. [In] The text being evaluated. Displayed in the call stack window if the function evaluation re-enters break mode. [In,Optional] The target method being evaluated if known. [Out] The result of doing the function evaluation. S_OK if all went well. Other possible values include S_EVAL_TIMEDOUT, S_EVAL_ABORTED, S_EVAL_RUDE_ABORTED or E_PROCESS_DESTROYED.

Provides the stack of all active statements across all threads. So if the same function is on a call stack multiple times, it will be duplicated in this array. Entries in the stack are grouped by thread. Location constraint: Can be called from client to server side. This API was introduced in Visual Studio 15 Update 5 (DkmApiVersion.VS15Update5).

[Out] Information about the statements that are currently on the stack of any thread.

Provides the stack of all active statements across all threads. So if the same function is on a call stack multiple times, it will be duplicated in this array. Entries in the stack are grouped by thread. This method will append a new work item to the specified work list, and return once the work item has been appended. The actual processing of the work item is asynchronous. The caller will be notified that the request is complete through the completion routine. Location constraint: Can be called from client to server side. This API was introduced in Visual Studio 15 Update 5 (DkmApiVersion.VS15Update5).

Internal helper method for finding candidate addresses for step in/over. Location constraint: None. This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTMPreview).

[In] The current stepper. [In] The beginning stack frame of the step. This frame may not be the top-most stack frame. [In] The stepping ranges to look for call instructions within. [Out] The result candidate addresses.

Checks whether Edit and Continue is supported for the corresponding runtime instance. Location constraint: API must be called from an IDE component (component level > 100,000). This API was introduced in Visual Studio 16 Update 1 (DkmApiVersion.VS16Update1).

[Out,Optional] Reason text message. This value should be null if EnC is available. [Out] Status regarding the availability of Edit and Continue for the runtime.

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

A sequence point is a point in a managed method where the JIT can guarantee all side effects have been written to local variables. The debugger typically only stops at sequence points. This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTMPreview).

The IL offset of the sequence point.

The sequence point length in bytes.

The text span this sequence point maps to.

Initialize a new DkmClrSequencePoint value. This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTMPreview).

[In] The IL offset of the sequence point. [In] The sequence point length in bytes. [In] The text span this sequence point maps to.

Represents a managed type. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

The type def token of the type. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

[Optional] If the type is generic, specifies the generic arguments for the type. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

[Optional] The type of the object encompassed or referenced by this type given the type is an array, pointer or reference. This value is null if there is no element type. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

The CorElementType of this type. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

The rank of the array. This value is 0 if the type is not an array. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

If this type is synthetic and does not exist in the debuggee, this is the MVID of the module the type belongs to. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

[Optional] If the current type is a function pointer, specifies the return type of the function pointer. This API was introduced in Visual Studio 14 Update 1 (DkmApiVersion.VS14Update1).

[Optional] If the current type is a function pointer, specifies the types of the arguments. This API was introduced in Visual Studio 14 Update 1 (DkmApiVersion.VS14Update1).

The app domain of the type. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

The process of the type. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

Create a new DkmClrType object instance. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

Create a new DkmClrType object instance. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

[In] The module the type resides in. If the type resides in a synthetic assembly, this value will be a real module in the same AppDomain. [In] The type def token of the type. [In,Optional] If the type is generic, specifies the generic arguments for the type. [In,Optional] The type of the object encompassed or referenced by this type given the type is an array, pointer or reference. This value is null if there is no element type. [In] The CorElementType of this type. [In] The rank of the array. This value is 0 if the type is not an array. [In] If this type is synthetic and does not exist in the debuggee, this is the MVID of the module the type belongs to. [Out] Result of this method call.

Create a new DkmClrType object instance. This API was introduced in Visual Studio 14 Update 1 (DkmApiVersion.VS14Update1).

Resolves a method name belonging to a given class into a DkmClrMethodId. Location constraint: API must be called from a Monitor component (component level < 100,000). This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

[In] The name of the method. [In,Optional] Optional array of parameter types. [Out] A DkmClrMethodId describing the method.

Gets attributes on the type that affect the way variables are displayed in the debugger windows. Location constraint: API must be called from a Monitor component (component level < 100,000). This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

[Out] A list of attributes that apply to this type or its members.

Gets the object favorites information for the type. Location constraint: API must be called from a Monitor component (component level < 100,000). This API was introduced in Visual Studio 16 Update 4 (DkmApiVersion.VS16Update4).

[Out,Optional] The object favorites information for the type.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

[Required] Create a DkmClrType given an App Domain and LMR type. An LMR Type looks and behaves like a System.Type, but represents a type that exists in the process being debugged. Location constraint: API must be called from a Monitor component (component level < 100,000). This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

Unused. The app domain is implied by the type. [Required] LMR type

[Required] LMR type

[Required] Get the LMR type for this DkmClrType. An LMR Type looks and behaves like a System.Type, but represents a type that exists in the process being debugged. Location constraint: API must be called from a Monitor component (component level < 100,000). This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

Determine if the caller is a monitor component.

[Required] Internal helper to create a DkmClrType given an LMR type

[Required] LMR type

[Required] Internal helper to get the LMR type when called from the monitor process.

Internal helper to ensure that we have found the methods to access the Clr Inspector.

EnC availability status - whether EnC is available or it is not supported given a specified reason. This API was introduced in Visual Studio 16 Update 1 (DkmApiVersion.VS16Update1).

Edit and Continue is available.

Edit and Continue not supported due to interop debugging.

Unable to edit code running in SQL server.

Edit and Continue not supported in minidump debugging.

Edit and Continue not supported since debugger was attached to a process that does not support EnC on attach.

Edit and Continue not supported if the assembly has not been loaded.

Edit and Continue not supported if the assembly that has been modified during debugging is reloaded.

Unable to edit while code is running.

Edit and Continue not supported if the source code on disk does not match the code running in the process.

Edit and Continue not supported for the current engine.

Edit and Continue in a 64-bit process requires .NET Framework version 4.5.1 or higher.

Edit and Continue not supported on the current module. This is a fallback scenario in case we fail to determine the exact reason the module does not support EnC.

Edit and Continue not supported if code was optimized.

Edit and Continue not supported if assembly was loaded as domain-neutral.

Edit and Continue not supported if assembly was loaded through reflection.

Edit and Continue not supported if IntelliTrace events and call information is enabled.

Edit and Continue not supported on the .NET Runtime the program is running.

ENC delta between lines (struct LINEDELTA). This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

Method token.

Line delta.

Initialize a new DkmEncLineDelta value. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

[In] Method token. [In] Line delta.

Exception regions which were affected during a managed update. This API was introduced in Visual Studio 16 Update 3 (DkmApiVersion.VS16Update3).

Method ID. It has the method token for the exception region, and the method version when the change was made. This API was introduced in Visual Studio 16 Update 3 (DkmApiVersion.VS16Update3).

Specifies where the exception region starts and ends, must be 1-based. This API was introduced in Visual Studio 16 Update 3 (DkmApiVersion.VS16Update3).

The delta is the total of lines modified after the update. This API was introduced in Visual Studio 16 Update 3 (DkmApiVersion.VS16Update3).

Create a new DkmExceptionRegionUpdate object instance. Location constraint: API must be called from an IDE component (component level > 100,000). This API was introduced in Visual Studio 16 Update 3 (DkmApiVersion.VS16Update3).

[In] Method ID. It has the method token for the exception region, and the method version when the change was made. [In] Specifies where the exception region starts and ends, must be 1-based. [In] The delta is the total of lines modified after the update. [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Result of an asynchronous DkmClrRuntimeInstance.GetActiveStatements call.

Creates a new result structure to hold the error from a failed call to DkmClrRuntimeInstance.GetActiveStatements.

[In] exception object containing the error

HRESULT code returned from the caller. This will be DkmExceptionCode.COR_E_OPERATIONCANCELED (0x8013153B) if the operation was canceled before processing was complete.

Information about the statements that are currently on the stack of any thread. This API was introduced in Visual Studio 15 Update 5 (DkmApiVersion.VS15Update5).

Creates a new result structure to hold the output from a successful call to DkmClrRuntimeInstance.GetActiveStatements.

[In] Information about the statements that are currently on the stack of any thread.

Marshal a native struct to managed

Pointer to native struct. Managed object.

Obtain a pointer to the native object used to call into native.

Outgoing managed->native call Native object

Validate the fields of this structure

Struct that holds the field path (ex: "myArgument.StructField")

Result of an asynchronous DkmClrInstructionSymbol.GetAllAwaitExpressionInfoForStatement call.

Creates a new result structure to hold the error from a failed call to DkmClrInstructionSymbol.GetAllAwaitExpressionInfoForStatement.

[In] exception object containing the error

HRESULT code returned from the caller. This will be DkmExceptionCode.COR_E_OPERATIONCANCELED (0x8013153B) if the operation was canceled before processing was complete.

An array of the yield and resume points for the statement.

Creates a new result structure to hold the output from a successful call to DkmClrInstructionSymbol.GetAllAwaitExpressionInfoForStatement.

[In] An array of the yield and resume points for the statement.

Marshal a native struct to managed

Pointer to native struct. Managed object.

Obtain a pointer to the native object used to call into native.

Outgoing managed->native call Native object

Validate the fields of this structure

Struct that holds the field path (ex: "myArgument.StructField")

Result of an asynchronous DkmClrInstructionSymbol.GetAsyncKickoffMethod call.

Creates a new result structure to hold the error from a failed call to DkmClrInstructionSymbol.GetAsyncKickoffMethod.

[In] exception object containing the error

HRESULT code returned from the caller. This will be DkmExceptionCode.COR_E_OPERATIONCANCELED (0x8013153B) if the operation was canceled before processing was complete.

Kickoff method token.

Creates a new result structure to hold the output from a successful call to DkmClrInstructionSymbol.GetAsyncKickoffMethod.

[In] Kickoff method token.

Result of an asynchronous DkmClrInstructionSymbol.GetAsyncMethodLocation call.

Creates a new result structure to hold the error from a failed call to DkmClrInstructionSymbol.GetAsyncMethodLocation.

[In] exception object containing the error

HRESULT code returned from the caller. This will be DkmExceptionCode.COR_E_OPERATIONCANCELED (0x8013153B) if the operation was canceled before processing was complete.

The location of the given instruction.

Creates a new result structure to hold the output from a successful call to DkmClrInstructionSymbol.GetAsyncMethodLocation.

[In] The location of the given instruction.

Result of an asynchronous DkmClrInstructionSymbol.GetMethodLocalSymbols call.

Creates a new result structure to hold the error from a failed call to DkmClrInstructionSymbol.GetMethodLocalSymbols.

[In] exception object containing the error

HRESULT code returned from the caller. This will be DkmExceptionCode.COR_E_OPERATIONCANCELED (0x8013153B) if the operation was canceled before processing was complete.

DkmClrMethodScopeData[] describes a scope within a method. These are defined using ISymUnmanagedWriter::OpenScope/CloseScope. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

Creates a new result structure to hold the output from a successful call to DkmClrInstructionSymbol.GetMethodLocalSymbols.

[In] DkmClrMethodScopeData[] describes a scope within a method. These are defined using ISymUnmanagedWriter::OpenScope/CloseScope.

Marshal a native struct to managed

Pointer to native struct. Managed object.

Obtain a pointer to the native object used to call into native.

Outgoing managed->native call Native object

Validate the fields of this structure

Struct that holds the field path (ex: "myArgument.StructField")

Result of an asynchronous DkmClrInstructionSymbol.GetMethodSymbolStoreAttribute call.

Creates a new result structure to hold the error from a failed call to DkmClrInstructionSymbol.GetMethodSymbolStoreAttribute.

[In] exception object containing the error

HRESULT code returned from the caller. This will be DkmExceptionCode.COR_E_OPERATIONCANCELED (0x8013153B) if the operation was canceled before processing was complete.

The value of the requested symbol store attribute. This will be an empty array if the specified attribute name cannot be found. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

Creates a new result structure to hold the output from a successful call to DkmClrInstructionSymbol.GetMethodSymbolStoreAttribute.

[In] The value of the requested symbol store attribute. This will be an empty array if the specified attribute name cannot be found.

Marshal a native struct to managed

Pointer to native struct. Managed object.

Obtain a pointer to the native object used to call into native.

Outgoing managed->native call Native object

Validate the fields of this structure

Struct that holds the field path (ex: "myArgument.StructField")

Result of an asynchronous DkmClrModuleInstance.GetMethodTokens call.

Creates a new result structure to hold the error from a failed call to DkmClrModuleInstance.GetMethodTokens.

[In] exception object containing the error

HRESULT code returned from the caller. This will be DkmExceptionCode.COR_E_OPERATIONCANCELED (0x8013153B) if the operation was canceled before processing was complete.

Array of tokens for the method. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

Creates a new result structure to hold the output from a successful call to DkmClrModuleInstance.GetMethodTokens.

[In] Array of tokens for the method.

Marshal a native struct to managed

Pointer to native struct. Managed object.

Obtain a pointer to the native object used to call into native.

Outgoing managed->native call Native object

Validate the fields of this structure

Struct that holds the field path (ex: "myArgument.StructField")

Result of an asynchronous DkmClrInstructionSymbol.GetNextAwaitExpressionInfo call.

Creates a new result structure to hold the error from a failed call to DkmClrInstructionSymbol.GetNextAwaitExpressionInfo.

[In] exception object containing the error

HRESULT code returned from the caller. This will be DkmExceptionCode.COR_E_OPERATIONCANCELED (0x8013153B) if the operation was canceled before processing was complete.

Next await expression info.

Creates a new result structure to hold the output from a successful call to DkmClrInstructionSymbol.GetNextAwaitExpressionInfo.

[In] Next await expression info.

Represents options for invoking the IL interpreter. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

If true and we are interpreting a virtual function, indicates that the IL interpreter should use virtual dispatch to figure out the most derived implementation. If false, the specific method provided will be the one interpreted.

A primitive value or string. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

The value to be passed into or returned from the interpreted method. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

Create a new DkmILInterpreterPrimitiveValue object instance. Location constraint: API must be called from a Monitor component (component level < 100,000). This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

[In] Represents a CLR instance running in a target process. [In] The value to be passed into or returned from the interpreted method. [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

A reference to an object in the debuggee's managed heap. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

[Optional] A reference to the object in the debuggee to be passed into or returned from the interpreted method. If the value refers to a null object reference, ReferenceValue will be null. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

Create a new DkmILInterpreterReferenceValue object instance. Location constraint: API must be called from a Monitor component (component level < 100,000). This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

[In] Represents a CLR instance running in a target process. [In,Optional] A reference to the object in the debuggee to be passed into or returned from the interpreted method. If the value refers to a null object reference, ReferenceValue will be null. [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

A value that can be passed into and returned from a managed method being interpreted. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM). Derived classes: DkmILInterpreterPrimitiveValue, DkmILInterpreterReferenceValue

DkmILInterpreterValue is an abstract base class. This enum indicates which derived class this object is an instance of.

Object is an instance of 'DkmILInterpreterPrimitiveValue'.

Object is an instance of 'DkmILInterpreterReferenceValue'.

DkmILInterpreterValue is an abstract base class. This enum indicates which derived class this object is an instance of.

Represents a CLR instance running in a target process. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Describes a range of IL instructions within a method.

Beginning IL offset the range.

Ending IL offset of the range.

Initialize a new DkmILRange value.

[In] Beginning IL offset the range. [In] Ending IL offset of the range.

Represents a set of managed Edit and Continue updates. This API was introduced in Visual Studio 16 Update 3 (DkmApiVersion.VS16Update3).

A collection of managed updates which will be applied to the session. This API was introduced in Visual Studio 16 Update 3 (DkmApiVersion.VS16Update3).

Create a new DkmManagedEncUpdates object instance. Location constraint: API must be called from an IDE component (component level > 100,000). This API was introduced in Visual Studio 16 Update 3 (DkmApiVersion.VS16Update3).

[In] A collection of managed updates which will be applied to the session. [Out] Result of this method call.

Apply the managed updates to all the modules across different processes which are currently being debugged. If an update was created from a module that was not loaded yet, the engine will track it and update when the module is actually loaded. Otherwise, the updates are applied immediately. The changes will persist until the end of the debugging session. Location constraint: API must be called from an IDE component (component level > 100,000). This API was introduced in Visual Studio 16 Update 3 (DkmApiVersion.VS16Update3).

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Represents managed heap object info. Corresponds to COR_HEAPOBJECT defined in cordebug.h. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

The address of the object in memory.

The total size of the object, in bytes.

A unique id that represents the type of the object.

Initialize a new DkmManagedHeapObjectInfo value. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

[In] The address of the object in memory. [In] The total size of the object, in bytes. [In] A unique id that represents the type of the object.

Represents info about a managed heap root. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

Address of the object.

Root type of the object.

Name of the root object (if available).

ExtraData field of the CorGCReference structure that changes depending on the root type. For instance for dependent handles this is the link to the secondary object. For RefCount handles this is the reference count.

Initialize a new DkmManagedHeapRootInfo value. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

[In] Address of the object. [In] Root type of the object. [In] Name of the root object (if available). [In] ExtraData field of the CorGCReference structure that changes depending on the root type. For instance for dependent handles this is the link to the secondary object. For RefCount handles this is the reference count.

Marshal a native struct to managed

Pointer to native struct. Managed object.

Obtain a pointer to the native object used to call into native.

Outgoing managed->native call Native object

Validate the fields of this structure

Struct that holds the field path (ex: "myArgument.StructField")

DkmManagedHeapSampler represents a sampler for objects in the managed heap. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

Guid which uniquely identifies this DkmManagedHeapSampler. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

[Optional] Specifies a connection to a worker process where the Heap Sampler's operations will be processed. This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTMPreview).

Closes a DkmManagedHeapSampler object instance. This will release any resources associated with this object across all components. This includes resources across computer or managed/native marshalling boundaries. DkmManagedHeapSampler objects are automatically closed when their associated DkmRuntimeInstance object is closed. This method may only be called by the component which created the object. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

Create a new DkmManagedHeapSampler object instance. The caller is responsible for closing the created object after they are done. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

[In] The DkmRuntimeInstance class represents an execution environment which is loaded into a DkmProcess and which contains code to be debugged. [In,Optional] Data object to add to the new DkmManagedHeapSampler instance. Pass 'null' in the case that the caller doesn't need to add a data item. [Out] Result of this method call.

Create a new DkmManagedHeapSampler object instance. The caller is responsible for closing the created object after they are done. This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTMPreview).

[In] The DkmRuntimeInstance class represents an execution environment which is loaded into a DkmProcess and which contains code to be debugged. [In,Optional] Specifies a connection to a worker process where the Heap Sampler's operations will be processed. [In,Optional] Data object to add to the new DkmManagedHeapSampler instance. Pass 'null' in the case that the caller doesn't need to add a data item. [Out] Result of this method call.

Initializes heap sampler. Location constraint: API must be called from an IDE component (component level > 100,000). This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

[In] The number of sampled objects to return. [In] Whether the sampler should calculate stats for only the live objects on the heap. E_MANAGED_HEAP_NOT_ENUMERABLE indicates that the managed heap is not a state that can be enumerated.

Walks the given number of objects on the heap. Location constraint: API must be called from an IDE component (component level > 100,000). This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

[In] Count of items requested. [Out] Count of items fetched.

Walks the given number of references on the heap. Location constraint: API must be called from an IDE component (component level > 100,000). This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

[In] Count of items requested. [Out] Count of items fetched.

Walks the given number of GC roots on the heap. Location constraint: API must be called from an IDE component (component level > 100,000). This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

[In] Count of items requested. [Out] Count of items fetched.

Returns the next requested portion of serialized object graph data. Location constraint: API must be called from an IDE component (component level > 100,000). This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

[In] Count of items requested. [Out] Sampled heap data.

Returns the heap type stats. Location constraint: API must be called from an IDE component (component level > 100,000). This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

[Out] Sampled heap type stats.

Returns roots from the sampled heap. Location constraint: API must be called from an IDE component (component level > 100,000). This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

[Out] Sampled heap roots.

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Represents info about a managed heap segment. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

Start address of the segment.

End address of the segment.

Generation of the segment.

Initialize a new DkmManagedHeapSegmentInfo value. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

[In] Start address of the segment. [In] End address of the segment. [In] Generation of the segment.

Represents info about a type in managed heap. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

Name of the type.

Total number of objects for the type.

Total size of the object for the type.

Initialize a new DkmManagedHeapTypeInfo value. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

[In] Name of the type. [In] Total number of objects for the type. [In] Total size of the object for the type.

Marshal a native struct to managed

Pointer to native struct. Managed object.

Obtain a pointer to the native object used to call into native.

Outgoing managed->native call Native object

Validate the fields of this structure

Struct that holds the field path (ex: "myArgument.StructField")

DkmManagedHeapWalker represents an enumerator for managed heap. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

Guid which uniquely identifies this DkmManagedHeapWalker. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

Closes a DkmManagedHeapWalker object instance. This will release any resources associated with this object across all components. This includes resources across computer or managed/native marshalling boundaries. DkmManagedHeapWalker objects are automatically closed when their associated DkmRuntimeInstance object is closed. This method may only be called by the component which created the object. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

Create a new DkmManagedHeapWalker object instance. The caller is responsible for closing the created object after they are done. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

[In] The DkmRuntimeInstance class represents an execution environment which is loaded into a DkmProcess and which contains code to be debugged. [In,Optional] Data object to add to the new DkmManagedHeapWalker instance. Pass 'null' in the case that the caller doesn't need to add a data item. [Out] Result of this method call.

Prepares enumerator for walking the objects in the heap, returns error if heap cannot be enumerated. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

E_MANAGED_HEAP_NOT_ENUMERABLE indicates that the managed heap is not a state that can be enumerated.

Prepares enumeration for reporting references between objects in the heap, returns error if heap cannot be enumerated. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

E_MANAGED_HEAP_NOT_ENUMERABLE indicates that the managed heap is not a state that can be enumerated.

Prepares enumeration for reporting roots in the heap, returns error if heap cannot be enumerated. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

E_MANAGED_HEAP_NOT_ENUMERABLE indicates that the managed heap is not a state that can be enumerated.

Returns the next set of objects from the enumeration. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

[In] Count of items requested. [Out] Array containing the managed heap object infos.

Returns the next set of elements from the enumeration. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

[In] Count of items requested. [Out] Array containing the managed heap reference infos.

Returns the next set of roots from the enumeration. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

[In] Count of items requested. [Out] Array containing the managed heap root infos.

Gets the type names for the given type ids. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

[In] The list of managed type ids. [Out] The list of type names.

Gets the list of segments in the heap. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

[Out] The list of heap segments.

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Represents a managed Edit and Continue update for a given managed module. This API was introduced in Visual Studio 16 Update 3 (DkmApiVersion.VS16Update3).

Module version Identifier which the managed update was applied. This uniquely identifies the symbol file. For Microsoft C++ or Microsoft .NET Framework binaries, this is a unique value which is embedded in an exe/dll by linkers/compilers when the dll/exe is built. A new value is generated each time that the dll/exe is compiled. This API was introduced in Visual Studio 16 Update 3 (DkmApiVersion.VS16Update3).

Collection of IL deltas affected by the update. This API was introduced in Visual Studio 16 Update 3 (DkmApiVersion.VS16Update3).

Collection of metadata deltas affected by the update. This API was introduced in Visual Studio 16 Update 3 (DkmApiVersion.VS16Update3).

Collection of PDB deltas affected by the update. This API was introduced in Visual Studio 16 Update 3 (DkmApiVersion.VS16Update3).

Collection of sequence points affected by the update. This will alter the line number for one or more existing sequence point in the symbolic data. This API was introduced in Visual Studio 16 Update 3 (DkmApiVersion.VS16Update3).

Method token for all the methods affected by the update. This API was introduced in Visual Studio 16 Update 3 (DkmApiVersion.VS16Update3).

Collection of active statements affected by the update. This API was introduced in Visual Studio 16 Update 3 (DkmApiVersion.VS16Update3).

Collection of exception regions affected by the update. This API was introduced in Visual Studio 16 Update 3 (DkmApiVersion.VS16Update3).

Create a new DkmManagedModuleUpdate object instance. Location constraint: API must be called from an IDE component (component level > 100,000). This API was introduced in Visual Studio 16 Update 3 (DkmApiVersion.VS16Update3).

[In] Module version Identifier which the managed update was applied. This uniquely identifies the symbol file. For Microsoft C++ or Microsoft .NET Framework binaries, this is a unique value which is embedded in an exe/dll by linkers/compilers when the dll/exe is built. A new value is generated each time that the dll/exe is compiled. [In] Collection of IL deltas affected by the update. [In] Collection of metadata deltas affected by the update. [In] Collection of PDB deltas affected by the update. [In] Collection of sequence points affected by the update. This will alter the line number for one or more existing sequence point in the symbolic data. [In] Method token for all the methods affected by the update. [In] Collection of active statements affected by the update. [In] Collection of exception regions affected by the update. [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Represents info about a managed object reference. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

Address of the source object.

Address of the target object.

Initialize a new DkmManagedObjectReferenceInfo value. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

[In] Address of the source object. [In] Address of the target object.

Contains information needed to construct a managed DkmStackWalkFrame. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

The thread that this frame belongs to. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

Flags associated with this frame. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

The managed method that this frame belongs to. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

The module that this method belongs to. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

The index of the await statement where code will transfer to when this frame later executes. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

Context to use for continuing to walk the async return stack beyond this frame. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

Optional data object to associate with this frame. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

The task id of the associated task, if one exists. This API was introduced in Visual Studio 15 Update 8 (DkmApiVersion.VS15Update8).

[Optional] Description of the frame which will be displayed in the call stack window. This API was introduced in Visual Studio 16 Update 3 (DkmApiVersion.VS16Update3).

Create a new DkmManagedReturnStackFrame object instance. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

[In] The thread that this frame belongs to. [In] Flags associated with this frame. [In] The managed method that this frame belongs to. [In] The module that this method belongs to. [In] The index of the await statement where code will transfer to when this frame later executes. [In] Context to use for continuing to walk the async return stack beyond this frame. [In] Optional data object to associate with this frame. [Out] Result of this method call.

Create a new DkmManagedReturnStackFrame object instance. This API was introduced in Visual Studio 15 Update 8 (DkmApiVersion.VS15Update8).

Create a new DkmManagedReturnStackFrame object instance. This API was introduced in Visual Studio 16 Update 3 (DkmApiVersion.VS16Update3).

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Provides a context for managed return value. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

The thread to retrieve the return value. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

The runtime of the Expression Evaluator that should evaluate this return value. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

Return value hitting guard breakpoint address. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

Name of the finished method call. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

[Optional] Deprecated - no longer used. Full names for return value properties should now be constructed based on the return value's id returned by DkmRawReturnValueContainer::Id(). This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

Create a new DkmManagedReturnValueContext object instance. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

[In] The thread to retrieve the return value. [In] The runtime of the Expression Evaluator that should evaluate this return value. [In] Return value hitting guard breakpoint address. [In] Name of the finished method call. [In,Optional] Deprecated - no longer used. Full names for return value properties should now be constructed based on the return value's id returned by DkmRawReturnValueContainer::Id(). [Out] Result of this method call.

Evaluates and formats a given DkmRawReturnValue using solely the provided data. Location constraint: API must be called from a Monitor component (component level < 100,000). This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

[Out] Return value from CLR.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Managed return value of value type copy. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

[Optional] The CorElementType of the value type. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

[Optional] The size of the value type. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

[Optional] The address of the value type. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

[Optional] The captured value type buffer. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

Create a new DkmManagedReturnValueCopy object instance. Location constraint: The caller is required to be in the same process (IDE process or Monitor process) as the implementation component. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

[In] ICorDebugType of the return value. [In,Optional] The CorElementType of the value type. [In,Optional] The size of the value type. [In,Optional] The address of the value type. [In,Optional] The captured value type buffer. [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Provides information for managed return value. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM). Derived classes: DkmManagedReturnValueCopy, DkmManagedReturnValueReference

DkmManagedReturnValueInfo is an abstract base class. This enum indicates which derived class this object is an instance of.

Object is an instance of 'DkmManagedReturnValueReference'.

Object is an instance of 'DkmManagedReturnValueCopy'.

DkmManagedReturnValueInfo is an abstract base class. This enum indicates which derived class this object is an instance of.

ICorDebugType of the return value. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Managed return value of reference type. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

[Optional] ICorDebugValue from CLR. It is null for value type. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

Create a new DkmManagedReturnValueReference object instance. Location constraint: The caller is required to be in the same process (IDE process or Monitor process) as the implementation component. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

[In] ICorDebugType of the return value. [In,Optional] ICorDebugValue from CLR. It is null for value type. [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Represents managed type id of an object. Corresponds to COR_TYPEID defined in cordebug.h. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

Compare two elements of the DkmManagedTypeId structure.

Value to comare against this instance. 'true' if the two elements are equal.

Compare two elements of the DkmManagedTypeId sructure.

Left side of the comparison Right side of the comparison

Compare two elements of the DkmManagedTypeId sructure.

Left side of the comparison Right side of the comparison

Compare two elements of the DkmManagedTypeId sructure.

Left side of the comparison Right side of the comparison

Compare two elements of the DkmManagedTypeId sructure.

Left side of the comparison Right side of the comparison

Compare two elements of the DkmManagedTypeId sructure.

Left side of the comparison Right side of the comparison

Compare two elements of the DkmManagedTypeId sructure.

Left side of the comparison Right side of the comparison

The first token.

The second token.

Initialize a new DkmManagedTypeId value. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

[In] The first token. [In] The second token.

Describes whether or not metadata is available for a given module instance. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

Not determined.

Metadata is present.

Metadata is not present. This case can happen only in minidumps without heap when we haven't loaded the binary.

Indicates whether non user code is due to DebuggerHidden, DebuggerStepThrough, or DebuggerNonUserCode attribute marked on method or class or marked hidden due 0xfeefee sequence point.

Method or class is not marked with non user code related attributes.

Method or class is marked with the DebuggerHidden attribute or marked hidden due to 0xfeefee sequence point.

Method or class is marked with the DebuggerStepThrough attribute.

Method or class is marked with the DebuggerNonUserCode attribute.

Sequence points affected by a managed update on a specified file. This API was introduced in Visual Studio 16 Update 3 (DkmApiVersion.VS16Update3).

Name of the file which was modified. This API was introduced in Visual Studio 16 Update 3 (DkmApiVersion.VS16Update3).

Collection of lines of the file affected by the update. This API was introduced in Visual Studio 16 Update 3 (DkmApiVersion.VS16Update3).

Create a new DkmSequencePointsUpdate object instance. Location constraint: API must be called from an IDE component (component level > 100,000). This API was introduced in Visual Studio 16 Update 3 (DkmApiVersion.VS16Update3).

[In] Name of the file which was modified. [In] Collection of lines of the file affected by the update. [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Source line affected by a managed update. This API was introduced in Visual Studio 16 Update 3 (DkmApiVersion.VS16Update3).

Line number before the update was made, must be 1-based. This API was introduced in Visual Studio 16 Update 3 (DkmApiVersion.VS16Update3).

Line number after the update was made, must be 1-based. This API was introduced in Visual Studio 16 Update 3 (DkmApiVersion.VS16Update3).

Create a new DkmSourceLineUpdate object instance. Location constraint: API must be called from an IDE component (component level > 100,000). This API was introduced in Visual Studio 16 Update 3 (DkmApiVersion.VS16Update3).

[In] Line number before the update was made, must be 1-based. [In] Line number after the update was made, must be 1-based. [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Result of an asynchronous DkmClrRuntimeInstance.UpdateFavorites call.

Creates a new result structure to hold the error from a failed call to DkmClrRuntimeInstance.UpdateFavorites.

[In] exception object containing the error

HRESULT code returned from the caller. This will be DkmExceptionCode.COR_E_OPERATIONCANCELED (0x8013153B) if the operation was canceled before processing was complete.

'DkmClrNcContainerModuleInstance' is used to represent a module instance which is 1:1 with a physical native dll loaded by the target app. This native dll functions as a logical container for one or more logical managed modules (DkmClrNcModuleInstance) which are embedded inside it. This API was introduced in Visual Studio 15 Update 6 (DkmApiVersion.VS15Update6).

Represents a native-compiled CLR instance running in a target process. This API was introduced in Visual Studio 15 Update 6 (DkmApiVersion.VS15Update6).

DkmClrAppDomain represents a CLR app domain inside a process which is being debugged. This API was introduced in Visual Studio 15 Update 6 (DkmApiVersion.VS15Update6).

Find a DkmClrNcModuleInstance element within this DkmClrNcContainerModuleInstance. If no element with the given input key is present, FindEmbeddedModule will fail. This API was introduced in Visual Studio 15 Update 6 (DkmApiVersion.VS15Update6).

[In] Search key used to find the element. [Out,Optional] Result of the search.

GetEmbeddedModules enumerates the DkmClrNcModuleInstance elements of this DkmClrNcContainerModuleInstance object. This API was introduced in Visual Studio 15 Update 6 (DkmApiVersion.VS15Update6).

[Out] Array containing the enumerated elements.

Returns the image bytes starting at a specified RVA. Implemented by symbol provider for managed DM. This API was introduced in Visual Studio 15 Update 6 (DkmApiVersion.VS15Update6).

[In] Starting RVA from where bytes are requested. [In] Number of bytes requested. [Out] Image bytes.

Retrieves the layout of the class. This API was introduced in Visual Studio 15 Update 6 (DkmApiVersion.VS15Update6).

[In,Optional] Can be non-null only for multi-file scenarios where the ClassSignature is relative to this module. If this parameter is null, the ClassSignature is relative to the mapping metadata (pseudo-il assembly) contained in the DkmClrNcContainerModuleInstance. [In] Signature of class. [Out] Array of instance fields. [Out] Size of the struct/class in bytes.

Returns true if the container module is not a merged .Net Native assembly. This API was introduced in Visual Studio 15 Update 6 (DkmApiVersion.VS15Update6).

[Out] True if this represents a multi-file assembly, false if it is a merged assembly.

Creates a DkmClrNcInstructionAddress from an RVA into the module. This method will append a new work item to the specified work list, and return once the work item has been appended. The actual processing of the work item is asynchronous. The caller will be notified that the request is complete through the completion routine. This API was introduced in Visual Studio 15 Update 6 (DkmApiVersion.VS15Update6).

WorkList to append the new work item to. [In] RVA of the instruction address. Routine to fire when the request is complete. If the request is successfully appended to the work list, this will always fire (including when the operation is canceled). This will never fire if appending the work item fails.

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Information about an instance field for a managed class that is compiled into native code. This API was introduced in Visual Studio 15 Update 6 (DkmApiVersion.VS15Update6).

Field name. This API was introduced in Visual Studio 15 Update 6 (DkmApiVersion.VS15Update6).

Size in bytes. This API was introduced in Visual Studio 15 Update 6 (DkmApiVersion.VS15Update6).

Byte offset in class. This API was introduced in Visual Studio 15 Update 6 (DkmApiVersion.VS15Update6).

Create a new DkmClrNcInstanceFieldSymbol object instance. This API was introduced in Visual Studio 15 Update 6 (DkmApiVersion.VS15Update6).

[In] Field name. [In] Size in bytes. [In] Byte offset in class. [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

DkmClrNcInstructionAddress is used to represent an addresses in native-compiled CLR code. It contains the information about where the instruction is using both managed concepts (DkmClrNcModuleInstance, method token, IL offset) and native concepts ( DkmClrNcContainerModuleInstance, RVA). This API was introduced in Visual Studio 15 Update 6 (DkmApiVersion.VS15Update6).

Represents a native-compiled CLR instance running in a target process. This API was introduced in Visual Studio 15 Update 6 (DkmApiVersion.VS15Update6).

The managed module containing the InstructionPointer. This API was introduced in Visual Studio 15 Update 6 (DkmApiVersion.VS15Update6).

The underlying container module (on-disk module) where this address is loaded. Symbols (DkmModule) are accessed through this module instead of 'ModuleInstance'. This API was introduced in Visual Studio 15 Update 6 (DkmApiVersion.VS15Update6).

[Optional] For generic methods, this provides the ECMA formatted TypeSpec signature for each generic parameter. For non-generic methods, this will be null. For non-merged modules this is relative to the mapping (or pseudo-IL assembly). This API was introduced in Visual Studio 15 Update 6 (DkmApiVersion.VS15Update6).

[Optional] In a multi-module assembly, MethodId.Token is a method token resolved to the appropriate virtual module. This token is can be looked up in the pseudo- assembly. This API was introduced in Visual Studio 15 Update 6 (DkmApiVersion.VS15Update6).

Create a new DkmClrNcInstructionAddress object instance. This API was introduced in Visual Studio 15 Update 6 (DkmApiVersion.VS15Update6).

[In] The version/token pair for this method. [In] For the standard .NET Framework, NativeOffset is a byte offset relative to start of the method where the CPU instruction can be found. For the purpose of this value, the method should be treated as a contiguous block of bytes. If the method has not been Just-in-time compiled or if this address is being used to refer purely to the IL address, NativeOffset will be set to UInt32.MaxValue. For native-compiled .NET Framework modules, this value is the RVA of the native instruction in the module. [In] ILOffset is the index of the IL instruction that this address represents. This value may be set to UInt32.MaxValue for an instruction that is within the given method, but not tied to a particular IL instruction. This is used for CLR native instructions that don't map to an IL instruction. (ICorDebugILFrame::GetIP indicates MAPPING_UNMAPPED_ADDRESS). [In] Represents a native-compiled CLR instance running in a target process. [In] The managed module containing the InstructionPointer. [In] The underlying container module (on-disk module) where this address is loaded. Symbols (DkmModule) are accessed through this module instead of 'ModuleInstance'. [In,Optional] For generic methods, this provides the ECMA formatted TypeSpec signature for each generic parameter. For non-generic methods, this will be null. For non-merged modules this is relative to the mapping (or pseudo-IL assembly). [In,Optional] In a multi-module assembly, MethodId.Token is a method token resolved to the appropriate virtual module. This token is can be looked up in the pseudo- assembly. [In,Optional] CPUInstruction provides the address that the CPU will execute. This is always provided for native instructions. It may be provided for CLR or custom addresses depending on how the address object was created. [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

DkmClrNcInstructionSymbol represents an IL instruction that has been compiled to native code and is running under the native-compiled CLR. DkmClrNcInstructionSymbol is in a hybrid of a native and CLR instruction symbols - like a CLR instruction symbol, it contains enough information to bind the symbol to the managed IL instruction address concepts. Like a native symbol, it contains enough information to bind it to a native CPU address. This API was introduced in Visual Studio 15 Update 6 (DkmApiVersion.VS15Update6).

The Mvid of the module where MethodId.Token is defined. This API was introduced in Visual Studio 15 Update 6 (DkmApiVersion.VS15Update6).

This value is the RVA of the native instruction from the beginning of the native module that contains this instruction. This API was introduced in Visual Studio 15 Update 6 (DkmApiVersion.VS15Update6).

Create a new DkmClrNcInstructionSymbol object instance. This API was introduced in Visual Studio 15 Update 6 (DkmApiVersion.VS15Update6).

[In] The DkmModule class represents a code bundle (ex: dll or exe) which is or once was loaded into one or more processes. The DkmModule class is the central object to the symbol APIs, and is 1:1 with the symbol handler's notation of what is loaded. If a code bundle loads into three different processes (or the same process but with three different base addresses or three different app domains) but the symbol handler thinks of all of these as being identical, there will be only one module object. [In] The version/token pair for this method. [In] ILOffset is the index of the IL instruction that this symbol represents. This value may be set to UInt32.MaxValue for an instruction that is within the given method, but not tied to a particular instruction. This is used for CLR native instructions that don't map to an IL instruction. [In] The Mvid of the module where MethodId.Token is defined. [In] This value is the RVA of the native instruction from the beginning of the native module that contains this instruction. [In,Optional] For generic methods, this provides the ECMA formatted TypeSpec signature for each generic parameter. For non-generic methods, this will be null. For non-merged modules this is relative to the mapping (or pseudo-IL assembly). [In,Optional] In a multi-module assembly, MethodId.Token is a method token resolved to the appropriate virtual module. This token is can be looked up in the pseudo- assembly. [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

'DkmClrNcModuleInstance' is used for managed modules which are compiled to native code and embedded inside of a native module. Like DkmClrModuleInstance, these are 1:1 with an ICorDebugModule. This API was introduced in Visual Studio 15 Update 6 (DkmApiVersion.VS15Update6).

Represents a native-compiled CLR instance running in a target process. This API was introduced in Visual Studio 15 Update 6 (DkmApiVersion.VS15Update6).

The container (physical) module instance that this embedded (virtual) module is built into. This API was introduced in Visual Studio 15 Update 6 (DkmApiVersion.VS15Update6).

The identifier for this embedded module within the container. This is used as a prefix on type names in the container module to indicate which embedded module a type belongs to. This API was introduced in Visual Studio 15 Update 6 (DkmApiVersion.VS15Update6).

Returns the image bytes starting at a specified RVA. Implemented by symbol provider for managed DM. This API was introduced in Visual Studio 15 Update 6 (DkmApiVersion.VS15Update6).

[In] Starting RVA from where bytes are requested. [In] Number of bytes requested. [Out] Image bytes.

Creates one or more DkmClrNcInstructionAddress from a method token + IL offset. There can be multiple addresses if either that IL offset maps to multiple instruction blocks or if this is a generic method and there are multiple instantiations. This method will append a new work item to the specified work list, and return once the work item has been appended. The actual processing of the work item is asynchronous. The caller will be notified that the request is complete through the completion routine. This API was introduced in Visual Studio 15 Update 6 (DkmApiVersion.VS15Update6).

WorkList to append the new work item to. [In] The method id of the IL method. [In] The IL offset of the instruction to map. Routine to fire when the request is complete. If the request is successfully appended to the work list, this will always fire (including when the operation is canceled). This will never fire if appending the work item fails.

Resolve a token. This API was introduced in Visual Studio 15 Update 8 (DkmApiVersion.VS15Update8).

[In] The type ref token. [Out] The name of the assembly containing the type. [Out] The type def token.

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Represents a native-compiled CLR instance running in a target process. This API was introduced in Visual Studio 15 Update 6 (DkmApiVersion.VS15Update6).

[In] DkmProcess represents a target process which is being debugged. The debugger debugs processes, so this is the basic unit of debugging. A DkmProcess can represent a system process or a virtual process such as minidumps. [In] Identifies a DkmRuntimeInstance object within a process. [In] Enumeration of runtime capabilities. [In,Optional] For runtimes that are implemented on top of another runtime, this can optionally be used to indicant the logical parent. This can then be used to request services from the parent when the child runtime doesn't implement the service. This is currently used only for obtaining the top stack frame to evaluate a conditional breakpoint when the child runtime doesn't walk stacks itself. [In,Optional] The version string for the CLR instance (ex: 'v2.0.50727'). [In,Optional] Data object to add to the new DkmClrNcRuntimeInstance instance. Pass 'null' in the case that the caller doesn't need to add a data item. [Out] Result of this method call.

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Result of an asynchronous DkmClrNcContainerModuleInstance.CreateInstructionAddressFromRva call.

Creates a new result structure to hold the error from a failed call to DkmClrNcContainerModuleInstance.CreateInstructionAddressFromRva.

[In] exception object containing the error

Created DkmClrNcInstructionAddress object. This API was introduced in Visual Studio 15 Update 6 (DkmApiVersion.VS15Update6).

Creates a new result structure to hold the output from a successful call to DkmClrNcContainerModuleInstance.CreateInstructionAddressFromRva.

[In] Created DkmClrNcInstructionAddress object.

Marshal a native struct to managed

Pointer to native struct. Managed object.

Obtain a pointer to the native object used to call into native.

Outgoing managed->native call Native object

Validate the fields of this structure

Struct that holds the field path (ex: "myArgument.StructField")

Result of an asynchronous DkmClrNcModuleInstance.CreateInstructionAddressesFromILAddress call.

Creates a new result structure to hold the error from a failed call to DkmClrNcModuleInstance.CreateInstructionAddressesFromILAddress.

[In] exception object containing the error

HRESULT code returned from the caller. This will be DkmExceptionCode.COR_E_OPERATIONCANCELED (0x8013153B) if the operation was canceled before processing was complete.

Created DkmClrNcInstructionAddress object. This API was introduced in Visual Studio 15 Update 6 (DkmApiVersion.VS15Update6).

Creates a new result structure to hold the output from a successful call to DkmClrNcModuleInstance.CreateInstructionAddressesFromILAddress.

[In] Created DkmClrNcInstructionAddress object.

Marshal a native struct to managed

Pointer to native struct. Managed object.

Obtain a pointer to the native object used to call into native.

Outgoing managed->native call Native object

Validate the fields of this structure

Struct that holds the field path (ex: "myArgument.StructField")

Represents a C++/CLI local variable or function parameter backed by an IL slot, which can be inspected by a ldloc or ldarg instruction. The types of IL local variables are not represented in the PDB, and are not provided through this API. Instead, consumers of DkmMCppILLocalVariableSymbol objects should obtain the type information through inspection of the managed metadata. This API was introduced in Visual Studio 14 Update 1 (DkmApiVersion.VS14Update1).

True if this variable is a function parameter; false if this variable is a local variable. In some cases, such as global functions or member functions of native classes, this API will provide parameter names from the PDB that are not available through inspection of just the metadata. This API was introduced in Visual Studio 14 Update 1 (DkmApiVersion.VS14Update1).

The local slot used by the IL in stloc/ldloc instructions to access the variable (or starg/ldarg instructions if this variable is a function parameter). This API was introduced in Visual Studio 14 Update 1 (DkmApiVersion.VS14Update1).

Create a new DkmMCppILLocalVariableSymbol object instance. Location constraint: API must be called from an IDE component (component level > 100,000). This API was introduced in Visual Studio 14 Update 1 (DkmApiVersion.VS14Update1).

[In] The name of the variable. [In] True if this variable is a function parameter; false if this variable is a local variable. In some cases, such as global functions or member functions of native classes, this API will provide parameter names from the PDB that are not available through inspection of just the metadata. [In] The local slot used by the IL in stloc/ldloc instructions to access the variable (or starg/ldarg instructions if this variable is a function parameter). [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Represents a symbol for a C++/CLI local variable or function parameter in a PDB. This API was introduced in Visual Studio 14 Update 1 (DkmApiVersion.VS14Update1). Derived classes: DkmMCppILLocalVariableSymbol, DkmMCppStaticLocalVariableSymbol

DkmMCppLocalVariableSymbol is an abstract base class. This enum indicates which derived class this object is an instance of.

Object is an instance of 'DkmMCppILLocalVariableSymbol'.

Object is an instance of 'DkmMCppStaticLocalVariableSymbol'.

DkmMCppLocalVariableSymbol is an abstract base class. This enum indicates which derived class this object is an instance of.

The name of the variable. This API was introduced in Visual Studio 14 Update 1 (DkmApiVersion.VS14Update1).

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Represents a scope within a method implemented in C++/CLI. This API was introduced in Visual Studio 14 Update 1 (DkmApiVersion.VS14Update1).

The method containing this scope. This API was introduced in Visual Studio 14 Update 1 (DkmApiVersion.VS14Update1).

The module for which this method belongs to. This API was introduced in Visual Studio 14 Update 1 (DkmApiVersion.VS14Update1).

The range of IL offsets within the method for which this scope is valid. This API was introduced in Visual Studio 14 Update 1 (DkmApiVersion.VS14Update1).

[Optional] The parent of this scope, null for the root scope of a method. This API was introduced in Visual Studio 14 Update 1 (DkmApiVersion.VS14Update1).

The variables defined within this scope. This API was introduced in Visual Studio 14 Update 1 (DkmApiVersion.VS14Update1).

Create a new DkmMCppMethodScope object instance. Location constraint: API must be called from an IDE component (component level > 100,000). This API was introduced in Visual Studio 14 Update 1 (DkmApiVersion.VS14Update1).

[In] The method containing this scope. [In] The module for which this method belongs to. [In] The range of IL offsets within the method for which this scope is valid. [In,Optional] The parent of this scope, null for the root scope of a method. [In] The variables defined within this scope. [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Represents a C++/CLI local variable of static storage duration. Static local variables are backed by an RVA, rather than an IL slot. This API was introduced in Visual Studio 14 Update 1 (DkmApiVersion.VS14Update1).

The address of the static variable, relative to the base address of the variable's module. This API was introduced in Visual Studio 14 Update 1 (DkmApiVersion.VS14Update1).

The type of the variable. Every static local variable is required to have a native type. This API was introduced in Visual Studio 14 Update 1 (DkmApiVersion.VS14Update1).

Create a new DkmMCppStaticLocalVariableSymbol object instance. Location constraint: API must be called from an IDE component (component level > 100,000). This API was introduced in Visual Studio 14 Update 1 (DkmApiVersion.VS14Update1).

[In] The name of the variable. [In] The address of the static variable, relative to the base address of the variable's module. [In] The type of the variable. Every static local variable is required to have a native type. [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Provides information about a C++ exception which was raised in the target process.

Type name of the exception. Example: 'std::exception'.

Address within the target process of the thrown object.

The address where the exception occurred.

[Optional] Extended information about a WinRT exception if it exists.

Create a new DkmCppExceptionInformation object instance.

[In] The DkmRuntimeInstance class represents an execution environment which is loaded into a DkmProcess and which contains code to be debugged. [In] DkmThread represents a thread running in the target process. [In,Optional] Address where the exception occurred. This will always be present for C++ and Win32 exceptions. It may be missing from CLR exceptions or MDAs as these may originate from inside the runtime. [In] The debugger receives notifications from the target process at various stages within exception processing (ex: exception thrown, exception unhandled). This enumeration indicates the stage(s) for a notification. [In,Optional] Information about the underlying exception used to implement a higher level exception. For example, CLR and C++ exceptions may be implemented on top of Win32 exceptions. So this may store the DkmWin32ExceptionInformation for CLR or C++ exceptions. [In] Type name of the exception. Example: 'std::exception'. [In] Address within the target process of the thrown object. [In] The address where the exception occurred. [In,Optional] Extended information about a WinRT exception if it exists. [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Extended information about a CPP exception thrown while debugging a windows runtime application.

Basic non-restricted description of the exception.

Restricted description of the exception.

Reference string used as a key to find restricted information when RestrictedReference is missing.

Security identifier of a missing capability if this exception was thrown for that reason.

The failed HRESULT value that caused this exception to be thrown.

The address of the IErrorInfo object associated with the exception. This is used to retrieve captured stack. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

[Optional] If the exception contains a captured stack trace, specifies the addresses of the captured frames. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

Create a new DkmCppWinRTExceptionInformation object instance.

Create a new DkmCppWinRTExceptionInformation object instance. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

[In] Basic non-restricted description of the exception. [In] Restricted description of the exception. [In] Reference string used as a key to find restricted information when RestrictedReference is missing. [In] Security identifier of a missing capability if this exception was thrown for that reason. [In] The failed HRESULT value that caused this exception to be thrown. [In] The address of the IErrorInfo object associated with the exception. This is used to retrieve captured stack. [In,Optional] If the exception contains a captured stack trace, specifies the addresses of the captured frames. [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Result of an asynchronous DkmNativeModuleInstance.FindExportByOrdinal call.

Creates a new result structure to hold the error from a failed call to DkmNativeModuleInstance.FindExportByOrdinal.

[In] exception object containing the error

HRESULT code returned from the caller. This will be DkmExceptionCode.COR_E_OPERATIONCANCELED (0x8013153B) if the operation was canceled before processing was complete.

[Optional] If the export was found in the specified module, this will contain the target address. Note that this instruction address object may be in a different module than the searched module. This can happen if the export was forwarded and the destination module is already loaded. If the destination module is not loaded, the export will be ignored. This API was introduced in Visual Studio 15 RTM (DkmApiVersion.VS15RTM).

Creates a new result structure to hold the output from a successful call to DkmNativeModuleInstance.FindExportByOrdinal.

[In,Optional] If the export was found in the specified module, this will contain the target address. Note that this instruction address object may be in a different module than the searched module. This can happen if the export was forwarded and the destination module is already loaded. If the destination module is not loaded, the export will be ignored.

Marshal a native struct to managed

Pointer to native struct. Managed object.

Obtain a pointer to the native object used to call into native.

Outgoing managed->native call Native object

Validate the fields of this structure

Struct that holds the field path (ex: "myArgument.StructField")

Result of an asynchronous DkmNativeModuleInstance.FindExportName call.

Creates a new result structure to hold the error from a failed call to DkmNativeModuleInstance.FindExportName.

[In] exception object containing the error

HRESULT code returned from the caller. This will be DkmExceptionCode.COR_E_OPERATIONCANCELED (0x8013153B) if the operation was canceled before processing was complete.

Creates a new result structure to hold the output from a successful call to DkmNativeModuleInstance.FindExportName.

Marshal a native struct to managed

Pointer to native struct. Managed object.

Obtain a pointer to the native object used to call into native.

Outgoing managed->native call Native object

Validate the fields of this structure

Struct that holds the field path (ex: "myArgument.StructField")

Result of an asynchronous DkmNativeInstructionAddress.FindNearestExport call.

Creates a new result structure to hold the error from a failed call to DkmNativeInstructionAddress.FindNearestExport.

[In] exception object containing the error

HRESULT code returned from the caller. This will be DkmExceptionCode.COR_E_OPERATIONCANCELED (0x8013153B) if the operation was canceled before processing was complete.

[Optional] Name of the export.

Byte offset from the start of the export.

Creates a new result structure to hold the output from a successful call to DkmNativeInstructionAddress.FindNearestExport.

[In,Optional] Name of the export. [In] Byte offset from the start of the export.

Marshal a native struct to managed

Pointer to native struct. Managed object.

Obtain a pointer to the native object used to call into native.

Outgoing managed->native call Native object

Validate the fields of this structure

Struct that holds the field path (ex: "myArgument.StructField")

Result of an asynchronous DkmNativeInstructionAddress.IsUserCodeExtended call.

Creates a new result structure to hold the error from a failed call to DkmNativeInstructionAddress.IsUserCodeExtended.

[In] exception object containing the error

HRESULT code returned from the caller. This will be DkmExceptionCode.COR_E_OPERATIONCANCELED (0x8013153B) if the operation was canceled before processing was complete.

True if the provided instruction address is user code. This API was introduced in Visual Studio 15 Update 8 (DkmApiVersion.VS15Update8).

The reason why the code was marked non-user code. This API was introduced in Visual Studio 15 Update 8 (DkmApiVersion.VS15Update8).

Creates a new result structure to hold the output from a successful call to DkmNativeInstructionAddress.IsUserCodeExtended.

[In] True if the provided instruction address is user code. [In] The reason why the code was marked non-user code.

DkmNativeAddressMetadata represents symbol based metadata about addresses. This includes if the address is a thunk, a prolog, or a trampoline.

A value from the DkmNativeAddressType enumeration describing what this address is in the debuggee.

A value from the DkmNativeAddressStepType enumeration describing how the native steppers should tread this address when a step encounters it.

The length of the current address type.

Create a new DkmNativeAddressMetadata object instance.

[In] A value from the DkmNativeAddressType enumeration describing what this address is in the debuggee. [In] A value from the DkmNativeAddressStepType enumeration describing how the native steppers should tread this address when a step encounters it. [In] The length of the current address type. [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

DkmNativeAddressStepType describes how the native range steppers should treat this location. Used during step-in and step-out.

No special treatment for this location.

Stopping at this address does not make sense. Continue stepping past it.

DkmNativeAddressType describes if an address represents a special location in the debuggee instruction stream.

The address has native symbols and is at a normal location.

The address has native symbols but has no source information.

The address represents a thunk in the target process.

The address represents a prolog to a function in the target process.

The address represents a epilog to a function in the target process.

The address represents a trampoline in the target process.

The address represents code telling debugger do not stop and step into for any call.

The address is at the label _NLG_Return or _NLG_Return2.

The address represents a custom location in the debuggee.

The address does not have native symbols.

The address has native symbols but should not be stepped into.

The address represents compiler generated WinRT glue code.

DkmNativeInstructionAddress is used for addresses that resolve to within a native module. This is used regardless as to if there are symbols for the module.

Represents the native code executing in a target process.

The module containing the InstructionPointer.

The RVA of InstructionPointer within Module.

Create a new DkmNativeInstructionAddress object instance.

[In] Represents the native code executing in a target process. [In] The module containing the InstructionPointer. [In] The RVA of InstructionPointer within Module. [In,Optional] CPUInstruction provides the address that the CPU will execute. This is always provided for native instructions. It may be provided for CLR or custom addresses depending on how the address object was created. [Out] Result of this method call.

[Out] Byte offset from the start of the export. [Out,Optional] Name of the export.

Finds the nearest module export from the specified instruction address. The export could either be a function or data export, though function exports are far more common. Because exports do not have address ranges, the specified address may not actually be associated with the returned export. This method will append a new work item to the specified work list, and return once the work item has been appended. The actual processing of the work item is asynchronous. The caller will be notified that the request is complete through the completion routine.

GetSteppingCallSites is called to get call sites reachable from an instruction. Location constraint: API must be called from an IDE component (component level > 100,000).

[In] The stepping ranges to evaluate for call sites. [Out] DkmNativeSteppingCallSite[] specifies a call instruction and it's target..

Determines if a given instruction address is user code or not. This method will append a new work item to the specified work list, and return once the work item has been appended. The actual processing of the work item is asynchronous. The caller will be notified that the request is complete through the completion routine. This API was introduced in Visual Studio 15 Update 8 (DkmApiVersion.VS15Update8).

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

DkmNativeInstructionSymbol represents a native instruction within a module of the target process. DkmNativeInstructionSymbol are 1:1 with the underlying native instructions. So if there are two template instantiations of a method (ex: MyMethod<CString> and MyMethod<int>) if the linker merges the two instantiations into a single function through COMDAT folding then the methods will be identical. If the linker isn't able to merge the two instantiations then both user-level functions will appear as one DkmNativeInstructionSymbol.

The RVA of InstructionPointer within Module.

Create a new DkmNativeInstructionSymbol object instance.

Returns address information to the native debug monitor.

[In,Optional] Abstract representation of an executable code location (ex: EIP value). If resolved, an Instruction Address will be within a particular module instance. An Instruction Address is always within a particular Runtime Instance. [Out,Optional] DkmNativeAddressMetadata represents symbol based metadata about addresses. This includes if the address is a thunk, a prolog, or a trampoline.

[In] Module instance which contains the current instruction symbol. [In,Optional] Instruction where the step began. May be null in unusual situations, such as beginning the step with no frames on the stack. Note that this is not necessarily a native instruction. [In] Indicates to the symbol provider the type of instructions to include in the 'no-step' regions. [In] True if the symbol provider should stop the stepping range when it encounters an inline functions. False otherwise. The Native DM will pass true for a step in so steps will stop in inline functions. It will pass false when doing a step-over so the stepper will not stop in inline functions. [Out] Array of ranges to step through. This array will be empty if there is no source information for the given instruction.

Called by the native DM to fetch data about an instruction which is used to decide how this instruction should be stepped. Location constraint: API must be called from a Monitor component (component level < 100,000). This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

'DkmNativeModuleInstance' is used for modules which contain CPU code and/or are loaded by the Win32 loader.

Represents the native code executing in a target process.

The starting memory address of where the module is loaded. This value should always be valid.

The number of bytes in the module's memory region.

Contains information from the 'Flags' field of the IMAGE_COR20_HEADER of the loaded module. This indicates which type of binary was loaded.

Create a new DkmNativeModuleInstance object instance. This method will send a ModuleInstanceLoad event. Location constraint: API must be called from a Monitor component (component level < 100,000).

[In] Short representation of the module name. For file-based modules, this is the file name and extension (ex: kernel32.dll). [In] Fully qualified module name. For file-based modules, this is the full path to the module (ex: c:\windows\system32\kernel32.dll. [In] Date/Time of when the loaded module was built. This value is obtained from the IMAGE_NT_HEADERS of the loaded module. The unit of measurement is a FILETIME value, which is a 64-bit value representing the number of 100-nanosecond intervals since January 1, 1601 (UTC). [In,Optional] File version information. [In,Optional] Contains information needed to locate symbols for this module. On Win32, this information is contained within the IMAGE_DEBUG_DIRECTORY. [In] Flags which indicate traits of a DkmModuleInstance. [In] Enumeration that indicates how a module is laid out in memory. [In] The integer count of the number of module instances that have loaded up to and including this module. Each runtime instance keeps track of its own load order count. [In] String description of the context under which this module has been loaded. ex: 'Win32' or 'CLR v2.0.50727: Default Domain'. [In] Represents the native code executing in a target process. [In] The starting memory address of where the module is loaded. This value should always be valid. [In] The number of bytes in the module's memory region. [In] Contains information from the 'Flags' field of the IMAGE_COR20_HEADER of the loaded module. This indicates which type of binary was loaded. [In] Indicates if this module instance has been disabled. Disabled modules are largely ignored by the debugger. For native modules, the address range of the disabled module is treated as if it is unmapped. For CLR modules, any frames from these modules is hidden from the call stack. [In,Optional] The symbol handler's representation of a module (DkmModule) which is associated with this module instance. This value is initially null, and is assigned if and when symbols are associated with this module instance. [In,Optional] 'MinidumpInfo' is used to convey additional information about modules in a DkmProcess for a minidump. [In,Optional] Data object to add to the new DkmNativeModuleInstance instance. Pass 'null' in the case that the caller doesn't need to add a data item. [Out] Result of this method call.

Obtain the function table entry for the passed address. The format of the engine is dependent on the debuggee architecture.

[In] The address to search the function table for. Normally, each entry contains a start and an end address. Implementations should return the entry whose address range contains the requested address. [Out] The contents of the function table entry.

Finds the address of the specified named exported function (or data export).

[In] The export name to search for in the module's export table. [In] If true, the implementation will ignore any export which is in non-executable memory. [Out,Optional] If the export was found in the specified module, this will contain the target address. Note that this instruction address object may be in a different module than the searched module. This can happen if the export was forwarded and the destination module is already loaded. If the destination module is not loaded, the export will be ignored.

Finds the address of the specified named exported function (or data export). This method will append a new work item to the specified work list, and return once the work item has been appended. The actual processing of the work item is asynchronous. The caller will be notified that the request is complete through the completion routine.

WorkList to append the new work item to. [In] The export name to search for in the module's export table. [In] If true, the implementation will ignore any export which is in non-executable memory. Routine to fire when the request is complete. If the request is successfully appended to the work list, this will always fire (including when the operation is canceled). This will never fire if appending the work item fails.

Finds the address of the exported function (or data export) specified by the ordinal. This API was introduced in Visual Studio 15 RTM (DkmApiVersion.VS15RTM).

[In] The ordinal number to search for in the module's export table (includes the Ordinal Base). [In] If true, the implementation will ignore any export which is in non-executable memory. [Out,Optional] If the export was found in the specified module, this will contain the target address. Note that this instruction address object may be in a different module than the searched module. This can happen if the export was forwarded and the destination module is already loaded. If the destination module is not loaded, the export will be ignored.

Finds the address of the exported function (or data export) specified by the ordinal. This method will append a new work item to the specified work list, and return once the work item has been appended. The actual processing of the work item is asynchronous. The caller will be notified that the request is complete through the completion routine. This API was introduced in Visual Studio 15 RTM (DkmApiVersion.VS15RTM).

WorkList to append the new work item to. [In] The ordinal number to search for in the module's export table (includes the Ordinal Base). [In] If true, the implementation will ignore any export which is in non-executable memory. Routine to fire when the request is complete. If the request is successfully appended to the work list, this will always fire (including when the operation is canceled). This will never fire if appending the work item fails.

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

The reason why code is marked non-user code. This API was introduced in Visual Studio 15 Update 8 (DkmApiVersion.VS15Update8).

No reason specified.

No symbols are loaded for this module.

No source information is associated with the address.

The function is marked as non-user code.

The file is marked as non-user code.

The module is marked as non-user code.

Represents the native code executing in a target process.

[In] DkmProcess represents a target process which is being debugged. The debugger debugs processes, so this is the basic unit of debugging. A DkmProcess can represent a system process or a virtual process such as minidumps. [In] Identifies a DkmRuntimeInstance object within a process. [In,Optional] Data object to add to the new DkmNativeRuntimeInstance instance. Pass 'null' in the case that the caller doesn't need to add a data item. [Out] Result of this method call.

[In] DkmProcess represents a target process which is being debugged. The debugger debugs processes, so this is the basic unit of debugging. A DkmProcess can represent a system process or a virtual process such as minidumps. [In] Identifies a DkmRuntimeInstance object within a process. [In] Enumeration of runtime capabilities. [In,Optional] For runtimes that are implemented on top of another runtime, this can optionally be used to indicant the logical parent. This can then be used to request services from the parent when the child runtime doesn't implement the service. This is currently used only for obtaining the top stack frame to evaluate a conditional breakpoint when the child runtime doesn't walk stacks itself. [In,Optional] Data object to add to the new DkmNativeRuntimeInstance instance. Pass 'null' in the case that the caller doesn't need to add a data item. [Out] Result of this method call.

Find a DkmNativeModuleInstance element within this DkmNativeRuntimeInstance. If no element with the given input key is present, FindNativeModuleInstance will fail.

[In] Search key used to find the element. [Out,Optional] Result of the search.

GetNativeModuleInstances enumerates the DkmNativeModuleInstance elements of this DkmNativeRuntimeInstance object.

[Out] Array containing the enumerated elements.

Notifies that a data breakpoint has been enabled. Enabling a data breakpoint means that the corresponding address will now be tracked. If the breakpoint is already enabled, this operation has no effect. Location constraint: API must be called from an IDE component (component level > 100,000). This API was introduced in Visual Studio 15 Update 8 (DkmApiVersion.VS15Update8).

[In] Memory address which is now being tracked by the data breakpoint. [In] Size being tracked by the data breakpoint.

Notifies that a data breakpoint has been disabled. Disabling a data breakpoint means that the corresponding address will no longer be tracked. If the breakpoint is already disabled, this operation has no effect. Location constraint: API must be called from an IDE component (component level > 100,000). This API was introduced in Visual Studio 15 Update 8 (DkmApiVersion.VS15Update8).

[In] Memory address which is no longer being tracked by a data breakpoint. [In] Size being tracked by the data breakpoint.

Checks if the specified address range is fully covered by a data breakpoint, and if so returns the address/size of the data breakpoint. In native code, this will return S_FALSE if the data breakpoint isn't found. Location constraint: API must be called from an IDE component (component level > 100,000). This API was introduced in Visual Studio 15 Update 8 (DkmApiVersion.VS15Update8).

[In] Memory address to search for. [In] Size of address range to check for. [Out] The actual address set when the data breakpoint was created. If not found, this will be set to 0. [Out] The actual size set when the data breakpoint was created.

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Provides information about a Win32 exception which was raised in the target process.

The exception flags. This can be either zero to indicate a continuable exception, or EXCEPTION_NONCONTINUABLE to indicate a noncontinuable exception.

Address within the target process where the parent EXCEPTION_RECORD pointer can be found. This is commonly zero.

The address where the exception occurred.

Parameters passed when the exception was raised. These parameters may be passed from the Kernel as part of handling a hardware fault (ex: access violation), or they may be passed from kernel32!RaiseException for software exceptions.

Create a new DkmWin32ExceptionInformation object instance.

[In] The DkmRuntimeInstance class represents an execution environment which is loaded into a DkmProcess and which contains code to be debugged. [In] DkmThread represents a thread running in the target process. [In,Optional] Address where the exception occurred. This will always be present for C++ and Win32 exceptions. It may be missing from CLR exceptions or MDAs as these may originate from inside the runtime. [In] 32-bit integer code for the exception. For Win32 exceptions, this is the code passed to RaiseException (ex:EXCEPTION_ACCESS_VIOLATION). This value is zero for exception categories that identify exceptions by string (ex: CLR). [In] The debugger receives notifications from the target process at various stages within exception processing (ex: exception thrown, exception unhandled). This enumeration indicates the stage(s) for a notification. [In] The exception flags. This can be either zero to indicate a continuable exception, or EXCEPTION_NONCONTINUABLE to indicate a noncontinuable exception. [In] Address within the target process where the parent EXCEPTION_RECORD pointer can be found. This is commonly zero. [In] The address where the exception occurred. [In] Parameters passed when the exception was raised. These parameters may be passed from the Kernel as part of handling a hardware fault (ex: access violation), or they may be passed from kernel32!RaiseException for software exceptions. [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

The result of compiling a native expression. This API was introduced in Visual Studio 14 Update 2 (DkmApiVersion.VS14Update2). Derived classes: DkmCompiledNativeCppTypeExpression, DkmCompiledNativeCppValueExpression

DkmCompiledNativeCppExpression is an abstract base class. This enum indicates which derived class this object is an instance of.

Object is an instance of 'DkmCompiledNativeCppValueExpression'.

Object is an instance of 'DkmCompiledNativeCppTypeExpression'.

DkmCompiledNativeCppExpression is an abstract base class. This enum indicates which derived class this object is an instance of.

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

The result of compiling a type expression. This API was introduced in Visual Studio 14 Update 2 (DkmApiVersion.VS14Update2).

The type represented by the expression text. This API was introduced in Visual Studio 14 Update 2 (DkmApiVersion.VS14Update2).

Create a new DkmCompiledNativeCppTypeExpression object instance. Location constraint: API must be called from an IDE component (component level > 100,000). This API was introduced in Visual Studio 14 Update 2 (DkmApiVersion.VS14Update2).

[In] The type represented by the expression text. [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

The result of compiling a native expression that evaluates to a value. This API was introduced in Visual Studio 14 Update 2 (DkmApiVersion.VS14Update2).

Inspection query use to evaluate the value of the expression. The query does not contain any return instructions, but finishes with the expression value on the top of the stack. This API was introduced in Visual Studio 14 Update 2 (DkmApiVersion.VS14Update2).

The type of the result of the expression. This may or may not be the type of the value returned by the inspection query, depending on the value of QueryResultIsAddress. This API was introduced in Visual Studio 14 Update 2 (DkmApiVersion.VS14Update2).

True if the expression evaluated to an l-value, that is, if the expression can be assigned to. This API was introduced in Visual Studio 14 Update 2 (DkmApiVersion.VS14Update2).

The category of the result of this expression. This API was introduced in Visual Studio 14 Update 2 (DkmApiVersion.VS14Update2).

The access level of the result of this expression. This API was introduced in Visual Studio 14 Update 2 (DkmApiVersion.VS14Update2).

Storage type for the result of this expression. This API was introduced in Visual Studio 14 Update 2 (DkmApiVersion.VS14Update2).

Type modifier flags of the result of this expression. This API was introduced in Visual Studio 14 Update 2 (DkmApiVersion.VS14Update2).

Create a new DkmCompiledNativeCppValueExpression object instance. Location constraint: API must be called from an IDE component (component level > 100,000). This API was introduced in Visual Studio 14 Update 2 (DkmApiVersion.VS14Update2).

[In] Inspection query use to evaluate the value of the expression. The query does not contain any return instructions, but finishes with the expression value on the top of the stack. [In] The type of the result of the expression. This may or may not be the type of the value returned by the inspection query, depending on the value of QueryResultIsAddress. [In] True if the expression evaluated to an l-value, that is, if the expression can be assigned to. [In] The category of the result of this expression. [In] The access level of the result of this expression. [In] Storage type for the result of this expression. [In] Type modifier flags of the result of this expression. [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Represents a C++ array type (e.g. int[5]). This API was introduced in Visual Studio 14 Update 2 (DkmApiVersion.VS14Update2).

Represents a symbol for a C++ type. This API was introduced in Visual Studio 14 Update 2 (DkmApiVersion.VS14Update2).

The number of elements in the array. This API was introduced in Visual Studio 14 Update 2 (DkmApiVersion.VS14Update2).

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

const/volatile qualifiers that can be used on a native C++ type. This API was introduced in Visual Studio 14 Update 2 (DkmApiVersion.VS14Update2).

No const/volatile qualifiers.

C++ 'const' keyword.

C++ 'volatile' keyword.

An error that occurred from DkmNativeCppInspectionSession::CompileExpression(). This API was introduced in Visual Studio 14 Update 2 (DkmApiVersion.VS14Update2).

The reason why a native expression failed to compile. This API was introduced in Visual Studio 14 Update 2 (DkmApiVersion.VS14Update2).

A human-readable error message. This API was introduced in Visual Studio 14 Update 2 (DkmApiVersion.VS14Update2).

Create a new DkmNativeCppCompilationError object instance. Location constraint: API must be called from an IDE component (component level > 100,000). This API was introduced in Visual Studio 14 Update 2 (DkmApiVersion.VS14Update2).

[In] The reason why a native expression failed to compile. [In] A human-readable error message. [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

The reason why a native expression failed to compile. This API was introduced in Visual Studio 14 Update 2 (DkmApiVersion.VS14Update2).

Indicates that the expression referred to a symbol that does not exist.

Indicates that the expression requires side effects, but the inspection context provided does not allow side effects.

Expression compilation failed for reasons that are not covered by this enumeration. The cause of failure can be displayed via the message of the DkmNativeCppCompilationError, but it cannot be programmatically examined.

Represents a C++ enum type. This API was introduced in Visual Studio 14 Update 2 (DkmApiVersion.VS14Update2).

The underlying type of the enumeration. This is always an integer type. This API was introduced in Visual Studio 14 Update 2 (DkmApiVersion.VS14Update2).

Qualified name of this symbol. Qualifiers are separated by "::". The unqualified name always appears at the end of the qualified name. This API was introduced in Visual Studio 14 Update 2 (DkmApiVersion.VS14Update2).

The module of this symbol. This API was introduced in Visual Studio 14 Update 2 (DkmApiVersion.VS14Update2).

The set of values that belong to this enumeration. This API was introduced in Visual Studio 14 Update 2 (DkmApiVersion.VS14Update2).

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

A constant value defined as part of a native C++ enum. This API was introduced in Visual Studio 14 Update 2 (DkmApiVersion.VS14Update2).

The name of this constant. This API was introduced in Visual Studio 14 Update 2 (DkmApiVersion.VS14Update2).

The value of this constant. This API was introduced in Visual Studio 14 Update 2 (DkmApiVersion.VS14Update2).

Create a new DkmNativeCppEnumValue object instance. Location constraint: API must be called from an IDE component (component level > 100,000). This API was introduced in Visual Studio 14 Update 2 (DkmApiVersion.VS14Update2).

[In] The name of this constant. [In] The value of this constant. [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Represents the type of a C++ function. This API was introduced in Visual Studio 14 Update 2 (DkmApiVersion.VS14Update2).

The return type of this function. This API was introduced in Visual Studio 14 Update 2 (DkmApiVersion.VS14Update2).

The types of each argument to the function. For instance member functions, this does not include the 'this' pointer. This API was introduced in Visual Studio 14 Update 2 (DkmApiVersion.VS14Update2).

The calling convention of this function. This API was introduced in Visual Studio 14 Update 2 (DkmApiVersion.VS14Update2).

True if this function contains the "..." specifier, allowing variable arguments at the end of the argument list. This API was introduced in Visual Studio 14 Update 2 (DkmApiVersion.VS14Update2).

[Optional] If this is an instance member function, specifies the type of the 'this' pointer parameter. Otherwise, null. This API was introduced in Visual Studio 14 Update 2 (DkmApiVersion.VS14Update2).

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Represents a context for managing the lifetime of DkmNativeCppType objects. Each type context is tied to a DkmInspectionSession. This API was introduced in Visual Studio 14 Update 2 (DkmApiVersion.VS14Update2).

DkmInspectionSession allows the various components which inspect data to store private data which is associated with a group of evaluations. This API was introduced in Visual Studio 14 Update 2 (DkmApiVersion.VS14Update2).

The unique id of this DkmNativeCppInspectionSession. This API was introduced in Visual Studio 14 Update 2 (DkmApiVersion.VS14Update2).

Create a new DkmNativeCppInspectionSession object instance. This API was introduced in Visual Studio 14 Update 2 (DkmApiVersion.VS14Update2).

[In] DkmInspectionSession allows the various components which inspect data to store private data which is associated with a group of evaluations. [In,Optional] Data object to add to the new DkmNativeCppInspectionSession instance. Pass 'null' in the case that the caller doesn't need to add a data item. [Out] Result of this method call.

Find a DkmNativeCppType element within this DkmNativeCppInspectionSession. If no element with the given input key is present, FindCppType will fail. This API was introduced in Visual Studio 14 Update 2 (DkmApiVersion.VS14Update2).

[In] Search key used to find the element. [Out,Optional] Result of the search.

GetCppTypes enumerates the DkmNativeCppType elements of this DkmNativeCppInspectionSession object. This API was introduced in Visual Studio 14 Update 2 (DkmApiVersion.VS14Update2).

[Out] Array containing the enumerated elements.

Compiles a given expression into native IL. Location constraint: API must be called from an IDE component (component level > 100,000). This API was introduced in Visual Studio 14 Update 2 (DkmApiVersion.VS14Update2).

[In] Flags which effect how an input expression should be parsed, compiled or displayed. [In] The DkmRuntimeInstance class represents an execution environment which is loaded into a DkmProcess and which contains code to be debugged. [In,Optional] Optional type specifying the context in which to evaluate the expression. If non-null, the expression text may use the 'this' pointer to bind to an instance of this type. [In] True if a 'this' pointer is available to evaluate the expression. The generated IL will expect the 'this' pointer to be passed in as the first IL parameter, which will come before any named parameters. The type of the 'this' pointer should be be a pointer to the type indicated in the 'TypeContext' parameter. If no 'this' pointer is available, 'IsThisPointerAvailable' should be set to false. In this case, the resultant IL will not expect a 'this' pointer, but expression will be restricted to global and static members only. 'IsThisPointerAvailable' should always be false whenever 'TypeContext' is NULL. [In] The instruction address at which the resultant query will execute. This may affect the content of the returned inspection query in optimized code debugging scenarios. [In] The expression to compile. [In,Optional] Optional list of named parameters available for use in the expression. [Out,Optional] If the expression failed to compile, specifies the reason for the failure. [Out,Optional] Result of compiling the expression.

Creates a C++ primitive type. Location constraint: API must be called from an IDE component (component level > 100,000). This API was introduced in Visual Studio 14 Update 2 (DkmApiVersion.VS14Update2).

[In] Represents a kind of primitive type in C++. [In] const/volatile qualifiers on this type. [Out] Represents a primitive type.

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Named parameter that may be used in CompileNativeExpression(). This API was introduced in Visual Studio 14 Update 2 (DkmApiVersion.VS14Update2).

The name of this parameter. This name must be a legal C++ identifier, with the exception that '$' is a valid character. Expressions passed to CompileNativeExpression() may use the parameter name to refer to the parameter. In the resultant IL, parameters are read via a DkmILLoad instruction. The first parameter (index 0) is an implicit 'this' pointer, present only if 'TypeContext' is non-null. Named parameter follow immediately after. This API was introduced in Visual Studio 14 Update 2 (DkmApiVersion.VS14Update2).

The type of this parameter. This API was introduced in Visual Studio 14 Update 2 (DkmApiVersion.VS14Update2).

Create a new DkmNativeCppNamedExpressionParameter object instance. Location constraint: API must be called from an IDE component (component level > 100,000). This API was introduced in Visual Studio 14 Update 2 (DkmApiVersion.VS14Update2).

[In] The name of this parameter. This name must be a legal C++ identifier, with the exception that '$' is a valid character. Expressions passed to CompileNativeExpression() may use the parameter name to refer to the parameter. In the resultant IL, parameters are read via a DkmILLoad instruction. The first parameter (index 0) is an implicit 'this' pointer, present only if 'TypeContext' is non-null. Named parameter follow immediately after. [In] The type of this parameter. [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Represents a pointer type (e.g. int*). This API was introduced in Visual Studio 14 Update 2 (DkmApiVersion.VS14Update2).

Represents a symbol for a C++ type. This API was introduced in Visual Studio 14 Update 2 (DkmApiVersion.VS14Update2).

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Represents a primitive type. This API was introduced in Visual Studio 14 Update 2 (DkmApiVersion.VS14Update2).

Represents a kind of primitive type in C++. This API was introduced in Visual Studio 14 Update 2 (DkmApiVersion.VS14Update2).

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Represents a kind of primitive type in C++. This API was introduced in Visual Studio 14 Update 2 (DkmApiVersion.VS14Update2).

Unknown C++ type.

C++ 'char' type.

C++ 'unsigned char' type.

C++ 'short' type.

C++ 'unsigned short' type.

C++ 'int' type.

C++ 'unsigned int' type.

C++ 'long' type.

C++ 'unsigned long' type.

C++ '__int64' type.

C++ 'unsigned __int64' type.

C++ 'bool' type.

C++ 'wchar_t' type.

C++ 'char16_t' type.

C++ 'char32_t' type.

C++ 'float' type.

C++ 'double' type.

C++ 'HRESULT' type.

C++ 'void' type.

Represents a reference type (e.g. int&). This API was introduced in Visual Studio 14 Update 2 (DkmApiVersion.VS14Update2).

Represents a symbol for a C++ type. This API was introduced in Visual Studio 14 Update 2 (DkmApiVersion.VS14Update2).

True if this type represents an r-value reference. False if this type represents an l-value reference. This API was introduced in Visual Studio 14 Update 2 (DkmApiVersion.VS14Update2).

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Represents a symbol for a C++ type. This API was introduced in Visual Studio 14 Update 2 (DkmApiVersion.VS14Update2). Derived classes: DkmNativeCppArrayType, DkmNativeCppEnumType, DkmNativeCppPrimitiveType, DkmNativeCppFunctionType, DkmNativeCppPointerType, DkmNativeCppReferenceType, DkmNativeCppUserDefinedType

DkmNativeCppType is an abstract base class. This enum indicates which derived class this object is an instance of.

Object is an instance of 'DkmNativeCppPrimitiveType'.

Object is an instance of 'DkmNativeCppPointerType'.

Object is an instance of 'DkmNativeCppReferenceType'.

Object is an instance of 'DkmNativeCppArrayType'.

Object is an instance of 'DkmNativeCppEnumType'.

Object is an instance of 'DkmNativeCppUserDefinedType'.

Object is an instance of 'DkmNativeCppFunctionType'.

DkmNativeCppType is an abstract base class. This enum indicates which derived class this object is an instance of.

The inspection session which controls the lifetime of this symbol object. This API was introduced in Visual Studio 14 Update 2 (DkmApiVersion.VS14Update2).

Unique identifier for this type, across all modules loaded in this debug session. This API was introduced in Visual Studio 14 Update 2 (DkmApiVersion.VS14Update2).

The size, in bytes, of an object of this type. This API was introduced in Visual Studio 14 Update 2 (DkmApiVersion.VS14Update2).

const/volatile qualifiers on this type. This API was introduced in Visual Studio 14 Update 2 (DkmApiVersion.VS14Update2).

Obtains a pointer to the IDiaSymbol object, when available, that backs this member. For non-class/struct/union types, a dia symbol may or may not be available, depending on how the type got created. Location constraint: API must be called from an IDE component (component level > 100,000). This API was introduced in Visual Studio 14 Update 2 (DkmApiVersion.VS14Update2).

[Out,Optional] A pointer to the underlying IDiaSymbol object used to represent this member.

Creates a C++ pointer type. Location constraint: API must be called from an IDE component (component level > 100,000). This API was introduced in Visual Studio 14 Update 2 (DkmApiVersion.VS14Update2).

[In] const/volatile qualifiers on this type. [Out] Represents a pointer type (e.g. int*).

[In] True if this type should be an r-value reference, false if this type should be an l-value reference. [In] const/volatile qualifiers on this type. [Out] Represents a reference type (e.g. int&).

Creates a C++ array type. Location constraint: API must be called from an IDE component (component level > 100,000). This API was introduced in Visual Studio 14 Update 2 (DkmApiVersion.VS14Update2).

[In] The number of elements in the array. [In] const/volatile qualifiers on this type. [Out] Represents a C++ array type (e.g. int[5]).

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Represents a C++ class/struct/union. This API was introduced in Visual Studio 14 Update 2 (DkmApiVersion.VS14Update2).

The module of this symbol. This API was introduced in Visual Studio 14 Update 2 (DkmApiVersion.VS14Update2).

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Result of an asynchronous DkmScriptRuntimeInstance.OnScriptCriticalError call.

Creates a new result structure to hold the error from a failed call to DkmScriptRuntimeInstance.OnScriptCriticalError.

[In] exception object containing the error

HRESULT code returned from the caller. This will be DkmExceptionCode.COR_E_OPERATIONCANCELED (0x8013153B) if the operation was canceled before processing was complete.

Provides the content and position of a block of code in a mixed-content document (ex: .aspx file). This can be used to map the block from source to generated document.

Text of the code in the script block.

The text span of this script block.

Create a new DkmScriptBlockMappingInfo object instance.

[In] Text of the code in the script block. [In] The text span of this script block. [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Represents a document which is executing in a script runtime environment. For example, the Microsoft JavaScript engine.

Guid which uniquely identifies this script document folder object.

The symbol container which owns this document.

[Optional] URL of the script document. This may be null if the document has no URL.

[Optional] File path (ex: c:\myfolder\file.js) of the script document. This will be null if the document has no URL, or has a non-'file://' URL.

Flag properties of a script document.

Indicates the content type of the underlying script document. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

Indicates the kind of embedded document (or none if not an embedded document). The type can be eval code, function code, or script block. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

[Optional] The project item which matches this document.

The Just-My-Code state of the document. To update the value of this variable, call DkmScriptDocument.SetJmcState. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

Create a new DkmScriptDocument object instance. This method will send a ScriptDocumentTreeNodeCreate event. Location constraint: API must be called from a Monitor component (component level < 100,000).

[In] The runtime which produced this container. [In,Optional] Parent in the script document tree. This will be null for the root application container. [In] Title of the node. [In] The symbol container which owns this document. [In,Optional] URL of the script document. This may be null if the document has no URL. [In,Optional] File path (ex: c:\myfolder\file.js) of the script document. This will be null if the document has no URL, or has a non-'file://' URL. [In] Flag properties of a script document. [In] Indicates the content type of the underlying script document. [In] Indicates the kind of embedded document (or none if not an embedded document). The type can be eval code, function code, or script block. [In,Optional] The project item which matches this document. [In] The Just-My-Code state of the document. To update the value of this variable, call DkmScriptDocument.SetJmcState. [In,Optional] Data object to add to the new DkmScriptDocument instance. Pass 'null' in the case that the caller doesn't need to add a data item. [Out] Result of this method call.

Provides the current content of the specified document object.

[In] If true, the script document provider should raise events when the content of this document changes. Passing true is equivalent to calling SetRaiseContentEvents(true). If false, the RaiseContentEvent state remains the same. [Out] For aggregate documents (DkmScriptDocumentFlags.AggregateDocument is set), this is the 1-based line numbers for where the section dividers should be drawn. For standard documents, an empty array is returned. [Out] The current content of this document.

[In] If true, content events should be enabled for this document. If false, the count of content event listeners is decremented. When the count reaches zero, no further events will be sent.

This method is called when a script document is created or when the project item path is set to try and bind breakpoints against the given script document. Location constraint: API must be called from an IDE component (component level > 100,000).

[In] Identifies a source file and provides the information which a symbol handler could use to search a symbol file (PDB) for information on this source file. [Out,Optional] If the given script document matches the given source file id, this returns a DkmResolvedDocument for the match. Otherwise, null is returned.

[In] If true, symbol events should be enabled for this document. If false, the count of symbol event listeners is decremented. When the count reaches zero, no further events will be sent.

Enables or disables raising ScriptSymbolsUpdated when symbols in the document are changed. By default, documents do not generate symbol events. So this method should be called by any component that wishes to receive symbol events. The script document manager maintains a count of the number of calls to enable symbol events, and will raise events whenever this count is greater than 0. Callers should take care to ensure that SetRaiseSymbolEvents(false) is called ONLY after a successful call to SetRaiseSymbolEvents(true). Symbol events are automatically disabled when the document is unloaded. This method will append a new work item to the specified work list, and return once the work item has been appended. The actual processing of the work item is asynchronous. The caller will be notified that the request is complete through the completion routine.

WorkList to append the new work item to. [In] If true, symbol events should be enabled for this document. If false, the count of symbol event listeners is decremented. When the count reaches zero, no further events will be sent. Routine to fire when the request is complete. If the request is successfully appended to the work list, this will always fire (including when the operation is canceled). This will never fire if appending the work item fails.

Queries the language service (IVsLanguageDebugInfoScript) to obtain script block information from the associated project item of the specified script document. Location constraint: API must be called from an IDE component (component level > 100,000).

[Out] Set of script blocks returned from the language service.

Raises a ScriptDocumentContentInsert event. The script document provider will only raise this event if events have been enabled for this document. This method may only be called by the component which created the object.

[In] The text span of the inserted text. For aggregate documents (DkmScriptDocumentFlags.AggregateDocument is set), this must start on a new line, and at at the end of a line immediately before a new section would begin. [In] The new text content which is inserted into the document.

Raises a ScriptDocumentContentRemove event. The script document provider will only raise this event if events have been enabled for this document. This method may only be called by the component which created the object.

[In] The text span of the removed text. For aggregate documents (DkmScriptDocumentFlags.AggregateDocument is set), this must start at the begging of a line, and correspond to a previously added section. [In] Number of characters within the section to remove.

Sets the JMC state for the script document. If the value is "Unsure", the script debug monitor can make its own determination of the JMC state or ask a project system for the JMC state. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

[In] The Just-My-Code state of the document exposed via the DkmScriptDocument.JmcState variable. The JMC state of the document is ignored if JMC is not enabled and all documents are treated as user code.

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Indicates the content type of the underlying script document. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

Document kind could not be determined.

Document is JavaScript.

Document is HTML.

Flag properties of a script document.

No flags are set.

Document represents a container which aggregated together many sub-documents. For JavaScript, this is use for 'eval code' and 'Function code' documents.

The Just-My-Code state of the document exposed via the DkmScriptDocument.JmcState variable. The JMC state of the document is ignored if JMC is not enabled and all documents are treated as user code. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

The project system and/or runtime engine does not know whether the script document is user code. Unsure means the engine will continuing querying the rest of the project systems until one of them returns something other than Unsure. If all project systems return Unsure, the script will be treated by the engine as though it is user code (see MyCode state).

The script document is user code and should not be hidden from the user in any way. All script documents behave as MyCode when JMC is not enabled.

The script document is library code. Unhandled exceptions and first chance exceptions where the call stack contains user code are exposed to the user. Step operations bypass the non-user code unless the step originates in non-user code. Stack frames in library code are collapsed to [External Code].

The script document is unrelated to any user code. Unhandled exceptions and first chance exceptions are not visible to the user. Embedded script breakpoints are also not visible to the user.

Represents a node in the 'Script Documents' virtual tree within solution explorer. Nodes may either be a virtual container, or they can be a document. In the latter case, they will be a DkmScriptDocument. Derived classes: DkmScriptDocument

The runtime which produced this container.

[Optional] Parent in the script document tree. This will be null for the root application container.

Guid which uniquely identifies this script document folder object.

Title of the node.

Create a new DkmScriptDocumentTreeNode object instance. This method will send a ScriptDocumentTreeNodeCreate event. Location constraint: API must be called from a Monitor component (component level < 100,000).

[In] The runtime which produced this container. [In,Optional] Parent in the script document tree. This will be null for the root application container. [In] Title of the node. [In,Optional] Data object to add to the new DkmScriptDocumentTreeNode instance. Pass 'null' in the case that the caller doesn't need to add a data item. [Out] Result of this method call.

Invoked by a script document provide to fire a ScriptDocumentTreeNodeUnload event. This method may only be called by the component which created the object.

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

This is not an embedded script document.

Document is eval code.

Document is function code.

Document is a script block.

DkmScriptInstructionAddress is used to represent an executable statement in a script-based runtime environment such the Microsoft JavaScript engine.

Represents a script-based execution environment executing in a target process.

Document containing this instruction.

Indicates the revision number which inserted the statement represented by this object. Typically, this will be zero for non-dynamic documents.

Indicates the starting character index of this statement, relative to the start of revision which inserted this statement.

Length of the statement (in characters).

[Optional] Additional runtime-specific data associated with an address. This data will not be used when comparing addresses.

Create a new DkmScriptInstructionAddress object instance.

[In,Optional] The module containing this address. Addresses without a module cannot have symbols (even for custom addresses). CLR addresses will always have a module. Native addresses will not have a module if either the CPU jumped to an invalid address (ex: NULL), or if the CPU is executing dynamically-emitted code. [In] Represents a script-based execution environment executing in a target process. [In] Document containing this instruction. [In] Indicates the revision number which inserted the statement represented by this object. Typically, this will be zero for non-dynamic documents. [In] Indicates the starting character index of this statement, relative to the start of revision which inserted this statement. [In] Length of the statement (in characters). [In,Optional] Additional runtime-specific data associated with an address. This data will not be used when comparing addresses. [In,Optional] CPUInstruction provides the address that the CPU will execute. This is always provided for native instructions. It may be provided for CLR or custom addresses depending on how the address object was created. [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

DkmScriptInstructionSymbol is used to represent an executable statement in a script-based runtime environment such the Microsoft JavaScript engine.

Document containing this instruction.

Indicates the revision number which inserted the statement represented by this object. Typically, this will be zero for non-dynamic documents.

Indicates the starting character index of this statement, relative to the start of revision which inserted this statement.

Length of the statement (in characters).

[Optional] Additional runtime-specific data associated with an address. This data will not be used when comparing addresses.

Create a new DkmScriptInstructionSymbol object instance.

[In] The DkmModule class represents a code bundle (ex: dll or exe) which is or once was loaded into one or more processes. The DkmModule class is the central object to the symbol APIs, and is 1:1 with the symbol handler's notation of what is loaded. If a code bundle loads into three different processes (or the same process but with three different base addresses or three different app domains) but the symbol handler thinks of all of these as being identical, there will be only one module object. [In] The Runtime Id identifies the execution environment for a particular piece of code. Runtime Ids are used by the dispatcher to decide which monitor to dispatch to. Note that the ordering of the runtime ID Guids is somewhat significant as this dictates which runtime gets the first shot during arbitration. Thus, if one wants to declare a new runtime instance which is built on the CLR, the runtime id should be less than DkmRuntimeId.Clr. [In] Document containing this instruction. [In] Indicates the revision number which inserted the statement represented by this object. Typically, this will be zero for non-dynamic documents. [In] Indicates the starting character index of this statement, relative to the start of revision which inserted this statement. [In] Length of the statement (in characters). [In,Optional] Additional runtime-specific data associated with an address. This data will not be used when comparing addresses. [Out] Result of this method call.

Call back implemented by the script symbol provider to tell the script debug monitor what to do next when stepping. Location constraint: API must be called from a Monitor component (component level < 100,000).

[In,Optional] The instruction symbol of the process at the time this step started. This will be NULL if the step originated on a thread with no frames. [In] true if the step is by line (instead of by statement). [Out] Enum value indicating the next action that the script dm should perform. NotImplementedException/E_NOTIMPL indicates that no symbol provider is available for the script symbol.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Represents a script-based execution environment executing in a target process.

Index indicating the relative load order of this script runtime instance to other script runtime instances within the target process. The first runtime instance to load will be given an index of zero.

A flag indicating whether the current loaded dll is EdgeHtml.dll or not. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

File version of the script host dll. This will be 0 if it cannot be obtained. The top 16 bits are the major version, followed by 16 bits for the minor version, followed by 16 bits for the build number followed by 16 bits for the build revision. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

[In] DkmProcess represents a target process which is being debugged. The debugger debugs processes, so this is the basic unit of debugging. A DkmProcess can represent a system process or a virtual process such as minidumps. [In] Identifies a DkmRuntimeInstance object within a process. [In] Index indicating the relative load order of this script runtime instance to other script runtime instances within the target process. The first runtime instance to load will be given an index of zero. [In,Optional] Data object to add to the new DkmScriptRuntimeInstance instance. Pass 'null' in the case that the caller doesn't need to add a data item. [Out] Result of this method call.

[In] DkmProcess represents a target process which is being debugged. The debugger debugs processes, so this is the basic unit of debugging. A DkmProcess can represent a system process or a virtual process such as minidumps. [In] Identifies a DkmRuntimeInstance object within a process. [In] Enumeration of runtime capabilities. [In,Optional] For runtimes that are implemented on top of another runtime, this can optionally be used to indicant the logical parent. This can then be used to request services from the parent when the child runtime doesn't implement the service. This is currently used only for obtaining the top stack frame to evaluate a conditional breakpoint when the child runtime doesn't walk stacks itself. [In] Index indicating the relative load order of this script runtime instance to other script runtime instances within the target process. The first runtime instance to load will be given an index of zero. [In,Optional] Data object to add to the new DkmScriptRuntimeInstance instance. Pass 'null' in the case that the caller doesn't need to add a data item. [Out] Result of this method call.

[In] DkmProcess represents a target process which is being debugged. The debugger debugs processes, so this is the basic unit of debugging. A DkmProcess can represent a system process or a virtual process such as minidumps. [In] Identifies a DkmRuntimeInstance object within a process. [In] Enumeration of runtime capabilities. [In,Optional] For runtimes that are implemented on top of another runtime, this can optionally be used to indicant the logical parent. This can then be used to request services from the parent when the child runtime doesn't implement the service. This is currently used only for obtaining the top stack frame to evaluate a conditional breakpoint when the child runtime doesn't walk stacks itself. [In] Index indicating the relative load order of this script runtime instance to other script runtime instances within the target process. The first runtime instance to load will be given an index of zero. [In] A flag indicating whether the current loaded dll is EdgeHtml.dll or not. [In] File version of the script host dll. This will be 0 if it cannot be obtained. The top 16 bits are the major version, followed by 16 bits for the minor version, followed by 16 bits for the build number followed by 16 bits for the build revision. [In,Optional] Data object to add to the new DkmScriptRuntimeInstance instance. Pass 'null' in the case that the caller doesn't need to add a data item. [Out] Result of this method call.

[Out] Debug application interface from the debugged process.

Provides notification to the user that a critical error has happened in the target process. This method will complete once the critical error UI has been dismissed. This method will append a new work item to the specified work list, and return once the work item has been appended. The actual processing of the work item is asynchronous. The caller will be notified that the request is complete through the completion routine. Location constraint: API must be called from a Monitor component (component level < 100,000).

WorkList to append the new work item to. [In] Specifies to the web developer what aspect of their page the issue pertains to. Ex: "HTML", "DOM", "SCRIPT", etc. [In] Indicates an error code. Source + MessageId should uniquely identify the message so that information about the error can be found in help. [In] Message to display to users. [In,Optional] When known, the script instruction address where the error occurred. [In,Optional] When InstructionAddress is non-null, this contains the current source position of this instruction. Routine to fire when the request is complete. If the request is successfully appended to the work list, this will always fire (including when the operation is canceled). This will never fire if appending the work item fails.

Raises the notification that one or more script documents have been updated.

[In] Set of documents which have been updated.

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

The source project system item for a script document.

Moniker of the project item returned from MapDeployedURLToProjectItem. Project systems can plug into this through IsDocumentInProject.

True if the script document is expected to be a generated client-side document, so the project item cannot be directly mapped.

Create a new DkmScriptSourceProjectItem object instance.

[In] Moniker of the project item returned from MapDeployedURLToProjectItem. Project systems can plug into this through IsDocumentInProject. [In] True if the script document is expected to be a generated client-side document, so the project item cannot be directly mapped. [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Value returned from IDkmScriptSymbolCallback.GetNextSteppingAction which indicates the next action that the script DM should take.

Step has landed at non-hidden code which maps to the same statement/line (depending on the IsSteppingByLine value) as where the step was originated.

Step completed at a hidden statement, or at a statement which is still part of the same statement/line (depending on the IsSteppingByLine value) as the StartingInstruction. The debug monitor should step again. If it is a performing a step into, the debug monitor should resume with a step into. Otherwise a step over should be performed.

Step completed at a hidden statement, or at a statement which is still part of the same statement/line (depending on the IsSteppingByLine value) as the StartingInstruction. The debug monitor should step again with a step over (even if the original operation was a step into).

Step completed in a hidden method, or the remainder of the method is hidden code. The debug monitor should step out of the method.

Result of an asynchronous DkmScriptDocument.SetRaiseSymbolEvents call.

Creates a new result structure to hold the error from a failed call to DkmScriptDocument.SetRaiseSymbolEvents.

[In] exception object containing the error

HRESULT code returned from the caller. This will be DkmExceptionCode.COR_E_OPERATIONCANCELED (0x8013153B) if the operation was canceled before processing was complete.

The model type that a compute kernel uses.

Compute kernel uses flat model.

Compute kernel uses tile model.

Compute kernel uses three-dimensional HLSL model.

Collection of properties of GPU compute kernel.

Property Name.

Property value.

Initialize a new DkmComputeProperty value.

[In] Property Name. [In] Property value.

Marshal a native struct to managed

Pointer to native struct. Managed object.

Obtain a pointer to the native object used to call into native.

Outgoing managed->native call Native object

Validate the fields of this structure

Struct that holds the field path (ex: "myArgument.StructField")

Collection of properties of GPU compute threads.

The number of threads represented by this object, could be greater than one if returned in a group by call.

Vector index.

Thread group ID, unique to kernel.

Thread ID, unique to kernel.

The IP of the compute thread.

State of the compute thread.

Flagged state of the compute thread.

Frozen state of the compute thread.

Initialize a new DkmComputeThreadInfo value.

[In] The number of threads represented by this object, could be greater than one if returned in a group by call. [In] Vector index. [In] Thread group ID, unique to kernel. [In] Thread ID, unique to kernel. [In] The IP of the compute thread. [In] State of the compute thread. [In] Flagged state of the compute thread. [In] Frozen state of the compute thread.

Compute thread state flags.

Not a valid compute thread state.

Compute thread is active.

Compute thread is divergent.

Compute thread is blocked.

Compute thread is unused.

Compute thread is not started.

Compute thread is completed.

DkmGPUAddressType describes if an address represents a special location in the GPU debuggee's byte code.

No type flat is set.

The address is at the inline function call site, that is, the instruction just before inline function.

The address has symbols but should not be stepped into.

Flags for describing GPU breakpoint behavior.

No specific behavior.

Break once per warp.

Break for every thread.

Break on first or default warp.

DkmGPUComputeKernel represents a GPU compute kernel running in the target process.

The GPU dispatch id for this kernel object.

The GPU device this compute kernel runs on.

A compute kernel is a running instance of this GPU shader.

The handle of the executing GPU shader corresponding to this compute kernel.

Thread group dimensions in a compute kernel.

Number of thread groups in a compute kernel.

Thread dimensions in a compute kernel.

Number of compute threads in a thread group of compute kernel.

Guid which uniquely identifies this compute kernel object.

DkmGPUComputeKernel is called by a debug monitor to create a new DkmGPUComputeKernel instance. DkmGPUComputeKernel objects for GPU compute kernels are created by the base debug monitor. Location constraint: API must be called from a Monitor component (component level < 100,000).

[In] The GPU dispatch id for this kernel object. [In] The GPU device this compute kernel runs on. [In] A compute kernel is a running instance of this GPU shader. [In] The handle of the executing GPU shader corresponding to this compute kernel. [In] Thread group dimensions in a compute kernel. [In] Number of thread groups in a compute kernel. [In] Thread dimensions in a compute kernel. [In] Number of compute threads in a thread group of compute kernel. [In] DkmProcess represents a target process which is being debugged. The debugger debugs processes, so this is the basic unit of debugging. A DkmProcess can represent a system process or a virtual process such as minidumps. [In,Optional] Data object to add to the new DkmGPUComputeKernel instance. Pass 'null' in the case that the caller doesn't need to add a data item. [Out] Result of this method call.

ComputeKernelExit is sent by the dispatcher when DkmGPUComputeKernel::Unload is invoked by the monitor. This method may only be called by the component which created the object.

[In] 32-bit value that the compute kernel returned on exit.

Find a DkmGPUComputeThread element within this DkmGPUComputeKernel. If no element with the given input key is present, FindComputeThread will fail.

[In] Search key used to find the element. [Out,Optional] Result of the search.

Obtain the warp size of the hardware or emulator.

[Out] Width of the hardware.

Obtain the active thread groups from the compute kernel.

[Out] List of global Thread group id of all active thread groups. [Out] Number of active thread groups in the compute kernel.

Get the dimension of the thread block.

[Out] Thread group dimensions. [Out] Number of Thread block dimensions.

Get the dimension of the thread block.

[Out] Grid Dimensions. [Out] Number of Grid dimensions.

Get the name of compute kernel.

[Out] Name of the ComputeKernel that is launched.

Get properties of the compute kernel.

[Out] List of Compute kernel properties. [Out] Number of properties in the compute kernel.

Runs the select query on thread info objects.

[In] From clause specification for selection (can be empty to select from all available threads). [In] Where clause specification for selection. [Out] The result set of compute thread info objects.

Runs the group by query on thread info objects.

[In] Flags specifying on which columns the group by is run. [In] From clause specification for selection (can be empty to select from all available threads). [In] Where clause specification for group by. [Out] The result set of compute thread info objects.

Get all threads that hit breakpoint.

[Out] The result set of compute thread ids that hit breakpoint.

Gets the DkmGPUComputeThread object for a given thread ID.

[In] ID of the thread to return. [Out] Thread object that matches the given thread ID.

Update flagged state of compute threads.

[In] Where clause specification for update. [In] The value to update with.

Update frozen state of compute threads.

[In] Where clause specification for update. [In] The value to update with.

Get the dimension of the thread block.

[Out] Thread group dimensions. [Out] Thread group dimensions. [Out] Number of Thread block dimensions. [Out] Model Type.

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

DkmGPUComputeThread represents a compute thread running in the GPU target process.

Unique to kernel compute thread index.

DkmGPUComputeKernel represents a GPU compute kernel running in the target process.

[Optional] The native thread on which an exception is raised to notify the debugger that a GPU debug event is available. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

Create a new DkmGPUComputeThread object instance. Location constraint: API must be called from a Monitor component (component level < 100,000).

[In] DkmProcess represents a target process which is being debugged. The debugger debugs processes, so this is the basic unit of debugging. A DkmProcess can represent a system process or a virtual process such as minidumps. [In] If available, this is the Win32 start address of this thread (value passed to the CreateThread API). The value will not always be available, for example, it is generally not available in scenarios where the thread was started after the debugger attached, or in minidumps. [In] True if this is the main thread of this process. The main thread is the first thread to start. [In] Unique to kernel compute thread index. [In] DkmGPUComputeKernel represents a GPU compute kernel running in the target process. [In,Optional] Describes traits of the thread which are relevant to a full Win32 thread. Currently, this value is required, and all threads will have a 'System' block. In the future, this value may be NULL if the DkmThread represents something other than a full Win32 thread. [In,Optional] Data object to add to the new DkmGPUComputeThread instance. Pass 'null' in the case that the caller doesn't need to add a data item. [Out] Result of this method call.

Create a new DkmGPUComputeThread object instance. Location constraint: API must be called from a Monitor component (component level < 100,000). This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

[In] DkmProcess represents a target process which is being debugged. The debugger debugs processes, so this is the basic unit of debugging. A DkmProcess can represent a system process or a virtual process such as minidumps. [In] If available, this is the Win32 start address of this thread (value passed to the CreateThread API). The value will not always be available, for example, it is generally not available in scenarios where the thread was started after the debugger attached, or in minidumps. [In] True if this is the main thread of this process. The main thread is the first thread to start. [In] Unique to kernel compute thread index. [In] DkmGPUComputeKernel represents a GPU compute kernel running in the target process. [In,Optional] The native thread on which an exception is raised to notify the debugger that a GPU debug event is available. [In,Optional] Describes traits of the thread which are relevant to a full Win32 thread. Currently, this value is required, and all threads will have a 'System' block. In the future, this value may be NULL if the DkmThread represents something other than a full Win32 thread. [In,Optional] Data object to add to the new DkmGPUComputeThread instance. Pass 'null' in the case that the caller doesn't need to add a data item. [Out] Result of this method call.

Get the dimension of the thread block.

[Out] Thread group dimensions. [Out] Number of Thread block dimensions.

Get the dimension of the thread block.

[Out] Grid dimensions. [Out] Number of Grid dimensions.

Get the dimension of the thread block.

[Out] Thread group dimensions. [Out] Number of Thread block dimensions.

Get the dimension of the thread block.

[Out] Grid dimensions. [Out] Number of Grid dimensions.

Read the memory of the target GPU process. The method is on DkmGPUComputeThread because it may read thread local memory, group shared memory or global memory.

[In] The address from which to read the target GPU process's memory. [In] The instruction pointer where to resolve address to register location. [In] Flags controlling the behavior of DkmProcess.ReadMemory and DkmProcess.ReadMemoryString. [In,Out] A buffer that receives the contents from the address space of the target process. On failure, the content of this buffer is unspecified. [In] The number of bytes to be read from the process. In scenarios where the call is marshalled to the remote debugger from the IDE, this must be less than 25 MBs. [Out] Indicates the number of bytes read from the target GPU process. If DkmReadMemoryFlags.AllowPartialRead is clear, on success this value will always be exactly equal to the input size. If DkmReadMemoryFlags.AllowPartialRead is specified, on success, this value will be greater than zero.

Read the memory of the target GPU process. The method is on DkmGPUComputeThread because it may read thread local memory, group shared memory or global memory.

[In] The address from which to read the target GPU process's memory. [In] The instruction pointer where to resolve address to register location. [In] Flags controlling the behavior of DkmProcess.ReadMemory and DkmProcess.ReadMemoryString. [In,Out] A buffer that receives the contents from the address space of the target process. On failure, the content of this buffer is unspecified. [Out] Indicates the number of bytes read from the target GPU process. If DkmReadMemoryFlags.AllowPartialRead is clear, on success this value will always be exactly equal to the input size. If DkmReadMemoryFlags.AllowPartialRead is specified, on success, this value will be greater than zero.

Writes memory to the target GPU process. The method is on DkmGPUComputeThread because it may write thread local memory, group shared memory or global memory.

[In] The base address from which to write the target GPU process's memory. [In] The instruction pointer where to resolve address to register location. [In] Data to be written in the address space of the specified GPU process.

Checks if a tag for a buffer has been forwarded for this kernel execution.

[In] The C++ AMP pointer tag. [Out] The forwarded tag value.

Validate the specified GPU memory address.

[In] The address to validate. [Out] True if the specified address is a valid GPU memory address, false otherwise.

Obtain the list of all register descriptions from the GPU compute thread.

[Out] The list of all register descriptions from the GPU compute thread.

Set the value of a register in the GPU compute thread.

[In] The description of a register from the GPU compute thread. [In] The value bytes of a register to be written in the GPU compute thread.

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Represents an address in GPU data. The high 32-bit in Value is tag and the low 32-bit in Value is offset.

DkmGPUComputeThread represents a compute thread running in the GPU target process.

GPU data address may correspond to different register location at different instruction pointer.

Create a new DkmGPUDataAddress object instance.

[In] The DkmRuntimeInstance class represents an execution environment which is loaded into a DkmProcess and which contains code to be debugged. [In] Data address. [In,Optional] Set when the data address is an instruction address. [In] DkmGPUComputeThread represents a compute thread running in the GPU target process. [In] GPU data address may correspond to different register location at different instruction pointer. [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Provides information about a GPU memory access exception which was raised in the target process.

The address of the conflicting instruction.

The global id of the conflicting thread.

Create a new DkmGPUMemoryAccessExceptionInformation object instance.

[In] The DkmRuntimeInstance class represents an execution environment which is loaded into a DkmProcess and which contains code to be debugged. [In] DkmThread represents a thread running in the target process. [In,Optional] Address where the exception occurred. This will always be present for C++ and Win32 exceptions. It may be missing from CLR exceptions or MDAs as these may originate from inside the runtime. [In,Optional] Name of the exception. For C++ or CLR exceptions, this is the type name. This value will be null for exception categories that identify exceptions by code (ex: Win32). [In] 32-bit integer code for the exception. For Win32 exceptions, this is the code passed to RaiseException (ex:EXCEPTION_ACCESS_VIOLATION). This value is zero for exception categories that identify exceptions by string (ex: CLR). [In] The debugger receives notifications from the target process at various stages within exception processing (ex: exception thrown, exception unhandled). This enumeration indicates the stage(s) for a notification. [In] The address of the conflicting instruction. [In] The global id of the conflicting thread. [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

The description of GPU registers for a GPU compute thread.

The GPU register type.

The index of a GPU register.

The size of a GPU register in bytes.

The value bytes of a GPU register. This is normally 16 bytes.

Initialize a new DkmGPURegisterDescription value.

[In] The GPU register type. [In] The index of a GPU register. [In] The size of a GPU register in bytes. [In] The value bytes of a GPU register. This is normally 16 bytes.

Marshal a native struct to managed

Pointer to native struct. Managed object.

Obtain a pointer to the native object used to call into native.

Outgoing managed->native call Native object

Validate the fields of this structure

Struct that holds the field path (ex: "myArgument.StructField")

Indicates which parts of a thread or group ID should be used.

The X portion of the id vector.

The Y portion of the id vector.

The Z portion of the id vector.

Options for how to query compute thread info.

No query option flags are set.

Do the query by ThreadGroupId.

Do the query by VectorId.

Do the query by ThreadId.

Do the query by ThreadState.

Do the query by FlagState.

Do the query by InstructionPointer.

Do the query by FrozenState.

A structure used as a where clause when querying compute thread info.

Flags specifying columns in a where clause.

Values of the columns specified in ColumnFlags.

Initialize a new DkmWhereClause value.

[In] Flags specifying columns in a where clause. [In] Values of the columns specified in ColumnFlags.

Provides information about an exception which was raised in the target process. Custom exceptions are used for C++ Runtime checks, Managed Debugging Assistant failures, and exceptions from 3rd party runtimes.

[Optional] Additional data about this custom exception. Format is defined by the custom exception type.

Create a new DkmCustomExceptionInformation object instance.

[In] The DkmRuntimeInstance class represents an execution environment which is loaded into a DkmProcess and which contains code to be debugged. [In] Indicates the type of exception. [In] DkmThread represents a thread running in the target process. [In,Optional] Address where the exception occurred. This will always be present for C++ and Win32 exceptions. It may be missing from CLR exceptions or MDAs as these may originate from inside the runtime. [In,Optional] Name of the exception. For C++ or CLR exceptions, this is the type name. This value will be null for exception categories that identify exceptions by code (ex: Win32). [In] 32-bit integer code for the exception. For Win32 exceptions, this is the code passed to RaiseException (ex:EXCEPTION_ACCESS_VIOLATION). This value is zero for exception categories that identify exceptions by string (ex: CLR). [In] The debugger receives notifications from the target process at various stages within exception processing (ex: exception thrown, exception unhandled). This enumeration indicates the stage(s) for a notification. [In,Optional] Information about the underlying exception used to implement a higher level exception. For example, CLR and C++ exceptions may be implemented on top of Win32 exceptions. So this may store the DkmWin32ExceptionInformation for CLR or C++ exceptions. [In,Optional] Additional data about this custom exception. Format is defined by the custom exception type. [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

DkmCustomInstructionAddress is used for addresses from a custom runtime environment (not native or CLR-based). For example, this could be used in a custom interpreter or Just-In-Time compiler.

The module containing the InstructionPointer.

[Optional] This is a runtime-specific data structure which custom runtimes may use to store the location of this instruction. Along with 'offset', this field will used to compare two instructions from the same module.

Along with 'EntityId' the 'Offset' field is used to uniquely identity an instruction. This could hold a pointer value (such as a pointer to the instruction) or an offset from the start of the function/module.

[Optional] Additional runtime-specific data associated with an address. This data will not be used when comparing addresses.

Create a new DkmCustomInstructionAddress object instance.

[In] The DkmRuntimeInstance class represents an execution environment which is loaded into a DkmProcess and which contains code to be debugged. [In] The module containing the InstructionPointer. [In,Optional] This is a runtime-specific data structure which custom runtimes may use to store the location of this instruction. Along with 'offset', this field will used to compare two instructions from the same module. [In] Along with 'EntityId' the 'Offset' field is used to uniquely identity an instruction. This could hold a pointer value (such as a pointer to the instruction) or an offset from the start of the function/module. [In,Optional] Additional runtime-specific data associated with an address. This data will not be used when comparing addresses. [In,Optional] CPUInstruction provides the address that the CPU will execute. This is always provided for native instructions. It may be provided for CLR or custom addresses depending on how the address object was created. [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

DkmCustomInstructionSymbol is used to represent an executable statement in any type of custom runtime environment.

[Optional] Additional runtime-specific data associated with an address. This data will not be used when comparing addresses.

Create a new DkmCustomInstructionSymbol object instance.

[In] The DkmModule class represents a code bundle (ex: dll or exe) which is or once was loaded into one or more processes. The DkmModule class is the central object to the symbol APIs, and is 1:1 with the symbol handler's notation of what is loaded. If a code bundle loads into three different processes (or the same process but with three different base addresses or three different app domains) but the symbol handler thinks of all of these as being identical, there will be only one module object. [In] The Runtime Id identifies the execution environment for a particular piece of code. Runtime Ids are used by the dispatcher to decide which monitor to dispatch to. Note that the ordering of the runtime ID Guids is somewhat significant as this dictates which runtime gets the first shot during arbitration. Thus, if one wants to declare a new runtime instance which is built on the CLR, the runtime id should be less than DkmRuntimeId.Clr. [In,Optional] This is a runtime-specific data structure which custom runtimes may use to store the location of this instruction. Along with 'offset', this field will used to compare two instructions from the same module. [In] Along with 'EntityId' the 'Offset' field is used to uniquely identity an instruction. This could hold a pointer value (such as a pointer to the instruction) or an offset from the start of the function/module. [In,Optional] Additional runtime-specific data associated with an address. This data will not be used when comparing addresses. [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

'DkmCustomModuleInstance' is used for modules from a custom runtime environment (not native or CLR-based). For example, this could be used in a custom interpreter or Just-In-Time compiler.

Create a new DkmCustomModuleInstance object instance. This method will send a ModuleInstanceLoad event. Location constraint: API must be called from a Monitor component (component level < 100,000).

[In] Short representation of the module name. For file-based modules, this is the file name and extension (ex: kernel32.dll). [In] Fully qualified module name. For file-based modules, this is the full path to the module (ex: c:\windows\system32\kernel32.dll. [In] Date/Time of when the loaded module was built. This value is obtained from the IMAGE_NT_HEADERS of the loaded module. The unit of measurement is a FILETIME value, which is a 64-bit value representing the number of 100-nanosecond intervals since January 1, 1601 (UTC). [In] The DkmRuntimeInstance class represents an execution environment which is loaded into a DkmProcess and which contains code to be debugged. [In,Optional] File version information. [In,Optional] Contains information needed to locate symbols for this module. On Win32, this information is contained within the IMAGE_DEBUG_DIRECTORY. [In] Flags which indicate traits of a DkmModuleInstance. [In] Enumeration that indicates how a module is laid out in memory. [In,Optional] The starting memory address of where the module loaded. This value will be zero if the module did not load in a contiguous block of memory. [In] The integer count of the number of module instances that have loaded up to and including this module. Each runtime instance keeps track of its own load order count. [In,Optional] The number of bytes in the module's memory region. This value will be zero if the module did not load in a contiguous block of memory. [In] String description of the context under which this module has been loaded. ex: 'Win32' or 'CLR v2.0.50727: Default Domain'. [In] Indicates if this module instance has been disabled. Disabled modules are largely ignored by the debugger. For native modules, the address range of the disabled module is treated as if it is unmapped. For CLR modules, any frames from these modules is hidden from the call stack. [In,Optional] The symbol handler's representation of a module (DkmModule) which is associated with this module instance. This value is initially null, and is assigned if and when symbols are associated with this module instance. [In,Optional] 'MinidumpInfo' is used to convey additional information about modules in a DkmProcess for a minidump. [In,Optional] Data object to add to the new DkmCustomModuleInstance instance. Pass 'null' in the case that the caller doesn't need to add a data item. [Out] Result of this method call.

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Represents the custom execution environment executing in the target process.

[In] DkmProcess represents a target process which is being debugged. The debugger debugs processes, so this is the basic unit of debugging. A DkmProcess can represent a system process or a virtual process such as minidumps. [In] Identifies a DkmRuntimeInstance object within a process. [In,Optional] Data object to add to the new DkmCustomRuntimeInstance instance. Pass 'null' in the case that the caller doesn't need to add a data item. [Out] Result of this method call.

[In] DkmProcess represents a target process which is being debugged. The debugger debugs processes, so this is the basic unit of debugging. A DkmProcess can represent a system process or a virtual process such as minidumps. [In] Identifies a DkmRuntimeInstance object within a process. [In] Enumeration of runtime capabilities. [In,Optional] For runtimes that are implemented on top of another runtime, this can optionally be used to indicant the logical parent. This can then be used to request services from the parent when the child runtime doesn't implement the service. This is currently used only for obtaining the top stack frame to evaluate a conditional breakpoint when the child runtime doesn't walk stacks itself. [In,Optional] Data object to add to the new DkmCustomRuntimeInstance instance. Pass 'null' in the case that the caller doesn't need to add a data item. [Out] Result of this method call.

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Contains information about a disassembled instruction in the debuggee. Objects are returned from DkmProcess.Disassemble.

The address of this instruction in the debuggee address space.

The length of the instruction in bytes.

The formatted address of this instruction in the debuggee address space.

The address as an offset from some starting point, usually the beginning of the associated function.

The code bytes for this instruction.

The raw opcode for this instruction with no symbolic lookups.

The raw operands for this instruction with no symbolic lookups.

The opcode for this instruction including resolved symbol names. If nothing is resolved, this is the same as RawOpcode.

The operands for this instruction including resolved symbol names. If nothing is resolved, this is the same as RawOperands.

[Optional] The symbol name, if any, associated with the address (public symbol, label, and so on).

[Optional] An optional reference to the document and text position this instruction belongs to in the source document.

The number of bytes from the beginning of the corresponding source statement.

A read only collection of CV constants representing any register arguments in the disassembled instruction.

True if this instruction was successfully disassembled. False if it is a filler instruction used by heuristic unwinders when an invalid op code is encountered. Most disassembly providers will fill the op code with question marks when this is set to true to indicate a bogus instruction.

Create a new DkmDisassembledInstruction object instance. Location constraint: API must be called from an IDE component (component level > 100,000).

[In] DkmProcess represents a target process which is being debugged. The debugger debugs processes, so this is the basic unit of debugging. A DkmProcess can represent a system process or a virtual process such as minidumps. [In] The address of this instruction in the debuggee address space. [In] The length of the instruction in bytes. [In] The formatted address of this instruction in the debuggee address space. [In] The address as an offset from some starting point, usually the beginning of the associated function. [In] The code bytes for this instruction. [In] The raw opcode for this instruction with no symbolic lookups. [In] The raw operands for this instruction with no symbolic lookups. [In] The opcode for this instruction including resolved symbol names. If nothing is resolved, this is the same as RawOpcode. [In] The operands for this instruction including resolved symbol names. If nothing is resolved, this is the same as RawOperands. [In,Optional] The symbol name, if any, associated with the address (public symbol, label, and so on). [In,Optional] An optional reference to the document and text position this instruction belongs to in the source document. [In] The number of bytes from the beginning of the corresponding source statement. [In] A read only collection of CV constants representing any register arguments in the disassembled instruction. [In] True if this instruction was successfully disassembled. False if it is a filler instruction used by heuristic unwinders when an invalid op code is encountered. Most disassembly providers will fill the op code with question marks when this is set to true to indicate a bogus instruction. [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

An effective address for an instruction. The effective address is the calculated address that an instruction operand represents. For instance, on x86, an instruction may be of the form dwordptr [esp-12]. The effective address of this operand will be the result of subtracting 12 from esp. The number of operands and effective addresses are architecture specific.

The effective address for the operand.

The size of the operand this address applies to.

Set if the the segment register is FS. Only used on x86.

Initialize a new DkmEffectiveAddress value.

[In] The effective address for the operand. [In] The size of the operand this address applies to. [In] Set if the the segment register is FS. Only used on x86.

Flags that impact the effective address.

No flags applied.

Indicates that the segment register is FS. Used only on x86.

A label existing in a function. This API was introduced in Visual Studio 16 Update 3 (DkmApiVersion.VS16Update3).

The RVA of the label.

The label.

Initialize a new DkmFunctionLabel value. This API was introduced in Visual Studio 16 Update 3 (DkmApiVersion.VS16Update3).

[In] The RVA of the label. [In] The label.

Marshal a native struct to managed

Pointer to native struct. Managed object.

Obtain a pointer to the native object used to call into native.

Outgoing managed->native call Native object

Validate the fields of this structure

Struct that holds the field path (ex: "myArgument.StructField")

A linker fixup record. This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTM).

The records type element.

The record's extra element.

The record's RVA element.

The record's RVA target element.

Initialize a new DkmLinkerFixupRecord value. This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTM).

[In] The records type element. [In] The record's extra element. [In] The record's RVA element. [In] The record's RVA target element.

Result of an asynchronous DkmThread.GetManagedThreadProperties call.

Creates a new result structure to hold the error from a failed call to DkmThread.GetManagedThreadProperties.

[In] exception object containing the error

HRESULT code returned from the caller. This will be DkmExceptionCode.COR_E_OPERATIONCANCELED (0x8013153B) if the operation was canceled before processing was complete.

The managed thread id of the thread.

Creates a new result structure to hold the output from a successful call to DkmThread.GetManagedThreadProperties.

[In] The managed thread id of the thread.

Result of an asynchronous DkmThread.GetSuspensionCount call.

Creates a new result structure to hold the error from a failed call to DkmThread.GetSuspensionCount.

[In] exception object containing the error

HRESULT code returned from the caller. This will be DkmExceptionCode.COR_E_OPERATIONCANCELED (0x8013153B) if the operation was canceled before processing was complete.

The suspension count of thread. The internal thread suspension count is subtracted from this value if ShowInternal is false.

Creates a new result structure to hold the output from a successful call to DkmThread.GetSuspensionCount.

[In] The suspension count of thread. The internal thread suspension count is subtracted from this value if ShowInternal is false.

Result of an asynchronous DkmRuntimeInstance.GetThreadDisplayProperties call.

Creates a new result structure to hold the error from a failed call to DkmRuntimeInstance.GetThreadDisplayProperties.

[In] exception object containing the error

HRESULT code returned from the caller. This will be DkmExceptionCode.COR_E_OPERATIONCANCELED (0x8013153B) if the operation was canceled before processing was complete.

[Optional] The Thread Display Name.

[Optional] The Thread Name Priority: Values are from DISPLAY_NAME_PRI as defined in MSDBG100.

[Optional] Values are from THREADCATEGORY as defined in EnvDTE90.dll/.tlb.

Creates a new result structure to hold the output from a successful call to DkmRuntimeInstance.GetThreadDisplayProperties.

[In,Optional] The Thread Display Name. [In,Optional] The Thread Name Priority: Values are from DISPLAY_NAME_PRI as defined in MSDBG100. [In,Optional] Values are from THREADCATEGORY as defined in EnvDTE90.dll/.tlb.

Marshal a native struct to managed

Pointer to native struct. Managed object.

Obtain a pointer to the native object used to call into native.

Outgoing managed->native call Native object

Validate the fields of this structure

Struct that holds the field path (ex: "myArgument.StructField")

Result of an asynchronous DkmRuntimeInstance.GetThreadName call.

Creates a new result structure to hold the error from a failed call to DkmRuntimeInstance.GetThreadName.

[In] exception object containing the error

HRESULT code returned from the caller. This will be DkmExceptionCode.COR_E_OPERATIONCANCELED (0x8013153B) if the operation was canceled before processing was complete.

[Optional] The Thread Name.

Creates a new result structure to hold the output from a successful call to DkmRuntimeInstance.GetThreadName.

[In,Optional] The Thread Name.

Marshal a native struct to managed

Pointer to native struct. Managed object.

Obtain a pointer to the native object used to call into native.

Outgoing managed->native call Native object

Validate the fields of this structure

Struct that holds the field path (ex: "myArgument.StructField")

Result of an asynchronous DkmThread.GetVolatileFlags call.

Creates a new result structure to hold the error from a failed call to DkmThread.GetVolatileFlags.

[In] exception object containing the error

HRESULT code returned from the caller. This will be DkmExceptionCode.COR_E_OPERATIONCANCELED (0x8013153B) if the operation was canceled before processing was complete.

Volatile flags that apply to a thread. These values are expected to change over time and should not be cached by callers.

Creates a new result structure to hold the output from a successful call to DkmThread.GetVolatileFlags.

[In] Volatile flags that apply to a thread. These values are expected to change over time and should not be cached by callers.

Result of an asynchronous DkmThread.GetVolatileProperties call.

Creates a new result structure to hold the error from a failed call to DkmThread.GetVolatileProperties.

[In] exception object containing the error

HRESULT code returned from the caller. This will be DkmExceptionCode.COR_E_OPERATIONCANCELED (0x8013153B) if the operation was canceled before processing was complete.

The priority of the thread. The values returned correspond directly to the values defined for kernel32!GetThreadPriority.

The affinity mask of the thread. The values returned correspond directly to the values defined for kernel32!SetThreadAffinityMask.

Creates a new result structure to hold the output from a successful call to DkmThread.GetVolatileProperties.

[In] The priority of the thread. The values returned correspond directly to the values defined for kernel32!GetThreadPriority. [In] The affinity mask of the thread. The values returned correspond directly to the values defined for kernel32!SetThreadAffinityMask.

Volatile flags that apply to a thread. These values are expected to change over time and should not be cached by callers.

No flags are set.

The thread is a user-mode scheduled helper or scheduler thread.

DkmJsAsyncStackFrame is used to represent a JS async stack frame. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

Pointer to the IDebugDocumentText implementation for the document where the source location resides. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

0-based index into the document. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

Length of the current source position. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

Name of the stack frame. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

Create a new DkmJsAsyncStackFrame object instance. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

[In] Pointer to the IDebugDocumentText implementation for the document where the source location resides. [In] 0-based index into the document. [In] Length of the current source position. [In] Name of the stack frame. [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Information about a managed task that is obtained via inspection. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

The task ID.

The ID of this tasks parent.

[Optional] String representing the AsyncState property of the task.

The state flags stored in the task object.

Initialize a new DkmManagedTaskInfo value. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

[In] The task ID. [In] The ID of this tasks parent. [In,Optional] String representing the AsyncState property of the task. [In] The state flags stored in the task object.

Marshal a native struct to managed

Pointer to native struct. Managed object.

Obtain a pointer to the native object used to call into native.

Outgoing managed->native call Native object

Validate the fields of this structure

Struct that holds the field path (ex: "myArgument.StructField")

Represents either a managed TPL task or a native Concurrency Runtime task.

Represents a task provider which is loaded into the target process.

[Optional] DkmThread represents a thread running in the target process.

Identifier for this particular instance.

ID of parent task, 0 if there is no parent task.

Represents stack segment that task applies to. AddressOriginalMin <= AddressMin <= AddressMax <= AddressOriginalMax.

The return status of the task or unknown if the task has not completed. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

The time since debugging started that this task started. The time is in seconds. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

The time since debugging started that this task completed. The time is in seconds. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

The current task duration in seconds. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

[Optional] The location frame of the task. This API was introduced in Visual Studio 15 Update 8 (DkmApiVersion.VS15Update8).

[Optional] The continuation frames of this task, if any. This API was introduced in Visual Studio 15 Update 8 (DkmApiVersion.VS15Update8).

Closes a DkmTask object instance. This will release any resources associated with this object across all components. This includes resources across computer or managed/native marshalling boundaries. DkmTask objects are automatically closed when their associated DkmTaskProvider object is closed.

This method is called to represent a task on a specific thread.

This method is called to represent a task on a specific thread. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

[In] Represents a task provider which is loaded into the target process. [In,Optional] DkmThread represents a thread running in the target process. [In] Identifier for this particular instance. [In] ID of parent task, 0 if there is no parent task. [In] Represents stack segment that task applies to. AddressOriginalMin <= AddressMin <= AddressMax <= AddressOriginalMax. [In] The return status of the task or unknown if the task has not completed. [In] The time since debugging started that this task started. The time is in seconds. [In] The time since debugging started that this task completed. The time is in seconds. [In] The current task duration in seconds. [In,Optional] Data object to add to the new DkmTask instance. Pass 'null' in the case that the caller doesn't need to add a data item. [Out] Result of this method call.

This method is called to represent a task on a specific thread. This API was introduced in Visual Studio 15 Update 8 (DkmApiVersion.VS15Update8).

[In] Represents a task provider which is loaded into the target process. [In,Optional] DkmThread represents a thread running in the target process. [In] Identifier for this particular instance. [In] ID of parent task, 0 if there is no parent task. [In] Represents stack segment that task applies to. AddressOriginalMin <= AddressMin <= AddressMax <= AddressOriginalMax. [In] The return status of the task or unknown if the task has not completed. [In] The time since debugging started that this task started. The time is in seconds. [In] The time since debugging started that this task completed. The time is in seconds. [In] The current task duration in seconds. [In,Optional] The location frame of the task. [In,Optional] The continuation frames of this task, if any. [In,Optional] Data object to add to the new DkmTask instance. Pass 'null' in the case that the caller doesn't need to add a data item. [Out] Result of this method call.

Returns children tasks. Location constraint: API must be called from an IDE component (component level > 100,000).

[Out] TODO.

Returns task properties. Location constraint: API must be called from an IDE component (component level > 100,000).

[In] TODO. [In] TODO. [Out] TODO.

TODO. Location constraint: API must be called from an IDE component (component level > 100,000).

[Out] TODO.

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Properties of the task.

[Optional] Name of task.

[Optional] TODO.

TODO.

Initialize a new DkmTaskProperties value.

[In,Optional] Name of task. [In,Optional] TODO. [In,Optional] TODO. [In,Optional] TODO. [In,Optional] TODO. [In] TODO. [In] TODO. [In] TODO.

Marshal a native struct to managed

Pointer to native struct. Managed object.

Obtain a pointer to the native object used to call into native.

Outgoing managed->native call Native object

Validate the fields of this structure

Struct that holds the field path (ex: "myArgument.StructField")

Represents a task provider which is loaded into the target process.

Extensible GUID indicating the task provider which a task is from.

Task name e.g. Chore or Task.

Identifier for this particular instance.

The DkmRuntimeInstance class represents an execution environment which is loaded into a DkmProcess and which contains code to be debugged.

Flags describing additional information that this Task Provider can supply, such as timestamps. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

Closes a DkmTaskProvider object instance. This will release any resources associated with this object across all components. This includes resources across computer or managed/native marshalling boundaries. DkmTaskProvider objects are automatically closed when their associated DkmRuntimeInstance object is closed.

This method is called a task provider component to create a DkmTaskProvider object. It may be called in response to a call to InitializeTaskProviders call, or to a module/app domain load event. This method will send a TaskProviderCreate event.

[In] Extensible GUID indicating the task provider which a task is from. [In] Task name e.g. Chore or Task. [In] The DkmRuntimeInstance class represents an execution environment which is loaded into a DkmProcess and which contains code to be debugged. [In,Optional] Data object to add to the new DkmTaskProvider instance. Pass 'null' in the case that the caller doesn't need to add a data item. [Out] Result of this method call.

[In] Extensible GUID indicating the task provider which a task is from. [In] Task name e.g. Chore or Task. [In] The DkmRuntimeInstance class represents an execution environment which is loaded into a DkmProcess and which contains code to be debugged. [In] Flags describing additional information that this Task Provider can supply, such as timestamps. [In,Optional] Data object to add to the new DkmTaskProvider instance. Pass 'null' in the case that the caller doesn't need to add a data item. [Out] Result of this method call.

Find a DkmTask element within this DkmTaskProvider. If no element with the given input key is present, FindTask will fail.

[In] Search key used to find the element. [Out,Optional] Result of the search.

Enumerates the current set of tasks running in the target process. Location constraint: API must be called from an IDE component (component level > 100,000).

[In] TODO. [In] Count of tasks requested. [Out] Number of scheduled tasks. [Out] Array contained the found tasks. [Out] TODO.

TODO. Location constraint: API must be called from an IDE component (component level > 100,000).

[Out] TODO.

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Flags indicating additional capabilities a Task Provider can have. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

No additional capabilities.

Can provide timestamps for Tasks, i.e. Creation Time.

Can provide the return value of completed tasks.

Extensible GUID indicating the task provider which a task is from.

Task provider for Microsoft Task Parallel Library (TPL) for managed.

Task provider for Microsoft Concurrency Runtime programming framework for C++.

Task provider for JavaScript runtime.

Task provider for Managed TPL tasks based on ETW.

Task provider for Native PPL tasks based on ETW.

Task provider for Managed tasks through heap inspection.

The return status for the task. If the task hasn't completed yet, the status is unknown. This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

The return status is unknown because the task has not completed.

The task succeeded.

There was an error executing the task.

The task has been cancelled.

Represents stack segment that task applies to. AddressOriginalMin <= AddressMin <= AddressMax <= AddressOriginalMax.

Trimmed minimum address on stack.

Trimmed maximum address on stack.

original minimum address on stack.

original maximum address on stack.

OS thread id.

Initialize a new DkmTaskStackSegment value.

[In] Trimmed minimum address on stack. [In] Trimmed maximum address on stack. [In] original minimum address on stack. [In] original maximum address on stack. [In] OS thread id.

Represents a synchronization object.

Represents either a managed TPL task or a native Concurrency Runtime task.

[Optional] The owning thread.

Identifier for this particular instance.

[Optional] Name of the object, in base 10.

[Optional] Name of the object, in base 16.

[Optional] TODO.

TODO.

The id of the awaited task referred to by this synchronization object. This API was introduced in Visual Studio 15 Update 8 (DkmApiVersion.VS15Update8).

Closes a DkmTaskSynchronizationObject object instance. This will release any resources associated with this object across all components. This includes resources across computer or managed/native marshalling boundaries. DkmTaskSynchronizationObject objects are automatically closed when their associated DkmTask object is closed.

Create a new DkmTaskSynchronizationObject object instance.

[In] Represents either a managed TPL task or a native Concurrency Runtime task. [In,Optional] The owning thread. [In,Optional] Name of the object, in base 10. [In,Optional] Name of the object, in base 16. [In,Optional] TODO. [In] TODO. [In] TODO. [In,Optional] Data object to add to the new DkmTaskSynchronizationObject instance. Pass 'null' in the case that the caller doesn't need to add a data item. [Out] Result of this method call.

Create a new DkmTaskSynchronizationObject object instance. This API was introduced in Visual Studio 15 Update 8 (DkmApiVersion.VS15Update8).

[In] Represents either a managed TPL task or a native Concurrency Runtime task. [In,Optional] The owning thread. [In,Optional] Name of the object, in base 10. [In,Optional] Name of the object, in base 16. [In,Optional] TODO. [In] TODO. [In] TODO. [In] The id of the awaited task referred to by this synchronization object. [In,Optional] Data object to add to the new DkmTaskSynchronizationObject instance. Pass 'null' in the case that the caller doesn't need to add a data item. [Out] Result of this method call.

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Native edit and continue notification. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

Compilation starts.

Compilation stops.

Internal object for accessing visualizer information from the target computer.

Guid which uniquely identifies this DkmEELocalObject.

Create a new DkmEELocalObject object instance.

[In] DkmProcess represents a target process which is being debugged. The debugger debugs processes, so this is the basic unit of debugging. A DkmProcess can represent a system process or a virtual process such as minidumps. [In,Optional] Data object to add to the new DkmEELocalObject instance. Pass 'null' in the case that the caller doesn't need to add a data item. [Out] Result of this method call.

Initializes the visualizer cache on the IDE computer. Location constraint: API must be called from a Monitor component (component level < 100,000).

Returns visualizer information for a class. Location constraint: API must be called from a Monitor component (component level < 100,000).

[In] Name of the class. [In] Assembly cookie. [Out] Class cookie. [Out] ValueAttributeCount. [Out] ViewerAttributeCount. [Out] VisualizerAttributeCount.

GetTargetAssembly. Location constraint: API must be called from a Monitor component (component level < 100,000).

[In] Name. [Out] Cookie.

GetAssembly. Location constraint: API must be called from a Monitor component (component level < 100,000).

[In] Assembly cookie. [In] GETASSEMBLY flags. [Out,Optional] ASSEMBLYFLAGS flags. [Out,Optional] name. [Out] Bytes of the visualizer assembly. [Out] Bytes of the visualizer assembly's PDB.

GetHostAssembly. Location constraint: API must be called from a Monitor component (component level < 100,000).

[In] Flags. [Out] Assembly bytes. [Out] Bytes of the visualizer assembly's PDB.

GetValueAttributeProps. Location constraint: API must be called from a Monitor component (component level < 100,000).

[In] Class cookie. [In] Ordinal. [Out,Optional] Target assembly. [Out,Optional] Assembly location. [Out,Optional] Name. [Out,Optional] Value. [Out,Optional] Type.

GetViewerAttributeProps. Location constraint: API must be called from a Monitor component (component level < 100,000).

[In] Class cookie. [In] Ordinal. [Out,Optional] Target assembly. [Out,Optional] Assembly location. [Out,Optional] Class name. [Out,Optional] ClassAssemblyLocation.

GetVisualizerAttributeProps. Location constraint: API must be called from a Monitor component (component level < 100,000).

[In] Class cookie. [In] Ordinal. [Out,Optional] Target assembly. [Out,Optional] Assembly location. [Out,Optional] Display class name. [Out,Optional] DisplayClassAssemblyLocation. [Out,Optional] Proxy class name. [Out,Optional] ProxyClassAssemblyLocation. [Out,Optional] Description. [Out,Optional] Type.

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Concord wrapper around IPropertyProxyEESide.

Not described (internal API).

The evaluation result this proxy is based on.

Guid which uniquely identifies this DkmPropertyProxy.

Create a new DkmPropertyProxy object instance.

[In] Not described (internal API). [In] The evaluation result this proxy is based on. [In,Optional] Data object to add to the new DkmPropertyProxy instance. Pass 'null' in the case that the caller doesn't need to add a data item. [Out] Result of this method call.

Not described (internal API). Location constraint: API must be called from an IDE component (component level > 100,000).

[Out,Optional] the result bytes.

Not described (internal API). Location constraint: API must be called from an IDE component (component level > 100,000).

[Out,Optional] Not described (internal API). [Out,Optional] Not described (internal API). [Out,Optional] Not described (internal API). [Out,Optional] class name. [Out] enum_ASSEMBLYLOCRESOLUTION enumeration. [Out] replacement ok.

Not described (internal API). Location constraint: API must be called from an IDE component (component level > 100,000).

[In] Not described (internal API). [Out,Optional] Not described (internal API).

Implements IPropertyProxyEESide::ResolveAssemblyReference(). Location constraint: API must be called from an IDE component (component level > 100,000).

[In] Not described (internal API). [In] GETASSEMBLY flags. [Out,Optional] Not described (internal API). [Out,Optional] Not described (internal API). [Out,Optional] Not described (internal API). [Out] ASSEMBLYLOCRESOLUTION enum.

Not described (internal API). Location constraint: API must be called from an IDE component (component level > 100,000). This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

[Out,Optional] Not described (internal API).

Not described (internal API). Location constraint: API must be called from an IDE component (component level > 100,000). This API was introduced in Visual Studio 12 RTM (DkmApiVersion.VS12RTM).

[In] Not described (internal API). [Out,Optional] Not described (internal API).

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Describes the JIT compilation of a method at a point in time. Optionally offers Original IL to Native mapping and/or Original IL to Instrumented IL native mapping. This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTM).

Implementation specific identifier for the module. This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTM).

The token of the JIT compiled method. This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTM).

The id of the re-JIT event for the method. This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTM).

The virtual memory address of the beginning of the JIT compiled code for this instance. Zero if not available. This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTM).

An id assigned by the runtime to the function that was JIT compiled. Note this will not be unique across JIT instances. This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTM).

True if an only if an IL to native mapping is available for this JIT event. This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTM).

The process associated with the JIT instance. This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTM).

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Describes a module instance in a Recorded process. This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTM).

The DkmRecordedProcessQuery that owns this module instance. This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTM).

Implementation defined identifier for the module. This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTM).

The base address at which the module was loaded. May be zero for dynamic modules. Note, multiple instances may have the same base address if they were loaded at different times. This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTM).

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Provides facilities to record data from a recorded process. This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTM).

The owning process. This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTM).

The id that identifies the process query. This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTM).

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Represents an snapshot event in time travel trace. This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTM).

Guid which identifies snapshot event. This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTM).

An internal identifier for the snapshot. This API was introduced in Visual Studio 16 Update 1 (DkmApiVersion.VS16Update1).

An internal identifier for the kind of snapshot. This API was introduced in Visual Studio 16 Update 1 (DkmApiVersion.VS16Update1).

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Represents a record section that's defined by the snapshots. This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTM).

The snapshot at the start of the recording. This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTM).

The snapshot at the end of the recording. This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTM).

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Represents an event in time travel trace. This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTM). Derived classes: DkmRecordedMethodJITInstance, DkmRecordedSnapshotEvent, DkmRecordedSnapshotRecordSectionEvent

The time at which the event occurred. This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTM).

The time travelling process used to query for this event. This API was introduced in Visual Studio 16 RTM (DkmApiVersion.VS16RTM).

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Represents an arbitrary name value pair. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

The name of this pair. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

The value of this pair. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

Create a new DkmNameValuePair object instance. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

[In] The name of this pair. [In] The value of this pair. [Out] Result of this method call.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

Result of an asynchronous DkmTelemetryEvent.Post call.

Creates a new result structure to hold the error from a failed call to DkmTelemetryEvent.Post.

[In] exception object containing the error

HRESULT code returned from the caller. This will be DkmExceptionCode.COR_E_OPERATIONCANCELED (0x8013153B) if the operation was canceled before processing was complete.

This object represents a single telemetry event. It has an event name and a set of properties. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

The name of the event. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

[Optional] A set of properties for this event. Each property consists of a Name and a Variant type. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

[Optional] Process to associate with this event. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

Create a new DkmTelemetryEvent object instance. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

[In] The name of the event. [In,Optional] A set of properties for this event. Each property consists of a Name and a Variant type. [In,Optional] Process to associate with this event. [Out] Result of this method call.

Send the Telemetry Event to the Visual Studio Telemetry Service. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

Send the Telemetry Event to the Visual Studio Telemetry Service. This method will append a new work item to the specified work list, and return once the work item has been appended. The actual processing of the work item is asynchronous. The caller will be notified that the request is complete through the completion routine. This API was introduced in Visual Studio 14 RTM (DkmApiVersion.VS14RTM).

Queries the VS Telemetry Service to determine if private user information can be collected. This API was introduced in Visual Studio 14 Update 1 (DkmApiVersion.VS14Update1).

[Out] True if private user information can be collected.

Outgoing managed->native call Native object

Convert a native dispatcher object to managed

[Optional] Pointer to native object. [Optional] Managed object. Null if input object is null.

Create a new managed object for the passed in native object. This function is called from 'NativeToManaged'

Native object [Optional] Managed object. Returns null if the native object is not of this type.

An implementation of ReadOnlyCollection that can provide a pointer to the underlying native memory. Currently this class is only used for ReadOnlyCollections storing bytes when the value is passed through a Concord API call.

Initializes a new instance of the DkmReadOnlyByteCollection from serialized data

[Required] Serialization info Not used

Gets a pointer to the native items buffer. The marshalling code assumes the collection is read only. Modifications to the buffer will have unpredictable effects. The pointer will not be available if this object has been serialized. The buffer may be released when this object is garbage collected.

Gets a pointer to the native DkmReadOnlyCollection. The pointer will be IntPtr.Zero if this collection has been serialized.

ISerializable implementation. Serialization requires copying the collection into the managed heap

[Required] Serialization info Not used

An IList<byte> implementation that wraps a native DkmReadOnlyCollection<byte> allowing it to be used from managed code.

Gets a pointer to the native DkmReadOnlyCollection

Gets a pointer to the native items buffer.

Enumerator for XapiNativeCollectionWrapper

The kind of consent already obtained from the user.

Allows the error reporting infrastructure to decide whether to ask the user based on their previously established consent level.

The user has already approved the submission of this error report through another means.

This value should not be used without first obtaining approval from mailto:ddwattac.

Indicates the user has denied permission to submit the report.

Causes UI to appear to ask the user before submitting the report.

Undocumented.

The level of detail and size of the dump to submit.

Similar to MiniDump but only capture the stack trace of the thread passed into WerReportAddDump which is the most reliable dump type If http://watson has been configured to ask for more information, this can be automatically upgraded to a heap dump.

By default, a dump that includes callstacks for all threads is submitted. If http://watson has been configured to ask for more information, this can be automatically upgraded to a heap dump.

Produces a much larger CAB that includes the heap.

Undocumented.

The severity of the error being reported.

Undocumented.

The type of files that can be added to the report.

A limited minidump that contains only a stack trace.

A minidump file.

An extended minidump that contains additional data such as the process memory.

The document in use by the application at the time of the event. The document is added only if the server asks for this type of document.

Any other type of file. This file will always get added to the cab (but only if the server asks for a cab).

Flags that can be specified when adding a file to the report.

Delete the file once WER is done

This file does not contain any PII

An immutable description of the type of error report to submit.

Initializes a new instance of the class.

Gets the type of information to include in the error report.

The default value is . This value should typically be left at its default unless you first check with mailto:ddwattac

Gets the type of report being

The default value is . This value should typically be either or unless you first check with mailto:ddwattac

Gets the logical component where the failure occurred.

A non-localized constant value. If null the default component name is used in the report. This value should not contain any parameterized values so that a single Watson bucket collects all instances of this failure. Its value will be used to assist in matching a failure to the team that owns the feature.

Gets the value that will appear as "Event Name" in the Windows Application Log and in the Watson error report.

A non-localized constant value. If null the default component name is used in the report. This value should not contain any parameterized values so that a single Watson bucket collects all instances of this failure. Generally it should be left at null so that the product's reserved event name can be used.

Gets the files being added to report.

Encapsulate the info required to add a file to report.

Initializes a new instance of the class.

Gets the file path being added to report

Gets the type of the file being added to report.

Gets the flags of the file being added to report.

Describes non-fatal exception from a given component.

This is intended to be used by callers of to represent information about the non-fatal error.

Creates a new instance of

[Required] Exception that triggered this non-fatal error [Required] Name of the component / implementation that triggered the error. This paramater is included in the watson bucket parameters to uniquely identify this error.

Exception that triggered this non-fatal error

The name of the component that triggered this error

The Fully qualified identifier to what triggered this error This is appended to the ModName parameter on the Watson bucket

Class for wrapping up information about an xapi exception.

This class overrides to include information from , , and

Creates a new instance of from the given parameters (typically passed to the exception filter in the ManagedAPI)

[Required] Exception that triggered this non-fatal error [Optional] Object that implemented the Dkm component [Optional] The Type of the interface that was called [Optional] Method name on the interface that was called

The Fully qualified path to the method that triggered this error, this is composed of , , and

[Optional] Object that implemented the Dkm component

[Optional] The Type of the interface that was called

[Optional] Method name on the interface that was called

Base exception class for all exceptions within this API.

Create a new exception instance. To enable native-interop scenarios, this exception system is error code based, so there is no excepion string.

The HRESULT code for this exception. Using HRESULT values that are defined outside the range of this enumerator are acceptable, but not encouraged.

Provides the DkmExcepionCode for this exception

[Optional] Marshal a native DkmReadOnlyCollection<byte> to a managed ReadOnlyCollection<byte>. Using this marshaller is more efficient than using RawToManaged for byte collections. This method returns null when the pointer to the native collection is IntPtr.Zero.

[Optional] Outgoing call if applicable [Optional] Pointer to native collection

Convert a native read only collection to a managed collection where the elements are structs.

native collection object Type of each native element rountine to unmarshal each element Created collection

Convert a native read only collection to a managed collection where the elements are typemap entries or dispatcher objects

native collection object rountine to unmarshal each element Created collection

Convert a managed array to native in the case that array elements are raw

Convert a managed array to native in the case that the array elements are typemap entries

Convert a managed array to native in the case that the array elements are dispatcher objects

Struct to hold that scope that a given field is at so that exceptions can be generated with good field names.

Helper for filing Watson reports.

The minimum interval that must pass between individual error submissions for the same failed component.

This is important so we don't slam the WER servers from a single dev box that keeps crashing. Particularly when the failing code happens to be in a loop or on multiple threads, we don't want to get the same crash over and over.

A record of when a given component last submitted an error report in this app domain's lifetime.

Used for throttling report submissions.

Info describing source of this error

Whether this represents a fatal error

pointer to ExceptionPointers structure that is created when the exception is thrown (required for submission to watson)

We do not need to clean this memory up because it will be cleaned up at the conclusion of the exception handling

WatsonBucket EventType for all non-fatal devenv errors we use "Dev11NonFatalError"

Id generated when opening the event handle used to identify this request

Open, Inheritable handle to the event that will be used to signal snapshotting complete

Open, Inheritable handle to this process (this is the process that will be snapshotted)

Open, Inheritable handle to this thread (used by watson to identify the thread where the error happened

Bool indicating if has been called on this instance

Initializes a new instance of the class.

Releases native resources.

Minimum submission interval

Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.

Releases unmanaged and - optionally - managed resources

true to release both managed and unmanaged resources; false to release only unmanaged resources.

This Initializes a new instance of that must be disposed.

Exception info describing this error New error report instance

If not throttled, this fires off a report request and waits for the snapshot to be taken. If throttled or a snapshot is not taken due to a failure this will return false.

This must be called from a exception filter to get the pointer to the ExceptionPointers structure. Thrown if this object has already been disposed

Sends information from the current error report to the IVSTelemetry service, allowing data collection from any OS running any platform (such as silverlight). Reporting is done from the IDE and will be remoted back to the local side before being sent.

Determines if an assembly is from Microsoft by checking the private key token.

[Required] An assembly to check True if the assembly has a Microsoft public key token

Gets the name of the exception type if it belongs to a Microsoft assembly.

[Required] An exception to sanitize The sanitized property string

Gets the exception callstack, removing and collapsing user code frames.

[Required] An exception to sanitize The sanitized exception callstack

Sets up for taking a snapshot by initializing the necessary handles for the helper process

This must be called from an Exception Filter inorder to gather the current exception information. true on success and false on failure

Reports the current non-fatal exception using a process snapshot (if InitializeHandlesForSnapshot has been called)

true if the report was successfully taken, false otherwise

Locates the helper required to take the snapshot

[Optional, Out] if this method returns true this will be the path to the helper exe true if the exe was found, false otherwise

Assembles the Watson bucket parameters.

Receives the bucket parameters. A value indicating whether error details were successfully collected. NOTE, this method should be called from the filter of an exception block. Otherwise the runtime will not fill in the bucket parameters because there won't be a "current" exception.

Determines whether a given component should be allowed to submit a report, considering throttling requirements.

The name of the failed component. true if the report submission is allowed; false otherwise.

Gets a string to pass to DebuggerReportingHelper as a commandline argument representing the Watson Arguments

[Required, Out] resulting process start arguments Bool indicating if gathering the required arguments was successful. If false report process should be aborted.

Defines the HRESULT codes used by this API.

The operation was canceled.

Unspecified error.

A debugger is already attached.

The process does not have sufficient privileges to be debugged.

The desktop cannot be debugged.

Unmanaged debugging is not available.

Debugging isn't possible due to an incompatability within the CLR implementation.

Visual Studio cannot debug managed applications because a kernel debugger is enabled on the system. Please see Help for further information.

Visual Studio cannot debug managed applications because a kernel debugger is present on the system. Please see Help for further information.

The debugger does not support debugging managed and native code at the same time on the platform of the target computer/device. Configure the debugger to debug only native code or only managed code.

The maximum number of processes is already being debugged.

Script debugging of your application is disabled in Internet Explorer. To enable script debugging in Internet Explorer, choose Internet Options from the Tools menu and navigate to the Advanced tab. Under the Browsing category, clear the 'Disable Script Debugging (Internet Explorer)' checkbox, then restart Internet Explorer.

The correct version of pdm.dll is not registered. Repair your Visual Studio installation, or run 'regsvr32.exe "%CommonProgramFiles%\Microsoft Shared\VS7Debug\pdm.dll"'.

The .NET debugger has not been installed properly. The most probable cause is that mscordbi.dll is not properly registered. Click Help for more information on how to repair the .NET debugger.

There is no managed code running in the process. In order to attach to a process with the .NET debugger, managed code must be running in the process before attaching.

The Visual Studio Remote Debugger has been closed on the remote machine.

The Visual Studio Remote Debugger on the remote computer does not support debugging code running in the Common Language Runtime.

The Visual Studio Remote Debugger on the remote computer does not support debugging code running in the Common Language Runtime on a 64-bit computer.

Cannot debug minidumps and processes at the same time.

This application has failed to start because the application configuration is incorrect. Review the manifest file for possible errors. Reinstalling the application may fix this problem. For more details, please see the application event log.

Failed to initialize msdbg2.dll for script debugging. If this problem persists, use 'Add or Remove Programs' in Control Panel to repair your Visual Studio installation.

The Visual Studio $(var.VSGeneralBrandVersion) Remote Debugger (MSVSMON.EXE) does not appear to be running on the remote computer. This may be because a firewall is preventing communication to the remote computer. Please see Help for assistance on configuring remote debugging.

Access is denied. Can not connect to Visual Studio Remote Debugger on the remote computer.

The debugger cannot connect to the remote computer. The debugger was unable to resolve the specified computer name.

The debugger is not properly installed. Run setup to install or repair the debugger.

Access is denied. This seems to be because the 'Network access: Sharing and security model for local accounts' security policy does not allow users to authenticate as themselves. Please use the 'Local Security Settings' administration tool on the local computer to configure this option.

The specified remote server name is not valid.

Visual Studio Remote Debugger (MSVSMON.EXE) failed to start. If this problem persists, please repair your Visual Studio installation via 'Add or Remove Programs' in Control Panel.

A DCOM error occurred trying to contact the remote computer. Access is denied. It may be possible to avoid this error by changing your settings to debug only native code or only managed code.

Debugging using the Default transport is not possible because the remote machine has 'Share-level access control' enabled. To enable debugging on the remote machine, go to Control Panel -> Network -> Access control, and set Access control to be 'User-level access control'.

Logon failure: unknown user name or bad password. See help for more information.

Windows authentication is disabled in the Visual Studio Remote Debugger (MSVSMON). To connect, choose one of the following options. 1. Enable Windows authentication in MSVSMON 2. Reconfigure your project to disable Windows authentication 3. Use the 'Remote (native with no authentication)' transport in the 'Attach to Process' dialog

A previous expression evaluation is still in progress.

The expression evaluation took too long.

Mixed-mode debugging does not support Microsoft.NET Framework versions earlier than 2.0.

Check for one of the following. 1. The application you are trying to debug uses a version of the Microsoft .NET Framework that is not supported by the debugger. 2. The debugger has made an incorrect assumption about the Microsoft .NET Framework version your application is going to use. 3. The Microsoft .NET Framework version specified by you for debugging is incorrect. Please see the Visual Studio .NET debugger documentation for correctly specifying the Microsoft .NET Framework version your application is going to use for debugging.

Unable to attach because process is running in fiber mode.

Visual Studio has insufficient privileges to debug this process. To debug this process, Visual Studio must be run as an administrator.

Visual Studio has insufficient privileges to inspect the process's identity.

Visual Studio was unable to inspect the process's identity. This is most likely due to service configuration on the computer running the process.

Visual Studio has insufficient privileges to debug this process. To debug this process, Visual Studio must be run as an administrator.

The type of code you are currently debugging does not support disassembly.

The specified address does not exist in disassembly.

The breakpoint has been deleted.

The process has been terminated.

Terminating this process is not allowed.

The thread has terminated.

Cannot find port. Check the remote machine name.

Detach is not supported on Microsoft Windows 2000 for native code.

This thread has called into a function that cannot be displayed.

The next statement cannot be set to another function.

In order to Set Next Statement, right-click on the active frame in the Call Stack window and select "Unwind To This Frame".

The next statement cannot be changed until the current statement has completed.

The next statement cannot be set from outside a finally block to within it.

The next statement cannot be set from within a finally block to a statement outside of it.

The next statement cannot be set from outside a catch block to within it.

The next statement cannot be changed at this time.

The next statement cannot be set into or out of a catch filter.

This process is not currently executing the type of code that you selected to debug.

The debugger is still attaching to the process or the process is not currently executing the type of code selected for debugging.

The debugger is handling debug events or performing evaluations that do not allow nested break state. Try again.

The web server has been locked down and is blocking the DEBUG verb, which is required to enable debugging. Please see Help for assistance.

ASP debugging is disabled because the ASP process is running as a user that does not have debug permissions. Please see Help for assistance.

The remote debugging components are not registered or running on the web server. Ensure the proper version of msvsmon is running on the remote computer.

An unexpected DCOM error occurred while trying to automatically attach to the remote web server. Try manually attaching to the remote web server using the 'Attach To Process' dialog.

Expected failure from web server CoCreating debug verb CLSID

The current thread cannot continue while an expression is being evaluated on another thread.

The specified working directory does not exist or is not a full path.

The application manifest has the uiAccess attribute set to 'true'. Running an Accessibility application requires following the steps described in Help.

This program requires additional permissions to start. To debug this program, restart Visual Studio as an administrator.

Cannot locate Microsoft Internet Explorer.

The Visual Studio Remote Debugger (MSVSMON.EXE) has insufficient privileges to debug this process. To debug this process, the remote debugger must be run as an administrator.

The Visual Studio Remote Debugger (MSVSMON.EXE) has insufficient privileges to debug this process. To debug this process, launch the remote debugger using 'Run as administrator'. If the remote debugger has been configured to run as a service, ensure that it is running under an account that is a member of the Administrators group.

This program requires additional permissions to start. To debug this program, launch the Visual Studio Remote Debugger (MSVSMON.EXE) using 'Run as administrator'.

The attempt to unwind the callstack failed. Unwinding is not possible in the following scenarios: 1. Debugging was started via Just-In-Time debugging. 2. An unwind is in progress. 3. A System.StackOverflowException or System.Threading.ThreadAbortException exception has been thrown.

You can only unwind to the function that caused the exception.

Unwinding from the current exception is not supported.

You cannot unwind from an unhandled exception while doing managed and native code debugging at the same time.

The process has been terminated.

The Visual Studio Remote Debugger is either not running on the remote machine or is running in Windows authentication mode.

The IP address for the remote machine is not valid.

The remote machine is not responding.

The remote machine name is not specified.

Other programs cannot be debugged during the current mixed dump debugging session.

All of the threads are frozen. Use the Threads window to unfreeze at least one thread before attempting to step or continue the process.

The debugger transport DLL cannot be loaded.

mspdb110.dll cannot be loaded.

MSDIS170.dll cannot be loaded.

NatDbgEE.dll cannot be loaded.

NatDbgDM.dll cannot be loaded.

Old version of DBGHELP.DLL found, does not support minidumps.

Input or output cannot be redirected because the specified file is invalid.

Input or output cannot be redirected because the syntax is incorrect.

This error code is not generally displayed to the user anymore. In most cases it is now transformed into E_REMOTE_MSVSMON_TOO_OLD.

This operation is not supported when debugging dump files.

The remote computer does not have a CLR version which is compatible with the remote debugging components. To install a compatible CLR version, see the instructions in the 'Remote Components Setup' page on the Visual Studio CD.

The specified file is an unrecognized or unsupported binary format.

The process has been soft broken.

The Visual Studio Remote Debugger on the remote computer is running as a different user.

Stepping to or from system code on a machine running Windows 95/Windows 98/Windows ME is not allowed.

The 64-bit version of the Visual Studio Remote Debugger (MSVSMON.EXE) cannot be used to debug 32-bit processes or 32-bit dumps. Please use the 32-bit version instead.

The 32-bit version of the Visual Studio Remote Debugger (MSVSMON.EXE) cannot be used to debug 64-bit processes or 64-bit dumps. Please use the 64-bit version instead.

Mini-Dumps cannot be read on this system. Please use a Windows NT based system

A stepping breakpoint could not be set

The debugger transport DLL being loaded has an incorrect version.

NatDbgDM.dll being loaded has an incorrect version.

msdia140.dll cannot be loaded.

The dump file you opened is corrupted.

Mixed-mode debugging of x64 processes is not supported when using Microsoft.NET Framework versions earlier than 4.0.

Debugging older format crashdumps is not supported.

Debugging managed-only minidumps is not supported. Specify 'Mixed' for the 'Debugger Type' in project properties.

Debugging managed or mixed-mode minidumps is not supported on IA64 platforms. Specify 'Native' for the 'Debugger Type' in project properties.

The remote tools are not signed correctly.

Attach is not enabled for this process with this debug type.

The connection has been broken.

The threads in the process cannot be suspended at this time. This may be a temporary condition.

Access denied. Try again, then check your device for a prompt.

Unable to complete the operation. This could be because the device's security settings are too restrictive. Please use the Device Security Manager to change the settings and try again.

The remote connection to the device has been lost. Verify the device connection and restart debugging.

Unable to load the CLR. The target device does not have a compatible version of the CLR installed for the application you are attempting to debug. Verify that your device supports the appropriate CLR version and has that CLR installed. Some devices do not support automatic CLR upgrade.

The Visual Studio Remote Debugger on the target computer cannot connect back to this computer. A firewall may be preventing communication via DCOM to the local computer. It may be possible to avoid this error by changing your settings to debug only native code or only managed code.

The Visual Studio Remote Debugger on the target computer cannot connect back to this computer. Authentication failed. It may be possible to avoid this error by changing your settings to debug only native code or only managed code.

The Visual Studio Remote Debugger on the remote computer could not connect to this computer because there was no available authentication service. It may be possible to avoid this error by changing your settings to debug only native code or only managed code.

Can not evaluate script expressions while thread is stopped in the CLR.

Server side-error occurred on sending debug HTTP request.

An authentication error occurred while communicating with the web server. Please see Help for assistance.

Could not start ASP.NET debugging. More information may be available by starting the project without debugging.

The web server is not configured correctly. See help for common configuration errors. Running the web page outside of the debugger may provide further information.

The server does not support debugging of ASP.NET or ATL Server applications. Click Help for more information on how to enable debugging.

Could not start ASP.NET or ATL Server debugging.

The web server could not find the requested resource.

The debug request could not be processed by the server due to invalid syntax.

You do not have permissions to debug the web server process. You need to either be running as the same user account as the web server, or have administrator privilege.

Unable to connect to the web server. Verify that the web server is running and that incoming HTTP requests are not blocked by a firewall.

The web server did not respond in a timely manner. This may be because another debugger is already attached to the web server.

IIS does not list a web site that matches the launched URL.

IIS does not list an application that matches the launched URL.

Debugging requires the IIS Management Console. To install, go to Control Panel->Programs->Turn Windows features on or off. Check Internet Information Services->Web Management Tools->IIS Management Console.

The IIS worker process for the launched URL is not currently running.

The Visual Studio debugger cannot connect to the remote computer. Unable to initiate DCOM communication. Please see Help for assistance.

The Visual Studio Remote Debugger on the remote computer cannot connect to the local computer. Unable to initiate DCOM communication. Please see Help for assistance.

The Visual Studio debugger cannot connect to the remote computer. An RPC policy is enabled on the local computer which prevents remote debugging. Please see Help for assistance.

The Visual Studio Remote Debugger cannot logon to the local computer: unknown user name or bad password. It may be possible to avoid this error by changing your settings to debug only native code or only managed code.

The Visual Studio debugger cannot establish a DCOM connection to the remote computer. A firewall may be preventing communication via DCOM to the remote computer. It may be possible to avoid this error by changing your settings to debug only native code or only managed code.

Windows file sharing has been configured so that you will connect to the remote computer using a different user name. This is incompatible with remote debugging. Please see Help for assistance.

Windows Firewall does not currently allow exceptions. Use Control Panel to change the Windows Firewall settings so that exceptions are allowed.

Cannot add an application to the Windows Firewall exception list. Use the Control Panel to manually configure the Windows Firewall.

Cannot add a port to the Windows Firewall exception list. Use the Control Panel to manually configure the Windows Firewall.

Cannot add 'File and Printer Sharing' to the Windows Firewall exception list. Use the Control Panel to manually configure the Windows Firewall.

Remote debugging is not supported.

Maximum packet length exceeded. If the problem continues, reduce the number of network host names or network addresses that are assigned to the computer running Visual Studio computer or to the target computer.

The target process is running a version of the Microsoft .NET Framework newer than this version of Visual Studio. Visual Studio cannot debug this process.

This version of Visual Studio does not support debugging code that uses Microsoft .NET Framework v1.0. Use Visual Studio 2008 or earlier to debug this process.

Mixed-mode debugging of IA64 processes is not supported.

See help for common configuration errors. Running the web page outside of the debugger may provide further information.

IDebugCoreServer* implementation does not have a connection to the remote computer. This can occur in T-SQL debugging when there is no Remote Debugger connected.

The specified remote debugging proxy server name is invalid.

Operation is not permitted on IDebugCoreServer* implementation which has a weak connection to the remote msvsmon instance. Weak connections are used when no process is being debugged.

Remote program providers are no longer supported before debugging begins (ex: process enumeration).

Connection request was rejected by the remote debugger. Ensure that the remote debugger is running in 'No Authentication' mode.

Connection request was rejected by the remote debugger. Ensure that the remote debugger is running in 'Windows Authentication' mode.

The debugger was unable to create a localhost TCP/IP connection, which is required for 64-bit debugging.

This operation requires the Windows Web Services API to be installed, and it is not currently installed on this computer.

This operation requires the Windows Web Services API to be installed, and it is not currently installed on this computer. To install Windows Web Services, please restart Visual Studio as an administrator on this computer.

The expression has not yet been translated to native machine code.

A Microsoft .NET Framework component, diasymreader.dll, is not correctly installed. Please repair your Microsoft .NET Framework installation via 'Add or Remove Programs' in Control Panel.

Unable to load the CLR. If a CLR version was specified for debugging, check that it was valid and installed on the machine. If the problem persists, please repair your Microsoft .NET Framework installation via 'Programs and Features' in Control Panel.

Unable to map the debug start page URL to a machine name.

The remote procedure could not be debugged. This usually indicates that debugging has not been enabled on the server. See help for more information.

Please install the Visual Studio Remote Debugger on the server to enable this functionality.

The debugger failed to stop in the server process.

Unable to determine a stopping location. Verify symbols are loaded.

Debugging this project is disabled. Debugging can be re-enabled from 'Start Options' under project properties.

Unable to attach the debugger to TSQL code.

Click Help for more information.

The operation isn't supported for the Common Language Runtime version used by the process being debugged.

The Visual Studio Remote Debugger does not support this edition of Windows.

Source server support is disabled because the assembly is partially trusted.

Operation is not supported on the platform of the target computer/device.

Unable to load Visual Studio debugger component (vsdebugeng.dll). If this problem persists, repair your installation via 'Add or Remove Programs' in Control Panel.

Unable to initialize Visual Studio debugger component (vsdebugeng.dll). If this problem persists, repair your installation via 'Add or Remove Programs' in Control Panel.

Unable to initialize Visual Studio debugger due to a configuration error. If this problem persists, repair your installation via 'Add or Remove Programs' in Control Panel.

Failed to launch minidump. The minidump file is corrupt.

Unable to load a Visual Studio component (VSDebugScriptAgent110.dll). If the problem persists, repair your installation via 'Add or Remove Programs' in Control Panel.

Remote script debugging requires that the remote debugger is registered on the target computer. Run the Visual Studio Remote Debugger setup (rdbgsetup_<processor>.exe) on the target computer.

The debugger was unable to find the registration for the target application. If the problem persists, try uninstalling and then reinstalling this application.

Unable to find a Visual Studio component (VsDebugLaunchNotify.exe). For remote debugging, this file must be present on the target computer. If the problem persists, repair your installation via 'Add or Remove Programs' in Control Panel.

Windows 8 build# 8017 or higher is required to debug Windows Store apps.

Cannot autoattach to the SQL Server, possibly because the firewall is configured incorrectly or autoattach is forbidden by the operating system.

Debugging multiple GPU processes is not supported.

No available devices supported by the selected debug engine. Please select a different engine.

A Microsoft Windows component is not correctly registered. Please ensure that the Desktop Experience is enabled in Server Manager -> Manage -> Add Server Roles and Features.

Windows 8 or higher was required for GPU debugging on the software emulator. For the most up-to-date information, please visit the link below. https://go.microsoft.com/fwlink/p/?LinkId=330081

There is a configuration issue with the selected Debugging Accelerator Type. For information on specific Accelerator providers, visit https://go.microsoft.com/fwlink/p/?LinkId=323500

Local debugging is not supported for the selected Debugging Accelerator Type. Use Remote Windows Debugger instead or change the Debugging Accelerator Type

The debug driver for the selected Debugging Accelerator Type is not installed on the target machine. For more information, visit https://go.microsoft.com/fwlink/p/?LinkId=323500

Timeout Detection and Recovery (TDR) must be disabled at the remote site. For more information search for 'TdrLevel' in MSDN or visit the link below. https://go.microsoft.com/fwlink/p/?LinkId=323500

Remote debugger does not support mixed (managed and native) debugger type.

Background Task activation failed Please see Help for further information.

This version of the Visual Studio $(var.VSGeneralBrandVersion) Remote Debugger does not support this operation. Please install the $(var.RemoteToolsBrandNameVersion) or newer from microsoft.com.

Unable to load a Visual Studio component (symbollocator.resources.dll). If the problem persists, repair your installation via 'Add or Remove Programs' in Control Panel.

The format of the PE module is invalid.

This dump is already being debugged.

The next statement cannot be set because the current assembly is optimized.

Debugging of ARM minidumps requires Windows 8 or above.

Cannot detach while process termination is in progress.

A required Microsoft Windows component, wldp.dll could not be found on the target device.

The target device does not allow debugging this process.

Unable to debug .NET Native code. Install the Microsoft .NET Native Developer SDK. Alternatively debug with native code type.

Unable to load a Visual Studio component (MSEnc.resources.dll). If the problem persists, repair your installation via 'Add or Remove Programs' in Control Panel.

The remote debugger is older than this version of Visual Studio $(var.VSGeneralBrandVersionRelease), and Visual Studio is no longer compatible with it. Upgrade your remote debugger to match Visual Studio.

The remote debugger is newer than your version of Visual Studio $(var.VSGeneralBrandVersionRelease), and the remote debugger is no longer compatible with it. Either upgrade Visual Studio to match your remote debugger, or downgrade the remote debugger.

Prelaunch is only supported on desktop versions of Windows 10 or newer.

Unable to load Visual Studio debugger component (msvcdis140.dll). If this problem persists, repair your installation via 'Add or Remove Programs' in Control Panel.

Mixed-mode debugging is not supported with the legacy managed debug engine.

This version of the Visual Studio Remote Debugger (MSVSMON.EXE) cannot be used to debug X86 processes or dumps. Please use the X86 version instead.

This version of the Visual Studio Remote Debugger (MSVSMON.EXE) cannot be used to debug X64 processes or dumps. Please use the X64 version instead.

This version of the Visual Studio Remote Debugger (MSVSMON.EXE) cannot be used to debug ARM processes or dumps. Please use the ARM version instead.

This version of the Visual Studio Remote Debugger (MSVSMON.EXE) cannot be used to debug ARM64 processes or dumps. Please use the ARM64 version instead.

The call to attach a debug program to the debug engine was received in an unexpected order.

The async operation is already running.

The async operation is not running.

The async operation has been added to a worklist and should not be managed manually.

Failed to post an async operation completion to the UI thread.

Cannot begin an async operation while the SDM is cancelling current operations.

This Time Travel Debugging trace file is already being debugged.

Script debugging is not supported on the target platform.

Tasks cannot be shown if a dump has multiple app domains.

The thread is virtual.

Viewing tasks for live processes is not supported in .NET Core 2.2.

Viewing tasks for live processes is not supported in attach scenario.

The CLR version is not supported to retrieve task information for the dump.

Symbols are not loaded for the target dll.

Symbols for the target dll do not contain source information.

Breakpoint could not be written at the specified instruction address.

Breakpoints cannot be set in optimized code when the debugger option 'Just My Code' is enabled.

The Common Language Runtime was unable to set the breakpoint.

Cannot set breakpoints in .NET Framework methods which are implemented in native code (ex: 'extern' function).

Cannot set breakpoint, target module is currently unloaded.

Stopping events cannot be sent. See stopping event processing documentation for more information.

This operation is not permitted because the target process is already stopped.

This operation is not permitted because the target process is not stopped.

This operation is not allowed on this thread.

This operation is not allowed at this time.

The caller is not allowed to request this operation. This operation must be requested by a different component.

Operation is only permitted on the latest version of an edited method.

A memory read or write operation failed because the specified memory address is not currently valid.

No source information is available for this instruction.

Failed to load localizable resource from vsdebugeng.impl.resources.dll. If this problem persists, please repair your Visual Studio installation via 'Add or Remove Programs' in Control Panel.

DkmVariant is of a form that marshalling is not supported. Marshalling is supported for primitives types, strings, and safe arrays of primitives.

An incorrect version of vsdebugeng.dll was loaded into Visual Studio. Please repair your Visual Studio installation.

The remote debugger was unable to initialize Microsoft Windows Web Services (webservices.dll). If the problem continues, try reinstalling the Windows Web Services redistributable. This redistributable can be found under the 'Remote Debugger\Common Resources\Windows Updates' folder.

Visual Studio encountered an error while loading a Windows component (Global Interface Table). If the problem persists, this may be an indication of operating system corruption, and Windows may need to be reinstalled.

Windows authentication was unable to establish a secure connection to the remote computer.

The Remote Debugger was unable to locate a resource dll (vsdebugeng.impl.resources.dll). Please ensure that the complete remote debugger folder was copied or installed on the target computer.

The hardware does not support monitoring the requested number of bytes.

The maximum number of data breakpoints have already been set.

Breakpoints cannot be set while debugging a minidump.

The minidump is from an ARM-based computer and can only be debugged on an ARM computer.

The minidump is from an unknown processor, and cannot be debugged with this version of Visual Studio.

The shell failed to find a checksum for this file.

On x64, context control must be included in a SetThreadContext

The size of the buffer does not match the size of the register.

The requested register was not found in the stack frame's unwound register collection.

Cannot set a read-only register.

Cannot set a register in a frame that is not the top of the stack.

String could not be read within the specified maximum number of characters.

The memory region does not meet the requested protection flags.

Instruction is invalid or unknown to the disassembler.

An invalid runtime was specified for this operation.

Variable is optimized away.

The text span is not currently loaded in the specified script document.

This location could not be mapped to client side script.

The file requested must be less than 100 megabytes in size

The file path requested could not be written to as it is invalid. Ensure the path does not contain a file where a directory is expected.

Script debugging is not enabled for WWAHost.exe.

The file path requested for deletion does not exist.

A command is already executing, only one may execute at a time. Please wait for the executable to exit, or abort the command.

The specified file path is a relative or unknown path format. File paths must be fully qualified.

Windows Store app debugging is not possible when the remote debugger is running as a service. Run the Remote Debugger Configuration Wizard on the target computer, and uncheck the option to start the remote debugger service. Then start the Visual Studio Remote Debugger application.

Applications cannot be launched under the debugger when the remote debugger is running as a service. Run the Remote Debugger Configuration Wizard on the target computer, and uncheck the option to start the remote debugger service. Then start the Visual Studio Remote Debugger application.

The AD7 AL Causality bridge has already been initialized.

App Packages may only be shutdown as part of a Visual Studio build operation.

A Microsoft Windows component is not correctly registered. If the problem persists, try repairing your Windows installation, or reinstalling Windows.

The application never reached a suspended state.

A different version of this script file has been loaded by the debugged process. The script file may need to be reloaded.

No stack frame was found.

Operation is not supported while interop debugging.

The selected accelerator does not support the run current tile to cursor operation.

Data breakpoints are not supported on this platform.

The debugger failed to attach to the process requested in the DkmDebugProcessRequest.

Evaluating the function caused the target process to exit.

An invalid NativeOffset or CPUInstructionPart value was used with a DkmClrInstructionAddress or DkmClrInstructionSymbol

Managed heap is not in a state that can be enumerated

This operation is unavailable when mixed mode debugging with Script

This operation is unavailable when debugging native-compiled .NET code.

Symbol file contains data which is in an unexpected format.

Dynamically enabling script debugging in the target process failed.

Expression evaluation is not available in async call stack frames.

This dump does not contain any thread information or the thread information is corrupt. Visual Studio does not support debugging of dumps without valid thread information.

DkmLoadCompleteEventDeferral.Add cannot be called after the load complete event has been sent.

DkmLoadCompleteEventDeferral was not present in the list during a call to DkmLoadCompleteEventDeferral.Remove.

The buffer size specified was too large to marshal over the remote boundary.

Emulation of iterator for results view failed. This is typically caused when the iterator calls into native code.

Managed heap enumeration is attempted on running target. This is typically caused by continuing the process while heap enumeration is in progress.

The Microsoft .NET Core CLR Debugging Services Loader (dbgshim.dll) could not be loaded or initialized.

Breakpoints cannot be set in modules that contain the implementation of the underlying runtime, such as clr.dll.

Detach is not allowed after changes have been applied through Edit and Continue.

Managed heap enumeration ran into an issue reading objects from the heap, not all objects were captured

The data requested is not present.

The DkmProcess isn't a valid process that supports snapshot operations.

Failed to find enough memory to create a new snapshot.

DkmProcess's flags indicate that it's associated with one snapshot but the snapshot information is missing.

DkmProcess doesn't contain snapshot information.

This file does not exactly match the original version.

No executable code of the debugger's target code type is associated with this line. Possible causes include: conditional compilation, compiler optimizations, or the target architecture of this line is not supported by the current debugger code type.

No symbols have been loaded for this document.

ProcessSnapshotCleanup.exe exited unexpectedly

There is no TimeContext set on this program.

Missing dependencies for Time Travel Debugging replay. This indicates an incomplete or corrupt installation of Visual Studio. Try repairing your installation.

The Time Travel Debugging trace file isn't supported.

Unable to start the Microsoft Visual Studio Debug Console. If this problem continues, repair the Visual Studio installation, or enable 'Tools->Options->Debugging->Automatically close the console when debugging stops'.

Unable to start a new process in the Microsoft Visual Studio Debug Console. The console is already in use.

See https://aka.ms/vsdbg-mac-troubleshooting for more information.

Unable to enumerate running instances of the CoreCLR in the specified process.

Unable to load Visual Studio debugger component (mspdbst.dll). If this problem persists, repair your installation via 'Add or Remove Programs' in Control Panel.

Unable to load Visual Studio debugger component (msenc.dll). If this problem persists, repair your installation via 'Add or Remove Programs' in Control Panel.

Unable to load Visual Studio debugger component (msobj140.dll). If this problem persists, repair your installation via 'Add or Remove Programs' in Control Panel.

The debugger's worker process (msvsmon.exe) unexpectedly exited. Debugging will be aborted.

Unable to initiate the connection to Time Travel Debugging component.

Unable to create a replay engine.

Indicates that the runtime breakpoint could not be enabled. The runtime breakpoint implementer will communicate back an error message through IDkmDataBreakpointErrorInfoClient.

Unable to delete an object ID that is currently tracked by a data breakpoint.

Unable to set the range for replaying.

Events are not loaded into Time Travel Debugging component.

The index is out of date.

The time travel recording file isn't compatible.

Debugging a Time Travel Debugging trace file requires a 64-bit version of Windows

There was a problem indexing the Time Travel Debugging trace file.

Unable to start the indexing program.

Unable to initialize a time travel replay engine.

A component dll failed to load. Try to restart this application. If failures continue, try disabling any installed add-ins or repair your installation.

Xapi has not been initialized on this thread. Call ComponentManager.InitializeThread.

Xapi has already been initialized on this thread.

Xapi event thread aborted unexpectedly.

Component failed a call to QueryInterface. QueryInterface implementation or component configuration is incorrect.

Object requested which is not available at the caller's component level.

Failed to process configuration file. Try to restart this application. If failures continue, try to repair your installation.

Failed to initialize managed/native marshalling system. Try to restart this application. If failures continue, try to repair your installation.

This operation may only be performed while processing the object's 'Create' event.

This operation may only be performed by the component which created the object.

The work item cannot be appended to the work list because it is already complete.

'Execute' may not be called on a work list which has already started.

The interface implementation released the completion routine without calling it.

Operation is not supported on this thread.

No component with the given component id could be found in the configuration store.

Call was attempted to a remote connection from a server-side component (component level > 100000). This is not allowed.

Destination of this call is on a remote connection and this method doesn't support remoting.

The network connection to the Visual Studio Remote Debugger was lost.

The network connection to the Visual Studio Remote Debugger has been closed.

A protocol compatibility error occurred between Visual Studio and the Remote Debugger. Please ensure that the Visual Studio and Remote debugger versions match.

Maximum allocation size exceeded while processing a remoting message.

An object already exists with the same key value.

An object cannot be found with the given key value.

A data item already exists with the same key value.

A data item cannot be for this component found with the given data item ID.

Interface implementation failed to provide a required out param.

Strong name signature validation error while trying to load the managed dispatcher

Method may only be called by components which load in the IDE process (component level > 100000).

Method may only be called by components which load in the remote debugger process (component level < 100000).

A component dll could not be found. If failures continue, try disabling any installed add-ins or repairing your installation.

Operation requires the remote debugger be updated to a newer version.

An exception was thrown from a debugger component.

STA threads are not supported in the remote debugger.

Standard remote operation attempted on a worker process connection or vice versa.

Method may not be called from a worker process.

The implementation found cannot be called in a worker process.

Invalid or null element present in array.

Represents a version of the CLR runtime

Information flags about the state of a CLR when it is being attached to in the native pipeline debugging model

Provides version specific debugging libraries such as mscordbi.dll and mscorwks.dll during startup in the native pipeline debugging architecture

Provides a version specific debugging library

The name of the library being requested The timestamp of the library being requested as specified in the PE header The SizeOfImage of the library being requested as specified in the PE header An OS handle to the requested library HResults.S_OK if the library was located, otherwise any appropriate error hresult

This interface exposes the native pipeline architecture startup APIs

Detects if a native module represents a CLR and if so provides the debugging interface and versioning information

The native base address of a module which might be a CLR The process abstraction which can be used for inspection A callback interface for locating version specific debug libraries such as mscordbi.dll and mscordacwks.dll The highest version of the CLR/debugging libraries which the caller can support The CLR's debugging interface or null if no debugger was detected The version of the CLR detected or null if no CLR was detected Flags which have additional information about the CLR. See ClrDebuggingProcessFlags for more details HResults.S_OK if an appropriate version CLR was detected, otherwise an appropriate error hresult

Determines if the module is no longer in use

A module handle that was provided via the ILibraryProvider HResults.S_OK if the module can be unloaded, HResults.S_FALSE if it is in use or an appropriate error hresult otherwise

Return a timestamp obtained using QueryPerformanceCounter

A timestamp for the call

This attribute enables the behavior of treating continuable corrupting managed exceptions(like NullReferenceException, ArgumentNullException etc...) as non-fatal which will be reported to Microsoft via non-fatal watson channel and not crash debugger process Note: non-continuable corrupting exceptions(like AccessViolationException, StackOverflowException etc...) are still treated as fatal and will crash debugger process

This attribute allows managed concord component to opt-in reporting of non-fatal exception to watson.

Specify the type of exception to exclude from reporting

Internal exception callout class which can be customized for each individual XAPI-based API.

Exception filter function for this dll. This method is called during the 'handler search' phase of exception handling.

Exception object which was thrown true if the excepion should be caught.

Convert the exception object to a HRESULT. This method is called when 'OnException' returned 'true'.

[Optional] exception to convert

Provides an implementation of CRT functions for use from managed code

Managed implementation of memcpy. This needs to be provided since there is no overload of Marshal.Copy which takes an IntPtr on both ends. This code needs to use GCHandle instead of 'fixed' because there is no way to constrain a generic to native types.

Managed implementation of memcpy. This needs to be provided since there is no overload of Marshal.Copy which takes an IntPtr on both ends.

Managed implementation of the CRT 'memcmp' function.

Pointer to the first value to compare Pointer to the second value to compare Number of bytes to compare less than zero : p0 less than p1 zero : p0 equals p1 greator than zero : p0 greator than p1

Implementation of memcmp which compares the two pointers one byte at a time. Currently this function is called with 'size' equal to (1,2,3,4).

Object to pool to use for items that are frequenty allocated/released. Pooling such objects can sometimes reduce pressure on the GC

[Required] Get an object from the pool. Create a new one if none are available

Return an object to the pool.

[Required] Object to return to the pool

Adds the specified object to the table and returns the object handle for it

[Required] object to add The created object handle

Frees the specified object handle

[Optional] handle to free

Frees the specified object handle

[Optional] the handle to free

Frees the specified handle and returns the object that was stored there

[Required] strong handle id handle to detach from [Required] The object that was stored with the specified handle

Returns the object that is stored with the specified handle.

[Required] strong handle id [Required] object stored at the specified handle.

Convert a native array of 'raw' objects into a managed array

Type of the managed object Pointer to the native array created array

Convert a native array of structs to a managed array of structs

Convert a native array of dispatcher objects or typemap entries to a managed array of objects

Convert a managed array to native in the case that array elements are raw

Convert a managed array to native in the case that the array elements are type map entries

Convert a managed array to native in the case that the array elements are structs or dispatcher objects

Indicates the current component on this thread. This is maintained by the managed dispatcher in order to correctly implement data container support.

Called from the native dispatcher to release all managed components

Pointer to the head class info. True if deployment connection related components should be skipped

Called from the native dispatcher to test if the given assembly is installed

Tracks resources associated with a managed->native call. Scenario Use Native->Managed call (in param) Null: don't want to release 'in' params Native->Managed call (out param) Null: references are owned by the callers. Marshalling errors are fatal. Managed->Native call (in param) Non-null: Release the temporary native objects. Managed->Native call (out param) Non-null: Release the native result once it has been converted to managed. Dispatcher object property marshalling Null: don't want to release embedded native resources

Add a native interface pointer to the tracked resource list

[Optional] current outgoing call [Optional] New native interface to add

Add a native interface pointer to the tracked resource list

[Optional] New native interface to add

Add memory allocated with ProcDkmAlloc to the tracked resource list

[Optional] current outgoing call [Optional] Allocated native memory

Add memory allocated with ProcDkmAlloc to the tracked resource list

[Optional] Allocated native memory

Pin a managed array. The array will be unpinned when the call completes

Managed array to pin. Pointer to the native address for the managed array

An array implementation that supports automatic resizing and provides access to its internal array. When the array size is less than or equal to MinCapacity, the internal array is pooled for faster performance.

Element type

[Required] Gets the internal array. Warning: The array is usually larger than Length!

Gets the number of items added to the array

Gets the item at 'index'. Warning: No runtime index checking

Adds an item to the array

[Optional] Item (can be null)

Structure defintions created from message packer and then edited for the needs of the managed dispatcher: 1. Structures are created from native code and then read from managed code, so they must be identical. Original structs were meant for message-packer usage so pointers were given 64-bits of space and layout was explicit. 2. Remove usage of message packer library 3. Remove all the types which the managed dispatcher doesn't need.

Should the dispatcher synchronize all accesses to the component? (place a big lock around it).

Should the component stay loaded after stop debugging if a deployment connection is still active? See src\debugger\concord\api\XapiCompiler\ConfigurationSchema.inl for more information.

Structure which describes the elements of a collection

This interface is implemented by non-raw XapiCompiler generated types (ex: implemented by all dispatcher objects, and structs which cannot simply be blitted between managed and native)

Type used to represent the native object in managed code. For dispatcher objects, this will be a 'IntPtr' for structs, this will be the 'native' struct (ex: NativeDkmClrDecodedFrame).

Marshal the managed object to native

Call object which stores resources to be freed at the end of the call Native object

Delegate used to marshal a managed type into native. This function is implemented by custom marshallers for typemap items (ex: the custom marshaller which converts between DkmString's and String's).

Managed type to marshal Call object which stores resources to be freed at the end of the call. COM Pointer. This COM pointer should be AddRef'ed and the COM pointer should be added to the call object so that it will be released at the end of the call.

Delegate used to marshal a native type into managed. This function is implemented by both custom marshallers (ex: strings) and by XapiCompiler generated types (dispatcher objects, and non-raw structs)

Managed type to return Pointer to the native object. In the case of a struct, this is a pointer to the struct. In the case of a COM object, this is a pointer to it. The new managed object

The XapiMarshallingLock guards all accesses to m_ObjectGCHandle. The alternative to this would be PInvoking Enter/LeaveCriticalSection on the native object that we are attempting to marshal/unmarshal

Aquire the the lock.

Release the lock

Try to obtain an existing managed object from the GCHandle stored in the native object

Pointer to the native object [Optional] the managed object

Try to obtain an existing managed object from the GCHandle stored in the native object

Pointer to the native object [Optional] the managed object

Used to invoke 'ManagedToNative' on a value dispatcher object through its implementation of the IXapiMarshalableElement interface. This is done to ensure that the most-derived version of ManagedToNativeImpl is called.

Convert a native array of structs to a managed array of structs

Managed struct type call object to store resurces Length of the native array Pointer to the start of the native array Native element type Function to unmarshal each element Created array

Convert a native array of dispatcher objects or typemap entries to a managed array of objects

Managed object type call object to store resurces Length of the native array Pointer to the start of the native array Function to unmarshal each element Created array

Determine if the given exception is continuable corrupting exception.

input exception true if the excepion

Determine if the given exception needs to be reported to watson.

input exception true if the excepion