Come verificare se un binario è a 32 o 64 bit su Windows?


319

C'è un modo semplice per verificare se un file binario è a 32 o 64 bit su Windows? Devo controllare prima di spostare il programma su una macchina a 32 bit e sperimentare un errore spettacolare.


Questa domanda è simile , tuttavia richiede del lavoro per verificarla.
ST3,

3
@Guillaume: le immagini eseguibili non sono processi. Task Manager mostra solo i processi.
Indispensabile il

Risposte:


346

Dopo aver esaminato i valori dell'intestazione dalla risposta di Richard , mi è venuta in mente una soluzione che è veloce, facile e richiede solo un editor di testo. Anche il notepad.exe predefinito di Windows funzionerebbe.

  1. Apri l'eseguibile nell'editor di testo. Potrebbe essere necessario trascinare la selezione o utilizzare la Open...finestra di dialogo dell'editor , poiché Windows non mostra l' Open with...opzione nel menu di scelta rapida per gli eseguibili.

  2. Controllare i primi caratteri stampabili dopo la prima occorrenza di PE. È molto probabile che questa parte sia circondata da almeno alcuni spazi bianchi (potrebbe essere molto), quindi può essere facilmente eseguita visivamente.

Ecco cosa troverai:

x86:

PE  L

x64:

PE  d†

Un avvertimento: l' utilizzo del Blocco note predefinito su file di grandi dimensioni può essere molto lento, quindi è meglio non utilizzarlo per file di dimensioni superiori a un megabyte o pochi. Nel mio caso, ci sono voluti circa 30 secondi per visualizzare un file di 12 MiB. Notepad ++, tuttavia, è stato in grado di visualizzare un eseguibile di 120 MiB quasi istantaneamente.

Questa soluzione potrebbe essere utile nel caso in cui sia necessario ispezionare un file su un computer su cui non è possibile installare alcun software aggiuntivo.

Informazioni addizionali:

Se è disponibile un editor HEX, l'offset della firma PE si trova nell'offset 0x3C. La firma è PE\0\0(lettere "P" ed "E" seguite da due byte nulli), seguita da un tipo di macchina a due byte in Little Endian.

I valori rilevanti sono 0x8664per x64 eseguibile e 0x14cper x86. Esistono molti più valori possibili, ma probabilmente non li incontrerai mai o non sarai in grado di eseguire tali eseguibili sul tuo PC Windows.

L'elenco completo dei tipi di macchine, insieme al resto delle specifiche .exe è disponibile nella sezione Tipi di macchine per le specifiche Microsoft PE e COFF .


21
Ehi, questo è piuttosto confuso. E per il meglio, dal momento che questa sembra essere la soluzione più semplice e veloce per la stragrande maggioranza dei casi :)
Septagram

4
Rara istanza quando notepad ha battuto notepad ++. Il Blocco note mostra questo diritto, nel Blocco note hai problemi con la codifica per farlo mostrare ma ha funzionato!
Zar

2
@CoDEmanX questa opzione indica che IDE o JIT fanno la scelta giusta per te. Vedi questa domanda o questo post sul blog per maggiori dettagli.
Alexander Revo,

2
@Ispettabile se ti fossi davvero preso la briga di leggere l'intero post prima di ridimensionarlo, avresti visto il link a Microsoft PE and COFF Specification, che è un contratto documentato che può ottenere, così come le istruzioni su come trovare l'indirizzo esatto dell'intestazione PE in qualsiasi .exefile. Se hai una fonte più affidabile delle specifiche ufficiali di Microsoft sul formato eseguibile di Microsoft, mi piacerebbe sapere di cosa si tratta.
Alexander Revo,

6
Per i file che iniziano con "MZ", devi cercare un po 'più in là. Ho trovato PE..L all'offset 0x110, subito dopo "RichMQ _........".
jnnnnn,

120

Lo strumento SDK dumpbin.execon l' /headersopzione include queste informazioni, confronta questi due (ho aggiunto il grassetto per le informazioni chiave)

PS [64] E: \ # 4> dumpbin / header C: \ Windows \ system32 \ cmd.exe
Dumper Microsoft (R) COFF / PE versione 10.00.40219.01
Copyright (C) Microsoft Corporation. Tutti i diritti riservati.


Dump del file C: \ Windows \ system32 \ cmd.exe

Firma PE trovata

Tipo di file: IMMAGINE ESECUTABILE

VALORI DELL'INTESTAZIONE DEL FILE
            Macchina 8664 (x64)
               6 numero di sezioni
        4CE798E5 data e ora sab 20 nov 09:46:13 2010
               0 puntatore al file nella tabella dei simboli
               0 numero di simboli
              Dimensione F0 dell'intestazione opzionale
              22 caratteristiche
                   eseguibile
                   L'applicazione può gestire indirizzi di grandi dimensioni (> 2 GB)
[...]

e

PS [64] E: \ # 5> dumpbin / header C: \ Windows \ syswow64 \ cmd.exe
Dumper Microsoft (R) COFF / PE versione 10.00.40219.01
Copyright (C) Microsoft Corporation. Tutti i diritti riservati.


Dump del file C: \ Windows \ syswow64 \ cmd.exe

Firma PE trovata

Tipo di file: IMMAGINE ESECUTABILE

VALORI DELL'INTESTAZIONE DEL FILE
             Macchina 14C (x86)
               4 numero di sezioni
        4CE78E2B data e ora sab 20 nov 09:00:27 2010
               0 puntatore al file nella tabella dei simboli
               0 numero di simboli
              Dimensione E0 dell'intestazione opzionale
             102 caratteristiche
                   eseguibile
                   Word machine a 32 bit
[...]

1
Potresti anche vedere (IA64) per un exe Itanium a 64 bit.
Darryl Braaten,

21
mentre leggo altrove su superutente, l'utilizzo dumpbin /headers | findstr "machine"semplifica notevolmente la presentazione di ciò che il QA sta cercando ...
user1055604

3
Dumpbin.exe si trova qui:C:\Program Files (x86)\Microsoft Visual Studio 12.0\VC\bin
Devid

3
@David: non necessariamente (versione diversa di VS, non utilizzando il percorso di installazione predefinito, utilizzando la versione da Windows SDK): ecco perché non l'ho specificato.
Richard,

6
È più semplice utilizzare dumpbin se lo si avvia dalla riga di comando di Visual Studio: stackoverflow.com/a/477389/1390430
Ben

46

Se non hai o desideri l'intero Windows SDK o Visual Studio, puoi utilizzare sigcheck.exeda SysInternals :

sigcheck.exe C:\Windows\Notepad.exe

Produzione:

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

4
Sembra non essere sempre preciso: prova a usarlo con LinqPad.exe (versione AnyCPU-64bit) e Sigcheck ti dirà che è "32 bit" ...
Matt,

@Matt interessante. LinqPad sembra un'app .net; Mi chiedo se sigcheck funzioni correttamente solo sugli eseguibili nativi (a questo scopo).
Briantist,

2
Sì, è un'app .NET. In .NET, se non è precompilato, puoi scegliere come target "x86" o "AnyCPU". "x86" verrà sempre eseguito come 32 bit, ma AnyCPU verrà eseguito come 64 bit su un sistema a 64 bit, ma come 32 bit su un sistema a 32 bit. SigCheck dovrebbe considerare questo e mostrare almeno ".NET 32 bit o 64 bit (AnyCPU)". ILSpy ad esempio dice in questo caso "Architecture: AnyCPU (preferibilmente a 64 bit)" - ma ILSpy non funzionerà con EXE non -.NET.
Matt,

1
Potrebbe essere il caso, come la vecchia intestazione "MZ" che è lì solo per sistemi operativi non Windows ("DOS") che dice "Questa applicazione richiede Microsoft Windows" ... ;-)
Matt,

2
Sì, i bei vecchi tempi, in cui avevi un debugger DOS nella shell e potresti smontare il codice (che conteneva solo una singola chiamata DOS che stampava questo messaggio) ... e sostituire il testo con "La risposta è 42". MrGreen
Matt,

38

Posso confermare che l' fileutility (ad esempio da Cygwin) distinguerà tra eseguibili a 32 e 64 bit. Appaiono come segue:

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

Come puoi vedere, è molto ovvio quale sia quale. Inoltre distingue tra eseguibili console e GUI, anche ovvio quale sia quale.


1
Questa soluzione è abbastanza comunemente disponibile per tutti gli sviluppatori che hanno installato msysgit.
FrontierPsycho,

Perché i file eseguibili in Windows hanno MZinvece di PE?
BattleTested

Vale la pena notare che le utility GNU possono essere ottenute come singoli binari se non si necessita altrimenti di Cygwin. gnuwin32.sourceforge.net/packages/file.htm
MJ Walsh

32

Un metodo semplice è eseguirlo (supponendo che sia attendibile) e dare un'occhiata alla scheda del processo in Task Manager. I processi a 32 bit mostreranno "* 32" alla fine del nome del processo. Se non è qualcosa che desideri eseguire sul tuo computer, puoi provare EXE Explorer . Mostrerà un sacco di informazioni sugli eseguibili, incluso se è a 32 o 64 bit.


8
Sfortunatamente, questo richiede di eseguire l'eseguibile. Forse è necessario controllare l'architettura del programma come metodo di risoluzione dei problemi sul perché non è in esecuzione.
Mike Christiansen,

6
Come si esegue una DLL?
user34660,


1
@samusarin che dovrebbe essere nel post.
user34660

@ user34660 Tecnicamente hai ragione, una DLL non ha un mainpunto di ingresso e quindi non verrà eseguita come processo autonomo. C'è una funzione di inizializzazione chiamata quando viene caricata ma non è "principale".
Samis,

24

Molte persone hanno installato l'eccellente 7-zip e hanno aggiunto la cartella 7-Zip alla loro PATH. 7-zip comprende formati di file diversi da ZIP e RAR, come file MSI ed eseguibili PE. Usa semplicemente la riga di comando 7z.exesul file PE (Exe o DLL) in questione:

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

L'output includerà le righe come segue, con la CPUriga che legge o x86o x64, che è ciò che viene richiesto qui:

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

wow, non ho mai saputo che 7z potesse farlo. Probabilmente contiene fileun'implementazione all'interno?
phuclv,

17

La versione a 64 bit di Process Explorer può dirti. Basta eseguire il file eseguibile e aprire la finestra delle proprietà del processo. Nella scheda principale c'è una voce che dice "Immagine: 32 bit" o "Immagine: 64 bit".

inserisci qui la descrizione dell'immagine


23
Simply run the executableE se non si desidera eseguire il programma?
Synetech,

3
@Synetech La domanda originale non implica che sia così.
Andrew Lambert,

Questo è il metodo più semplice per me penso, a meno che l'eseguibile non esca troppo velocemente.
Starbeamrainbowlabs

7
Come si esegue una DLL?
user34660,

15

Il modo più semplice (quando i dati non sono riservati)

Trovo che Virustotal File detail sia il modo più semplice per scoprire se un binario è a 32 bit o 64 bit.

L' Additional informationopzione fornisce inoltre molte informazioni utili sul file.

Analisi virustotale


[TrID virustotale


12

Il metodo per eseguire un eseguibile e quindi il check in process explorer o uno strumento simile presenta alcuni ovvi inconvenienti:

  1. Dobbiamo eseguire il processo.
  2. Per i processi di breve durata (come echo hello world types.), Process Explorer potrebbe non registrare nemmeno l'avvio di un nuovo processo.

Il metodo Dumpbin.exe può risolvere probabilmente lo scopo.

Un'altra alternativa sarebbe usare il comando file di cygwin . Tuttavia, non l'ho testato su Windows. Funziona bene su Linux.

Usage: file program_under_test.exe

EDIT: appena testato file.exe sulla finestra. funziona bene. :)


1
Volevo solo dire che ci sono alcune situazioni in cui il metodo di Dracs non sarà molto utile.
anishsane,

3
>> Ciò richiede ancora l'esecuzione del programma che l'autore voleva evitare: No .. lo eseguiamo come:
file.exe program_under_test.exe

1
E coloro che desiderano evitare di installare l'intero cygwinpacchetto possono prendere il pacchetto gnuwin32file .
Bob,

6
@anishsane Completamente sbagliato. filelegge semplicemente i dati dal disco in formato binario e verifica l'eventuale presenza di numeri magici che li identificano, confrontandoli con un database. I programmi di Windows a 32 bit vengono visualizzati come PE32 e i programmi a 64 bit e .NET vengono visualizzati come PE32 +. Il testimone di filese stesso fa una differenza assolutamente nulla: sia le applicazioni a 32 che a 64 bit possono leggere i dati dal disco, che è tutto ciò di cui ha bisogno.
Bob,

1
@MarcH Ha! Questo è interessante Immagino che ciò significhi che lo stub di runtime .NET è a 32 bit. Quindi esegue un processo a 32 bit per una frazione di secondo, ma tutto ciò che fa è avviare il runtime .NET, che crea un processo nativo a 64 bit.
clacke,

10

Ecco una soluzione Powershell, nessuna dipendenza esterna o altro. Apri Powershell, incolla la funzione lì (premi Invio due volte in modo da tornare al prompt), quindi usala come nei miei esempi sotto la funzione:

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
}

Ecco un esempio di output:

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

Slickness. Lo script sopra sembra lasciare un riferimento al file aperto. Impossibile compilare fino alla prima chiusura di PowerShell (ho eseguito lo script per interrogare la DLL in \ bin).
samis,

1
Molto bello. +1. Itanium è decisamente a 64 bit :)
Rich Homolka,

@samusarin: forse aggiungere $stream.dispose();dopo la chiusura? Dovrebbe rilasciare handle di file. ( stackoverflow.com/questions/1999858/… )
Yorik,

1
una versione più completa è disponibile in Controlla se exe è a 64 bit
phuclv,

6

Anche un eseguibile contrassegnato come 32 bit può essere eseguito come 64 bit se, ad esempio, è un eseguibile .NET che può essere eseguito come 32 o 64 bit. Per maggiori informazioni consultare https://stackoverflow.com/questions/3782191/how-do-i-determine-if-a-net-application-is-32-or-64-bit , che ha una risposta che dice che il L'utilità CORFLAGS può essere utilizzata per determinare come verrà eseguita un'applicazione .NET.

Uscita CORFLAGS.EXE

Per eseguibile a 32 bit:

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

Per eseguibile a 64 bit:

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

Per eseguibili che possono essere eseguiti a 32 o 64 bit e verranno eseguiti a 64 bit quando possibile:

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

Per eseguibili che possono essere eseguiti a 32 o 64 bit, ma verranno eseguiti a 32 bit a meno che non vengano caricati in un processo a 64 bit:

Version   : v4.0.30319
CLR Header: 2.5
PE        : PE32
CorFlags  : 0x20003
ILONLY    : 1
32BITREQ  : 0
32BITPREF : 1
Signed    : 0

Ottimo comando, ma non funzionerà con eseguibili / dll nativi (non gestiti). ( corflags : error CF008 : The specified file does not have a valid managed header)
Tomasz Gandor,

@TomaszGandor Sì, il contesto di questa risposta era solo codice gestito. Il codice non gestito riceve risposta dalle altre risposte. Per quanto ne so, solo il codice gestito può passare dall'esecuzione sia a 32 che a 64 bit.
BlueMonkMN,


3

Se sei su Windows 7, su Windows Explorer, fai clic con il pulsante destro del mouse sull'eseguibile e seleziona Proprietà. Nella finestra delle proprietà selezionare la scheda Compatibilità. Se nella sezione Modalità compatibilità vedi Windows XP, questo è un eseguibile a 32 bit. Se vedi Windows Vista, è a 64 bit.


-1 non è affatto vero. Vari binari a 32 e 64 bit mostrano tutti una modalità di compatibilità diWindows 8
Peter Hahndorf,

@Peter Ne ho provati parecchi su Windows 7 e ha sempre funzionato per me. Potresti dare un esempio di un binario in cui la modalità di compatibilità predefinita è Windows 8? Anche su quale Windows sei? Grazie.
axxis,

Sono su Server 2012 R2 e ho provato alcuni binari casuali. Alcuni 32 bit mostrano come Windows XP SP2ma altri mostrano come Vistao Windows 8. Quindi questo metodo non è corretto.
Peter Hahndorf,

3

Come aggiungere test a 32/64 bit al menu di scelta rapida

Crea un file di testo chiamato exetest.reg e contenente questo codice:

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\""

Crea un file di testo chiamato x86TestStart.batcontenente solo questa riga di codice e salvalo in C: \ temp:

c:\temp\x86or64.vbs %1

Crea un file di testo chiamato x86or64.vbscontenente questo codice e salvalo in 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

Fare doppio clic sul file exetest.reg: una nuova chiave verrà aggiunta nel registro di Windows:

[HKEY_CLASSES_ROOT\exefile\shell\command32_64\command]

Apparirà come " test a 32/64 bit " nel menu contestuale facendo clic con il tasto destro su un file eseguibile.

Facendo clic sull'elemento, verrà avviato il file batch c:\\temp\\x86TestStart.bat\, che avvia il file VBscript x86or64.vbs, che legge la firma exe e mostra il risultato.

Se non puoi o non vuoi manomettere il registro, copia semplicemente il file .vbs nella barra di QuickLaunch e trascina il file eseguibile su di esso.


3

I miei due centesimi saranno solo scaricare walker delle dipendenze e controllare cosa è stato usato per l'architettura in uno dei file eseguibili.

Come usarlo:

Basta semplicemente scaricare l'app, avviarla, fare clic sull'icona Apri → trova un file * .exe → selezionare e in fondo dopo aver eseguito la scansione della riflessione si vede una griglia con dati in cui una colonna contiene dettagli di "architettura" (x86, x64)

Apri eseguibile e vedi l'architettura di compilazione

screenshot del walker delle dipendenze


1

Non l'ho visto menzionato. Esiste un programma di visualizzazione PE chiamato CFF Explorer di NTCore , che può fornirti queste informazioni. Può essere scaricato ed eseguito come portatile, ma è possibile installarlo anche, se lo si desidera.

Fai clic destro sul binario ( .exe, .dllecc.) E seleziona "Apri con CFF Explorer". Vai a Intestazioni Nt -> Intestazione file -> Nel campo "Caratteristiche" fai clic su "Fai clic qui"

Se è un programma a 32 bit, la casella di controllo "Word machine a 32 bit" sarà selezionata. Ad esempio, ho installato la versione a 32 bit di Notepad ++ come puoi vedere nell'immagine qui sotto. Altrimenti, è a 64 bit.

inserisci qui la descrizione dell'immagine


Esiste un modo più veloce con CFF explorer: immediatamente quando si carica un file, in "tipo di file" si ha "Portable Executable 64" o "Portable Executable 32"
Arthur.V

0
  • eseguire l'applicazione
  • apri Task Manager
  • fare clic con il tasto destro e creare il file di dump
  • annotare il percorso
  • vai al percorso e apri il .DMPdump in Visual Studio
  • lì ottieni tutti i dettagli
  • controlla l'architettura di processo:

3
Mi sento in dovere di sottolineare il fatto che questa risposta richiede l'esecuzione dell'applicazione. I commentatori precedenti hanno suggerito che ciò potrebbe essere indesiderabile. Inoltre, Visual Studio non sarà automaticamente disponibile su tutte le piattaforme Windows.
G-Man,

0

i miei due centesimi: come sviluppatore C ++, walker delle dipendenze ( http://www.dependencywalker.com/ ) è molto istruttivo, non mostra solo 64/32 bit, ma anche tutte le DLL coinvolte: inserisci qui la descrizione dell'immagine

Puoi vedere 64 a sinistra di ogni nome di file ...


1
La schermata non mostra la risposta - informazioni a 32 bit contro 64 bit ...
TomEus,

0

Tuttavia, il comando di WSLfile funziona molto.

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

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

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

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

0

La colonna della piattaforma nel task manager di Windows 10

Windows 7 non ha una colonna della piattaforma. Quindi il task manager di Windows 7 non lo mostrerà.

In Windows 10 la scelta delle colonne non è più in "vista". In Windows 10, nella scheda dei dettagli, fai clic con il pulsante destro del mouse sull'intestazione della colonna, quindi seleziona le colonne. Quindi selezionare la casella per "piattaforma".

inserisci qui la descrizione dell'immagine

inserisci qui la descrizione dell'immagine

Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.