As ferramentas

Artigo
06/13/2023

Este tópico descreve as ferramentas disponíveis para você usar para preparar seu aplicativo de 64 bits. Windows 10 está disponível para processadores baseados em x64 e ARM64.

Arquivos de inclusão

Os elementos de API são praticamente idênticos entre o Windows de 32 e 64 bits. Os arquivos de cabeçalho do Windows foram modificados para que possam ser usados para código de 32 e 64 bits. Os novos tipos e macros de 64 bits são definidos em um novo arquivo de cabeçalho, Basetsd.h, que está no conjunto de arquivos de cabeçalho incluído pelo Windows.h. Basetsd.h inclui as novas definições de tipo de dados para ajudar a tornar o tamanho da palavra do código-fonte independente.

Novos tipos de dados

Os arquivos de cabeçalho do Windows contêm novos tipos de dados. Esses tipos são principalmente para compatibilidade de tipo com os tipos de dados de 32 bits. Os novos tipos fornecem exatamente a mesma digitação que os tipos existentes, ao mesmo tempo em que dão suporte para o Windows de 64 bits. Para obter mais informações, consulte Os Novos Tipos de Dados ou o arquivo de cabeçalho Basetsd.h.

Macros predefinidas

O compilador define as macros a seguir para identificar a plataforma.

Macro	Significado
_WIN64	Uma plataforma de 64 bits. Isso inclui x64 e ARM64.
_WIN32	Uma plataforma de 32 bits. Esse valor também é definido pelo compilador de 64 bits para compatibilidade com versões anteriores.
_WIN16	Uma plataforma de 16 bits

As macros a seguir são específicas para a arquitetura.

Macro	Significado
_M_IA64	Plataforma Intel Itanium
_M_IX86	Plataforma x86
_M_X64	Plataforma x64
_M_ARM64	Plataforma ARM64

Não use essas macros, exceto com código específico da arquitetura, em vez disso, use _WIN64, _WIN32 e _WIN16 sempre que possível.

Funções auxiliares

As seguintes funções embutidas (definidas em Basetsd.h) podem ajudá-lo a converter valores com segurança de um tipo para outro.

void            * Handle64ToHandle( const void * POINTER_64 h ) 
void * POINTER_64 HandleToHandle64( const void *h )
long              HandleToLong(     const void *h )
unsigned long     HandleToUlong(    const void *h )
void            * IntToPtr(         const int i )
void            * LongToHandle(     const long h )
void            * LongToPtr(        const long l )
void            * Ptr64ToPtr(       const void * POINTER_64 p )
int               PtrToInt(         const void *p )
long              PtrToLong(        const void *p )
void * POINTER_64 PtrToPtr64(       const void *p )
short             PtrToShort(       const void *p )
unsigned int      PtrToUint(        const void *p )
unsigned long     PtrToUlong(       const void *p )
unsigned short    PtrToUshort(      const void *p )
void            * UIntToPtr(        const unsigned int ui )
void            * ULongToPtr(       const unsigned long ul )

Aviso

IntToPtr sign-extends the int value, UIntToPtr zero-extends the unsigned int value, LongToPtr sign-extends the long value, and ULongToPtr zero-extends the unsigned long value.

Compilador de 64 bits

Os compiladores de 64 bits podem ser usados para identificar truncamento de ponteiro, conversões de tipo inadequadas e outros problemas específicos de 64 bits.

Quando o compilador for executado pela primeira vez, ele provavelmente gerará muitos avisos de truncamento de ponteiro ou incompatibilidade de tipo, como o seguinte:

warning C4311: 'type cast' : pointer truncation from 'unsigned char *' to 'unsigned long '

Use esses avisos como um guia para tornar o código mais robusto. É uma boa prática eliminar todos os avisos, especialmente avisos de truncamento de ponteiro.

Avisos e opções do compilador de 64 bits

Observe que esse compilador habilita o modelo de dados LLP64.

Há uma opção de aviso para ajudar na portabilidade para LLP64. A opção -Wp64 -W3 habilita os seguintes avisos:

C4305: aviso de truncamento. Por exemplo, "return": truncamento de "unsigned int64" para "long".
C4311: aviso de truncamento. Por exemplo, "conversão de tipo": truncamento de ponteiro de "int*_ptr64" para "int".
C4312: conversão para aviso de tamanho maior. Por exemplo, "conversão de tipo": conversão de "int" para "int*_ptr64" de maior tamanho.
C4318: passando comprimento zero. Por exemplo, passando a constante zero como o comprimento para a função memset .
C4319: não operador. Por exemplo, "~": zero estendendo "unsigned long" para "unsigned _int64" de maior tamanho.
C4313: chamando a família printf de funções com especificadores e argumentos de tipo de conversão conflitantes. Por exemplo, "printf": "%p" na cadeia de caracteres de formato está em conflito com o argumento 2 do tipo "_int64". Outro exemplo é a chamada printf("%x", pointer_value); isso causa um truncamento dos 32 bits superiores. A chamada correta é printf("%p", pointer_value).
C4244: o mesmo que o aviso C4242 existente. Por exemplo, "return": conversão de "_int64" para "unsigned int", possível perda de dados.

Vinculador e bibliotecas de 64 bits

Para criar aplicativos, use o vinculador e as bibliotecas fornecidas pelo SDK do Windows. A maioria das bibliotecas de 32 bits tem uma versão de 64 bits correspondente, mas determinadas bibliotecas herdadas estão disponíveis apenas em versões de 32 bits. O código que chama essas bibliotecas não será vinculado quando o aplicativo for criado para o Windows de 64 bits.

Compartilhar via