Partilhar via

/arch (x86)

Especifica a arquitetura para geração de código em x86. Essas opções se aplicam à versão de destino x86 (32 bits) do compilador. Para obter mais informações sobre /arch outras arquiteturas de destino, consulte /arch (ARM64),/arch (x64) e /arch (ARM).

Sintaxe

/arch:[IA32AVX10.2|AVX10.1|AVX512|AVX2|||AVX|SSESSE2]

Argumentos

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

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

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

/arch:AVX
Habilita as extensões vetoriais avançadas Intel.

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

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

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

/arch:AVX10.2
Habilita o Intel Advanced Vetor Extensions 10 versão 2.

Observações

A /arch opção permite ou desativa o uso de certas extensões do conjunto de instruções, particularmente para cálculo vetorial, disponíveis em processadores da Intel e AMD. Em geral, os processadores introduzidos mais recentemente podem suportar extensões além das suportadas por 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 do conjunto de instruções. Você também pode usar o __check_isa_support intrínseco para verificar se há recursos de CPU usados com mais frequência.

/arch afeta apenas a geração de código para funções nativas. Quando você usa /clr para compilar, /arch não tem efeito na geração de código para funções gerenciadas.

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

  • IA32 é o conjunto de instruções x86 de 32 bits herdado sem quaisquer operações vetoriais e usando 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. Instruções escalares correspondentes de ponto flutuante 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. Instruções escalares de precisão dupla também foram adicionadas.

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

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

  • AVX512 introduziu outro formulário de codificação de instruções que permite vetores de 512 bits, mascaramento, arredondamento/difusã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 o 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. Esta opção foi introduzida no Visual Studio 2022 17.13.

  • AVX10.2 expande o conjunto de instruções introduzido no AVX10.1. O comprimento do vetor padrão é AVX10.2 de 256 bits e pode ser aumentado para 512 bits usando o /vlen sinalizador. AVX10.2 Adiciona instruções que são aprimoramentos de instruções herdadas e instruções de aceleração de mídia. Para obter mais informações sobre as novas instruções, consulte a seção 3.1.4 na Especificação da arquitetura Intel Advanced Vetor Extensions 10.2 As instruções relacionadas à IA nesse documento são suportadas via intrínsecas do MSVC em vez de serem emitidas diretamente porque o MSVC não suporta seus tipos de dados. Esta opção de compilador foi introduzida no Visual Studio 2026.

O otimizador escolhe quando e como usar instruções vetoriais, dependendo do que /arch é especificado. Cálculos escalares de ponto flutuante são geralmente 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. 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 vetoriais e de ponto flutuante, cada /arch opção também pode permitir o uso de outras instruções não vetoriais associadas a essa opção. Um exemplo é a família de instruções CMOVcc que apareceu pela primeira vez nos processadores Intel Pentium Pro. 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 são normalmente 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 configuração do controle de precisão para precisão estendida (80 bits) ou precisão única (32 bits). Para obter mais informações, consulte _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 o código SSE/AVX. Ele pode alterar 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 seguintes operações:

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 em conjunto. A /QIfist opção altera o comportamento de arredondamento da conversão de ponto flutuante para inteiro. O comportamento padrão é truncar (arredondar para zero), enquanto a opção especifica o /QIfist 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 do ambiente de ponto flutuante usando uma sequência de função 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____AVX512BW__, __AVX512DQ__, __AVX512VL__, e __AVX10_VER__ indicam qual, se houver, /arch opção do compilador foi usada. Para obter mais informações, consulte Macros predefinidas. A opção e /arch:AVX2 a __AVX2__ macro foram introduzidas no Visual Studio 2013 Update 2, versão 12.0.34567.1. Suporte limitado para /arch:AVX512 foi adicionado no 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 de compilador /arch no Visual Studio

  1. Abra a caixa de diálogo Property Pages para o projeto. Para obter mais informações, consulte Definir compilador C++ e criar propriedades no Visual Studio.

  2. Selecione a página de propriedades Configuration Properties>C/C++>Code Generation página de propriedades.

  3. Modifique a propriedade Enable Enhanced Instruction set .

Para definir essa opção do compilador programaticamente

Ver também

/arch (Arquitetura mínima da CPU)
opções do compilador MSVC
de sintaxe de linha de comando do compilador MSVC

  • Last updated on