/arch (x86)

Especifica a arquitetura para a geração de código no x86. Para obter mais informações sobre /arch de outras arquiteturas de destino, confira /arch (ARM64), /arch (x64) e /arch (ARM).

Sintaxe

/arch:[IA32|SSE|SSE2|AVX|AVX2|AVX512]

Argumentos

/arch:IA32
Não especifica instruções aprimoradas e especifica x87 para cálculos de ponto flutuante.

/arch:SSE
Habilita o uso de instruções SSE.

/arch:SSE2
Habilita o uso de instruções SSE2. Essa opção é a instrução padrão definida nas plataforma x86 se nenhuma opção /arch for especificada.

/arch:AVX
Habilita o uso de instruções Intel Advanced Vector Extensions.

/arch:AVX2
Habilita o uso de instruções Intel Advanced Vector Extensions 2.

/arch:AVX512
Habilita o uso de instruções Intel Advanced Vector Extensions 512.

Comentários

A opção /arch habilita ou desabilita o uso de determinadas extensões de conjunto de instruções, especialmente para cálculo de vetor, disponíveis em processadores da Intel e do AMD. Em geral, os processadores introduzidos mais recentemente podem dar suporte a extensões além daquelas compatíveis com processadores mais antigos. Você deve consultar a documentação de um processador específico ou testar o suporte à extensão do conjunto de instruções usando __cpuid antes de executar o código usando uma extensão de conjunto de instruções.

/arch afeta somente a geração de código de funções nativas. Ao usar /clr para compilar, /arch não tem efeito sobre a geração de código das funções gerenciadas.

As opções /arch referem-se a extensões de conjunto de instruções com as seguintes características:

  • IA32 é o conjunto de instruções x86 herdado de 32 bits sem nenhuma operação de vetor e o uso de x87 para cálculos de ponto flutuante.

  • SSE permite o cálculo com vetores de até quatro valores de ponto flutuante de precisão única. As instruções de ponto flutuante escalar correspondentes também foram adicionadas.

  • SSE2 permite o cálculo com vetores de 128 bits de precisão única, precisão dupla e valores inteiros de 1, 2, 4 ou 8 bytes. Também foram adicionadas instruções escalares de precisão dupla.

  • AVX introduziu uma codificação de instrução alternativa para instruções escalares de vetor e ponto flutuante. Ela permite vetores de 128 bits ou 256 bits e estende todos os resultados de vetor para o tamanho total do vetor. (Para compatibilidade herdada, as instruções de vetor no estilo SSE preservam todos os bits além do bit 127.) A maioria das operações de ponto flutuante é estendida para 256 bits.

  • AVX2 estende a maioria das operações de inteiro para vetores de 256 bits e permite o uso de instruções de FMA (Fused Multiply-Add).

  • AVX512 introduziu outro formulário de codificação de instrução que permite vetores de 512 bits, além de alguns outros recursos opcionais. Instruções para outras operações também foram adicionadas.

O otimizador escolhe quando e como usar instruções de vetor, dependendo do que /arch for especificado. Cálculos de ponto flutuante escalar são executados com instruções SSE ou AVX quando disponíveis. Algumas convenções de chamada especificam a passagem de argumentos de ponto flutuante na pilha x87 e, como resultado, seu código pode usar uma mistura de instruções x87 e SSE/AVX para cálculos de ponto flutuante. As instruções de vetor inteiro também podem ser usadas para algumas operações de inteiro de 64 bits quando disponíveis.

Além das instruções escalares de vetor e ponto flutuante, cada opção /arch também pode habilitar o uso de outras instruções não vetoriais associadas a essa opção. Um exemplo disso é a instrução CMOVcc que apareceu pela primeira vez na revisão Pentium Pro dos processadores Intel. Como as instruções SSE foram introduzidas com o processador Intel Pentium III subsequente, as instruções CMOVcc podem ser geradas, exceto quando /arch:IA32 é especificado.

As operações de ponto flutuante normalmente são arredondadas para precisão dupla (64 bits) no código x87, mas você pode usar _controlfp para modificar a palavra de controle FP, incluindo a definição do controle de precisão para precisão estendida (80 bits) ou precisão única (32 bits). Para obter mais informações, confira _control87, _controlfp, __control87_2. SSE e AVX têm instruções separadas de precisão única e precisão dupla para cada operação, portanto, não há equivalente para código SSE/AVX. Ele pode alterar a forma como os resultados são arredondados quando o resultado de uma operação de ponto flutuante é usado diretamente no cálculo adicional, em vez de atribuí-lo a uma variável de usuário. Considere as operações a seguir:

r = f1 * f2 + d;  // Different results are possible on SSE/SSE2.

Com atribuição explícita:

t = f1 * f2;   // Do f1 * f2, round to the type of t.
r = t + d;     // This should produce the same overall result
               // whether x87 stack is used or SSE/SSE2 is used.

/arch e /QIfist não podem ser usados no mesmo compiland. A opção /QIfist altera o comportamento de arredondamento de ponto flutuante para conversão de inteiro. O comportamento padrão é truncar (em direção a zero), enquanto a opção /QIfist especifica o uso do modo de arredondamento do ambiente de ponto flutuante. Como a opção altera o comportamento de todas as conversões de ponto flutuante para inteiro, /QIfist foi preterida. Ao compilar para SSE ou AVX, você pode arredondar um valor de ponto flutuante para um inteiro usando o modo de arredondamento de ambiente de ponto flutuante usando uma sequência de funções intrínseca:

int convert_float_to_int(float x) {
    return _mm_cvtss_si32(_mm_set_ss(x));
}

int convert_double_to_int(double x) {
    return _mm_cvtsd_si32(_mm_set_sd(x));
}

As macros _M_IX86_FP, __AVX__, __AVX2__, __AVX512F__, __AVX512CD__, __AVX512BW__, __AVX512DQ__ e __AVX512VL__ indicam qual opção do compilador, /arch, foi usada, se houver. Para obter mais informações, confira Macros predefinidas. A opção /arch:AVX2 e a macro __AVX2__ foram introduzidas na versão 12.0.34567.1 da atualização 2 do Visual Studio 2013. O suporte limitado para /arch:AVX512 foi adicionado ao Visual Studio 2017 e expandido no Visual Studio 2019.

Para definir essa opção de compilador para AVX, AVX2, AVX512, IA32, SSE ou SSE2 no Visual Studio

  1. Abra a caixa de diálogo Páginas de Propriedades do projeto. Para obter mais informações, confira Definir as propriedades de build e do compilador do C++ no Visual Studio.

  2. Selecione a página de propriedades Propriedades da Configuração>C/C++>Geração de Código.

  3. Modifique a propriedade Habilitar Conjunto de Instruções Avançadas.

Para definir essa opção do compilador via programação

Confira também

/arch (Arquitetura de CPU mínima)
Opções do compilador MSVC
Sintaxe de linha de comando do compilador MSVC