Compartilhar via

/arch (x86)

  • Artigo

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:[IA32AVX10.1|AVX512|AVX2|||AVX|SSESSE2]

Argumentos

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

/arch:SSE
Habilita extensões Intel Streaming SIMD.

/arch:SSE2
Habilita as extensões Intel Streaming SIMD 2. O conjunto de instruções padrão será SSE2 se nenhuma /arch opção for especificada.

/arch:AVX
Habilita extensões de vetor avançadas da Intel.

/arch:AVX2
Habilita o Intel Advanced Vector Extensions 2.

/arch:AVX512
Habilita o Intel Advanced Vector Extensions 512.

/arch:AVX10.1
Habilita o Intel Advanced Vector Extensions 10 versão 1.

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. Você também pode usar o __check_isa_support intrínseco para verificar os recursos da CPU usados com mais frequência.

/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 outra forma de codificação de instrução que permite vetores de 512 bits, mascaramento, arredondamento/transmissão incorporados e novas instruções. O comprimento do vetor padrão para AVX512 é de 512 bits e pode ser alterado para 256 bits usando o /vlen sinalizador.

  • AVX10.1 adiciona mais instruções sobre AVX-512. O comprimento do vetor padrão para AVX10.1 é de 256 bits e pode ser alterado para 512 bits usando o /vlen sinalizador.

O otimizador escolhe quando e como usar instruções de vetor, dependendo do que /arch for especificado. Os cálculos escalares de ponto flutuante geralmente são realizados 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 juntos. A opção /QIfist altera o comportamento de arredondamento de ponto flutuante para conversão de inteiro. O comportamento padrão é truncar (arredondar em direção a zero), enquanto a /QIfist opção especifica o uso do modo de arredondamento de ambiente de ponto flutuante. Como a opção altera o comportamento de todas as conversões de ponto flutuante para inteiro, /QIfist está obsoleta. 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 _M_IX86_FPmacros , __AVX__, __AVX2__, __AVX512F__, __AVX512CD__, __AVX512VL____AVX512BW____AVX512DQ__e __AVX10_VER__ indicam qual opção do compilador, se houver, /arch foi usada. Para obter mais informações, confira Macros predefinidas. A opção e __AVX2__ a /arch:AVX2 macro foram introduzidas no Visual Studio 2013 Atualização 2, versão 12.0.34567.1. O suporte limitado para /arch:AVX512 foi adicionado ao Visual Studio 2017 e expandido no Visual Studio 2019. O suporte para /arch:AVX10.1 foi adicionado no Visual Studio 2022.

Para definir a opção /arch do compilador 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 da linha de comando do compilador MSVC