DetailPage-MSS-KB

Base de Dados de Conhecimento

ID do artigo: 155763 - Última revisão: segunda-feira, 11 de julho de 2005 - Revisão: 2.3

 

Nesta página

Sumário

Como desenvolvedor, talvez você precise acessar a funcionalidade fornecida por uma biblioteca de vínculo dinâmico 16 bits (DLL) do seu aplicativo Win32. Isso é verdadeiro especialmente quando você não tem o código-fonte para a DLL para que você pode a porta para Win32. Este artigo descreve o mecanismo pelo qual DLLs de 32 bits podem chamar DLLs de 16 bits. O mecanismo é chamado de uma conversão e o método implementado no Microsoft Windows 95, Windows 98 e Windows Millennium Edition é chamado de uma conversão simples.

O seguinte descreve as três etapas principais envolvidas na criação de uma conversão simples:
  1. Crie o script de conversão.
  2. Crie a DLL de 32 bits.
  3. Crie a DLL de 16 bits.

Mais Informações

Uma conversão simples consiste em 32 bits e uma DLL de 16 bits que funcionam juntos. Um aplicativo Win32 chama a DLL de 32 bits, e a DLL de 32 bits chama uma função exportada na DLL de 16 bits. Quando a função na DLL de 16 bits retorna, ele retorna para a DLL de 32 bits, que por sua vez retorna volta para o aplicativo Win32. Trabalho de DLLs de 32 bits e 16 bits, chamando os Windows 95 de 32 bits e 16 bits kernels para lidar com todos os detalhes de baixo nível necessários para fazer a transição do código de 32 bits para 16 bits e de volta.

Criar uma nova conversão simples envolve criar um script de conversão (.thk arquivo). Esse script é compilado com o compilador Thunk em um arquivo de linguagem assembly, que é montado, em seguida, duas vezes; uma vez com cada um dos dois sinalizadores de - DIS_32 e - DIS_16. Isso permite que você criar os módulos de objeto de 32 bits e 16 bits. Esses módulos de objeto são vinculados em DLLs de 32 bits e 16 bits, respectivamente. O diagrama a seguir resume os arquivos envolvidos na criação de DLLs:
                         +------------+
                         | 32to16.thk |
                         +------------+
                               |
                         +------------+
                         | 32to16.asm |
                         +------------+
                           /         \ 
                  -DIS_32 /           \ -DIS_16
                        /              \ 
                  +-----------+  +-----------+
                  | 32THK.obj |  | 16THK.obj |
                  +-----------+  +-----------+
                        /                 \ 
        +-------+    +-------+             +-------+
        | APP32 | -> | DLL32 | -- THUNK -- | DLL16 |
        +-------+    +-------+             +-------+
				

Ferramentas necessárias para criar Thunks simples

  • Microsoft Visual C++ versão 1.5 x compilador (16 bits) para o lado 16 bits de criar a conversão. O lado de 16 bits da conversão é uma DLL de 16 bits.
  • Microsoft Visual C++ versão 2.x ou superior compilador (32-bit) para criar o lado de 32 bits da conversão. O lado de 32 bits da conversão é uma DLL de 32 bits.
  • Compilador de conversão (Thunk.exe) do Microsoft Win32 SDK para compilar scripts de conversão.
  • Macro de Microsoft Assembler (MASM) versão 6.1 ou superior para montar a saída de linguagem assembly do compilador de conversão.
  • arquivo de RC.exe 16 bits do diretório BINW16 do Microsoft Win32 SDK para marcar a DLL de conversão de 16 bits como versão 4.0.

Criar o Script Thunk

Você precisará criar um script que pode ser usado pelo compilador Thunk para criar uma conversão. Um script de conversão é um arquivo de texto que contém definições de tipo, protótipos de função das funções que você deseja chamar via thunks e uma especificação da direção dos parâmetros para cada função. Por exemplo, algumas funções requerem parâmetros de entrada e saídos enquanto outros podem exigir somente parâmetros de entrada. Conversão scripts usam sintaxe especial para descrever se parâmetros são entrados, saída, ou entrada e saída.

Um script de conversão para 32-> 16 thunks começa com a instrução a seguir:
enablemapdirect3216 = true;
O compilador Thunk espera que o lado de 32 bits da conversão é declarado como __stdcall e que o lado de 16 bits é __pascal __far. (A declaração WINAPI cuida desse em ambos os lados.) Não há suporte para __cdecl e __fastcall convenções de chamada pelo compilador Thunk. No entanto, observe que o compilador Thunk não aceita, na verdade, as palavras-chave __far, __pascal ou __stdcall; eles são considerados.

O exemplo a seguir mostra um script de conversão para uma função que não tem parâmetros:
   enablemapdirect3216 = true;

   void MyThunk16()
   {
   }
				
a declaração equivalente seria:
   C   language:  void WINAPI MyThunk16(void);
   C++ language:  extern "C" void WINAPI MyThunk16();
				
o script de exemplo a seguir descreve uma função que usa dois parâmetros e retorna um valor. O segundo parâmetro é um parâmetro de saída que contém um ponteiro é passado de volta para a DLL de 32 bits.
   enablemapdirect3216 = true;

   typedef int   BOOL;
   typedef char *LPSTR;

   BOOL MyThunk16(LPSTR lpstrInput, LPSTR lpstrOutput)
   {
      lpstrInput  = input;    // optional; input is default
      lpstrOutput = output;
   }
				
a instrução "lpstrOutput = saída" informa ao compilador Thunk que a função de 16 bits retorna um endereço que precisa ser convertido de um ponteiro de deslocamento de seletor: em um endereço de 32 bits linear.

O seguinte script de conversão usa tipos de parâmetro mais complexos, como estruturas. Este exemplo também mostra como especificar parâmetros de entrada e saídos.
   enablemapdirect1632 = true;

   typedef unsigned int UINT;
   typedef char *LPSTR;

   typedef struct _POINT {
      UINT x;
      UINT y;
   }POINT, *LPPOINT;

   typedef struct _CIRCLE {
      POINT center;
      UINT  radius;
   }CIRCLE, *LPCIRCLE;

   void MyThunk32( LPCIRCLE lpCircleInOut)
   {
      lpCircleInOut = inout;
   }
				
a instrução "lpCircleInOut = inout" informa o compilador do script que esse ponteiro será a ser usado para entrada e saída. Isso faz com que o compilador Thunk converter lpCircleInOut de um endereço de 32 bits linear para um ponteiro de seletor: deslocamento, quando a função é chamada e, em seguida, de volta para um endereço de 32 bits linear quando a função retorna. A conversão é manipulada pela conversão criado pelo compilador Thunk.

Usando o compilador Thunk

O uso de compilador Thunk é da seguinte maneira:
Thunk.exe/opções <outputfile> <inputfile> -o
A seguinte linha de comando mostra como compilar uma 32-> 16 script de conversão. Essa linha tem um script de conversão chamado 32to16.thk e produz um arquivo de linguagem assembly denominado 32to16.asm.
conversão -t thk 32to16.thk -o 32to16.asm
O "-t thk" opção informa o compilador Thunk prefixo as funções de conversão no arquivo de linguagem assembly com "thk_." Esse prefixo é usado ao vincular vários scripts de conversão em um par de DLLs e é útil para criar um par de DLLs que contêm ambas as 32-> 16-> 32 thunks e 16. Cada script de conversão deve ter um prefixo exclusivo.

Criando a DLL de 32 bits

  1. Na função DllMain de sua DLL de 32 bits, você deve fazer uma chamada para uma função criada pelo compilador Thunk denominado thk_ThunkConnect32 para cada motivo (dwReason) DllMain é chamado, conforme mostrado aqui ("thk" é o prefixo do comutador Thunk compilador -t):
          // prototype for function in .obj file from the thunk script
          BOOL WINAPI thk_ThunkConnect32(LPSTR     lpDll16,
                                         LPSTR     lpDll32,
                                         HINSTANCE hDllInst,
                                         DWORD     dwReason);
    
          BOOL WINAPI DllMain(HINSTANCE hDLLInst,
                              DWORD     dwReason,
                              LPVOID    lpvReserved)
          {
             if (!thk_ThunkConnect32("DLL16.DLL", "DLL32.DLL",
                                     hDLLInst, dwReason))
             {
                return FALSE;
             }
             switch (dwReason)
             {
                case DLL_PROCESS_ATTACH:
                   break;
    
                case DLL_PROCESS_DETACH:
                   break;
    
                case DLL_THREAD_ATTACH:
                   break;
    
                case DLL_THREAD_DETACH:
                   break;
             }
             return TRUE;
          }
    						
  2. Inclua as seguintes linhas na seção EXPORTS do arquivo de definição (.def) módulo para a DLL de 32 bits. Por exemplo:
          
       thk_ThunkData32
    						
  3. Exporte as funções que o aplicativo Win32 chama. Você pode usar arquivo de definição (.def) de módulo a DLL de 32 bits ou a palavra-chave __declspec(dllexport). Certifique-se as funções são declaradas e definidas como __stdcall (ou WINAPI). Se a DLL de 32 bits está escrita em C++, certifique-se de declarar as funções como extern "C".
  4. Compilar o script de conversão da seguinte maneira (se ainda não compilado):
          thunk -t thk 32to16.thk -o 32to16.asm
    						
  5. Monte o arquivo de linguagem assembly gerado pelo compilador Thunk como um módulo de objeto de 32 bits. Por exemplo:
          ml /DIS_32 /c /W3 /nologo /coff /Fo thk32.obj 32to16.asm
    						
  6. Vincule este módulo de objeto como parte da DLL de 32 bits.
  7. Vincule a biblioteca Thunk32.lib como parte da DLL de 32 bits. Isso é a biblioteca de importação de 32 bits fornecida no SDK do Win32 que contém referências para as APIs de conversão (thunking) de 32 bits que usa o código criado pelo compilador Thunk.

Criando a DLL de 16 bits

  1. A DLL de 16 bits deve exportar uma função chamada "DllEntryPoint." Esta função deve fazer uma chamada para uma função criada pelo compilador Thunk chamado thk__ThunkConnect16 ("thk" é o prefixo do comutador Thunk compilador -t) toda vez que é chamado de DllEntryPoint:
          // prototype for function in .obj file from the thunk script
          BOOL WINAPI __export thk_ThunkConnect16(LPSTR lpDll16,
                                                  LPSTR lpDll32,
                                                  WORD  hInst,
                                                  DWORD dwReason);
    
          BOOL WINAPI __export DllEntryPoint(DWORD dwReason,
                                             WORD  hInst,
                                             WORD  wDS,
                                             WORD  wHeapSize,
                                             DWORD dwReserved1,
                                             WORD  wReserved 2)
          {
             if (!thk_ThunkConnect16("DLL16.DLL",
                                     "DLL32.DLL",
                                     hInst,
                                     dwReason))
             {
                return FALSE;
             }
             return TRUE;
          }
    						
  2. Inclua as seguintes linhas na seção IMPORTA o arquivo de definição (.def) módulo para a DLL de 16 bits. Por exemplo:
          C16ThkSL01      = KERNEL.631
          ThunkConnect16  = KERNEL.651
    						
  3. Inclua as seguintes linhas na seção EXPORTS do arquivo de definição (.def) módulo para a DLL de 16 bits. THK_THUNKDATA16 é definido no arquivo do objeto montado da saída do compilador Thunk. Ambos esses símbolos devem ter a palavra-chave RESIDENTNAME, mas podem ter qualquer número ordinal.
          THK_THUNKDATA16 @1  RESIDENTNAME
          DllEntryPoint   @2  RESIDENTNAME
    						
  4. Adicione as funções de conversão à instrução EXPORTS do arquivo de definição (.def) de módulo do DLL de 16 bits. Certifique-se eles são declarados e definidos como __pascal __far __export (ou WINAPI __export). Se a DLL está escrita em C++, certifique-se de declará-los como extern "C". O lado de 32 bits da conversão chama essas funções.
  5. Compilar o script de conversão da seguinte maneira (se ainda não compilado):
          thunk -t thk 32to16.thk -o 32to16.asm
    						
  6. Monte o arquivo de linguagem assembly gerado pelo compilador Thunk como um módulo de objeto de 16 bits. Por exemplo:
          ml /DIS_16 /c /W3 /nologo /Fo thk16.obj 32to16.asm
    						
  7. Vincule este módulo de objeto como parte da DLL de 16 bits.
  8. Marcar a DLL de 16 bits como versão 4.0. Para fazer isso, use o compilador de recursos (rc.exe). A linha a seguir mostra a sintaxe:
    rc 40 º < arquivo DLL >
    Esta opção de 40 º está disponível no compilador de recurso é fornecido com o Win32 SDK.

    Observação : Certifique-se de usar o arquivo RC.exe no diretório BINW16 para que a DLL é marcada com versão 4.0. O arquivo RC.exe que é fornecido com as versões de 16 bits do Microsoft Visual C++ não marca a DLL como versão 4.0.

Referências

Para obter informações sobre como depurar thunks simples, consulte o seguinte artigo na Base de dados de Conhecimento da Microsoft:
133722  (http://support.microsoft.com/kb/133722/EN-US/ ) Como depurar Thunks simples

A informação contida neste artigo aplica-se a:
  • Interface de Programação de Aplicativos do Microsoft Win32 nas seguintes plataformas
    • Microsoft Windows 95
    • Microsoft Windows 98 Standard Edition
    • Microsoft Windows Millennium Edition
    • Microsoft Platform Software Development Kit-January 2000 Edition
Palavras-chave: 
kbmt kbapi kbhowto kbkernbase kbnetwork kbprogramming kbthunks kbtshoot KB155763 KbMtpt
Tradução automáticaTradução automática
IMPORTANTE: Este artigo foi traduzido por um sistema de tradução automática (também designado por Machine Translation ou MT), não tendo sido portanto traduzido ou revisto por pessoas. A Microsoft possui artigos traduzidos por aplicações (MT) e artigos traduzidos por tradutores profissionais, com o objetivo de oferecer em português a totalidade dos artigos existentes na base de dados de suporte. No entanto, a tradução automática não é sempre perfeita, podendo conter erros de vocabulário, sintaxe ou gramática. A Microsoft não é responsável por incoerências, erros ou prejuízos ocorridos em decorrência da utilização dos artigos MT por parte dos nossos clientes. A Microsoft realiza atualizações freqüentes ao software de tradução automática (MT). Obrigado.
Clique aqui para ver a versão em Inglês deste artigo: 155763  (http://support.microsoft.com/kb/155763/en-us/ )
Compartilhar
Opções de suporte adicionais
Fóruns de Suporte do Microsoft Community
Contate-nos diretamente
Localize um parceiro certificado da Microsoft
Microsoft Store