Como verificar se um binário é de 32 ou 64 bits no Windows?

319

Existe uma maneira fácil de verificar se um binário é de 32 ou 64 bits no Windows? Preciso verificar antes de mover o programa para uma máquina de 32 bits e experimentar uma falha espetacular.

Septagrama
fonte
Essa pergunta é semelhante , porém requer algum trabalho para verificá-la.
ST3
3
@ Guillaume: Imagens executáveis ​​não são processos. O Gerenciador de tarefas mostra apenas processos.
IInspectable

Respostas:

346

Depois de examinar os valores dos cabeçalhos da resposta de Richard , criei uma solução que é rápida, fácil e requer apenas um editor de texto. Até o notepad.exe padrão do Windows funcionaria.

  1. Abra o executável no editor de texto. Pode ser necessário arrastar e soltar ou usar a Open...caixa de diálogo do editor , porque o Windows não mostra a Open with...opção no menu de contexto para executáveis.

  2. Verifique os primeiros caracteres imprimíveis após a primeira ocorrência de PE. É provável que esta parte esteja cercada por pelo menos algum espaço em branco (pode ser muito), para que possa ser feita facilmente visualmente.

Aqui está o que você encontrará:

x86:

PE  L

x64:

PE  d†

Uma palavra de aviso: o uso do bloco de notas padrão em arquivos grandes pode ser muito lento, por isso é melhor não usá-lo para arquivos maiores que um megabyte ou poucos. No meu caso, demorou cerca de 30 segundos para exibir um arquivo de 12 MiB. O Notepad ++, no entanto, conseguiu exibir um executável de 120 MiB quase instantaneamente.

Essa solução pode ser útil caso você precise inspecionar um arquivo em uma máquina na qual não possa instalar nenhum software adicional.

Informação adicional:

Se você tiver um editor HEX disponível, o deslocamento da assinatura do PE estará localizado no deslocamento 0x3C. A assinatura é PE\0\0(letras "P" e "E" seguidas por dois bytes nulos), seguidas por um Tipo de máquina de dois bytes em Little Endian.

Os valores relevantes são 0x8664para executável x64 e 0x14cx86. Existem muito mais valores possíveis, mas você provavelmente nunca encontrará nenhum desses, nem poderá executar esses executáveis ​​no seu PC com Windows.

A lista completa de tipos de máquinas, juntamente com o restante das especificações .exe, pode ser encontrada na seção Tipos de Máquinas de Especificação do Microsoft PE e COFF .

Alexander Revo
fonte
21
Ei, isso é bastante hacky. E para melhor, uma vez que este realmente parece ser a solução mais rápida e fácil para a grande maioria dos casos :)
Septagram
4
Instância rara quando o bloco de notas vence o bloco de notas ++. O bloco de notas mostra isso direito, no bloco de notas você mexe com a codificação para mostrar, mas funcionou!
zar
2
@CoDEmanX esta opção significa que o IDE ou JIT faz a sua escolha. Veja esta pergunta ou esta postagem no blog para obter mais detalhes.
Alexander Revo
2
@I Inspecionável se você realmente tivesse se incomodado em ler a postagem inteira antes de votá-la novamente, teria visto o link Microsoft PE and COFF Specification, que é o contrato mais documentado possível, além de instruções sobre como encontrar o endereço exato do cabeçalho do PE em qualquer .exearquivo. Se você tem uma fonte mais confiável que a especificação oficial da Microsoft no próprio formato executável da Microsoft, eu adoraria saber o que é isso.
Alexander Revo
6
Para arquivos que começam com "MZ", você precisa procurar um pouco mais. Encontrei PE..L no deslocamento 0x110, logo após "RichMQ _........".
Jnnnnn
120

A ferramenta SDK dumpbin.execom a /headersopção inclui essas informações, compare essas duas (adicionei negrito para as informações principais)

PS [64] E: \ # 4> dumpbin / cabeçalhos C: \ Windows \ system32 \ cmd.exe
Dumper Microsoft (R) COFF / PE versão 10.00.40219.01
Copyright (C) Microsoft Corporation. Todos os direitos reservados.


Despejo do arquivo C: \ Windows \ system32 \ cmd.exe

Assinatura PE encontrada

Tipo de arquivo: IMAGEM EXECUTÁVEL

VALORES DO CABEÇA DE ARQUIVO
            8664 máquinas (x64)
               6 número de seções
        Carimbo de data e hora 4CE798E5 sáb 20 nov 09:46:13 2010
               Ponteiro de 0 arquivo para tabela de símbolos
               0 número de símbolos
              Tamanho F0 do cabeçalho opcional
              22 características
                   Executável
                   O aplicativo pode lidar com endereços grandes (> 2 GB)
[...]

e

PS [64] E: \ # 5> dumpbin / headers C: \ Windows \ syswow64 \ cmd.exe
Dumper Microsoft (R) COFF / PE versão 10.00.40219.01
Copyright (C) Microsoft Corporation. Todos os direitos reservados.


Despejo do arquivo C: \ Windows \ syswow64 \ cmd.exe

Assinatura PE encontrada

Tipo de arquivo: IMAGEM EXECUTÁVEL

VALORES DO CABEÇA DE ARQUIVO
             Máquina 14C (x86)
               4 número de seções
        Carimbo de data e hora 4CE78E2B sáb 20 nov 09:00:27 2010
               Ponteiro de 0 arquivo para tabela de símbolos
               0 número de símbolos
              Tamanho E0 do cabeçalho opcional
             102 características
                   Executável
                   Máquina de palavras de 32 bits
[...]
Richard
fonte
1
Você também pode ver (IA64) um exe de Itanium de 64 bits.
precisa
21
como eu li em outro lugar no superusuário, usando dumpbin /headers | findstr "machine"simplifica a apresentação do que o QA está procurando ...
user1055604
3
Dumpbin.exe está localizado aqui:C:\Program Files (x86)\Microsoft Visual Studio 12.0\VC\bin
Devid
3
@ David: não necessariamente (versão diferente do VS, não usando o local de instalação padrão, usando a versão do Windows SDK): é por isso que não especifiquei.
Richard
6
É mais fácil de usar dumpbin se você iniciá-lo a partir da linha de comando Visual Studio: stackoverflow.com/a/477389/1390430
Ben
46

Se você não possui ou deseja todo o SDK do Windows ou o Visual Studio, pode usar o sigcheck.exeSysInternals :

sigcheck.exe C:\Windows\Notepad.exe

Resultado:

Sigcheck v2.1 - File version and signature viewer
Copyright (C) 2004-2014 Mark Russinovich
Sysinternals - www.sysinternals.com

c:\windows\notepad.exe:
    Verified:       Signed
    Signing date:   8:59 AM 8/22/2013
    Publisher:      Microsoft Windows
    Description:    Notepad
    Product:        Microsoft« Windows« Operating System
    Prod version:   6.3.9600.16384
    File version:   6.3.9600.16384 (winblue_rtm.130821-1623)
    MachineType:    64-bit
briantist
fonte
4
Parece não ser sempre precisas: Tente usá-lo com LinqPad.exe (versão AnyCPU-64bit) e SigCheck irá dizer-lhe que é "32 bit" ...
Matt
@ Matt interessante. O LinqPad parece um aplicativo .net; Gostaria de saber se sigcheck só funciona corretamente em executáveis ​​nativos (para esse fim).
Briantist
2
Sim, é um aplicativo .NET. No .NET, se não estiver pré-compilado, você poderá segmentar "x86" ou "AnyCPU". "x86" sempre será executado como 32 bits, mas o AnyCPU será executado como 64 bits em um sistema de 64 bits, mas como 32 bits em um sistema de 32 bits. O SigCheck deve considerar isso e mostrar pelo menos ".NET 32 bits ou 64 bits (AnyCPU)". O ILSpy, por exemplo, diz neste caso "Arquitetura: AnyCPU (preferencial de 64 bits)" - mas o ILSpy não funcionará para EXE que não sejam do .NET.
Matt
1
Pode ser esse o caso, como o antigo cabeçalho "MZ", que existe apenas para sistemas operacionais que não sejam Windows ("DOS"), dizendo "Este aplicativo requer o Microsoft Windows" ... ;-)
Matt
2
Sim, nos bons velhos tempos, em que você tinha um depurador do DOS no shell e podia desmontar o código (que continha apenas uma única chamada do DOS imprimindo esta mensagem) ... e substituir o texto por "A resposta é 42". :-D
Matt
38

Posso confirmar que o fileutilitário (por exemplo, do cygwin) fará a distinção entre executáveis ​​de 32 e 64 bits. Eles aparecem da seguinte maneira:

32.exe: PE32 executable (GUI) Intel 80386, for MS Windows
64.exe: PE32+ executable (console) x86-64, for MS Windows

Como você pode ver, é muito óbvio qual é qual. Além disso, ele distingue entre os executáveis ​​do console e da GUI, também óbvio qual é qual.

Wmassingham
fonte
1
Esta solução é bastante comum para todos os desenvolvedores que instalaram o msysgit.
FrontierPsycho
Por que arquivos executáveis ​​no Windows têm em MZvez de PE?
BattleTested
Vale ressaltar que os utilitários GNU podem ser obtidos como binários individuais se você não precisar do Cygwin. gnuwin32.sourceforge.net/packages/file.htm
MJ Walsh
32

Um método simples é executá-lo (supondo que você confie nele) e dar uma olhada na guia de processo no gerenciador de tarefas. Os processos de 32 bits exibirão "* 32" no final do nome do processo. Se não for algo que você deseja executar no seu computador, tente o EXE Explorer . Ele mostrará várias informações sobre os executáveis, incluindo 32 ou 64 bits.

Dracs
fonte
8
Infelizmente, isso requer que você execute o executável. Talvez você precise verificar a arquitetura do programa como um método de solução de problemas sobre o motivo de ele não estar sendo executado.
Mike Christiansen
6
Como você executa uma DLL?
user34660
1
@ samusarin que deve estar no post.
user34660
@ user34660 Você está tecnicamente correto, uma DLL não tem um mainponto de entrada e, portanto, não será executada como um processo autônomo. Há uma função de inicialização chamada quando carregada, mas que não é "principal".
samis 18/12/19
24

Muitas pessoas têm o excelente 7-zip instalado e adicionaram a pasta 7-Zip ao seu PATH. O 7-zip compreende outros formatos de arquivo que não ZIP e RAR, como arquivos MSI e executáveis ​​PE. Basta usar a linha de comando 7z.exeno arquivo PE (Exe ou DLL) em questão:

7z l some.exe | more
7z l some.exe | findstr CPU

A saída incluirá linhas da seguinte forma, com a CPUlinha lendo x86ou x64, ou seja , o que está sendo solicitado aqui:

Path = C:\Extra\AV\neroAacEnc.exe
Type = PE
CPU = x86
Characteristics = Executable 32-bit

Path = C:\Extra\AV\LAME\lame_enc.dll
Type = PE
CPU = x86
Characteristics = Executable DLL 32-bit

Path = C:\Extra\AV\FFmpeg\bin\ffmpeg.exe
Type = PE
CPU = x64
64-bit = +
Characteristics = Executable LargeAddress NoRelocs NoLineNums NoLocalSyms NoDebugInfo

Path = C:\Extra\AV\FFmpeg\bin\avcodec-56.dll
Type = PE
CPU = x64
64-bit = +
Characteristics = Executable DLL LargeAddress NoLineNums NoLocalSyms NoDebugInfo
Lumi
fonte
uau, eu nunca soube que o 7z pode fazer isso. Provavelmente contém uma fileimplementação dentro?
phuclv
17

A versão de 64 bits do Process Explorer pode lhe dizer. Basta executar o executável e abrir a janela de propriedades do processo. Na guia principal, há uma entrada que diz "Imagem: 32 bits" ou "Imagem: 64 bits".

insira a descrição da imagem aqui

Andrew Lambert
fonte
23
Simply run the executableE se você não quiser executar o programa?
Synetech
3
@ Synetech A pergunta original não implica que é esse o caso.
Andrew Lambert
Este é o método mais fácil para mim, a menos que o executável saia muito rápido.
starbeamrainbowlabs
7
Como você executa uma DLL?
user34660
15

Maneira mais simples (quando os dados não são confidenciais)

Acho que o Virustotal File detail é a maneira mais simples de descobrir se um binário é de 32 ou 64 bits.

A Additional informationopção fornece, além disso, muitas informações úteis sobre o arquivo.

Análise virustotal


[TrID virustotal

marsh-wiggle
fonte
12

O método de executar um executável e, em seguida, fazer o check-in no Process Explorer ou ferramenta similar, tem algumas desvantagens óbvias:

  1. Temos que executar o processo.
  2. Para os processos de curta duração (como os tipos echo hello world.), O Process Explorer pode até não registrar que um novo processo foi iniciado.

O método Dumpbin.exe pode provavelmente resolver o objetivo.

Outra alternativa seria usar o comando file do cygwin . No entanto, eu não testei no Windows. Funciona bem em Linux.

Usage: file program_under_test.exe

EDIT: Apenas testado file.exe na janela. funciona bem. :)

anishsane
fonte
1
Só queria dizer que existem algumas situações em que o método de Dracs não será muito útil.
anishsane
3
>> Isso ainda requer a execução do programa que o autor queria evitar: Não .. nós executá-lo como: file.exe program_under_test.exe
anishsane
1
E aqueles que desejam evitar a instalação de todo o cygwinpacote podem pegar o pacote gnuwin32file .
Bob
6
@anishsane Completamente errado. filesimplesmente lê os dados do disco em formato binário e verifica os números mágicos que os identificam, comparando-os com um banco de dados. Os programas de 32 bits do Windows aparecem como PE32 e os de 64 bits e .NET como PE32 +. O testemunho de filesi mesmo faz absolutamente nenhuma diferença - aplicativos de 32 e 64 bits podem ler dados do disco, o que é tudo o que precisa.
Bob
1
@MarcH Ha! Isso é interessante. Suponho que isso significa que o stub de tempo de execução do .NET é de 32 bits. Portanto, ele executa um processo de 32 bits por uma fração de segundo, mas tudo o que faz é iniciar o tempo de execução do .NET, que cria um processo nativo de 64 bits.
Clacke
10

Aqui está uma solução Powershell, sem dependências externas ou qualquer coisa. Abra o PowerShell, cole a função lá (pressione Enter duas vezes para retornar ao prompt) e use-a como nos meus exemplos abaixo da função:

function Test-is64Bit {
    param($FilePath=“$env:windir\notepad.exe”)

    [int32]$MACHINE_OFFSET = 4
    [int32]$PE_POINTER_OFFSET = 60

    [byte[]]$data = New-Object -TypeName System.Byte[] -ArgumentList 4096
    $stream = New-Object -TypeName System.IO.FileStream -ArgumentList ($FilePath, 'Open', 'Read')
    $stream.Read($data, 0, 4096) | Out-Null

    [int32]$PE_HEADER_ADDR = [System.BitConverter]::ToInt32($data, $PE_POINTER_OFFSET)
    [int32]$machineUint = [System.BitConverter]::ToUInt16($data, $PE_HEADER_ADDR + $MACHINE_OFFSET)
    $stream.Close()

    $result = "" | select FilePath, FileType, Is64Bit
    $result.FilePath = $FilePath
    $result.Is64Bit = $false

    switch ($machineUint) 
    {
        0      { $result.FileType = 'Native' }
        0x014c { $result.FileType = 'x86' }
        0x0200 { $result.FileType = 'Itanium' }
        0x8664 { $result.FileType = 'x64'; $result.is64Bit = $true; }
    }

    $result
}

Aqui está um exemplo de saída:

D:\> Test-is64bit

FilePath               FileType Is64Bit
--------               -------- -------
C:\Windows\notepad.exe x64         True


D:\> Test-is64bit 'C:\Program Files (x86)\Mozilla Firefox\firefox.exe'

FilePath                                           FileType Is64Bit
--------                                           -------- -------
C:\Program Files (x86)\Mozilla Firefox\firefox.exe x86        False
megamorf
fonte
Slickness. O script acima parece deixar uma referência para o arquivo aberto. Não foi possível criar até fechar o PowerShell (executei o script para interrogar a DLL em \ bin).
samis 20/10/16
1
Muito legal. +1. O Itanium é definitivamente de 64 bits :) :)
Homolka Rich
@ samusarin: talvez adicionar $stream.dispose();após o fechamento? Deve liberar identificadores de arquivo. ( stackoverflow.com/questions/1999858/… )
Yorik
1
uma versão mais completa pode ser encontrada em Verifique se exe é de 64-bit
phuclv
6

Mesmo um executável marcado como 32 bits pode ser executado como 64 bits se, por exemplo, for um executável .NET que pode ser executado como 32 ou 64 bits. Para obter mais informações, consulte https://stackoverflow.com/questions/3782191/how-do-i-determine-if-a-net-application-is-32-or-64-bit , que possui uma resposta que diz que o O utilitário CORFLAGS pode ser usado para determinar como um aplicativo .NET será executado.

Saída CORFLAGS.EXE

Para executável de 32 bits:

Version   : v2.0.50727
CLR Header: 2.5
PE        : PE32
CorFlags  : 0x3
ILONLY    : 1
32BITREQ  : 1
32BITPREF : 0
Signed    : 0

Para executável de 64 bits:

Version   : v2.0.50727
CLR Header: 2.5
PE        : PE32+
CorFlags  : 0x1
ILONLY    : 1
32BITREQ  : 0
32BITPREF : 0
Signed    : 0

Para executável que pode ser executado em 32 ou 64 bits e em 64 bits quando possível:

Version   : v2.0.50727
CLR Header: 2.5
PE        : PE32
CorFlags  : 0x1
ILONLY    : 1
32BITREQ  : 0
32BITPREF : 0
Signed    : 0

Para executável que pode ser executado em 32 ou 64 bits, mas em 32 bits, a menos que esteja carregado em um processo de 64 bits:

Version   : v4.0.30319
CLR Header: 2.5
PE        : PE32
CorFlags  : 0x20003
ILONLY    : 1
32BITREQ  : 0
32BITPREF : 1
Signed    : 0
BlueMonkMN
fonte
Comando legal, mas não funcionará para executáveis ​​/ dlls nativos (não gerenciados). ( corflags : error CF008 : The specified file does not have a valid managed header)
Tomasz Gandor
@TomaszGandor Sim, o contexto desta resposta foi apenas código gerenciado. O código não gerenciado é respondido pelas outras respostas. Tanto quanto eu sei, apenas o código gerenciado pode alternar entre a execução de 32 e 64 bits.
precisa saber é o seguinte
4

você também pode usar a fileferramenta no pacote msys do mingw . Funciona como o comando unix. Similar funciona a fileferramenta do GNUwin32 .

Bastian Ebeling
fonte
3

Se você estiver no Windows 7, no Windows Explorer, clique com o botão direito do mouse no executável e selecione Propriedades. Na janela de propriedades, selecione a guia Compatibilidade. Se na seção Modo de compatibilidade você vir o Windows XP, este é um executável de 32 bits. Se você vir o Windows Vista, é de 64 bits.

axxis
fonte
-1 não é verdade. Todos os binários de 32 e 64 bits são mostrados no Modo de Compatibilidade deWindows 8
Peter Hahndorf
@ Peter Eu tentei bastante no Windows 7 e sempre funcionou para mim. Você poderia dar um exemplo de um binário em que o modo de compatibilidade padrão é o Windows 8? Também em que Windows você está? Obrigado.
axxis
Estou no Server 2012 R2 e tentei alguns binários aleatórios. Alguns de 32 bits mostram como, Windows XP SP2mas outros mostram como Vistaou Windows 8. Portanto, este método não está correto.
Peter Hahndorf
3

Como adicionar o teste de 32/64 bits ao seu menu de contexto

Crie um arquivo de texto chamado exetest.reg e contendo este código:

Windows Registry Editor Version 5.00

; What will appear in the contextual menu when right-clicking on a .exe file
[HKEY_CLASSES_ROOT\exefile\shell\command32_64]
@="32/64 bit test"

; What to do with it
; here, %1 is the file given as argument of the script
[HKEY_CLASSES_ROOT\exefile\shell\command32_64\command]
@="\"c:\\temp\\x86TestStart.bat\" \"%1\""

Crie um arquivo de texto chamado x86TestStart.batcontendo apenas essa linha de código e salve-o em C: \ temp:

c:\temp\x86or64.vbs %1

Crie um arquivo de texto chamado x86or64.vbscontendo esse código e salve-o em C: \ temp:

rem Reading binary file in VBScript: http://stackoverflow.com/questions/21249440/modify-first-two-bytes-of-a-file-using-vbscript
rem Info on executables: https://dmoj.ca/problem/exe

rem x86/64 signature is located dinamycally; its position is addressed
rem from bytes in 0x3C-0x3D position.

rem Possible signatures;
rem "PE..L" (hex code: 50.45.00.00.4C) = 32 bit
rem "PE..d†" (hex code: 50.45.00.00.64.86) = 64 bit

' ------------------------------------
' Source code by Jumpkack 2015
' ------------------------------------

' Read all arguments from command line:
Set args = Wscript.Arguments

' Store first argument (full path to file)
FileName = args(0)

' Find address of executable signature:
FirstChars = readBinary(FileName)
FirstChars = FirstChars
Addr1 = asc(mid(FirstChars,61,1))
Addr2 = asc(mid(FirstChars,62,1))
AddrFinal = Addr2*256 + Addr1 + 1

' Check signature:
if ucase(hex(asc(mid(FirstChars,AddrFinal+4,2)))) = "4C" then Wscript.Echo Filename & " is a 32 bit executable."
if ucase(hex(asc(mid(FirstChars,AddrFinal+4,2)))) = "64" then Wscript.Echo Filename & " is a 64 bit executable."


Function readBinary(path)
    Dim a, fso, file, i, ts
    Set fso = CreateObject("Scripting.FileSystemObject")
    Set file = fso.getFile(path)
    If isNull(file) Then
        wscript.echo "File not found: " & path
        Exit Function
    End If
    Set ts = file.OpenAsTextStream()
    'a = makeArray(file.size)
    a=""
    i = 0
    While (Not ts.atEndOfStream) and (i<60000)
       'a(i) = ts.read(1)
       a = a + ts.read(1)
       i = i + 1
    Wend
    ts.close
    readBinary = a
 End Function

Clique duas vezes no arquivo exetest.reg: uma nova chave será adicionada no registro do Windows:

[HKEY_CLASSES_ROOT\exefile\shell\command32_64\command]

Ele aparecerá como " teste de 32/64 bits " no menu de contexto ao clicar com o botão direito do mouse em um arquivo executável.

Clicar no item resultará no início do arquivo em lote c:\\temp\\x86TestStart.bat\, que inicia o arquivo VBscript x86or64.vbs, que lê a assinatura exe e mostra o resultado.

Se você não pode ou não deseja adulterar o registro, basta copiar o arquivo .vbs na barra QuickLaunch e arrastar o executável sobre ele.

jumpjack
fonte
3

Meus dois centavos serão apenas baixar o walker de dependência e verificar o que a arquitetura foi usada em um dos arquivos executáveis.

Como usá-lo:

Simplesmente faça o download do aplicativo, inicie-o, clique no ícone aberto → encontre um arquivo * .exe → selecione e, na parte inferior, após a verificação da reflexão, você verá uma grade com dados em que uma coluna possui detalhes de "arquitetura" (x86, x64)

Abra o executável e veja a arquitetura de compilação

captura de tela do dependency walker

stenly
fonte
1

Eu não vi isso mencionado. Existe um programa visualizador de PE chamado CFF Explorer da NTCore , que pode fornecer essas informações. Ele pode ser baixado e executado como portátil, mas você também pode instalá-lo, se desejar.

Clique com o botão direito do mouse no binário ( .exe, .dlletc.) e selecione "Abrir com o CFF Explorer". Vá para Nt Headers -> File Header -> No campo "Características", clique em "Clique aqui"

Se for um programa de 32 bits, a caixa de seleção "máquina de palavras de 32 bits" será marcada. Por exemplo, eu instalei a versão de 32 bits do Notepad ++, como você pode ver na imagem abaixo. Caso contrário, é de 64 bits.

insira a descrição da imagem aqui

Nikos
fonte
Existe uma maneira mais rápida com o CFF explorer: imediatamente ao carregar um arquivo, em "tipo de arquivo" você tem "Portable Executable 64" ou "Portable Executable 32"
Arthur.V
0
  • executar o aplicativo
  • abra o Gerenciador de tarefas
  • clique com o botão direito e crie um arquivo de despejo
  • anote o caminho
  • vá para o caminho e abra o .DMPdespejo no Visual Studio
  • aí você encontra todos os detalhes
  • verifique a arquitetura do processo:
user429538
fonte
3
Sinto-me obrigado a destacar o fato de que essa resposta requer a execução do aplicativo. Comentaristas anteriores sugeriram que isso pode ser indesejável. Além disso, o Visual Studio não estará disponível automaticamente em todas as plataformas Windows.
G-Man
0

meus dois centavos: como desenvolvedor de C ++, o dependency walker ( http://www.dependencywalker.com/ ) é muito informativo, não apenas exibe 64/32 bits, mas também todas as DLLs envolvidas: insira a descrição da imagem aqui

Você pode ver 64 à esquerda de cada nome de arquivo ...

ingconti
fonte
1
A
captura de
0

No entanto, WSL 's filecomando funciona muito.

file /mnt/c/p/bin/rg.exe produziria:

/mnt/c/p/bin/rg.exe: PE32+ executable (console) x86-64, for MS Windows

file /mnt/c/p/bin/u.exe produziria:

/mnt/c/p/bin/u.exe: PE32 executable (GUI) Intel 80386, for MS Windows, UPX compressed
Bohr
fonte
0

A coluna da plataforma no gerenciador de tarefas do windows 10

O Windows 7 não possui uma coluna de plataforma. Portanto, o gerenciador de tarefas do Windows 7 não mostrará isso.

No Windows 10, a escolha de colunas não está mais em 'visualização'. No Windows 10, quando na guia detalhes, clique com o botão direito do mouse no cabeçalho da coluna e depois em 'selecionar colunas'. Em seguida, marque a caixa para 'plataforma'.

insira a descrição da imagem aqui

insira a descrição da imagem aqui

barlop
fonte