Compartilhar via


.call (Função de chamada)

O comando .call faz com que o processo de destino execute uma função.

.call [/v] Function( Arguments ) 
.call /s Prototype Function( Arguments ) 
.call /c 
.call /C 

Parâmetros

/v
Informações detalhadas sobre a chamada e seus argumentos são exibidas.

/s Protótipo
Permite chamar a função especificada por Function mesmo que você não tenha os símbolos corretos. Nesse caso, você deve ter símbolos para outra função que tenha o mesmo protótipo de chamada que a função que você está tentando chamar. O parâmetro Prototype é o nome dessa função prototype.

Função
Especifica a função que está sendo chamada. Pode ser o nome da função (preferencialmente qualificado com um nome de módulo) ou qualquer outra expressão que seja avaliada como o endereço da função. Se você precisar chamar um construtor ou destruidor, deverá fornecer o endereço -- ou então usar uma expressão C++ para avaliar a sintaxe nomeada para os operadores (consulte Sintaxe de expressão numérica para obter detalhes).

Argumentos
Especifica os argumentos passados para a função. Se você estiver chamando um método, o primeiro argumento deverá ser this e todos os outros argumentos o seguirão. Os argumentos devem ser separados por vírgulas e devem corresponder à sintaxe usual do argumento. Há suporte para listas de argumentos de comprimento variável. As expressões dentro de um argumento são analisadas pelo avaliador de expressão C++; consulte Números e operadores do C++ para obter detalhes. Você não pode inserir uma cadeia de caracteres literal como um argumento, mas pode usar um ponteiro para uma cadeia de caracteres ou qualquer outra memória acessível ao processo de destino.

/c
Limpa qualquer chamada existente no thread atual.

/C
Limpa qualquer chamada existente no thread atual e redefine o contexto do thread atual para o contexto armazenado pela chamada pendente.

Ambiente

Modos

somente modo de usuário

Destinos

somente depuração ao vivo

Plataformas

Somente x86 e x64

Comentários

A função especificada é chamada pelo thread atual do processo atual.

Somente as convenções de chamada cdecl, stdcall, fastcall e thiscall são suportadas. O código gerenciado não pode ser chamado por esse comando.

Depois que .call for usado, o depurador atualizará a pilha, alterará o ponteiro de instrução para apontar para o início da função chamada e, em seguida, parará. Use g (Go) para retomar a execução ou ~. g para executar apenas o thread que está fazendo a chamada.

Quando a função retorna, ocorre uma interrupção e o depurador exibe o valor retornado da função. O valor retornado também é armazenado no pseudo-registrador $callret , que adquire o tipo do valor retornado.

Se você tiver invadido o destino usando CTRL+C ou CTRL+BREAK, o thread atual será um thread adicional criado para lidar com a interrupção. Se você emitir um comando .call neste ponto, o thread extra será usado para a função chamada.

Se você tiver atingido um ponto de interrupção predefinido, não haverá thread de interrupção extra. Se você usar .call enquanto estiver em um ponto de interrupção no modo de usuário, poderá usar g para executar todo o processo ou ~. g para executar apenas o thread atual. Usar g pode distorcer o comportamento do seu programa, já que você pegou um thread e o desviou para essa nova função. Por outro lado, este thread ainda terá seus bloqueios e outros atributos e, portanto , ~. g pode arriscar deadlocks.

A maneira mais segura de usar .call é definir um ponto de interrupção em seu código em um local onde uma determinada função possa ser chamada com segurança. Quando esse ponto de interrupção é atingido, você pode usar .call se desejar que essa função seja executada. Se você usar .call em um ponto em que essa função normalmente não pode ser chamada, poderá ocorrer um deadlock ou corrupção de destino.

Pode ser útil adicionar funções extras ao código-fonte que não são chamadas pelo código existente, mas devem ser chamadas pelo depurador. Por exemplo, você pode adicionar funções que são usadas para investigar o estado atual do código e seu ambiente e armazenar informações sobre o estado em um local de memória conhecido. Certifique-se de não otimizar seu código, ou essas funções podem ser removidas pelo compilador. Use essa técnica apenas como último recurso, pois se o aplicativo falhar , .call não estará disponível ao depurar o arquivo de despejo.

Os comandos .call /c e .call /C só devem ser usados se uma tentativa de usar .call falhar ou se você mudou de ideia antes de inserir o comando g . Eles não devem ser usados casualmente, pois abandonar uma chamada incompleta pode levar a um estado de destino corrompido.

O exemplo de código a seguir mostra como o comando .call /s é usado.

.call /s KnownFunction UnknownFunction( 1 )

Neste exemplo, você tem símbolos privados para KnownFunction, que usa um inteiro como seu único argumento e retorna, por exemplo, um ponteiro para uma matriz. Você não tem símbolos ou, possivelmente, só tem símbolos públicos para UnknownFunction, mas sabe que ele usa um inteiro como seu único argumento e retorna um ponteiro para uma matriz. Usando a opção /s, você pode especificar que UnknownFunction funcionará da mesma maneira que KnownFunction. Assim, você pode gerar com êxito uma chamada para UnknownFunction.