Compartilhar via

Registrar o programa

Depois que o mecanismo de depuração tiver adquirido uma porta, representada por uma interface IDebugPort2 , a próxima etapa para habilitar o programa a ser depurado é registrá-la na porta. Depois de registrado, o programa fica disponível para depuração por um dos seguintes meios:

  • O processo de anexação, que permite que o depurador obtenha controle de depuração completo de um aplicativo em execução.

  • A depuração just-in-time (JIT) permite a depuração de um programa após sua execução, sendo que ele é executado independentemente de um depurador. Quando a arquitetura em tempo de execução captura uma falha, o depurador é notificado antes que o sistema operacional ou o ambiente de tempo de execução libere a memória e os recursos do programa com falha.

Procedimento de registro

Para registrar seu programa

  1. Chame o método AddProgramNode implementado pela porta.

    IDebugPortNotify2::AddProgramNode requer um ponteiro para uma interface IDebugProgramNode2 .

    Normalmente, quando o sistema operacional ou o ambiente em tempo de execução carrega um programa, ele cria o nó do programa. Se o DE (mecanismo de depuração) for solicitado a carregar o programa, ele criará e registrará o nó do programa.

    O exemplo a seguir mostra o motor de depuração iniciando o programa e registrando-o em uma porta.

    Observação

    Este exemplo de código não é a única maneira de iniciar e retomar um processo; esse código é principalmente um exemplo de registro de um programa com uma porta.

    // This is an IDebugEngineLaunch2 method.
HRESULT CDebugEngine::LaunchSuspended(/* omitted parameters */,
                                      IDebugPort2 *pPort,
                                      /* omitted parameters */,
                                      IDebugProcess2**ppDebugProcess)
{
    // do stuff here to set up for a launch (such as handling the other parameters)
    ...

    // Now get the IPortNotify2 interface so we can register a program node
    // in CDebugEngine::ResumeProcess.
    CComPtr<IDebugDefaultPort2> spDefaultPort;
    HRESULT hr = pPort->QueryInterface(&spDefaultPort);
    if (SUCCEEDED(hr))
    {
        CComPtr<IDebugPortNotify2> spPortNotify;
        hr = spDefaultPort->GetPortNotify(&spPortNotify);
        if (SUCCEEDED(hr))
        {
            // Remember the port notify so we can use it in ResumeProcess.
            m_spPortNotify = spPortNotify;

            // Now launch the process in a suspended state and return the
            // IDebugProcess2 interface
            CComPtr<IDebugPortEx2> spPortEx;
            hr = pPort->QueryInterface(&spPortEx);
            if (SUCCEEDED(hr))
            {
                // pass on the parameters we were given (omitted here)
                hr = spPortEx->LaunchSuspended(/* omitted parameters */,ppDebugProcess)
            }
        }
    }
    return(hr);
}

HRESULT CDebugEngine::ResumeProcess(IDebugProcess2 *pDebugProcess)
{
    // Make a program node for this process
    HRESULT hr;
    CComPtr<IDebugProgramNode2> spProgramNode;
    hr = this->GetProgramNodeForProcess(pProcess, &spProgramNode);
    if (SUCCEEDED(hr))
    {
        hr = m_spPortNotify->AddProgramNode(spProgramNode);
        if (SUCCEEDED(hr))
        {
            // resume execution of the process using the port given to us earlier.
           // (Querying for the IDebugPortEx2 interface is valid here since
           // that's how we got the IDebugPortNotify2 interface in the first place.)
            CComPtr<IDebugPortEx2> spPortEx;
            hr = m_spPortNotify->QueryInterface(&spPortEx);
            if (SUCCEEDED(hr))
            {
                hr  = spPortEx->ResumeProcess(pDebugProcess);
            }
        }
    }
    return(hr);
}

Conteúdo relacionado

  • Last updated on