¿Cómo verificar si un binario es de 32 o 64 bits en Windows?

319

¿Hay alguna manera fácil de verificar si un binario es de 32 o 64 bits en Windows? Necesito verificar antes de mover el programa a una máquina de 32 bits y experimentar una falla espectacular.

Septagrama
fuente
Esta pregunta es similar , sin embargo, requiere un poco de trabajo para verificarla.
ST3
3
@Guillaume: las imágenes ejecutables no son procesos. El Administrador de tareas solo muestra procesos.
Inspectable el

Respuestas:

346

Después de examinar los valores de encabezado de la respuesta de Richard , se me ocurrió una solución que es rápida, fácil y solo requiere un editor de texto. Incluso el notepad.exe predeterminado de Windows funcionaría.

  1. Abra el ejecutable en el editor de texto. Puede que tenga que arrastrar y soltar o usar el Open...cuadro de diálogo del editor , porque Windows no muestra la Open with...opción en el menú contextual para los ejecutables.

  2. Verifique los primeros caracteres imprimibles después de la primera aparición de PE. Es muy probable que esta parte esté rodeada por al menos un espacio en blanco (podría ser mucho), por lo que se puede hacer fácilmente de forma visual.

Esto es lo que vas a encontrar:

x86:

PE  L

x64:

PE  d†

Una advertencia: el uso del Bloc de notas predeterminado en archivos grandes puede ser muy lento, por lo que es mejor no usarlo para archivos de más de un megabyte o pocos. En mi caso, tardé unos 30 segundos en mostrar un archivo de 12 MiB. Notepad ++, sin embargo, pudo mostrar un ejecutable de 120 MiB casi al instante.

Esta solución puede ser útil en caso de que necesite inspeccionar un archivo en una máquina en la que no puede instalar ningún software adicional.

Información adicional:

Si tiene un editor HEX disponible, el desplazamiento de PE Signature se encuentra en el desplazamiento 0x3C. La firma es PE\0\0(letras "P" y "E" seguidas de dos bytes nulos), seguidas de un tipo de máquina de dos bytes en Little Endian.

Los valores relevantes son 0x8664para x64 ejecutable y 0x14cpara x86. Hay muchos más valores posibles, pero probablemente nunca se encuentre con ninguno de estos, ni podrá ejecutar dichos ejecutables en su PC con Windows.

La lista completa de tipos de máquina, junto con el resto de especificaciones .exe se puede encontrar en la sección Tipos de máquina de especificación de Microsoft PE y COFF .

Alexander Revo
fuente
21
Oye, esto es bastante hacky. Y para mejor, ya que esta parece ser la solución más rápida y fácil para la gran mayoría de los casos :)
Septagram
44
Instancia rara cuando notepad venció a notepad ++. El Bloc de notas muestra esto correctamente, en el Bloc de notas tienes problemas con la codificación para que se muestre, ¡pero funcionó!
zar
2
@CoDEmanX esta opción significa que IDE o JIT hacen la elección por usted. Vea esta pregunta o esta publicación de blog para más detalles.
Alexander Revo
2
@IInspectable si realmente se hubiera molestado en leer la publicación completa antes de votar, habría visto el enlace Microsoft PE and COFF Specification, que es un contrato documentado, así como instrucciones sobre cómo encontrar la dirección exacta del encabezado PE en cualquier .exearchivo Si tiene una fuente más confiable que la especificación oficial de Microsoft en el formato ejecutable de Microsoft, me encantaría saber de qué se trata.
Alexander Revo
66
Para los archivos que comienzan con "MZ", debe buscar un poco más. Encontré PE..L en el desplazamiento 0x110, justo después de "RichMQ _........".
jnnnnn
120

La herramienta SDK dumpbin.execon la /headersopción incluye esta información, compare estos dos (he agregado negrita para la información clave)

PS [64] E: \ # 4> basurero / encabezados C: \ Windows \ system32 \ cmd.exe
Microsoft (R) COFF / PE Dumper Versión 10.00.40219.01
Derechos de autor (C) Microsoft Corporation. Todos los derechos reservados.


Volcado del archivo C: \ Windows \ system32 \ cmd.exe

Firma de PE encontrada

Tipo de archivo: IMAGEN EJECUTABLE

VALORES DEL ENCABEZADO DE ARCHIVO
            Máquina 8664 (x64)
               6 número de secciones
        4CE798E5 sello de fecha y hora sábado 20 de noviembre 09:46:13 2010
               0 puntero de archivo a la tabla de símbolos
               0 número de símbolos
              Tamaño F0 del encabezado opcional
              22 características
                   Ejecutable
                   La aplicación puede manejar direcciones grandes (> 2GB)
[...]

y

PS [64] E: \ # 5> basurero / encabezados C: \ Windows \ syswow64 \ cmd.exe
Microsoft (R) COFF / PE Dumper Versión 10.00.40219.01
Derechos de autor (C) Microsoft Corporation. Todos los derechos reservados.


Volcado del archivo C: \ Windows \ syswow64 \ cmd.exe

Firma de PE encontrada

Tipo de archivo: IMAGEN EJECUTABLE

VALORES DEL ENCABEZADO DE ARCHIVO
             Máquina 14C (x86)
               4 número de secciones
        4CE78E2B sello de fecha y hora sáb 20 nov 09:00:27 2010
               0 puntero de archivo a la tabla de símbolos
               0 número de símbolos
              Tamaño E0 del encabezado opcional
             102 características
                   Ejecutable
                   Máquina de palabras de 32 bits
[...]
Ricardo
fuente
1
También podría ver (IA64) para un Itanium exe de 64 bits.
Darryl Braaten el
21
Como he leído en otra parte de superusuario, utilizando dumpbin /headers | findstr "machine"en gran medida simplifica la presentación de lo que el control de calidad está buscando ...
user1055604
3
Dumpbin.exe se encuentra aquí:C:\Program Files (x86)\Microsoft Visual Studio 12.0\VC\bin
Devid
3
@David: no necesariamente (versión diferente de VS, sin usar la ubicación de instalación predeterminada, usando la versión del SDK de Windows): es por eso que no especifiqué.
Richard
66
Es más fácil usar dumpbin si lo inicia desde la línea de comandos de Visual Studio: stackoverflow.com/a/477389/1390430
Ben
46

Si no tiene o no desea todo el SDK de Windows o Visual Studio, puede usarlo sigcheck.exedesde SysInternals :

sigcheck.exe C:\Windows\Notepad.exe

Salida:

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
briantista
fuente
44
Parece que no siempre es preciso: intente usarlo con LinqPad.exe (versión AnyCPU-64bit) y Sigcheck le dirá que es "32 bits" ...
Matt
@Matt interesante. LinqPad suena como una aplicación .net; Me pregunto si sigcheck solo funciona correctamente en ejecutables nativos (para este propósito).
briantist
2
Sí, es una aplicación .NET. En .NET, si no está precompilado, puede seleccionar "x86" o "AnyCPU". "x86" siempre se ejecutará como 32 bits, pero AnyCPU se ejecutará como 64 bits en un sistema de 64 bits, pero como 32 bits en un sistema de 32 bits. SigCheck debería considerar esto y mostrar al menos ".NET 32 bit o 64 bit (AnyCPU)". ILSpy, por ejemplo, dice en este caso "Arquitectura: AnyCPU (se prefiere 64 bits)", pero ILSpy no funcionará para archivos EXE que no sean .NET.
Matt
1
Ese podría ser el caso, como el viejo encabezado "MZ" que solo está ahí para sistemas operativos que no son Windows ("DOS") y dice "Esta aplicación requiere Microsoft Windows" ... ;-)
Matt
2
Sí, en los viejos tiempos, donde tenía un depurador de DOS en el shell y podía desmontar el código (que solo contenía una sola llamada de DOS que imprimía este mensaje) ... y reemplazar el texto por "La respuesta es 42". :-D
Matt
38

Puedo confirmar que la fileutilidad (por ejemplo, de cygwin) distinguirá entre ejecutables de 32 y 64 bits. Aparecen de la siguiente manera:

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

Como puede ver, es muy obvio cuál es cuál. Además, distingue entre ejecutables de consola y GUI, también es obvio cuál es cuál.

wmassingham
fuente
1
Esta solución está bastante disponible para cualquier desarrollador que haya instalado msysgit.
FrontierPsycho
¿Por qué los archivos ejecutables en Windows tienen en MZlugar de PE?
BattleTested
Vale la pena señalar que las utilidades GNU se pueden obtener como archivos binarios individuales si de lo contrario no necesita Cygwin. gnuwin32.sourceforge.net/packages/file.htm
MJ Walsh
32

Un método simple es ejecutarlo (suponiendo que confía en él) y echar un vistazo a la pestaña de proceso en el administrador de tareas. Los procesos de 32 bits mostrarán "* 32" al final del nombre del proceso. Si no es algo que esté dispuesto a ejecutar en su computadora, puede probar EXE Explorer . Mostrará un montón de información sobre ejecutables, incluso si es de 32 o 64 bits.

Dracs
fuente
8
Desafortunadamente, esto requiere que ejecutes el ejecutable. Quizás deba verificar la arquitectura del programa como método de solución de problemas para saber por qué no se está ejecutando.
Mike Christiansen
66
¿Cómo se ejecuta una DLL?
user34660
1
@samusarin que debería estar en la publicación.
user34660
@ user34660 Estás técnicamente correcto, una DLL no tiene un mainpunto de entrada y, por lo tanto, no se ejecutará como un proceso independiente. Hay una función de inicialización llamada cuando se carga pero que no es "principal".
samis
24

Muchas personas tienen instalado el excelente 7-zip y han agregado la carpeta 7-Zip a su PATH. 7-zip comprende formatos de archivo que no sean ZIP y RAR, como archivos MSI y ejecutables PE. Simplemente use la línea de comando 7z.exeen el archivo PE (Exe o DLL) en cuestión:

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

La salida incluirá líneas de la siguiente manera, con la CPUlectura de la línea x86o x64, que es lo que se solicita aquí:

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
fuente
wow, nunca supe que 7z puede hacer esto. ¿Probablemente contiene una fileimplementación dentro?
phuclv
17

La versión de 64 bits de Process Explorer puede decírtelo. Simplemente ejecute el ejecutable y abra la ventana de propiedades del proceso. En la pestaña principal hay una entrada que dice "Imagen: 32 bits" o "Imagen: 64 bits".

ingrese la descripción de la imagen aquí

Andrew Lambert
fuente
23
Simply run the executable¿Y qué pasa si no quieres ejecutar el programa?
Synetech
3
@Synetech La pregunta original no implica que ese sea el caso.
Andrew Lambert
Creo que este es el método más fácil para mí, a menos que el ejecutable salga demasiado rápido.
starbeamrainbowlabs
77
¿Cómo se ejecuta una DLL?
user34660
15

La forma más simple (cuando los datos no son confidenciales)

Me parece que Virustotal File detail es la forma más sencilla de averiguar si un binario es de 32 bits o de 64 bits.

La Additional informationopción proporciona además mucha información útil sobre el archivo.

Análisis virustotal


[Virustotal TrID

meneo de pantano
fuente
12

El método de ejecutar un ejecutable y luego registrar el explorador de procesos o una herramienta similar tiene algunos inconvenientes obvios:

  1. Tenemos que ejecutar el proceso.
  2. Para los procesos de corta duración (como los tipos echo hello world), el explorador de procesos podría ni siquiera registrar que un nuevo proceso ha comenzado.

El método Dumpbin.exe puede resolver el propósito probablemente.

Otra alternativa sería usar el comando de archivo de cygwin . Sin embargo, no lo he probado en Windows. Funciona bien en Linux.

Usage: file program_under_test.exe

EDITAR: Acabo de probar file.exe en la ventana. funciona bien. :)

anishsane
fuente
1
Solo quería decir que hay algunas situaciones en las que el método de Dracs no será de mucha ayuda.
anishsane
3
>> Esto todavía requiere ejecutar el programa que el autor quería evitar: No ... lo ejecutamos como: file.exe program_under_test.exe
anishsane
1
Y aquellos que deseen evitar instalar el cygwinpaquete completo pueden obtener el paquete gnuwin32file .
Bob
66
@anishsane Completamente equivocado. filesimplemente lee los datos del disco en formato binario y comprueba los números mágicos que los identifican, comparándolos con una base de datos. Los programas de Windows de 32 bits aparecen como PE32, y los programas de 64 bits y .NET aparecen como PE32 +. El bitness en filesí mismo no hace absolutamente ninguna diferencia: tanto las aplicaciones de 32 bits como las de 64 bits pueden leer datos del disco, que es todo lo que necesita.
Bob
1
@MarcH Ja! Eso es interesante Supongo que eso significa que el código auxiliar de tiempo de ejecución de .NET es de 32 bits. Por lo tanto, ejecuta un proceso de 32 bits durante una fracción de segundo, pero todo lo que hace es iniciar el tiempo de ejecución de .NET, que crea un proceso nativo de 64 bits.
clacke
10

Aquí hay una solución Powershell, sin dependencias externas ni nada. Abra Powershell, pegue la función allí (presione Entrar dos veces para volver al indicador), luego úsela como en mis ejemplos debajo de la función:

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
}

Aquí hay un ejemplo de salida:

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
fuente
Slickness El script anterior parece dejar abierta una referencia al archivo. No se pudo compilar hasta que cerré PowerShell por primera vez (ejecuté el script para interrogar a DLL en \ bin).
samis
1
Muy genial. +1. Itanium definitivamente es de 64 bits :)
Rich Homolka
@samusarin: ¿quizás agregar $stream.dispose();después del cierre? Debería liberar los identificadores de archivo. ( stackoverflow.com/questions/1999858/… )
Yorik
1
se puede encontrar una versión más completa en Verificar si exe es de 64 bits
phuclv
6

Incluso un ejecutable marcado como 32 bits puede ejecutarse como 64 bits si, por ejemplo, es un ejecutable .NET que puede ejecutarse como 32 o 64 bits. Para obtener más información, consulte https://stackoverflow.com/questions/3782191/how-do-i-determine-if-a-net-application-is-32-or-64-bit , que tiene una respuesta que dice que el La utilidad CORFLAGS se puede usar para determinar cómo se ejecutará una aplicación .NET.

Salida CORFLAGS.EXE

Para ejecutable de 32 bits:

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

Para ejecutable de 64 bits:

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

Para el ejecutable que puede ejecutarse como 32 o 64 bits y se ejecutará como 64 bits cuando sea posible:

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

Para el ejecutable que puede ejecutarse como 32 o 64 bits, pero se ejecutará como 32 bits a menos que se cargue en un proceso de 64 bits:

Version   : v4.0.30319
CLR Header: 2.5
PE        : PE32
CorFlags  : 0x20003
ILONLY    : 1
32BITREQ  : 0
32BITPREF : 1
Signed    : 0
BlueMonkMN
fuente
Comando genial, pero no funcionará para ejecutables / dlls nativos (no administrados). ( corflags : error CF008 : The specified file does not have a valid managed header)
Tomasz Gandor
@TomaszGandor Sí, el contexto de esta respuesta fue solo código administrado. El código no administrado es respondido por las otras respuestas. Hasta donde sé, solo el código administrado puede cambiar entre la ejecución tanto de 32 como de 64 bits.
BlueMonkMN
4

También puede usar la fileherramienta desde el paquete msys de mingw . Funciona como el comando unix. Similar funciona la fileherramienta de GNUwin32 .

Bastian Ebeling
fuente
3

Si está en Windows 7, en un Explorador de Windows, haga clic derecho en el ejecutable y seleccione Propiedades. En la ventana de propiedades, seleccione la pestaña Compatibilidad. Si en la sección Modo de compatibilidad ve Windows XP, este es un ejecutable de 32 bits. Si ve Windows Vista, es de 64 bits.

axxis
fuente
-1 no es cierto en absoluto. Varios binarios de 32 y 64 bits muestran un modo de compatibilidad deWindows 8
Peter Hahndorf
@ Peter He probado bastantes en Windows 7 y siempre funcionó para mí. ¿Podría dar un ejemplo de un binario donde el modo de compatibilidad predeterminado es Windows 8? ¿También en qué Windows estás? Gracias.
axxis
Estoy en Server 2012 R2 y probé algunos binarios aleatorios. Algunos de 32 bits se muestran como Windows XP SP2pero otros se muestran como Vistao Windows 8. Entonces este método no es correcto.
Peter Hahndorf
3

Cómo agregar una prueba de 32/64 bits a su menú contextual

Cree un archivo de texto llamado exetest.reg y que contenga 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\""

Cree un archivo de texto llamado que x86TestStart.batcontenga solo esta línea de código y guárdelo en C: \ temp:

c:\temp\x86or64.vbs %1

Cree un archivo de texto llamado que x86or64.vbscontenga este código y guárdelo en 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

Haga doble clic en el archivo exetest.reg: se agregará una nueva clave en el registro de Windows:

[HKEY_CLASSES_ROOT\exefile\shell\command32_64\command]

Aparecerá como " prueba de 32/64 bits " en el menú contextual al hacer clic derecho en un archivo ejecutable.

Al hacer clic en el elemento, se iniciará el archivo por lotes c:\\temp\\x86TestStart.bat\, que inicia el archivo VBscript x86or64.vbs, que lee la firma exe y muestra el resultado.

Si no puede o no quiere alterar el registro, simplemente copie el archivo .vbs en la barra de QuickLaunch y arrastre el archivo ejecutable sobre él.

jumpjack
fuente
3

Mis dos centavos serán solo descargar el caminante de dependencia y verificar qué arquitectura se ha utilizado en uno de los archivos ejecutables.

Cómo usarlo:

Simplemente descargue la aplicación, iníciela, haga clic en el ícono abrir → encuentre un archivo * .exe → seleccione y en la parte inferior después de realizar el escaneo de reflexión verá una cuadrícula con datos donde una columna tiene detalles de "arquitectura" (x86, x64)

Abra el ejecutable y vea la arquitectura de construcción

captura de pantalla del caminante de dependencia

stenly
fuente
1

No he visto esto mencionado. Hay un programa de visualización PE llamado CFF Explorer por NTCore , que puede proporcionarle esta información. Se puede descargar y ejecutar como portátil, pero también puede instalarlo, si lo desea.

Haga clic derecho en el binario ( .exe, .dlletc.) y seleccione "Abrir con CFF Explorer". Vaya a Nt Headers -> File Header -> En el campo "Características" haga clic en "Haga clic aquí"

Si se trata de un programa de 32 bits, se marcará la casilla de verificación "máquina de palabras de 32 bits". Por ejemplo, he instalado la versión de 32 bits de Notepad ++ como puede ver en la imagen a continuación. De lo contrario, es de 64 bits.

ingrese la descripción de la imagen aquí

Nikos
fuente
Hay una forma más rápida con CFF explorer: inmediatamente al cargar un archivo, en "tipo de archivo" tiene "Portable Executable 64" o "Portable Executable 32"
Arthur.V
0
  • ejecuta la aplicación
  • abrir el Administrador de tareas
  • haga clic derecho y cree un archivo de volcado
  • anotar camino
  • ir a la ruta y abrir el .DMPvolcado en Visual Studio
  • ahí tienes todos los detalles
  • comprobar la arquitectura del proceso:
usuario429538
fuente
3
Me siento obligado a subrayar el hecho de que esta respuesta requiere ejecutar la aplicación. Los comentaristas anteriores sugirieron que esto podría ser indeseable. Además, Visual Studio no estará disponible automáticamente en todas las plataformas de Windows.
G-Man
0

mis dos centavos: como desarrollador de C ++, el caminante de dependencia ( http://www.dependencywalker.com/ ) es muy informativo, no solo muestra 64/32 bits, sino también cada Dll involucrado: ingrese la descripción de la imagen aquí

Puede ver 64 a la izquierda de cada nombre de archivo ...

ingconti
fuente
1
La
captura de
0

Sin embargo, el comando de WSLfile funciona en gran medida.

file /mnt/c/p/bin/rg.exe daría salida:

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

file /mnt/c/p/bin/u.exe daría salida:

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

La columna de plataforma en el administrador de tareas de windows 10

Windows 7 no tiene una columna de plataforma. Entonces el administrador de tareas de Windows 7 no lo mostrará.

En Windows 10, la elección de columnas ya no está en 'vista'. En Windows 10, cuando está en la pestaña de detalles, hace clic derecho en el encabezado de la columna y luego 'selecciona columnas'. Luego marque la casilla 'plataforma'.

ingrese la descripción de la imagen aquí

ingrese la descripción de la imagen aquí

barlop
fuente